From 17687d8c7845c3b3e6db10b005b652e78980f2a3 Mon Sep 17 00:00:00 2001 From: Peter Schachte Date: Fri, 18 Oct 2024 20:15:17 +1100 Subject: [PATCH] Update compiler to use latest LLVM version (#471) * Start branch to rework LLVM generation The plan is to generate a .ll file directly and compile and link that, to move away from the unmaintained Haskell interface to LLVM. * Remove all dependencies on llvm-hs and shim out all LLVM generation code. * Compiler successfully builds, but doesn't generate LLVM * A couple of minor code cleanups * First version of prelude and set up for LLVM * Add generated .ll file as a sample. * Generate external declarations for resources. * Make resource globals undef instead of extern * Clean up resource global declaration generation * Add code to write LPVM code into LPVM section * Don't add 1 to specified lengths of strings * Introduce LLVM state monad, currently just holding file handle * Generate LLVM function signatures: start of code generation * Take signature info from ProcImpln (PrimProto instead of Proto) * pick lint * First go at generating LLVM proc bodies; much is wrong. * Generate foreign LLVM instructions and simple branches. Will need to convert from single assignment to true SSA. * Generate proper SSA; built and disassemble tuples for multi-argument return. * Generate LLVM switches for LPVM forks with more than 2 branches. * Generate C code to report sizes of C types. Start work on generating foreign lpvm instructions. Fix generation of llvm switches. * Generate string constants and use them when generating code. * Generate decimal integers as character constants in LLVM code. * Introduce new CPointer TypeRepresentation, used to represent opaque pointers, represented as 'ptr' in LLVM. Add type representation in 'representation is' Wybe type declarations. Use CPointer as the type of manifest string constants. Generate an LLVM declaration for each string constant, and use that constant by name everywhere a manifest string constant appears in the code. * Fix fencepost bug in switch generation. * Implement LPVM cast, load, and store * Now generates declarations of external called functions; generates good LLVM code for many library modules. * Define the size of a C pointer Also document assumptions made by c_config.c * Generate correct form for Wybe strings; add code to generate constant structures, needed to generate manifest constant strings. * Handle lpvm access and mutate; improve logging Not handling OutByReference or TakeReference yet. * Partially handle FlowOutByReference and FlowTakeReference * Add separate partitionArgsWithRefs function to handle by-ref arguments * Improve doc; start work on handling out-by-reference arguments. * Reformat description of LLVM output parts * regenerate src directory README * Improve LLVM module doc * Reorganise LLVM module * More LLVM module reorg * Now handle FlowTakeReference and FlowOutByReference; untested. * Improve generated README.md * fix duplicated types in type conversion exprs * Fix bugs in deferring calls; add more logging * Bug fixes, more logging * Slight cleanup * avoid use of bitcast for var = var assignment use LLVMName for both local and global vars * Use conversion instrs except for constants include temp counter with proc dumps * bug fix: temp counter was messed up by expansion with fusion * Properly set up LLVM monad for each proc * Eliminate unwanted args/parameters Exclude phantom and unneeded arguments and parameters from calls and definitions. Include source type in constant type conversion expressions. * Be more systematic with LLVM arguments; fix bug Generate \\ for backslash character in C strings; was generating single \. Avoid conversion instruction when marshalling constants to pass in C function call. * Generate HO calls * Supply new 'volatile' argument to memcpy intrinsic * Generate LLVM for proc specialisations, too Scan specialisation bodies when scanning bodies for strings and externs to generate. Generate separate LLVM definitions for specialisation bodies. * Systematially use LLVM names for instructions * typo * Fix type convertion during LLVM generation Automatically convert between representations when generating LLVM code. Remove cast from smaller to larger type in generating unboxed representations of small constructors. Make type checker aware of automatic conversion during LLVM generation, so it can be more forgiving. Conversion includes zero and sign extension, truncation, and bitcasting. * Support switching on signed integers. * Add XXX comments * Fix generation of switch defaults * Ensure SSA form by renaming assigned variables * Fix generation of unboxed mutator * Fix handling of load and store instructions * Log LLVM code; generate .s files on request Fix logging to include logging of LLVM code Make a few changes to make LLVM logging closer to old LLVM logging Add support for generating .s (native assembler) files. * delete accidentally added file * Improve compatibility with old LLVM generation * Fix empty variable name for main LLVM section * update version number to 0.2 * Fix problems with extern declarations Generate extern declarations for imported resources, but only if they're used. Name the main proc 'main', and use ccc instead of fastcc for it. Quote names if they contain characters other than alphanumerics, underscore and period. * Write LLVM code for submodules along with parent * Reduce change to logged LLVM code; Don't include submodules in generated LLVM when logging, because logging is already recursive. Omit git hash from header comment in .ll file, because it gives spurious diffs when testing. Explicitly specify C calling convention when calling C code. Generate extern decl for memcpy intrinsic last instead of first. * Get most tests to pass ... although many still fail. Updated update-exp script to give tighter diffs Understand void and intrinsic_bool (i1) C types Show Pointer type as "pointer" instead of "address". Include "ccc" in calls to wybe_malloc. Correctly consider string constants to be Pointers instead of CPointers. Eliminate many spurious bitcasts of constants (but accidentally add one in at least one place). * Delete spurious directory * Distinguish between wybe strings and C strings Unfortunately, this change renumbers all the string constants, but also, we don't generate a wybe string constant when only a C string is used. * filter out target triple when checking expected results. * Bug fix: non-destructive lpvm mutate mutated wrong structure * bug fix: declare wybe_malloc for non-destructive lpvm mutate * Bug fix: lpvm cast fields of unboxed constructors while constructing. * Bug fix: support resources in submodules * Track whether to prefix with 'tail' or 'musttail' based on alloca calls * Finish omitted comment * some code reorganisation * Fix handling of HO calls; drop mustinline in defs * Properly load outByRef value from the ref after the call, when it wasn't created by a takeRef * Insert date at top of ERRS file * Allocate closures on the heap Ensure wybe_malloc is declared Handle type conversion of closures correctly Fix generation of alloca instruction * Correct generation of HO trampoline * Eliminate more unnecessary bitcasts * more trivial bitcast removal test cases * XXX turn HO call to known closure into FO call * refactor LLVM prescanning to be monadic * Rename fns to generalise from strings to consts * Generate static constants for all-constant closures * Don't turn all HO arguments to i64 * Fix duplicated externs, building dynamic closures Generates externs in a different order now. * Add a log message * Store value through out-by-ref pointer as needed Wherever a value is stored in a variable that was an out-by-reference parameter, store the value where the out-by-reference pointer points. Use new function makeLLVMArg wherever we append an llvm type and llvm value, separated by a space. * Store floats in closures as floats, not ints * Fix handling of externs for mutually recursive modules * No conversion needed for equivalent types + add doc * Handle conversions better Just use bitcast for automatic integer <-> float converstions, to preserve all information. Track assigned LLVM variable types, so we can convert when the value is subsequently used as a different type. This happens for generics, when a typed value is supplied for a generic value. This really isn't ideal, but the type checker can give the same variable different types in this case. * Ignore changes to source_filename and target triple in complex tests * Fix syntax error in last commit * Fix bug in out-by-reference call argument Handle the case where out-by-reference argument is also an out-by-reference parameter. In this case, we can just use the pointer parameter, rather than passing a pointer to alloca-ed memory and fetching the contents after the call. This allows the call to be tail recursive. * Delete no-longer-used source files * Fix expected output for one test; fix test case to be more readable. * Address most of Jame's review comments * Install llvm package for CI testing * Code cleanup, remove unused code, changesome XXX comments to TODO * Update github CI runners to recent OSes; don't specify llvm 9 * Try debugging CI workflow * Another try to debug github CI * Heuristic for final-dump tests to show actual output for error cases rather than diff * Explicitly specify llvm version in ubuntu CI workflow * Also install llvm-18-dev for CI * Keep trying to get ubuntu workflow working * attempt to fix ubuntu build; normalise spaced LLVM array type syntax (#472) * attempt to fix ubuntu build; normalie spaced LLVM array type syntax * clean CConfig * one more lpvm section name * normalise tmp dir in complex tests * normalise more paths * add path to complx-test call; fix type on signum * derive path in python * Do LLVM type conversions (bitcasts) on call and return * Fix: delete .ll file after generating a .s file. * Fix generated trampolines Update trampoline parameters to have type AnyType and generated name, and generate code to convert from AnyType to the actual type of the parameter on entry, and similarly on exit for output parameters. Do similarly for closure arguments. * Delete accidental file; fix up documentation * Some cleanups, mostly removing commented-out code --------- Co-authored-by: James <41111926+jimbxb@users.noreply.github.com> --- .github/workflows/macos.yml | 4 +- .github/workflows/ubuntu.yml | 15 +- .gitignore | 2 + Makefile | 40 +- TODO.md | 10 +- WYBE.md | 65 +- hie.yaml | 6 - src/AST.hs | 203 +- src/ASTShow.hs | 35 +- src/AliasAnalysis.hs | 11 +- src/BinaryFactory.hs | 14 - src/Blocks.hs | 1710 ----- src/BodyBuilder.hs | 23 +- src/Builder.hs | 92 +- src/Callers.hs | 11 +- src/Codegen.hs | 724 -- src/Compiler.ipe | 112 +- src/Compiler.png | Bin 14055 -> 13886 bytes src/Config.hs | 59 +- src/Emit.hs | 307 +- src/LLVM.hs | 2199 ++++++ src/LastCallAnalysis.hs | 50 +- src/Normalise.hs | 76 +- src/ObjectInterface.hs | 3 +- src/Options.hs | 23 +- src/Parser.hs | 5 +- src/README.md | 228 +- src/Resources.hs | 1 - src/Types.hs | 101 +- src/Unbranch.hs | 3 +- src/UnivSet.hs | 7 + src/Util.hs | 6 +- src/c_config.c | 39 + stack.yaml | 9 +- test-cases/complex-test.py | 7 +- .../exp/testcase_multi_specz-drone.exp | 1620 ++-- .../exp/testcase_multi_specz-int_list.exp | 2116 +++--- test-cases/complex/utils.py | 18 +- test-cases/execution/type_generics.exp | 4 +- test-cases/execution/type_generics.wybe | 7 +- test-cases/final-dump-test.sh | 18 +- test-cases/final-dump/aaa.exp | 150 +- test-cases/final-dump/afterbreak.exp | 65 +- test-cases/final-dump/alias1.exp | 714 +- test-cases/final-dump/alias2.exp | 485 +- test-cases/final-dump/alias3.exp | 470 +- test-cases/final-dump/alias4.exp | 478 +- test-cases/final-dump/alias5.exp | 143 +- test-cases/final-dump/alias_cyclic.exp | 511 +- test-cases/final-dump/alias_data.exp | 806 +- test-cases/final-dump/alias_des.exp | 424 +- test-cases/final-dump/alias_des2.exp | 353 +- test-cases/final-dump/alias_fork1.exp | 749 +- test-cases/final-dump/alias_fork2.exp | 712 +- test-cases/final-dump/alias_fork3.exp | 662 +- test-cases/final-dump/alias_m.exp | 677 +- test-cases/final-dump/alias_mbar.exp | 584 +- test-cases/final-dump/alias_mfoo.exp | 584 +- test-cases/final-dump/alias_mod_param.exp | 384 +- test-cases/final-dump/alias_multifunc.exp | 538 +- test-cases/final-dump/alias_multifunc1.exp | 538 +- test-cases/final-dump/alias_multifunc2.exp | 514 +- test-cases/final-dump/alias_multifunc3.exp | 479 +- test-cases/final-dump/alias_multifunc4.exp | 619 +- test-cases/final-dump/alias_recursion1.exp | 511 +- test-cases/final-dump/alias_scc_proc.exp | 641 +- test-cases/final-dump/alias_type1.exp | 571 +- test-cases/final-dump/alias_type2.exp | 592 +- test-cases/final-dump/alias_type3.exp | 594 +- test-cases/final-dump/alias_type4.exp | 599 +- test-cases/final-dump/alloc_args.exp | 50 +- test-cases/final-dump/anon_field.exp | 936 ++- test-cases/final-dump/anon_field_variable.exp | 274 +- test-cases/final-dump/assert_error.exp | 43 +- test-cases/final-dump/backquote_OK.exp | 19 +- test-cases/final-dump/backwards_assign.exp | 61 +- test-cases/final-dump/bar.exp | 114 +- test-cases/final-dump/bbb.exp | 76 +- test-cases/final-dump/benchmark_fib.exp | 315 +- test-cases/final-dump/block_comment.exp | 73 +- test-cases/final-dump/break_in_loop_in_do.exp | 61 +- test-cases/final-dump/bug214.exp | 1335 ++-- test-cases/final-dump/bug217.exp | 69 +- test-cases/final-dump/bug228-okay.exp | 61 +- test-cases/final-dump/bug_var_def.exp | 19 +- test-cases/final-dump/call_site_id.exp | 137 +- test-cases/final-dump/card.exp | 943 ++- test-cases/final-dump/caret.exp | 997 ++- test-cases/final-dump/cases.exp | 65 +- test-cases/final-dump/ccc.exp | 76 +- test-cases/final-dump/chain_assign.exp | 19 +- test-cases/final-dump/char-escape.exp | 189 +- test-cases/final-dump/common_fields.exp | 1536 ++-- test-cases/final-dump/commonsubexpr.exp | 65 +- test-cases/final-dump/compute.exp | 134 +- test-cases/final-dump/cond_expr_no_else.exp | 309 +- test-cases/final-dump/constfold.exp | 37 +- test-cases/final-dump/constructors.exp | 186 +- test-cases/final-dump/continuation_args.exp | 224 +- test-cases/final-dump/coordinate.exp | 407 +- test-cases/final-dump/ctor_char.exp | 437 +- test-cases/final-dump/ctor_char2.exp | 531 +- test-cases/final-dump/ctor_visibility.exp | 1006 ++- .../final-dump/current_module_alias.exp | 64 +- .../final-dump/current_module_alias_fail.exp | 64 +- .../current_module_alias_type_args.exp | 272 +- .../current_module_alias_warning.exp | 74 +- test-cases/final-dump/ddd.exp | 39 +- test-cases/final-dump/dead_cell_size.exp | 1682 ++--- test-cases/final-dump/decimal.exp | 77 +- test-cases/final-dump/det_for.exp | 55 +- test-cases/final-dump/disjunction.exp | 139 +- test-cases/final-dump/disjunctive-cond.exp | 201 +- .../final-dump/dont_care_constraint.exp | 25 +- test-cases/final-dump/early_error.exp | 75 +- test-cases/final-dump/early_exit.exp | 45 +- test-cases/final-dump/early_exit2.exp | 53 +- test-cases/final-dump/empty.exp | 13 +- test-cases/final-dump/eof_comment.exp | 39 +- test-cases/final-dump/exp_if.exp | 69 +- test-cases/final-dump/exp_print.exp | 73 +- test-cases/final-dump/exp_simple.exp | 79 +- .../final-dump/explicit_type_warning.exp | 321 +- test-cases/final-dump/exporter.exp | 37 +- .../final-dump/extern_anon_params_a.exp | 67 +- .../final-dump/extern_anon_params_b.exp | 106 +- test-cases/final-dump/factor_bug.exp | 49 +- test-cases/final-dump/failure_backtrack.exp | 729 +- .../final-dump/failure_in_cond_test.exp | 35 +- test-cases/final-dump/fn_update.exp | 367 +- test-cases/final-dump/foreign_def.exp | 39 +- .../final-dump/foreign_def_unordered.exp | 385 +- test-cases/final-dump/foreign_test.exp | 149 +- test-cases/final-dump/func_factorial.exp | 55 +- test-cases/final-dump/func_let.exp | 35 +- test-cases/final-dump/func_quadruple.exp | 31 +- test-cases/final-dump/func_typed.exp | 21 +- test-cases/final-dump/func_untyped.exp | 21 +- test-cases/final-dump/func_where.exp | 23 +- test-cases/final-dump/generic_list.exp | 304 +- test-cases/final-dump/generic_use.exp | 760 +- .../final-dump/global_flow_inference.exp | 234 +- test-cases/final-dump/higher_order_anon.exp | 201 +- test-cases/final-dump/higher_order_append.exp | 298 +- test-cases/final-dump/higher_order_impure.exp | 58 +- test-cases/final-dump/higher_order_inline.exp | 37 +- test-cases/final-dump/higher_order_loop.exp | 127 +- .../final-dump/higher_order_phantom.exp | 45 +- test-cases/final-dump/higher_order_refs.exp | 215 +- .../final-dump/higher_order_resources.exp | 487 +- test-cases/final-dump/higher_order_sort.exp | 155 +- test-cases/final-dump/higher_order_tests.exp | 363 +- test-cases/final-dump/hypot.exp | 339 +- test-cases/final-dump/import.exp | 404 +- .../final-dump/import_in_sub_mod_lib.exp | 31 +- .../final-dump/import_in_sub_mod_main.exp | 89 +- test-cases/final-dump/importer.exp | 151 +- test-cases/final-dump/imports.exp | 85 +- test-cases/final-dump/inequality.exp | 35 +- test-cases/final-dump/inline_decl.exp | 95 +- test-cases/final-dump/inline_pos.exp | 168 +- test-cases/final-dump/inline_rename.exp | 55 +- test-cases/final-dump/int_list.exp | 418 +- test-cases/final-dump/int_sequence.exp | 405 +- test-cases/final-dump/io.exp | 55 +- test-cases/final-dump/io_flow_ok.exp | 103 +- test-cases/final-dump/list_loop.exp | 496 +- test-cases/final-dump/list_this.exp | 304 +- test-cases/final-dump/loop_bug.exp | 418 +- test-cases/final-dump/loop_terminators.exp | 89 +- test-cases/final-dump/main_hello.exp | 170 +- test-cases/final-dump/main_hello2.exp | 49 +- test-cases/final-dump/mainless.exp | 19 +- test-cases/final-dump/mixed_fields.exp | 584 +- test-cases/final-dump/mod1.exp | 13 +- test-cases/final-dump/mod2.exp | 13 +- test-cases/final-dump/mod3.exp | 13 +- test-cases/final-dump/mod4.exp | 13 +- test-cases/final-dump/mod5.exp | 13 +- test-cases/final-dump/mod6.exp | 13 +- test-cases/final-dump/mod7.exp | 13 +- test-cases/final-dump/mod8.exp | 13 +- test-cases/final-dump/multi_out.exp | 31 +- test-cases/final-dump/multi_specz.exp | 575 +- .../final-dump/multi_specz_cyclic_exe.exp | 679 +- .../final-dump/multi_specz_cyclic_lib.exp | 399 +- .../final-dump/multi_specz_cyclic_lib2.exp | 399 +- test-cases/final-dump/multi_specz_reverse.exp | 340 +- test-cases/final-dump/multictr.exp | 6538 ++++++++--------- test-cases/final-dump/multictr2.exp | 1815 +++-- test-cases/final-dump/mutual_res_a.exp | 30 +- test-cases/final-dump/mutual_res_b.exp | 30 +- test-cases/final-dump/mutual_type.exp | 597 +- test-cases/final-dump/mytree.exp | 497 +- test-cases/final-dump/need.exp | 94 +- test-cases/final-dump/nested_if.exp | 111 +- test-cases/final-dump/nested_loop.exp | 87 +- test-cases/final-dump/numbers.exp | 71 +- .../final-dump/out_global_overwritten.exp | 49 +- .../final-dump/out_only_global_flow.exp | 51 +- test-cases/final-dump/person1.exp | 252 +- test-cases/final-dump/person2.exp | 254 +- test-cases/final-dump/person3.exp | 262 +- test-cases/final-dump/person4.exp | 262 +- test-cases/final-dump/person5.exp | 303 +- test-cases/final-dump/position.exp | 290 +- test-cases/final-dump/position1.exp | 355 +- test-cases/final-dump/position2.exp | 394 +- test-cases/final-dump/position_float.exp | 226 +- test-cases/final-dump/proc_allin.exp | 19 +- test-cases/final-dump/proc_beer.exp | 91 +- test-cases/final-dump/proc_factorial.exp | 75 +- test-cases/final-dump/proc_gcd.exp | 89 +- test-cases/final-dump/proc_hello.exp | 39 +- test-cases/final-dump/proc_print2.exp | 27 +- test-cases/final-dump/proc_yorn.exp | 151 +- test-cases/final-dump/proc_yorn2.exp | 81 +- test-cases/final-dump/pub_importer.exp | 48 +- test-cases/final-dump/purity_warning.exp | 19 +- test-cases/final-dump/representation.exp | 21 +- test-cases/final-dump/res_decl.exp | 17 +- test-cases/final-dump/resource_conflict_a.exp | 17 +- test-cases/final-dump/resource_conflict_b.exp | 17 +- test-cases/final-dump/resource_rollback.exp | 107 +- test-cases/final-dump/resource_tmp_vars.exp | 57 +- test-cases/final-dump/save_restore_cond.exp | 35 +- test-cases/final-dump/save_restore_disj.exp | 19 +- test-cases/final-dump/simple_loop.exp | 51 +- test-cases/final-dump/sister_module.exp | 69 +- test-cases/final-dump/specials.exp | 85 +- test-cases/final-dump/specials_one_module.exp | 121 +- test-cases/final-dump/specials_use.exp | 160 +- test-cases/final-dump/stmt_for.exp | 2001 +++-- test-cases/final-dump/stmt_if.exp | 591 +- test-cases/final-dump/stmt_if2.exp | 545 +- test-cases/final-dump/stmt_nop.exp | 19 +- test-cases/final-dump/stmt_unless.exp | 83 +- test-cases/final-dump/stmt_until.exp | 67 +- test-cases/final-dump/stmt_when.exp | 83 +- test-cases/final-dump/stmt_while.exp | 67 +- test-cases/final-dump/string.exp | 499 +- .../final-dump/string_interpolation.exp | 127 +- test-cases/final-dump/student.exp | 688 +- test-cases/final-dump/submodule.exp | 105 +- test-cases/final-dump/subresource.exp | 77 +- test-cases/final-dump/terminal_ok.exp | 43 +- test-cases/final-dump/test_loop.exp | 658 +- test-cases/final-dump/tests.exp | 648 +- test-cases/final-dump/thistype.exp | 501 +- test-cases/final-dump/top_level_use.exp | 35 +- test-cases/final-dump/type_enum.exp | 64 +- test-cases/final-dump/type_generics.exp | 290 +- test-cases/final-dump/type_int.exp | 134 +- test-cases/final-dump/type_list.exp | 513 +- test-cases/final-dump/unbranch_bug.exp | 57 +- test-cases/final-dump/unbranch_inout.exp | 37 +- test-cases/final-dump/unbranch_issue.exp | 45 +- test-cases/final-dump/undef_bug.exp | 123 +- .../final-dump/uneeded_closure_args.exp | 56 +- test-cases/final-dump/unique_conditional.exp | 39 +- test-cases/final-dump/unique_position.exp | 232 +- test-cases/final-dump/unneeded.exp | 21 +- test-cases/final-dump/update.exp | 33 +- test-cases/final-dump/use_resource.exp | 123 +- test-cases/final-dump/weird_err_b.exp | 72 +- test-cases/final-dump/weird_err_d.exp | 55 +- update-exp | 2 +- wybe.cabal | 121 +- wybelibs/wybe/cbits.c | 4 + wybelibs/wybe/float.wybe | 12 +- wybelibs/wybe/opaque_pointer.wybe | 7 + 271 files changed, 33312 insertions(+), 41463 deletions(-) delete mode 100644 src/Blocks.hs delete mode 100644 src/Codegen.hs create mode 100644 src/LLVM.hs create mode 100644 src/c_config.c create mode 100644 wybelibs/wybe/opaque_pointer.wybe diff --git a/.github/workflows/macos.yml b/.github/workflows/macos.yml index 8b6a9a8fd..d8cf4bafa 100644 --- a/.github/workflows/macos.yml +++ b/.github/workflows/macos.yml @@ -16,14 +16,14 @@ on: jobs: build: - runs-on: macos-10.15 + runs-on: macos-14 steps: - uses: actions/checkout@v2 - name: Install dependencies run: | + brew install llvm brew install bdw-gc - brew install llvm-hs/llvm/llvm-9 brew install dwdiff brew install coreutils diff --git a/.github/workflows/ubuntu.yml b/.github/workflows/ubuntu.yml index 3ea9f47c9..274290404 100644 --- a/.github/workflows/ubuntu.yml +++ b/.github/workflows/ubuntu.yml @@ -10,16 +10,15 @@ on: jobs: build: - runs-on: ubuntu-20.04 + runs-on: ubuntu-24.04 steps: - uses: actions/checkout@v2 - name: Install dependencies run: | + sudo apt-get install llvm sudo apt-get install clang sudo apt-get install libgc-dev - sudo apt-get install llvm-9-dev - sudo apt-get install libtinfo-dev sudo apt-get install dwdiff # GitHub-hosted runners provide Haskell Stack @@ -27,6 +26,16 @@ jobs: # - name: Install Haskell Stack # run: wget -qO- https://get.haskellstack.org/ | sh + - name: Verify dependencies + run: | + dpkg -s llvm + dpkg -s clang + dpkg -s libgc-dev + dpkg -s dwdiff + llvm-config --version + llc --version + clang --version + # cache Haskell Stack stuff - name: Cache stack global package db uses: actions/cache@v1 diff --git a/.gitignore b/.gitignore index c9e897ebd..7f19941ab 100644 --- a/.gitignore +++ b/.gitignore @@ -58,3 +58,5 @@ README.html dist-newstyle stack.yaml.lock LOG* +src/c_config +src/CConfig.hs diff --git a/Makefile b/Makefile index 510453dc3..8d1a30ed4 100644 --- a/Makefile +++ b/Makefile @@ -7,9 +7,13 @@ INSTALLBIN=/usr/local/bin INSTALLLIB=/usr/local/lib/wybe +# Configure any extra C library and include directories +EXTRALIBS=-L /usr/local/lib -L /opt/homebrew/lib +EXTRAINCLUDES=-I /usr/local/include -I /opt/homebrew/include + # You shouldn't need to edit anything below here -VERSION = 0.1 +VERSION = 0.2 SRCDIR = src LIBDIR = wybelibs WYBELIBS = wybe.o command_line.o logging.o random.o benchmark.o @@ -40,7 +44,7 @@ install: wybemk "$(INSTALLBIN)/wybemk" --force-all $(addsuffix ", $(addprefix "$(INSTALLLIB)/,$(WYBELIBS))) -wybemk: $(SRCDIR)/*.hs $(SRCDIR)/Version.lhs +wybemk: $(SRCDIR)/*.hs $(SRCDIR)/CConfig.hs $(SRCDIR)/Version.lhs stack -j3 build && cp "`stack path --local-install-root`/bin/$@" "$@" libs: $(addprefix $(LIBDIR)/,$(LIBS)) @@ -53,7 +57,7 @@ $(LIBDIR)/wybe.o: wybemk $(LIBDIR)/wybe/*.wybe $(LIBDIR)/wybe/cbits.o: $(LIBDIR)/wybe/cbits.c - clang $(ISSYSROOT) -I /usr/local/include -c "$<" -o "$@" + clang $(ISSYSROOT) $(EXTRAINCLUDES) -c "$<" -o "$@" $(SRCDIR)/Version.lhs: $(addprefix $(SRCDIR)/,*.hs) @@ -61,29 +65,38 @@ $(SRCDIR)/Version.lhs: $(addprefix $(SRCDIR)/,*.hs) @rm -f "$@" @printf "Version.lhs automatically generated: DO NOT EDIT\n" > "$@" @printf "\n" >> "$@" - @printf "> module Version (version,gitHash,buildDate,libDir) where\n\n" >> "$@" + @printf "> module Version (version,gitHash,buildDate,libDir,defaultTriple) where\n\n" >> "$@" @printf "> version :: String\n> version = \"%s\"\n\n" "$(VERSION)" >> "$@" @printf "> gitHash :: String\n> gitHash = \"%s\"\n\n" "`git rev-parse --short HEAD`" >> "$@" @printf "> buildDate :: String\n> buildDate = \"%s\"\n\n" "`date`" >> "$@" @printf "> libDir :: String\n> libDir = \"%s\"\n\n" "$(INSTALLLIB)" >> "$@" + @printf "> defaultTriple :: String\n> defaultTriple = \"" >> "$@" + @clang --version | sed -n 's/Target: *\(.*\)/\1\"/p' >> "$@" + @printf "\n\n" >> "$@" + +$(SRCDIR)/CConfig.hs: $(SRCDIR)/c_config + $< > $@ + +$(SRCDIR)/c_config: $(SRCDIR)/c_config.c + clang $(ISSYSROOT) $(EXTRAINCLUDES) -o $@ $< + .PHONY: doc doc: src/README.md # Assemble README markdown source file automatically -src/README.md: src/*.hs Makefile src/README.md.intro src/README.md.outro +src/README.md: src/*.hs Makefile src/README.md.intro src/README.md.outro \ + src/Compiler.png src/Detail.png cat src/README.md.intro > "$@" printf "The source files in this directory and their purposes are:\n\n" >> "$@" - printf "| File " >> "$@" - printf "| Purpose |\n" >> "$@" - printf "| ---------------------------- " >> "$@" - printf "| -------------------------------------------------------- |\n" >> "$@" + printf "| File | Purpose |\n" >> "$@" + printf "| ---- | -------------------------------------------- |\n" >> "$@" for f in src/*.hs ; do \ b=`basename $$f` ; \ m=`basename $$f .hs` ; \ - printf "| `printf '%-29s' [$$b]\(#$$m\)`| " ; \ + printf "| `printf '%-20s' [$$b]\(#$$m\)` | " ; \ sed -n "s/^-- *Purpose *: *\(.*\)/\1/p" $$f | tr -d '\n' ; \ printf " |\n" ; \ done >> "$@" @@ -92,7 +105,8 @@ src/README.md: src/*.hs Makefile src/README.md.intro src/README.md.outro for f in src/*.hs ; do \ m=`basename $$f .hs` ; \ echo -e ; \ - sed -E -e '/^-- *Purpose *:/{s/^-- *Purpose *:/## '"$$m -- "'/; G; p;}' -e '/BEGIN MAJOR DOC/,/END MAJOR DOC/{//d ; s/^-- ? ?//p;}' -e 'd' <$$f ; \ + echo -e "## $$m " ; \ + sed -E -e '/BEGIN MAJOR DOC/,/END MAJOR DOC/{//d ; s/^-- ? ?//p;}' -e 'd' <$$f ; \ done >> "$@" printf "\n\n" >> "$@" @@ -100,7 +114,7 @@ src/README.md: src/*.hs Makefile src/README.md.intro src/README.md.outro test: wybemk - @rm -f ERRS ; touch ERRS + @rm -f ERRS ; printf "Testing run " > ERRS ; date >> ERRS @rm -f $(LIBDIR)/*.o $(LIBDIR)/wybe/*.o @echo -e "Building $(LIBDIR)/wybe/cbits.o" @make $(LIBDIR)/wybe/cbits.o @@ -111,4 +125,4 @@ test: wybemk clean: stack clean - rm -f $(SRCDIR)/*.o $(SRCDIR)/*.hi $(SRCDIR)/Version.lhs documentation/*.pdf publications/*.pdf $(LIBDIR)/*.o $(LIBDIR)/wybe/*.o test-cases/*.o + rm -f $(SRCDIR)/*.o $(SRCDIR)/*.hi $(SRCDIR)/Version.lhs $(SRCDIR)/CConfig.hs documentation/*.pdf publications/*.pdf $(LIBDIR)/*.o $(LIBDIR)/wybe/*.o test-cases/*.o diff --git a/TODO.md b/TODO.md index 7b1491022..fee25769e 100644 --- a/TODO.md +++ b/TODO.md @@ -19,7 +19,7 @@ ## Error checking: -* Error if foreign call has no outputs; suggest use !I/O. +* Error if foreign call has no outputs; suggest `use !io` or make it impure. * Ensure no statement binds the same variable multiple times @@ -38,11 +38,8 @@ * Fix the syntax! * Support curley braces to specify sets and maps * Interpolation (in strings, arrays, sets, and maps) - * "...@foo..." means "..." `,,` foo `,,` "..." - * "...@(foo(bar,baz))..." means "..." `,,` foo(bar,baz) `,,` "..." - * [foo,@bar(baz),zip] means [foo] `,,` bar(baz) `,,` [zip] - * if `,,` can run backwards, then [?foo,@?bar] and [@?foo,bar] can be patterns - * with this, do we need `[ ... | ...]` syntax? + * "...$(foo(bar,baz))..." means "..." `,,` foo(bar,baz) `,,` "..." + * [foo,$bar(baz),zip] means [foo] `,,` bar(baz) `,,` [zip] * Support "commutative" resources, which don't need to be threaded everywhere * Support unicode * Investigate situation calculus @@ -86,5 +83,4 @@ ## Porting: -* to Windows * Rewrite compiler in Wybe diff --git a/WYBE.md b/WYBE.md index b7f82f5e0..8cf42b801 100644 --- a/WYBE.md +++ b/WYBE.md @@ -95,7 +95,9 @@ Hello, World! Note that `wybemk` is like `make` in that you give it the name of the file you want it to build, and it figures out what files it needs -to compile. +to compile. Currently, the Wybe compiler can generate an executable file, an +object (.o) file, an LLVM assembler (.ll) file, an LLVM bitcode (.bc), and a +native assembly language (.s) file from a wybe source file. ### Compiler Options @@ -108,8 +110,8 @@ can be found with the following: #### Optimisation Options -The `--llvm-opt-level` (`-O`) options specifies the level of optimisation used -within the LLVM compiler during the compilations stage of a Wybe module. By default, this is set to 3, yet supports the values 0, 1, 2, or 3. More information +The `--llvm-opt-level` (-O) option specifies the level of optimisation used +within the LLVM compiler during the compilation stage of a Wybe module. By default, this is set to 3, yet supports the values 0, 1, 2, or 3. More information can be found [here](https://llvm.org/docs/CommandGuide/llc.html#id1). @@ -2243,18 +2245,38 @@ Floating point multiplication Floating point division - `foreign llvm frem(`arg1:float, arg2:float`)`:float Floating point remainder -- `foreign llvm fcmp_eq(`arg1:float, arg2:float`)`:bool +- `foreign llvm fcmp_ord(`arg1:float, arg2:float`)`:bool +Floating point ordered (neither is a NaN) +- `foreign llvm fcmp_oeq(`arg1:float, arg2:float`)`:bool Floating point equality -- `foreign llvm fcmp_ne(`arg1:float, arg2:float`)`:bool +- `foreign llvm fcmp_one(`arg1:float, arg2:float`)`:bool Floating point disequality -- `foreign llvm fcmp_slt(`arg1:float, arg2:float`)`:bool +- `foreign llvm fcmp_olt(`arg1:float, arg2:float`)`:bool Floating point (signed) strictly less -- `foreign llvm fcmp_sle(`arg1:float, arg2:float`)`:bool +- `foreign llvm fcmp_ole(`arg1:float, arg2:float`)`:bool Floating point (signed) less or equal -- `foreign llvm fcmp_sgt(`arg1:float, arg2:float`)`:bool +- `foreign llvm fcmp_ogt(`arg1:float, arg2:float`)`:bool Floating point (signed) strictly greater -- `foreign llvm fcmp_sge(`arg1:float, arg2:float`)`:bool +- `foreign llvm fcmp_oge(`arg1:float, arg2:float`)`:bool Floating point (signed) greater or equal +- `foreign llvm fcmp_ord(`arg1:float, arg2:float`)`:bool +Floating point unordered (either is a NaN) +- `foreign llvm fcmp_ueq(`arg1:float, arg2:float`)`:bool +Floating point unordered or equal +- `foreign llvm fcmp_une(`arg1:float, arg2:float`)`:bool +Floating point unordered or not equal +- `foreign llvm fcmp_ult(`arg1:float, arg2:float`)`:bool +Floating point unordered or strictly less +- `foreign llvm fcmp_ule(`arg1:float, arg2:float`)`:bool +Floating point unordered or less or equal +- `foreign llvm fcmp_ugt(`arg1:float, arg2:float`)`:bool +Floating point unordered or strictly greater +- `foreign llvm fcmp_uge(`arg1:float, arg2:float`)`:bool +Floating point unordered or greater or equal +- `foreign llvm fcmp_true(`arg1:float, arg2:float`)`:bool +Always returns true with no comparison +- `foreign llvm fcmp_false(`arg1:float, arg2:float`)`:bool +Always returns false with no comparison ##### Integer/floating point conversion @@ -2281,17 +2303,20 @@ declaration has the form: where *rep* has one of these forms: -- `address` -the type is a machine address, similar to the `void *` type in C. -- *n* `bit` *numbertype* -a primitive number type comprising *n* bits, where *n* is any non-negative -integer and *numbertype* is one of: - - `signed` - a signed integer type - - `unsigned` - an unsigned integer type - - `float` - a floating point number; *n* must be 16, 32, 64, or 128. +- `pointer` + the type is the address of a Wybe data structure. Foreign code should not +treat this as an ordinary pointer. +- `opaque` +the type is a machine address, similar to the `void *` type in C. Wybe treats such values as opaque. +- *n* `bit signed` +a signed primitive number type comprising *n* bits, where *n* is any non-negative +integer. Represents integers between -2*n*-1 and 2*n*-1-1 inclusive. +- *n* `bit unsigned` +an unsigned primitive number type comprising *n* bits, where *n* is any non-negative +integer. Represents integers between 0 and 2*n*-1 inclusive. +- *n* `bit float` +a floating point number type comprising *n* bits, where *n* is one of 16, 32, +64, or 128. Like a `constructor` declaration, a `representation` declaration makes the enclosing module into type. Also like a `constructor` declaration, a submodule diff --git a/hie.yaml b/hie.yaml index 97ba7c21c..49b09395f 100644 --- a/hie.yaml +++ b/hie.yaml @@ -9,9 +9,6 @@ cradle: - path: "./src/BinaryFactory.hs" component: "wybe:exe:wybemk" - - path: "./src/Blocks.hs" - component: "wybe:exe:wybemk" - - path: "./src/BodyBuilder.hs" component: "wybe:exe:wybemk" @@ -24,9 +21,6 @@ cradle: - path: "./src/Clause.hs" component: "wybe:exe:wybemk" - - path: "./src/Codegen.hs" - component: "wybe:exe:wybemk" - - path: "./src/Config.hs" component: "wybe:exe:wybemk" diff --git a/src/AST.hs b/src/AST.hs index 8a7b176cb..3c71650fd 100644 --- a/src/AST.hs +++ b/src/AST.hs @@ -8,6 +8,7 @@ {-# LANGUAGE DeriveGeneric #-} {-# LANGUAGE LambdaCase #-} {-# LANGUAGE TupleSections #-} +{-# LANGUAGE EmptyCase #-} -- |The abstract syntax tree, and supporting types and functions. -- This includes the parse tree, as well as the AST types, which @@ -37,7 +38,7 @@ module AST ( TypeRepresentation(..), TypeFamily(..), typeFamily, defaultTypeRepresentation, typeRepSize, integerTypeRep, defaultTypeModifiers, - lookupTypeRepresentation, lookupModuleRepresentation, + lookupTypeRepresentation, lookupModuleRepresentation, argIsReal, paramIsPhantom, argIsPhantom, typeIsPhantom, repIsPhantom, primProtoParamNames, protoRealParams, realParams, paramIsReal, paramIsNeeded, @@ -54,9 +55,9 @@ module AST ( emptyInterface, emptyImplementation, getParams, getPrimParams, getDetism, getProcDef, getProcPrimProto, mkTempName, updateProcDef, updateProcDefM, - ModSpec, validModuleName, maybeModPrefix, - ProcImpln(..), ProcDef(..), procInline, procCallCount, - transformModuleProcs, + ModSpec, validModuleName, maybeModPrefix, + ProcImpln(..), ProcDef(..), procBody, allProcBodies, procInline, + procCallCount, transformModuleProcs, getProcGlobalFlows, primImpurity, flagsImpurity, flagsDetism, AliasMap, aliasMapToAliasPairs, ParameterID, parameterIDToVarName, @@ -70,12 +71,12 @@ module AST ( argDescription, argIntVal, trustArgInt, setParamType, paramIsResourceful, setPrimParamType, setTypeFlowType, flowsIn, flowsOut, primFlowToFlowDir, isInputFlow, isOutputFlow, - foldStmts, foldExps, foldBodyPrims, foldBodyDistrib, + foldStmts, foldExps, foldBodyPrims, foldBodyDistrib, mapLPVMBodyM, expToStmt, seqToStmt, stmtsImpurity, stmtImpurity, procCallToExp, stmtsInputs, expOutputs, pexpListOutputs, expInputs, pexpListInputs, setExpTypeFlow, setPExpTypeFlow, - Prim(..), primArgs, replacePrimArgs, - primGlobalFlows, argGlobalFlow, argsGlobalFlows, effectiveGlobalFlows, + Prim(..), primArgs, replacePrimArgs, + primGlobalFlows, argGlobalFlow, argsGlobalFlows, effectiveGlobalFlows, argIsVar, argIsConst, argIntegerValue, varsInPrims, varsInPrim, varsInPrimArgs, varsInPrimArg, ProcSpec(..), PrimVarName(..), PrimArg(..), PrimFlow(..), ArgFlowType(..), @@ -115,7 +116,7 @@ module AST ( showBody, showPlacedPrims, showStmt, showBlock, showProcDef, showProcIdentifier, showProcName, showModSpec, showModSpecs, showResources, showOptPos, showProcDefs, showUse, - shouldnt, nyi, checkError, checkValue, trustFromJust, trustFromJustM, + shouldnt, should, nyi, checkError, checkValue, trustFromJust, trustFromJustM, flowPrefix, showProcModifiers, showProcModifiers', showFlags, showFlags', showMap, showVarMap, simpleShowMap, simpleShowSet, bracketList, maybeShow, showMessages, stopOnError, @@ -160,7 +161,7 @@ import System.Console.ANSI import GHC.Generics (Generic) -import qualified LLVM.AST as LLVMAST +-- import qualified LLVM.AST as LLVMAST import Data.Binary (Binary) ---------------------------------------------------------------- @@ -285,14 +286,20 @@ determinismCanFail Det = False determinismCanFail SemiDet = True --- | Internal representation of data +-- | Internal representation of data. +-- Because Wybe uses a tagged representation for data structures, which requires +-- integer and bit operations, while C and LLVM do not, we distinguish between +-- two different kinds of pointers: Pointer for possibly tagged pointers used +-- for Wybe data structures and CPointer for untagged pointers (just raw +-- addresses) used for C and LLVM code. data TypeRepresentation - = Address -- ^ A pointer; occupies wordSize bits + = Pointer -- ^ A (possibly tagged) pointer as represented in Wybe | Bits Int -- ^ An unsigned integer representation | Signed Int -- ^ A signed integer representation | Floating Int -- ^ A floating point representation | Func [TypeRepresentation] [TypeRepresentation] -- ^ A function pointer with inputs and outputs + | CPointer -- ^ A pointer as represented in C deriving (Eq, Ord, Generic) @@ -307,7 +314,8 @@ typeRepSize (Bits bits) = bits typeRepSize (Signed bits) = bits typeRepSize (Floating bits) = bits typeRepSize (Func _ _) = wordSize -typeRepSize Address = wordSize +typeRepSize Pointer = wordSize +typeRepSize CPointer = wordSize -- | The type representation is for a (signed or unsigned) integer type @@ -664,8 +672,7 @@ getSpecModule context getter spec = do -- " matching modules under compilation" case curr of [] -> gets (maybe (error msg) getter . Map.lookup spec . modules) - [mod] -> return $ getter mod - _ -> shouldnt "getSpecModule: multiple modules with same spec" + (mod:_) -> return $ getter mod -- | Is the specified module a type? Determined by checking if it has a @@ -891,9 +898,9 @@ addConstructor vis pctor = do ++ " with declared representation" pctors <- fromMaybe [] <$> getModuleImplementationField modConstructors let redundant = - any (\c -> procProtoName c == procProtoName ctor + any ((\c -> procProtoName c == procProtoName ctor && length (procProtoParams c) == length (procProtoParams ctor)) - $ content . snd <$> pctors + . content . snd) pctors when redundant $ errmsg pos $ "Declaring constructor for type " ++ showModSpec currMod @@ -1592,15 +1599,14 @@ data ModuleImplementation = ModuleImplementation { -- ^Resources visible to this mod modKnownProcs:: Map Ident (Set ProcSpec), -- ^Procs visible to this module modForeignObjects:: Set FilePath, -- ^Foreign object files used - modForeignLibs:: Set String, -- ^Foreign libraries used - modLLVM :: Maybe LLVMAST.Module -- ^Module's LLVM representation + modForeignLibs:: Set String -- ^Foreign libraries used } deriving (Generic) emptyImplementation :: ModuleImplementation emptyImplementation = ModuleImplementation Set.empty Map.empty Nothing Map.empty Map.empty Map.empty Nothing Map.empty Map.empty Map.empty - Set.empty Set.empty Nothing + Set.empty Set.empty -- Nothing -- These functions hack around Haskell's terrible setter syntax @@ -1982,6 +1988,26 @@ transformModuleProcs trans thisMod = do (modProcs imp) }) reexitModule + +-- | Return the LPVM-form proc body, if the proc has been compiled to LPVM +procBody :: ProcDef -> Maybe ProcBody +procBody def = + case procImpln def of + ProcDefSrc{} -> Nothing + ProcDefPrim{procImplnBody=body} -> Just body + + +-- | Return all the LPVM-form proc bodies available, including the main body and +-- all specialisations. Anything that hasn't been compiled to LPVM is silently +-- omitted. +allProcBodies :: ProcDef -> [ProcBody] +allProcBodies def = + case procImpln def of + ProcDefSrc{} -> [] + ProcDefPrim{procImplnBody=body, procImplnSpeczBodies=specz} -> + body : catMaybes (Map.elems specz) + + -- |Whether this proc should definitely be inlined, either because the user said -- to, or because we inferred it would be a good idea. procInline :: ProcDef -> Bool @@ -1995,7 +2021,7 @@ getProcGlobalFlows pspec = do case procImpln pDef of ProcDefSrc _ -> let ProcProto _ params resFlows = procProto pDef - paramFlows + paramFlows | any (isResourcefulHigherOrder . paramType . content) params = UniversalSet | otherwise @@ -2192,9 +2218,9 @@ addGlobalResourceFlows (ResourceFlowSpec res flow) gFlows -- | Add a GlobalInfo to the set of global flows associated with the given flow addGlobalFlow :: GlobalInfo -> PrimFlow -> GlobalFlows -> GlobalFlows addGlobalFlow info FlowIn gFlows@GlobalFlows{globalFlowsIn=ins} - = gFlows{globalFlowsIn=whenFinite (Set.insert info) ins} + = gFlows{globalFlowsIn=USet.insert info ins} addGlobalFlow info FlowOut gFlows@GlobalFlows{globalFlowsOut=outs} - = gFlows{globalFlowsOut=whenFinite (Set.insert info) outs} + = gFlows{globalFlowsOut=USet.insert info outs} -- global flows don't use this flow type addGlobalFlow info FlowOutByReference gFlows = gFlows addGlobalFlow info FlowTakeReference gFlows = gFlows @@ -2213,9 +2239,9 @@ hasGlobalFlow GlobalFlows{globalFlowsIn=ins, globalFlowsOut=outs} flow info -- | Take the union of the sets of two global flows globalFlowsUnion :: GlobalFlows -> GlobalFlows -> GlobalFlows globalFlowsUnion (GlobalFlows ins1 outs1 params1) (GlobalFlows ins2 outs2 params2) - = GlobalFlows - (USet.union ins1 ins2) - (USet.union outs1 outs2) + = GlobalFlows + (USet.union ins1 ins2) + (USet.union outs1 outs2) (USet.union params1 params2) globalFlowsUnions :: [GlobalFlows] -> GlobalFlows @@ -2224,11 +2250,11 @@ globalFlowsUnions = List.foldr globalFlowsUnion emptyGlobalFlows -- | Take the intersection of the sets of two global flows globalFlowsIntersection :: GlobalFlows -> GlobalFlows -> GlobalFlows -globalFlowsIntersection (GlobalFlows ins1 outs1 params1) +globalFlowsIntersection (GlobalFlows ins1 outs1 params1) (GlobalFlows ins2 outs2 params2) - = GlobalFlows - (USet.intersection ins1 ins2) - (USet.intersection outs1 outs2) + = GlobalFlows + (USet.intersection ins1 ins2) + (USet.intersection outs1 outs2) (USet.intersection params1 params2) @@ -2631,6 +2657,43 @@ foldBodyDistrib primFn emptyConj abDisj abConj (ProcBody pprims fork) = $ bodies ++ maybeToList deflt +-- |Traverse a ProcBody applying a monadic primFn to every Prim and applying a +-- monadic argFn to every arg. This code does nothing to track where the +-- Prims and PrimArgs appear. +mapLPVMBodyM :: Monad m => (Prim -> m ()) -> (PrimArg -> m ()) -> ProcBody + -> m () +mapLPVMBodyM primFn argFn (ProcBody pprims fork) = do + mapM_ (mapSinglePrimM primFn argFn . content) pprims + case fork of + NoFork -> return () + (PrimFork _ _ _ bodies deflt) -> do + mapM_ (mapLPVMBodyM primFn argFn) bodies + maybe (return ()) (mapLPVMBodyM primFn argFn) deflt + + +-- |Handle a single Prim for mapLPVMBodyM doing the needful. +mapSinglePrimM :: Monad m => (Prim -> m ()) -> (PrimArg -> m ()) -> Prim -> m () +mapSinglePrimM primFn argFn prim = do + primFn prim + case prim of + PrimForeign _ _ _ args -> mapM_ (mapSinglePrimArgM primFn argFn) args + PrimCall _ _ _ args _ -> mapM_ (mapSinglePrimArgM primFn argFn) args + PrimHigher _ fn _ args -> do + mapSinglePrimArgM primFn argFn fn + mapM_ (mapSinglePrimArgM primFn argFn) args + + +-- |Handle a single PrimArg for mapLPVMBodyM doing the needful. +mapSinglePrimArgM :: Monad m => (Prim -> m ()) -> (PrimArg -> m ()) -> PrimArg + -> m () +mapSinglePrimArgM primFn argFn arg = do + argFn arg + case arg of + ArgClosure _ args _ -> + mapM_ (mapSinglePrimArgM primFn argFn) args + _ -> return () + + -- |Info about a proc call, including the ID, prototype, and an -- optional source position. data ProcSpec = ProcSpec { @@ -2811,7 +2874,7 @@ data PrimParam = PrimParam { -- |Info inferred about a single proc parameter data ParamInfo = ParamInfo { paramInfoUnneeded :: Bool, -- ^Can this parameter be eliminated? - paramInfoGlobalFlows :: GlobalFlows + paramInfoGlobalFlows :: GlobalFlows } deriving (Eq,Generic) -- |A dataflow direction: in, out, both, or neither. @@ -2828,8 +2891,14 @@ showFlowName ParamInOut = "in/output (!)" data PrimFlow = -- in or out FlowIn | FlowOut - -- Two "special" flows used to improve last-call optimization. - -- Users cannot (at present) manually refer to these flows + -- Two "special" flows used to improve last-call optimization. Users cannot + -- (at present) manually refer to these flows. FlowOutByReference denotes an + -- argument that is notionally an output, but is actually passed as an input + -- reference to the place to write the output. FlowTakeReference is + -- notionally an input, but is actually passed as an output of a pointer to + -- the place to write the input when it becomes available. These flows are + -- generated in the LastCallAnalysis module, and the transformation is + -- explained there. | FlowOutByReference | FlowTakeReference deriving (Show,Eq,Ord,Generic) @@ -3077,8 +3146,15 @@ data StringVariant = WybeString | CString -- Information about a global variable. -- A global variable is a variable that is available everywhere, --- and can be access via an LPVM load instruction, or written to via an LPVM store +-- and can be access via an LPVM load instruction, or written to via an LPVM +-- store. This is used to implement resources, or for other things represented +-- as low level global constants or variables. The latter case is used in +-- manifest constant wybe strings, which are represented as a structure holding +-- the string length and a pointer to a C-style string. Eventually we want to +-- use this for other cases of constant values appearing in Wybe code, such as a +-- constant list. data GlobalInfo = GlobalResource { globalResourceSpec :: ResourceSpec } + | GlobalVariable { globalVarSpec :: Ident } deriving (Eq, Ord, Generic) @@ -3317,13 +3393,13 @@ primGlobalFlows varFlows prim = do -- |Return the GlobalFlows of a PrimArg, given the currently known GlobalFlows -- of variables argGlobalFlow :: Map PrimVarName GlobalFlows -> PrimArg -> Compiler GlobalFlows -argGlobalFlow varFlows (ArgVar name ty _ _ _) +argGlobalFlow varFlows (ArgVar name ty _ _ _) = return $ Map.findWithDefault univGlobalFlows name varFlows argGlobalFlow varFlows (ArgClosure pspec args _) = do - params <- getPrimParams pspec + params <- getPrimParams pspec let nArgs = length args (closedParams, freeParams) = List.splitAt nArgs params - if any (\(PrimParam _ ty flow _ _) -> + if any (\(PrimParam _ ty flow _ _) -> isInputFlow flow && isResourcefulHigherOrder ty) freeParams then return univGlobalFlows else do @@ -3334,17 +3410,17 @@ argGlobalFlow _ _ = return emptyGlobalFlows -- Get the corresponding GlobalFlows and Flows of the given PrimArgs argsGlobalFlows :: Map PrimVarName GlobalFlows -> [PrimArg] -> Compiler [(GlobalFlows, PrimFlow)] -argsGlobalFlows varFlows +argsGlobalFlows varFlows = mapM (\a -> (, argFlowDirection a) <$> argGlobalFlow varFlows a) -- | Gather the effective GlobalFLows of a given set of GlobalGlows, -- using the GlobalFlows of the arguments corresponding to each parameter effectiveGlobalFlows :: [(GlobalFlows, PrimFlow)] -> GlobalFlows -> GlobalFlows -effectiveGlobalFlows argFlows primFlows@(GlobalFlows _ _ UniversalSet) +effectiveGlobalFlows argFlows primFlows@(GlobalFlows _ _ UniversalSet) = globalFlowsUnions $ primFlows{globalFlowsParams=emptyUnivSet} : List.map fst (List.filter (isInputFlow . snd) argFlows) -effectiveGlobalFlows argFlows primFlows@(GlobalFlows _ _ (FiniteSet ids)) +effectiveGlobalFlows argFlows primFlows@(GlobalFlows _ _ (FiniteSet ids)) = globalFlowsUnions $ primFlows{globalFlowsParams=emptyUnivSet} : List.map (fst . (argFlows !!)) (Set.toList ids) @@ -3355,7 +3431,9 @@ argIsVar ArgVar{} = True argIsVar _ = False --- | Test if a PrimArg is a compile-time constant. +-- | Test if a PrimArg is a compile-time constant. This can include a +-- compile-time constant pointer to mutable memory, so it doesn't mean +-- *recursively* constant. argIsConst :: PrimArg -> Bool argIsConst ArgVar{} = False argIsConst ArgInt{} = True @@ -3363,11 +3441,26 @@ argIsConst ArgFloat{} = True argIsConst ArgString{} = True argIsConst ArgChar{} = True argIsConst (ArgClosure _ as _) = all argIsConst as -argIsConst ArgGlobal{} = False -argIsConst ArgUnneeded{} = False +argIsConst ArgGlobal{} = True +argIsConst ArgUnneeded{} = True argIsConst ArgUndef{} = False +-- | Test if a PrimArg actually needs to be passed; ie, it is not a phantom type +-- and is not unneeded. +argIsReal :: PrimArg -> Compiler Bool +argIsReal ArgVar{argVarType=ty} = not <$> typeIsPhantom ty +argIsReal (ArgInt _ ty) = not <$> typeIsPhantom ty -- 0 is a valid phantom constant +argIsReal ArgFloat{} = return True +argIsReal ArgString{} = return True +argIsReal ArgChar{} = return True +argIsReal (ArgClosure _ as _) = return True +argIsReal (ArgGlobal _ ty) = not <$> typeIsPhantom ty +argIsReal ArgUnneeded{} = return False +argIsReal ArgUndef{} = return True + + + -- | Return Just the integer constant value if a PrimArg iff it is an integer -- constant. argIntegerValue :: PrimArg -> Maybe Integer @@ -3617,7 +3710,8 @@ varsInPrims dir = List.foldr (Set.union . (varsInPrim dir)) Set.empty varsInPrim :: PrimFlow -> Prim -> Set PrimVarName -varsInPrim dir prim = let (args, globals) = primArgs prim in varsInPrimArgs dir args +varsInPrim dir prim = let (args, globals) = primArgs prim + in varsInPrimArgs dir args varsInPrimArgs :: PrimFlow -> [PrimArg] -> Set PrimVarName varsInPrimArgs dir = @@ -3632,7 +3726,7 @@ varsInPrimArg _ ArgInt{} = Set.empty varsInPrimArg _ ArgFloat{} = Set.empty varsInPrimArg _ ArgString{} = Set.empty varsInPrimArg _ ArgChar{} = Set.empty -varsInPrimArg _ ArgGlobal{} = Set.empty +varsInPrimArg _ ArgGlobal{} = Set.empty varsInPrimArg _ ArgUnneeded{} = Set.empty varsInPrimArg _ ArgUndef{} = Set.empty @@ -3707,7 +3801,7 @@ instance Show Item where ++ show typeModifiers ++ showOptPos pos ++ "\n " ++ visibilityPrefix vis ++ "constructors " - ++ intercalate "\n | " + ++ intercalate "\n | " (List.map (\(vis, ctor) -> visibilityPrefix vis ++ show ctor) ctors) ++ concatMap (("\n "++) . show) items ++ "\n}\n" @@ -3774,13 +3868,14 @@ instance Show Item where -- |How to show a type representation instance Show TypeRepresentation where - show Address = "address" + show Pointer = "pointer" show (Bits bits) = show bits ++ " bit unsigned" show (Signed bits) = show bits ++ " bit signed" show (Floating bits) = show bits ++ " bit float" show (Func ins outs) = "function {" ++ intercalate ", " (List.map show outs) ++ "}" ++ "(" ++ intercalate ", " (List.map show ins) ++ ")" + show CPointer = "opaque" -- |How to show a type family @@ -3791,6 +3886,7 @@ instance Show TypeFamily where -- |How to show a ModSpec. showModSpec :: ModSpec -> String +showModSpec [] = "*main* module" showModSpec spec = intercalate "." $ (\case "" -> "``" ; m -> m) <$> spec @@ -3892,7 +3988,8 @@ showProcDefs firstID (def:defs) = -- |How to show a proc definition. showProcDef :: Int -> ProcDef -> String showProcDef thisID - procdef@(ProcDef n proto def pos _ _ _ vis detism inline impurity ctor sub _) = + procdef@(ProcDef n proto def pos tmpCount _ _ vis detism inline impurity ctor + sub _) = "\n" ++ showProcName n ++ " > " ++ visibilityPrefix vis @@ -4176,7 +4273,7 @@ instance Show StringVariant where instance Show GlobalInfo where show (GlobalResource res) = "<<" ++ show res ++ ">>" - + show (GlobalVariable res) = "@" ++ res showMap :: String -> String -> String -> (k->String) -> (v->String) @@ -4221,6 +4318,12 @@ shouldnt :: String -> a shouldnt what = error $ "Internal error: " ++ what +-- |Report an internal error and abort unless the test succeeds. +should :: String -> Bool -> () +should _ True = () +should what False = shouldnt what + + -- |Report that some feature is not yet implemented and abort. nyi :: String -> a nyi what = error $ "Not yet implemented: " ++ what @@ -4306,7 +4409,7 @@ showMessages :: Compiler () showMessages = do opts <- gets options let verbose = optVerbose opts - let noFonts = optNoFont opts + let noFonts = optNoFont opts messages <- reverse <$> gets msgs -- messages are collected in reverse order let filtered = if verbose @@ -4320,7 +4423,7 @@ showMessage :: Bool -> Message -> IO () showMessage noFont (Message lvl pos msg) = do posMsg <- makeMessage pos msg let showMsg colour msg = - if noFont + if noFont then putStrLn msg else do setSGR [SetColor Foreground Vivid colour] diff --git a/src/ASTShow.hs b/src/ASTShow.hs index fe2f9b7b5..868a82d72 100644 --- a/src/ASTShow.hs +++ b/src/ASTShow.hs @@ -16,11 +16,10 @@ import Data.List as List import Data.Set as Set import Data.Map as Map import Data.Maybe --- import Control.Monad +import Control.Monad import Control.Monad.Trans (lift,liftIO) import Control.Monad.Trans.State import System.IO -import LLVM.Pretty (ppllvm) import qualified Data.Text.Lazy as TL @@ -65,11 +64,9 @@ instance Show Module where showMap "" ", " "" (const "") showModSpec (modSubmods impl)) ++ "\n procs : " ++ "\n" ++ - (showMap "" "\n\n" "" (const "") (showProcDefs 0) - (modProcs impl)) ++ - (maybe "\n\nLLVM code : None\n" - (("\n\n LLVM code :\n\n" ++) . TL.unpack . ppllvm) - $ modLLVM impl) + showMap "" "\n\n" "" (const "") (showProcDefs 0) + (modProcs impl) ++ + "" -- |How to show a map, one line per item. @@ -86,25 +83,25 @@ showMapPoses = showMap "" ", " "" id showOptPos -- of the specified log selectors have been selected for logging. This -- is called between the passes of those two selectors. logDump :: LogSelection -> LogSelection -> String -> Compiler () -logDump = logDumpWith (const $ return Nothing) +logDump = logDumpWith (\_ _ _ _ -> return ()) --- |Dump the content of the specified module and all submodules, with the --- result of an optional action applied to each module if either of the --- specified log selectors have been selected for logging. This is called --- between the passes of those two selectors. -logDumpWith :: (Module -> Compiler (Maybe String)) +-- |Dump the content of the specified module and all submodules, using the +-- specified LLVM printer to emit the LLVM code, if either of the specified log +-- selectors have been selected for logging. This is called between the passes +-- of those two selectors. +logDumpWith :: (Handle -> ModSpec -> Bool -> Bool -> Compiler ()) -> LogSelection -> LogSelection -> String -> Compiler () -logDumpWith action selector1 selector2 pass = +logDumpWith llPrinter selector1 selector2 pass = whenLogging2 selector1 selector2 $ do modList <- gets (Map.elems . modules) dumpLib <- gets (optDumpLib . options) let toLog mod = let spec = modSpec mod in List.null spec || dumpLib || head spec /= "wybe" let logging = List.filter toLog modList - mbStrs <- mapM action logging liftIO $ hPutStrLn stderr $ replicate 70 '=' - ++ "\nAFTER " ++ pass ++ ":\n" - ++ intercalate ("\n" ++ replicate 50 '-' ++ "\n") - (zipWith (\mod mbStr -> show mod ++ maybe "" ("\n\n" ++) mbStr) - logging mbStrs) + ++ "\nAFTER " ++ pass ++ ":\n" + forM_ logging $ \mod -> do + liftIO $ hPutStrLn stderr $ "\n" ++ replicate 50 '-' ++ "\n" + ++ show mod ++ "\n\n LLVM code :\n" + llPrinter stderr (modSpec mod) False False diff --git a/src/AliasAnalysis.hs b/src/AliasAnalysis.hs index 69c37c870..67c7533ea 100644 --- a/src/AliasAnalysis.hs +++ b/src/AliasAnalysis.hs @@ -344,10 +344,9 @@ _maybeAliasPrimArgs args = do ArgGlobal global ty -> maybeAddressAlias arg ty $ AliasByGlobal global _ -> return Nothing maybeAddressAlias arg ty item = do - isPhantom <- argIsPhantom arg rep <- lookupTypeRepresentation ty - -- Only Address type will create alias - if not isPhantom && rep == Just Address + -- Only Pointer types will create alias + if rep == Just Pointer then return $ Just item else return Nothing @@ -574,12 +573,12 @@ updateMultiSpeczDepInfo multiSpeczDepInfo callSiteID pSpec items = -- XXX currently it relies on the size arg of the access instruction. Another -- way (much more flexible) to do it is introducing some lpvm instructions -- that do nothing and only provide information for the compiler. --- XXX call "GC_free" on large unused dead cells. +-- TODO call "GC_free" on large unused dead cells. -- (according to https://github.com/ivmai/bdwgc, > 8 bytes) --- XXX we'd like this analysis to detect structures that are dead aside from +-- TODO we'd like this analysis to detect structures that are dead aside from -- later access instructions, which could be moved earlier to allow the -- structure to be reused. --- XXX consider re-run the optimiser after this or even run this before the +-- TODO consider re-run the optimiser after this or even run this before the -- optimiser. diff --git a/src/BinaryFactory.hs b/src/BinaryFactory.hs index 8a2788f76..7f3b6c69e 100644 --- a/src/BinaryFactory.hs +++ b/src/BinaryFactory.hs @@ -12,12 +12,10 @@ import AST import Control.Monad import Crypto.Hash import Data.Binary as B --- import qualified Data.ByteString.Char8 as BL import Config (magicVersion) import UnivSet import qualified Data.ByteString.Lazy as BL import qualified Data.List as List -import qualified LLVM.AST as LLVMAST import Text.Parsec.Pos (SourcePos, newPos, sourceColumn, sourceLine, sourceName) import Util @@ -95,18 +93,6 @@ instance Binary SourcePos where get = liftM3 newPos get get get -instance Binary LLVMAST.Definition where - put = put . show - get = do def <- get - return (read def :: LLVMAST.Definition) - -instance Binary LLVMAST.Module where - put = put . show - get = do def <- get - return (read def :: LLVMAST.Module) - - - -- * Encoding diff --git a/src/Blocks.hs b/src/Blocks.hs deleted file mode 100644 index 10941c52f..000000000 --- a/src/Blocks.hs +++ /dev/null @@ -1,1710 +0,0 @@ --- File : Blocks.hs --- Author : Ashutosh Rishi Ranjan --- Purpose : Transform a clausal form (LPVM) module to LLVM --- Copyright: (c) 2015-2019 Peter Schachte. All rights reserved. --- License : Licensed under terms of the MIT license. See the file --- : LICENSE in the root directory of this project. - -{-# LANGUAGE TupleSections #-} - -module Blocks (concatLLVMASTModules, blockTransformModule, - llvmMapBinop, llvmMapUnop - ) where - -import AST -import Debug.Trace -import ASTShow -import BinaryFactory -import Codegen -import Resources -import Config (wordSize, wordSizeBytes) -import Util (maybeNth, lift2, - (|||), (&&&)) -import Snippets -import Control.Monad as M -import Control.Monad.Extra (ifM) -import Control.Monad.Trans (lift, liftIO) -import Control.Monad.Trans.Class -import Control.Monad.Trans.Except -import Control.Monad.Trans.State -import Data.Char (ord) -import Data.Foldable -import Data.List as List -import Data.List.Predicate -import Data.Map as Map -import qualified Data.Set as Set -import Data.String -import Data.Functor ((<&>)) -import Data.Word (Word32) -import Data.Maybe (fromMaybe, isJust, catMaybes, isNothing, maybeToList) -import Flow ((|>)) -import qualified LLVM.AST as LLVMAST -import qualified LLVM.AST.Constant as C -import qualified LLVM.AST.Float as F -import qualified LLVM.AST.FloatingPointPredicate as FP -import qualified LLVM.AST.Global as G -import LLVM.AST.Instruction -import qualified LLVM.AST.IntegerPredicate as IP -import LLVM.AST.Operand hiding (PointerType, operands) -import LLVM.AST.Type -import LLVM.AST.Typed -import qualified LLVM.AST.Attribute as A (FunctionAttribute(..)) -import LLVM.Pretty (ppllvm) - -import qualified Data.ByteString as BS -import qualified Data.ByteString.Char8 as B8 -import qualified Data.ByteString.Lazy as BL -import qualified Data.ByteString.Short as BSS -import Options (LogSelection (Blocks)) -import Unsafe.Coerce -import System.FilePath -import qualified UnivSet -import Control.Exception (assert) -import Data.Set (Set) - --- | Holds information on the LLVM representation of the LPVM procedure. -data ProcDefBlock = - ProcDefBlock { blockProto :: PrimProto - , blockDef :: LLVMAST.Definition - } deriving (Show, Eq) - - --- | Transform the module's procedures (in LPVM by now) into LLVM function --- definitions. A LLVMAST.Module is built up using these global definitions --- and then stored in the modLLVM field of 'ModuleImplementation'. --- Before translation of ProcDefs, all the prototypes of the ProcDef's LPVM --- form is collected, along with the same for all the imported modules. --- This is passed along to the codegen monad so that Primitive calls to these --- procedures can the prototype checked (match and eliminate unneeded --- arguments in cgen.) -blockTransformModule :: ModSpec -> Compiler () -blockTransformModule thisMod = do - reenterModule thisMod - logBlocks $ "*** Translating Module: " ++ showModSpec thisMod - modRec <- getModule id - modFile <- getSource - logWrapWith '-' $ show modRec - procs <- getModuleImplementationField (Map.elems . modProcs) - -- Collect all procedure prototypes in the module - let protos = List.map extractLPVMProto (concat procs) - -------------------------------------------------- - -- Collect prototypes of imported modules - imports <- getModuleImplementationField (keys . modImports) - importProtos <- mapM getPrimProtos - (List.filter (not . isStdLib) imports) - let allProtos = protos ++ concat importProtos - - logBlocks $ "Prototypes:\n\t" - ++ intercalate "\n\t" (List.map show allProtos) - -------------------------------------------------- - -- Listing all known types - knownTypesSet <- Map.elems <$> - getModuleImplementationField modKnownTypes - let knownTypes = concatMap Set.toList knownTypesSet - trs <- mapM moduleLLVMType knownTypes - -- typeList :: [(TypeSpec, LLVMAST.Type)] - let typeList = zip knownTypes trs - -- log the assoc list typeList - logWrapWith '.' $ "Known Types:\n" ++ intercalate "\n" ( - List.map (\(a,b) -> show a ++ ": " ++ show b) typeList) - - -------------------------------------------------- - -- Name mangling - let mangledProcs = concat $ mangleProcs <$> procs - - -------------------------------------------------- - -- Translate - (procBlocks, txState) <- mapM translateProc mangledProcs - `runStateT` emptyTranslation - - let procBlocks' = List.concat procBlocks - -------------------------------------------------- - - let resDefs = modResources $ trustFromJust "blockTransformModule" - $ modImplementation modRec - let ress = concat $ Map.keys <$> Map.elems resDefs - llmod <- newLLVMModule (showModSpec thisMod) modFile procBlocks' txState ress - updateImplementation (\imp -> imp { modLLVM = Just llmod }) - logBlocks $ "*** Translated Module: " ++ showModSpec thisMod - modRec' <- getModule id - logWrapWith '-' $ show modRec' - reexitModule - logBlocks $ "*** Finished Translating Module " ++ showModSpec thisMod ++ " ***" - - --- |Affix its id number to the end of each proc name -mangleProcs :: [ProcDef] -> [ProcDef] -mangleProcs ps = zipWith mangleProc ps [0..] - - -mangleProc :: ProcDef -> Int -> ProcDef -mangleProc def i = - let proto = procImplnProto $ procImpln def - s = primProtoName proto - pname = s ++ "<" ++ show i ++ ">" - newProto = proto {primProtoName = pname} - in - def {procImpln = (procImpln def){procImplnProto = newProto}} - - - --- mangleProcs :: [ProcDef] -> [ProcDef] --- mangleProcs ps = changeNameWith nameMap ps --- where --- nameMap = buildNameMap ps - - --- changeNameWith :: [(String, Int)] -> [ProcDef] -> [ProcDef] --- changeNameWith [] [] = [] --- changeNameWith ((s,i):ns) (p:ps) = --- let (ProcDefPrim proto body) = procImpln p --- pname = s ++ "<" ++ show i ++ ">" --- newProto = proto {primProtoName = pname} --- newImpln = ProcDefPrim newProto body --- in p {procImpln = newImpln} : changeNameWith ns ps --- changeNameWith _ _ = shouldnt "Incorrect name map used for mangling." - --- buildNameMap :: [ProcDef] -> [(String, Int)] --- buildNameMap ps = List.foldl reduceNameMap [] procNames --- where --- procNames = List.map pullDefName ps - --- reduceNameMap :: [(String, Int)] -> String -> [(String, Int)] --- reduceNameMap namemap name = --- case List.lookup name namemap of --- Just val -> namemap ++ [(name, val + 1)] --- Nothing -> namemap ++ [(name, 0)] - - --- pullDefName :: ProcDef -> String --- pullDefName p = --- let (ProcDefPrim proto _) = procImpln p --- in primProtoName proto - - --- | Extract the LPVM compiled primitive from the procedure definition. -extractLPVMProto :: ProcDef -> PrimProto -extractLPVMProto procdef = - case procImpln procdef of - ProcDefPrim{procImplnProto = proto} -> proto - uncompiled -> - shouldnt $ "Proc reached backend uncompiled: " ++ show uncompiled - --- | Go into a (compiled) Module and pull out the PrimProto implementation --- of all ProcDefs in the module implementation. -getPrimProtos :: ModSpec -> Compiler [PrimProto] -getPrimProtos modspec = do - (_, procs) <- unzip . Map.toList . modProcs <$> - getLoadedModuleImpln modspec - let protos = List.map extractLPVMProto (concat procs) - return protos - --- | Filter for avoiding the standard library modules -isStdLib :: ModSpec -> Bool -isStdLib [] = False -isStdLib (m:_) = m == "wybe" - - - --- | Translate a ProcDef whose procImpln field is of the type ProcDefPrim, to --- ProcDefBlocks (LLVM form). Each ProcDef is converted into a Global --- Definition in a LLVM Module by translating it's primitives. Translated --- procedures (ProcDefBlocks ...) can optionally have a list of extern --- declarations (which are also global definitions) if any primitive is going --- to call some foreign function (mostly C). Translated procedures will also --- require some global variable/constant declarations which is represented as --- G.Global values in the neededGlobalVars field of LLVMCompstate. All in all, --- externs and globals go on the top of the module. -translateProc :: ProcDef -> Translation [ProcDefBlock] -translateProc proc = do - let impln = procImpln proc - let proto = procImplnProto impln - let speczBodies = procImplnSpeczBodies impln - -- translate the standard version - block <- _translateProcImpl proc - -- translate the specialized versions - let speczBodies' = speczBodies - |> Map.toList - |> List.map (\(ver, body) -> - let msg = "Required specialized version should be \ - \ generated by now" in - (speczVersionToId ver, trustFromJust msg body)) - -- Make sure there aren't collision in specz version id. If such thing - -- happened, we may consider increasing the length of id (more in AST.hs). - let hasDuplicates l = List.length l /= (Set.size . Set.fromList) l - when (hasDuplicates (List.map fst speczBodies')) - $ shouldnt $ "Specz version id conflicts" - ++ show (List.map fst speczBodies') - blocks <- mapM (\(id, currBody) -> - -- rename this version of proc - let pname = primProtoName proto ++ "[" ++ id ++ "]" - proto' = proto {primProtoName = pname} - in _translateProcImpl proc{procImpln=impln{procImplnProto = proto', - procImplnBody=currBody}} - ) speczBodies' - return $ block:blocks - - --- Helper for `translateProc`. Translate the given `ProcBody` --- (A specialized version of a procedure). -_translateProcImpl :: ProcDef -> Translation ProcDefBlock -_translateProcImpl proc@ProcDef{procVariant=variant, - procImpln=(ProcDefPrim _ proto body _ _)} = do - let (proto', body') = if isClosureVariant variant - then closeClosure proto body - else (proto, body) - modspec <- lift getModuleSpec - lift $ do - logBlocks $ "\n" ++ replicate 70 '=' ++ "\n" - logBlocks $ "In Module: " ++ showModSpec modspec - ++ ", creating definition of:\n\n" - logBlocks $ show proto' - ++ showBlock 4 body' - ++ "\n" ++ replicate 50 '-' ++ "\n" - codestate <- doCodegenBody body' `execStateT` emptyCodegen proto' - let blocks = createBlocks codestate - lldef <- lift $ makeGlobalDefinition proc proto' blocks - lift $ logBlocks $ show lldef - return $ ProcDefBlock proto lldef -_translateProcImpl ProcDef{procImpln=ProcDefSrc{}} = shouldnt "_translateProcImpl on source" - --- | Updates a PrimProto and ProcBody as though the Free Params are accessed --- via the closure environment -closeClosure :: PrimProto -> ProcBody -> (PrimProto, ProcBody) -closeClosure proto@PrimProto{primProtoParams=params} - body@ProcBody{bodyPrims=prims} = - (proto{primProtoParams= - envPrimParam:(setPrimParamType AnyType <$> actualParams)}, - body{bodyPrims=unpacker ++ prims}) - where - (free, actualParams) = List.partition ((==Free) . primParamFlowType) params - neededFree = List.filter (not . paramInfoUnneeded - . primParamInfo) free - unpacker = Unplaced <$> - [ primAccess (ArgVar envParamName AnyType FlowIn Ordinary False) - (ArgInt (i * toInteger wordSizeBytes) intType) - (ArgInt (toInteger wordSize) intType) - (ArgInt 0 intType) - (ArgVar nm ty FlowOut Free False) - | (i,PrimParam nm ty _ _ _) <- zip [1..] neededFree ] - - --- | Create LLVM's module level Function Definition from the LPVM procedure --- prototype and its body as a list of BasicBlock(s). The return type of such --- a definition is decided based on the Ouput parameter of the procedure, or --- is made to be phantom. -makeGlobalDefinition :: ProcDef -> PrimProto - -> [LLVMAST.BasicBlock] - -> Compiler LLVMAST.Definition -makeGlobalDefinition proc proto bls = do - modName <- showModSpec <$> getModuleSpec - let label0 = modName ++ "." ++ primProtoName proto - -- For the top-level main program - let isMain = label0 == ".<0>" - let (label,isForeign) = if isMain then ("main",True) else (label0,False) - fnargs <- protoLLVMArguments proto - retty <- protoLLVMOutputType proto - let attrs = procLLVMFuncAttrs proc - return $ globalDefine isForeign retty label fnargs attrs bls - --- | Convert a primitive's input parameter to LLVM's Definition parameter. -makeFnArg :: PrimParam -> Compiler (Type, LLVMAST.Name) -makeFnArg param = do - ty <- primParamLLVMType param - let nm = LLVMAST.Name $ toSBString $ show $ primParamName param - return (ty, nm) - -type LLVMCallSignature = ([Type], Type) - -getLLVMSignature :: PrimProto -> Compiler LLVMCallSignature -getLLVMSignature proto = do - out <- protoLLVMOutputType proto - args <- protoLLVMArguments proto - return (List.map fst args, out) - -protoLLVMArguments :: PrimProto -> Compiler [(Type, LLVMAST.Name)] -protoLLVMArguments proto = do - inputs <- protoRealParamsWhere paramGoesIn proto - mapM makeFnArg inputs - --- | Open the Out parameter of a primitive (if there is one) into it's --- inferred 'Type' and name. -protoLLVMOutputType :: PrimProto -> Compiler Type -protoLLVMOutputType proto = do - outputs <- protoRealParamsWhere paramGoesOut proto - outTys <- mapM primParamLLVMType outputs - primReturnLLVMType outTys - -procLLVMFuncAttrs :: ProcDef -> [A.FunctionAttribute] -procLLVMFuncAttrs ProcDef{procInlining=MayInline} = [] -procLLVMFuncAttrs ProcDef{procInlining=Inline} = [A.AlwaysInline] -procLLVMFuncAttrs ProcDef{procInlining=NoInline} = [A.NoInline] - ----------------------------------------------------------------------------- --- Body Compilation -- ----------------------------------------------------------------------------- - --- | Compile a Procedure Body containing primitives to a list of llvm basic --- blocks, the operand generated by the last block will be the terminitor's --- emitted value. The parameters of the procedure will all enter the local --- scope by being referenced on the symbol table (including the output --- parameter). This is useful in leveraging the existing SSA form in the LPVM --- rather than generating more unique names. Mostly all primitive's variable --- arguments can be resolved from the symbol table. Each procedure might also --- need some module level extern declarations and global constants which are --- pulled and recorded, to be defined later when the whole module is built. --- | Generate LLVM instructions for a procedure. -doCodegenBody :: ProcBody -> Codegen () -doCodegenBody body = do - entry <- addBlock entryBlockName - -- Start with creation of blocks and adding instructions to it - setBlock entry - proto <- gets cgProto - params <- lift2 $ protoRealParams proto - let (ins,outs) = List.partition paramGoesIn params - mapM_ assignParam ins - -- This handles the fact that some outputs are not defined on failing branches, - -- by initialising all outputs to `Undef` at the start of the proc. - mapM_ preassignOutput outs - -- Codegen on body prims - codegenBody body - --- | Convert a PrimParam to an Operand value and reference this value by the --- param's name on the symbol table. Don't assign if phantom. -assignParam :: PrimParam -> Codegen () -assignParam p@PrimParam{primParamType=ty, primParamFlow = paramFlow } = do - trep <- typeRep' ty - logCodegen $ "Maybe generating parameter " ++ show p - ++ " (" ++ show trep ++ ")" - unless (repIsPhantom trep || paramInfoUnneeded (primParamInfo p)) - $ do - let nm = show (primParamName p) - llty <- lift2 $ primParamLLVMType p - modifySymtab nm (localVar llty nm) - --- | Convert a PrimParam to an Operand value and reference this value by the --- param's name on the symbol table. Don't assign if phantom -preassignOutput :: PrimParam -> Codegen () -preassignOutput p = do - let nm = show (primParamName p) - llty <- lift2 $ primParamLLVMType p - modifySymtab nm (cons $ C.Undef llty) - - --- | Retrive or build the output operand from the given parameters. --- For no valid ouputs, return Nothing --- For 1 single output, retrieve it's assigned operand from the symbol --- table, and for multiple outputs, generate code for creating an valid --- structure, pack the operands into it and return it. -buildOutputOp :: Codegen (Maybe Operand) -buildOutputOp = do - proto <- gets cgProto - outParams <- lift2 $ protoRealParamsWhere paramGoesOut proto - logCodegen $ "OutParams: " ++ show outParams - outputs <- mapM (liftM3 castVar primParamName primParamType primParamFlow) outParams - logCodegen $ "Built outputs from symbol table: " ++ show outputs - case outputs of - -- No valid output - [] -> return Nothing - -- single output case - [single] -> return $ Just single - -- multiple output case - _ -> Just <$> structPack outputs - - --- | Pack operands into a structure through a sequence of insertvalue --- instructions. -structPack :: [Operand] -> Codegen Operand -structPack ops = do - let opTypes = List.map typeOf ops - let strType = struct_t opTypes - let strCons = cons $ C.Undef strType - sequentialInsert ops strType strCons 0 - - --- | Helper for structInsert to properly and sequentially index each --- operand into the structure. --- Sequentially call the insertvalue instruction to add each --- of the given operand into a new structure type. Each call to the --- insertvalue instruction would return a new structure which should be --- used for the next insertion at the next index. -sequentialInsert :: [Operand] -> Type -> - Operand -> Word32 -> Codegen Operand -sequentialInsert [] _ finalStruct _ = return finalStruct -sequentialInsert (op:ops) ty struct i = do - newStruct <- instr ty $ insertvalue struct op i - sequentialInsert ops ty newStruct (i + 1) - - -structUnPack :: Operand -> Codegen [Operand] -structUnPack st = case typeOf st of - StructureType { elementTypes = tys } -> do - let n = (fromIntegral $ length tys) :: Word32 - let ins = List.map (extractvalue st) [0..n-1] - zipWithM instr tys ins - _ -> shouldnt "expected struct to unpack" - - --- | Generate basic blocks for a procedure body. -codegenBody :: ProcBody -> Codegen () -codegenBody body = do - let prims = List.map content (bodyPrims body) - case bodyFork body of - NoFork -> do - cgen prims True - M.void $ ret =<< buildOutputOp - PrimFork var ty _ fbody deflt -> do - cgen prims False - codegenFork var ty fbody deflt - - --- | Code generation for a conditional branch. --- XXX revise when LPVM can be transformed to have n>3-ary branches -codegenFork :: PrimVarName -> TypeSpec -> [ProcBody] -> Maybe ProcBody - -> Codegen () -codegenFork _ _ [] _ = shouldnt "fork with no branches" -codegenFork _ _ [body] Nothing = codegenBody body -codegenFork var ty [bElse,bThen] Nothing = do - ifThen <- addBlock "if.then" - ifElse <- addBlock "if.else" - brOp <- castVar var ty FlowIn - cbr brOp ifThen ifElse - codegenForkBody ifThen bThen - codegenForkBody ifElse bElse -codegenFork var ty bodies deflt = do - let bodies' = bodies ++ maybeToList deflt - let nBodies = length bodies' - let blockPrefix = "switch." ++ show nBodies ++ "." - names <- mapM (addBlock . (blockPrefix ++) . show) - [0..nBodies-1] - brOp <- castVar var ty FlowIn - let bits = getBits $ typeOf brOp - switch brOp (last names) (zip (C.Int bits <$> [0..]) names) - zipWithM_ codegenForkBody names bodies' - - --- | Code generation for the fork of a conditional branch -codegenForkBody :: LLVMAST.Name -> ProcBody -> Codegen () -codegenForkBody name body = - preservingSymtab $ do - setBlock name - codegenBody body - - --- | Translate a Primitive statement (in clausal form) to a LLVM instruction. --- Foreign calls are resolved through numerous instruction maps which map --- function name to a correspoinding LLVM instruction wrapper defined in --- 'Codegen'. Two main maps are the ones containing Binary and Unary --- instructions respectively. Adding each matched instruction to the --- BasicBlock creates a resulting Operand. --- --- PrimCall: CodegenState contains the list of all the Prim prototypes defined --- in the current module and imported modules. All primitive calls' arguments --- are position checked with the respective prototype, eliminating arguments --- which do not eventually appear in the prototype. -cgen :: [Prim] -> Bool -> Codegen () -cgen (prim@(PrimCall callSiteID pspec _ args _):nextPrims) isLeaf = do - logCodegen $ "--> Compiling " ++ show prim - let nm = LLVMAST.Name $ toSBString $ show pspec - -- Find the prototype of the pspec being called - -- and match it's parameters with the args here - -- and remove the unneeded ones. - callerProto <- gets cgProto - calleeProto <- lift2 $ getProcPrimProto pspec - logCodegen $ "Proto = " ++ show calleeProto - args' <- prepareArgs args (primProtoParams calleeProto) - logCodegen $ "Prepared args = " ++ show args' - - -- If this call was marked with `tail`, then we generate the remaining prims - -- *before* the call instruction. - nextPrims' <- cgenTakeReferences nextPrims - let isTailPosition = List.null nextPrims' && isLeaf - - -- if the call is to an external module, declare it - addExternProc pspec - - let (inArgs,outArgs) = partitionArgs args' - logCodegen $ "In args = " ++ show inArgs - - (inops, allocaTracking) <- cgenArgsFull inArgs - - outTy <- lift2 $ primReturnType outArgs - callerSignature <- lift2 $ getLLVMSignature callerProto - calleeSignature <- lift2 $ getLLVMSignature calleeProto - let tailCall = getTailCallHint isTailPosition allocaTracking outTy callerSignature calleeSignature - logCodegen $ "Tail call kind = " ++ show tailCall ++ " (isTailPosition=" ++ show isTailPosition ++ " allocaTracking=" ++ show allocaTracking ++ " outTy=" ++ show outTy ++ " callerSignature=" ++ show callerSignature ++ " calleeSignature=" ++ show calleeSignature ++ ")" - - logCodegen $ "Translated inputs = " ++ show inops - logCodegen $ "Out ty = " ++ show outTy - let funcRef = externf (ptr_t (FunctionType outTy (typeOf <$> inops) False)) nm - let callIns = callWybe tailCall funcRef inops - logCodegen $ "Translated ins = " ++ show callIns - addInstruction callIns outArgs - - -- We may need to generate "load" instructions after this call to grab - -- the underlying values written to by these `outByReference` pointers. - mapM_ (cgenMaybeLoadReference isTailPosition) args' - - -- Generate the remaining prims in the block - cgen nextPrims' isLeaf - -cgen (prim@(PrimHigher cId (ArgClosure pspec closed _) impurity args):ps) isLeaf - = do - pspec' <- fromMaybe pspec <$> lift2 (maybeGetClosureOf pspec) - globalFlows <- lift2 $ getProcGlobalFlows pspec' - logCodegen $ "Compiling " ++ show prim - ++ " as first order call to " ++ show pspec' - ++ " closed over " ++ show closed - cgen (PrimCall cId pspec' impurity (closed ++ args) globalFlows : ps) isLeaf - -cgen [] _ = return () -cgen (p:ps) isLeaf = do - cgenPrim p - cgen ps isLeaf - -cgenPrim :: Prim -> Codegen () -cgenPrim prim@(PrimHigher callSiteId - fn@ArgVar{argVarType=ty@(HigherOrderType mods _)} _ args) = do - logCodegen $ "--> Compiling " ++ show prim - -- If a HO call only produces phantoms, no need to call it - allPhantoms <- and <$> lift2 (mapM argIsPhantom $ snd $ partitionArgs args) - unless (allPhantoms && not (isResourcefulHigherOrder ty) - && modifierImpurity mods <= Pure) $ do - args' <- mapM fixHigherOrderArg args - let (inArgs, outArgs) = partitionArgs args' - inOps@(env:_) <- mapM cgenArg $ fn:inArgs - logCodegen $ "In args = " ++ show inOps - fnPtrTy <- llvmClosureType (argType fn) - let addrPtrTy = ptr_t address_t - envPtr <- inttoptr env addrPtrTy - eltPtr <- doLoad address_t envPtr - fnPtr <- doCast eltPtr fnPtrTy - --- XXX: Tail could cause undef-behaviour in optimizer if the callee - --- user allocas from the caller. Double check this is okay. - let callIns = callWybe (Just LLVMAST.Tail) fnPtr inOps - addInstruction callIns outArgs - -cgenPrim prim@(PrimHigher _ fn _ _) = - shouldnt $ "cgen higher call to " ++ show fn - -cgenPrim prim@(PrimForeign "llvm" name flags args) = do - logCodegen $ "--> Compiling " ++ show prim - args' <- filterPhantomArgs args - case partitionArgs args' of - ([], []) | name == "move" -> return () -- move phantom to phantom - ([a], [b]) -> cgenLLVMUnop name flags a b - ([a, b], [c]) -> cgenLLVMBinop name flags a b c - _ -> shouldnt $ "LLVM instruction " ++ name - ++ " with wrong arity (" ++ show (length args') ++ ")!" - -cgenPrim prim@(PrimForeign "lpvm" name flags args) = do - logCodegen $ "--> Compiling " ++ show prim - args' <- filterPhantomArgs args - cgenLPVM name flags args' - -cgenPrim prim@(PrimForeign lang name flags args) = do - logCodegen $ "--> Compiling " ++ show prim - when (lang /= "c") $ - shouldnt $ "Unknown foreign language " ++ lang ++ " in call " ++ show prim - args' <- filterPhantomArgs args - addExtern $ PrimForeign lang name flags args' - let (inArgs,outArgs) = partitionArgs args' - let nm = LLVMAST.Name $ toSBString name - inops <- mapM cgenArg inArgs - outty <- lift2 $ primReturnType outArgs - -- XXX this ignores lang and just uses C calling conventions for all calls - let ins = - callC - (externf (ptr_t (FunctionType outty (typeOf <$> inops) False)) nm) - inops - addInstruction ins outArgs - -cgenPrim prim@PrimCall {} = shouldnt "calls should be handled by `cgen`" - - --- | We use a number of indicators to choose the best TailCallKind where possible. --- In the best case, the call is marked `musttail`, which signals LLVM must --- tail-call-optimize, or else will throw an error. --- `tail` is just a hint that LLVM "can" tail-call optimize but doesn't have to. --- However there are certain restrictions on when these hints. LLVM may optimize --- our code incorrectly (or crash) if we get this wrong. -getTailCallHint :: Bool -> AllocaTracking -> LLVMAST.Type -> LLVMCallSignature -> LLVMCallSignature -> Maybe LLVMAST.TailCallKind --- Oh no! There is an `outByReference` argument which points to an `alloca`. --- The LLVM language reference dictates that we are not allowed to add --- `tail` or `musttail` in this case -getTailCallHint _ DoesAlloca _ _ _ = Nothing --- Although this call is in LPVM tail position, we'll need to add some --- `extractvalue` instrs after this call, so it won't be in LLVM --- tail position, thus we cannot use `musttail` -getTailCallHint True NoAlloca StructureType {} _ _ = Just LLVMAST.Tail --- Although this call is in LPVM tail position, the signatures of the --- the caller and callee may not match , thus according to LLVM --- language reference we aren't allowed to use `musttail`. --- XXX: LLVM version >= 13.0.0 relaxes this restriction -getTailCallHint True NoAlloca _ callerSignature calleeSignature | callerSignature /= calleeSignature = Just LLVMAST.Tail --- We know this LLVM call will be in LLVM tail position (since scalar/void --- return type), and also we don't refer to any allocas to in the caller. -getTailCallHint True NoAlloca _ _ _ = Just LLVMAST.MustTail --- This function isn't in LPVM tail position, --- but we know it doesn't take any arguments which were created by allocas --- in the caller. -getTailCallHint False NoAlloca _ _ _ = Just LLVMAST.Tail - - --- | Fix a higher order call argument. Transforms an input phantom into an ArgUndef, --- and all types into AnyType -fixHigherOrderArg :: PrimArg -> Codegen PrimArg -fixHigherOrderArg arg@ArgVar{argVarType=ty, argVarFlow=FlowIn} = - ifM (lift2 $ argIsPhantom arg) - (return $ ArgUndef AnyType) - (return $ setArgType AnyType arg) -fixHigherOrderArg arg = return $ setArgType AnyType arg - - --- | Translate a Binary primitive procedure into a binary llvm instruction, --- add the instruction to the current BasicBlock's instruction stack and emit --- the resulting Operand. Reads the 'llvmMapBinop' Map. The primitive --- arguments are split into inputs and outputs (according to their flow --- type). The output argument is used to name and reference the resulting --- Operand of the instruction. -cgenLLVMBinop :: ProcName -> [Ident] -> PrimArg -> PrimArg -> PrimArg -> Codegen () -cgenLLVMBinop name flags inArg1 inArg2 outArg = do - inOp1 <- cgenArg inArg1 - inOp2 <- cgenArg inArg2 - case Map.lookup (withFlags name flags) llvmMapBinop of - Just (f,_,_) -> addInstruction (f inOp1 inOp2) [outArg] - Nothing -> shouldnt $ "LLVM Instruction not found: " ++ name - - --- | Similar to 'cgenLLVMBinop', but for unary operations on the --- 'llvmMapUnary'. There is no LLVM move instruction, a special case has to --- be made for it. The special move instruction takes one input const/var --- param, one output variable, and assigns the output variable operand the --- input operand at the front of the symbol table. The next time the output --- name is referenced, the symbol table will return the latest assignment to --- it. -cgenLLVMUnop :: ProcName -> [Ident] -> PrimArg -> PrimArg -> Codegen () -cgenLLVMUnop "move" flags input output = do - inRep <- typeRep' $ argType input - inop <- cgenArg input - assign (pullName output) inop - -cgenLLVMUnop name flags inArg outArg = - case Map.lookup name llvmMapUnop of - Just (f,_,_) -> do - inOp <- cgenArg inArg - outTy <- lift2 $ argLLVMType outArg - addInstruction (f inOp outTy) [outArg] - Nothing -> shouldnt $ "Unknown unary LLVM Instruction " ++ name - - --- | Match PrimArgs with the parameters in the given prototype. If a PrimArg's --- counterpart in the prototype is unneeded, filtered out. Arguments --- are matched positionally, and are coerced to the type of corresponding --- parameters. -prepareArgs :: [PrimArg] -> [PrimParam] -> Codegen [PrimArg] -prepareArgs [] [] = return [] -prepareArgs [] (_:_) = shouldnt "more parameters than arguments" -prepareArgs (_:_) [] = shouldnt "more arguments than parameters" -prepareArgs (ArgUnneeded _ _:as) (p:ps) - | paramIsNeeded p = shouldnt $ "unneeded arg for needed param " ++ show p - | otherwise = prepareArgs as ps -prepareArgs (a:as) (p@PrimParam{primParamType=ty}:ps) | argFlowDirection a == primParamFlow p = do - real <- lift2 $ paramIsReal p - rest <- prepareArgs as ps - return $ if real then setArgType ty a:rest else rest -prepareArgs (a:as) (p:ps) = do - shouldnt $ "incompatible flows: invocation=" ++ show (argFlowDirection a) ++ " definition: " ++ show (primParamFlow p) - -cgenMaybeLoadReference :: Bool -> PrimArg -> Codegen () -cgenMaybeLoadReference callIsTailPosition arg@ArgVar { argVarName = name, argVarType = ty, argVarFlow = FlowOutByReference } = do - proto <- gets cgProto - outParams <- lift2 $ protoRealParamsWhere paramGoesOut proto - let outParamNames = List.map primParamName outParams - let isFlowOutParam = name `elem` outParamNames - logCodegen $ "determining whether to `load` " ++ show name ++ " after call. callIsTailPosition=" ++ show callIsTailPosition ++ " isFlowOutParam=" ++ show isFlowOutParam - when (not callIsTailPosition || isFlowOutParam) $ do - -- This call isn't in LPVM tail position, - -- or the output was one of the outputs of the overall proc. - -- In this case, we need to perform the load - op <- maybeGetVar $ show (getRefName name) - op' <- maybeGetVar $ show name - var <- case (op, op') of - -- the corresponding shadow variable `[name]#ref` exists - (Just var, _) -> return var - -- the shadow `[name]#ref` variable wasn't created, so instead - -- we load `[name]` directly - (Nothing, Just var) -> return var - _ -> shouldnt $ show name ++ "not defined - when loading reference after call" - logCodegen $ "doing `load` after call: " ++ show var - outTy <- lift2 $ argLLVMType arg { argVarFlow = FlowOut } - loadOp <- doLoad outTy var - modifySymtab (show name) loadOp -cgenMaybeLoadReference _ _ = return () - -filterPhantomArgs :: [PrimArg] -> Codegen [PrimArg] -filterPhantomArgs = filterM ((not <$>) . lift2 . argIsPhantom) - - --- | Code generation for LPVM instructions. -cgenLPVM :: ProcName -> [Ident] -> [PrimArg] -> Codegen () -cgenLPVM "alloc" _ args@[sizeArg,addrArg] = do - logCodegen $ "lpvm alloc " ++ show sizeArg ++ " " ++ show addrArg - let (inputs,outputs) = partitionArgs args - case inputs of - [input] -> do - outTy <- lift2 $ argLLVMType addrArg - op <- gcAllocate sizeArg outTy - assign (pullName addrArg) op - _ -> - shouldnt $ "alloc instruction with " ++ show (length inputs) - ++ " inputs" - -cgenLPVM "access" _ args@[addrArg,offsetArg,_,_,val] = do - logCodegen $ "lpvm access " ++ show addrArg ++ " " ++ show offsetArg - ++ " " ++ show val - baseAddr <- cgenArg addrArg - finalAddr <- offsetAddr baseAddr iadd offsetArg - outTy <- lift2 $ argLLVMType val - logCodegen $ "outTy = " ++ show outTy - op <- gcAccess finalAddr outTy - assign (pullName val) op - -cgenLPVM "mutate" flags - [addrArg, outArg, offsetArg, ArgInt 0 intTy, sizeArg, startOffsetArg, - valArg] | argFlowDirection valArg == FlowIn = do - -- Non-destructive case: copy structure before mutating - logCodegen $ "lpvm mutate " ++ show addrArg - ++ " " ++ show outArg - ++ " " ++ show offsetArg ++ " *nondestructive*" - ++ " " ++ show sizeArg - ++ " " ++ show startOffsetArg - ++ " " ++ show valArg - -- First copy the structure - outTy <- lift2 $ argLLVMType addrArg - allocAddr <- gcAllocate sizeArg outTy - outAddr <- offsetAddr allocAddr iadd startOffsetArg - assign (pullName outArg) outAddr - taggedAddr <- cgenArg addrArg - baseAddr <- offsetAddr taggedAddr isub startOffsetArg - callMemCpy allocAddr baseAddr sizeArg - -- Now destructively mutate the copy - cgenLPVM "mutate" flags - [outArg, outArg, offsetArg, ArgInt 1 intTy, sizeArg, startOffsetArg, - valArg] -cgenLPVM "mutate" _ - [addrArg, outArg, offsetArg, ArgInt 1 _, sizeArg, startOffsetArg, - valArg] | argFlowDirection valArg == FlowIn = do - -- Destructive case: just mutate - logCodegen $ "lpvm mutate " ++ show addrArg - ++ " " ++ show outArg - ++ " " ++ show offsetArg ++ " *destructive*" - ++ " " ++ show sizeArg - ++ " " ++ show startOffsetArg - ++ " " ++ show valArg - baseAddr <- cgenArg addrArg - gcMutate baseAddr offsetArg valArg - assign (pullName outArg) baseAddr -cgenLPVM "mutate" _ [inArg, outArg, offsetArg, ArgInt 1 _, sizeArg, startOffsetArg, - refArg@ArgVar { argVarName = refArgName, argVarFlow = FlowTakeReference }] = do - shouldnt "lpvm mutate(..., takeReference ...) should be immediately following a call instruction, and should have already been generated" -cgenLPVM "mutate" _ - [_, _, _, ArgInt x _, _, _, _, _] | x == 0 || x == 1 = shouldnt "final argument to mutate should be FlowIn" -cgenLPVM "mutate" _ [_, _, _, destructiveArg, _, _, _] = - nyi "lpvm mutate instruction with non-constant destructive flag" - -cgenLPVM "cast" _ args@[inArg,outArg] = - case partitionArgs args of - ([inArg],[outArg]) -> do - inTy <- lift2 $ argLLVMType inArg - outTy <- lift2 $ argLLVMType outArg - - castOp <- if argIsConst inArg - then do - inOp <- cgenArgConst inArg - cons <$> consCast inOp outTy - else do - inOp <- cgenArg inArg - doCast inOp outTy - - logCodegen $ "CAST IN : " ++ show inArg ++ " -> " - ++ show (argType inArg) - logCodegen $ "CAST OUT : " ++ show outArg ++ " -> " - ++ show (argType outArg) - logCodegen $ " CAST OP : " ++ show castOp - - assign (pullName outArg) castOp - - -- A cast with no outputs: do nothing - (_, []) -> return () - (inputs,outputs) -> - shouldnt $ "cast instruction with " ++ show (length inputs) - ++ " inputs and " ++ show (length outputs) - ++ " outputs" - -cgenLPVM "store" _ args = do - case partitionArgs args of - ([input, global@(ArgGlobal (GlobalResource res) ty)], []) -> do - logCodegen $ "lpvm store " ++ show input ++ " " ++ show global - ty' <- llvmType' ty FlowIn - global <- getGlobalResource res ty' - op <- cgenArg input - store global op - ([],[]) -> return () - _ -> - shouldnt "lpvm store instruction with wrong arity" - -cgenLPVM "load" _ args = do - case partitionArgs args of - ([input@(ArgGlobal (GlobalResource res) ty)], - [output@(ArgVar nm _ _ _ _)]) -> do - logCodegen $ "lpvm load " ++ show input ++ " " ++ show output - ty' <- llvmType' ty FlowIn - global <- getGlobalResource res ty' - op' <- doLoad ty' global - assign (show nm) op' - ([],[]) -> - return () - _ -> - shouldnt $ "lpvm load instruction with wrong arity " ++ show args - -cgenLPVM pname flags args = do - shouldnt $ "Instruction " ++ pname ++ " arity " ++ show (length args) - ++ " not implemented." - - --- | Codegen all `foreign lpvm mutate(..., takeReference xyz)` calls which occur --- immediately after a PrimCall. --- Returns the remaining prims which didn't match the above pattern. -cgenTakeReferences :: [Prim] -> Codegen [Prim] -cgenTakeReferences (prim@(PrimForeign "lpvm" "mutate" _ [inArg, outArg, offsetArg, ArgInt 1 _, sizeArg, startOffsetArg, - refArg@ArgVar { argVarName = refArgName, argVarFlow = FlowTakeReference }]):nextPrims) = do - logCodegen $ "--> Compiling " ++ show prim - baseAddr <- cgenArg inArg - outTy <- lift2 $ argLLVMType refArg - finalAddr <- offsetAddr baseAddr iadd offsetArg - finalAddrPtr <- doCast finalAddr outTy - -- take a reference to the field that we're interested in - assign (show refArgName) finalAddrPtr - -- assign outArg to be the same address as inArg - -- This may implicitly write to a pointer (through a `store` - -- instruction) if outArg is an `outByReference` param - assign (pullName outArg) baseAddr - cgenTakeReferences nextPrims -cgenTakeReferences prims = return prims - --- | Generate code to add an offset to an address -offsetAddr :: Operand -> (Operand -> Operand -> Instruction) -> PrimArg - -> Codegen Operand -offsetAddr baseAddr offsetFn offset = do - offsetOp <- cgenArg offset - case argIntVal offset of - Just 0 -> return baseAddr - _ -> do - offsetArg <- cgenArg offset - instr address_t (offsetFn baseAddr offsetArg) - - -doCast :: Operand -> LLVMAST.Type -> Codegen Operand -doCast op ty2 = do - (op',caseStr) <- castHelper bitcast zext trunc inttoptr ptrtoint op (typeOf op) ty2 - logCodegen $ "doCast from " ++ show op' ++ " to " ++ show ty2 - ++ ": " ++ caseStr - return op' - - -consCast :: C.Constant -> LLVMAST.Type -> Codegen C.Constant -consCast c ty2 = do - (c',caseStr) <- castHelper cbitcast czext ctrunc cinttoptr cptrtoint c (typeOf c) ty2 - logCodegen $ "doCast from " ++ show c' ++ " to " ++ show ty2 - ++ ": " ++ caseStr - return c' - - -castHelper :: (a -> LLVMAST.Type -> Codegen a) -- bitcast - -> (a -> LLVMAST.Type -> Codegen a) -- zext - -> (a -> LLVMAST.Type -> Codegen a) -- trunc - -> (a -> LLVMAST.Type -> Codegen a) -- inttoptr - -> (a -> LLVMAST.Type -> Codegen a) -- ptrtoint - -> a -> LLVMAST.Type -> LLVMAST.Type -> Codegen (a,String) -castHelper _ _ _ _ _ op fromTy toTy - | fromTy == toTy = return (op, "identity cast") -castHelper _ _ _ i _ op (IntegerType _) ty2@(PointerType _ _) = - (,"inttoptr") <$> i op ty2 -castHelper _ _ _ i _ op (IntegerType _) ty2@(FunctionType _ _ _) = - (,"inttoptr") <$> i op ty2 -castHelper _ _ _ i _ op (IntegerType _) ty2@(ArrayType _ _) = - (,"inttoptr") <$> i op ty2 -castHelper _ _ _ _ p op (PointerType _ _) ty2@(IntegerType _) = - (,"ptrtoint") <$> p op ty2 -castHelper _ _ _ _ p op (FunctionType _ _ _) ty2@(IntegerType _) = - (,"ptrtoint") <$> p op ty2 -castHelper _ _ _ _ p op (ArrayType _ _) ty2@(IntegerType _) = - (,"ptrtoint") <$> p op ty2 -castHelper b z t _ _ op (IntegerType bs1) ty2@(IntegerType bs2) - | bs1 == bs2 = (,"bitcast no-op") <$> b op ty2 - | bs2 > bs1 = (,"zext") <$> z op ty2 - | bs1 > bs2 = (,"trunc") <$> t op ty2 -castHelper b z t _ _ op ty1@(FloatingPointType fp) ty2@(IntegerType bs2) - | bs1 == bs2 = caseStr <$> b op ty2 - | bs2 > bs1 = caseStr <$> (b op ty' >>= flip z ty2) - | bs1 > bs2 = caseStr <$> (b op ty' >>= flip t ty2) - where - bs1 = getBits ty1 - ty' = IntegerType bs1 - caseStr = (,"fp" ++ show bs1 ++ "-int" ++ show bs2) -castHelper b z t _ _ op ty1@(IntegerType bs1) ty2@(FloatingPointType fp) - | bs2 == bs1 = caseStr <$> b op ty2 - | bs2 > bs1 = caseStr <$> (z op ty' >>= flip b ty2) - | bs1 > bs2 = caseStr <$> (t op ty' >>= flip b ty2) - where - bs2 = getBits ty2 - ty' = IntegerType bs2 - caseStr = (,"int" ++ show bs1 ++ "-fp" ++ show bs2) -castHelper b _ _ _ _ op ty1 ty2 = - (,"bitcast from " ++ show ty1 ++ " case") <$> b op ty2 - - ----------------------------------------------------------------------------- --- Helpers for dealing with instructions -- ----------------------------------------------------------------------------- - - --- | Append an 'Instruction' to the current basic block's instruction stack. --- The return type of the operand value generated by the instruction call is --- inferred depending on the output arguments. The name is inferred from --- the output argument's name (LPVM is in SSA form). -addInstruction :: Instruction -> [PrimArg] -> Codegen () -addInstruction ins outArgs = do - logCodegen $ "addInstruction " ++ show outArgs ++ " = " ++ show ins - outTy <- lift2 $ primReturnType outArgs - logCodegen $ "outTy = " ++ show outTy - case outArgs of - [] -> case outTy of - VoidType -> voidInstr ins - _ -> shouldnt "empty outArgs cant assign values" - [outArg] -> do - outTy <- lift2 $ argLLVMType outArg - logCodegen $ "outTy = " ++ show outTy - let outName = pullName outArg - outop <- instr outTy ins - assign outName outop - _ -> do - outOp <- instr outTy ins - fields <- structUnPack outOp - zipWithM_ assign (pullName <$> outArgs) fields - - -pullName :: PrimArg -> String -pullName ArgVar{argVarName=var} = show var -pullName _ = shouldnt "Expected variable as output." - --- | Generate an expanding instruction name using the passed flags. This is --- useful to augment a simple instruction. (Ex: compare instructions can have --- the comparision type specified as a flag). -withFlags :: ProcName -> [Ident] -> String -withFlags p [] = p -withFlags p f = unwords (p:f) - - - - ----------------------------------------------------------------------------- --- Helpers for primitive arguments -- ----------------------------------------------------------------------------- - - --- | Partition the argument list into inputs and outputs -partitionArgs :: [PrimArg] -> ([PrimArg],[PrimArg]) -partitionArgs = List.partition goesIn - - --- | Get the LLVM 'Type' of the given primitive output argument --- list. If there is no output arg, return void_t. -primReturnType :: [PrimArg] -> Compiler Type -primReturnType outputs = mapM argLLVMType outputs >>= primReturnLLVMType - - -primReturnLLVMType :: [Type] -> Compiler Type -primReturnLLVMType [] = return void_t -primReturnLLVMType [ty] = return ty -primReturnLLVMType tys = return $ struct_t tys - -isLLVMInput :: PrimFlow -> Bool -isLLVMInput FlowIn = True -isLLVMInput FlowOut = False --- a `FlowOutByReference` arg is codegen-ed as a pointer input -isLLVMInput FlowOutByReference = True --- a `FlowTakeReference` arg is codegen-ed as a pointer output -isLLVMInput FlowTakeReference = False - -goesIn :: PrimArg -> Bool -goesIn = isLLVMInput . argFlowDirection - -paramGoesIn :: PrimParam -> Bool -paramGoesIn = isLLVMInput . primParamFlow - -paramGoesOut :: PrimParam -> Bool -paramGoesOut = not . paramGoesIn - --- | 'cgenArg' makes an Operand of the input argument. --- * Variables return a casted version of their respective symbol table operand --- * Constants are generated with cgenArgConst, then wrapped in `cons` --- --- Also returns `AllocaTracking`, which specifies if any of these arguments will --- point to allocas from the current proc. --- The presence of such allocas breaks core assumptions of the LLVM `tail` --- attribute, so we need to carefully handle this case. -cgenArgFull :: PrimArg -> Codegen (LLVMAST.Operand, AllocaTracking) -cgenArgFull arg = do - opds <- gets (stOpds . cgSymtab) - case Map.lookup arg opds of - Just opd -> noAlloca $ return opd - Nothing -> do - (opd, alloca) <- cgenArg' arg - addOperand arg opd - return (opd, alloca) - -cgenArg :: PrimArg -> Codegen LLVMAST.Operand -cgenArg a = fst <$> cgenArgFull a - --- Tracks whether a given pointer argument comes --- from an LLVM "alloca" instruction inside the current function. --- In this case, we are not allowed to mark an LLVM call --- with `tail` or `musttail` -data AllocaTracking = DoesAlloca | NoAlloca deriving (Eq, Show) - -noAlloca :: Codegen LLVMAST.Operand -> Codegen (LLVMAST.Operand, AllocaTracking) -noAlloca s = s >>= (\op -> return (op, NoAlloca)) - --- | Makes Operands of the passed arguments, and returns --- an summary AllocaTracking result for the whole list of arguments. -cgenArgsFull :: [PrimArg] -> Codegen ([LLVMAST.Operand], AllocaTracking) -cgenArgsFull args = do - args' <- mapM cgenArgFull args - let allocaTracking = if elem DoesAlloca $ List.map snd args' then DoesAlloca else NoAlloca - return (List.map fst args', allocaTracking) - -cgenArg' :: PrimArg -> Codegen (LLVMAST.Operand, AllocaTracking) -cgenArg' var@ArgVar{argVarName=name, argVarType=ty, argVarFlow=flow@FlowOutByReference} = do - op <- maybeGetVar (show name) - proto <- gets cgProto - outParams <- lift2 $ protoRealParamsWhere paramGoesOut proto - let outParamNames = List.map primParamName outParams - if isNothing op || name `elem` outParamNames then do - -- This variable wasn't already defined or was an output param of the - -- current proc (which get set to `Undef`, so not really explicitly defined) - -- In this case we need to allocate space on the stack and create a - -- shadow reference variable to it. - allocaTy <- llvmType' ty FlowOut - alloca <- doAlloca allocaTy - logCodegen $ "Performing %" ++ show name ++ " = alloca " ++ show allocaTy - let refName = getRefName name - assign (show refName) alloca - -- Supply the shadow reference variable as argument to this proc. - op <- castVar refName ty flow - return (op,DoesAlloca) - else noAlloca $ castVar name ty flow -cgenArg' var@ArgVar{argVarName=nm, argVarType=ty, argVarFlow=flow} = noAlloca $ castVar nm ty flow -cgenArg' (ArgUnneeded _ _) = shouldnt "Trying to generate LLVM for unneeded arg" -cgenArg' arg@(ArgClosure ps args ty) = do - logCodegen $ "cgenArg of " ++ show arg - args' <- neededFreeArgs ps args - if all argIsConst args' - then do - noAlloca $ cons <$> cgenArgConst arg - else do - fnOp <- cons <$> cgenFuncRef ps - (envArgs, allocaTracking) <- cgenArgsFull (setArgType intType <$> args') - mem <- gcAllocate (toInteger (wordSizeBytes * (1 + length args)) - `ArgInt` intType) address_t - memPtr <- inttoptr mem (ptr_t address_t) - mapM_ (\(idx,arg) -> do - let getEltPtr = getElementPtrInstr memPtr [idx] - accessPtr <- instr (ptr_t address_t) getEltPtr - store accessPtr arg - ) $ zip [0..] (fnOp:envArgs) - return (mem, allocaTracking) -cgenArg' arg = do - noAlloca $ cons <$> cgenArgConst arg - - --- returns the name of a "shadow" variable which is a pointer to the --- underlying variable -getRefName :: PrimVarName -> PrimVarName -getRefName name = name { primVarName = primVarName name ++ "#ref" } - - --- Generates a constant for a constant PrimArg, casted to the respective type --- * Ints, Floats, Chars, Undefs are of respective LLVMTypes --- * Strings are handled based on string variant --- * CString - ptr to global constant of [N x i8] --- * WybeString - ptr to global constant of { i64, i64 } with the second --- element being as though it were a CString. This representation --- is to comply with the stdlib string implementation -cgenArgConst :: PrimArg -> Codegen C.Constant -cgenArgConst arg = do - opds <- gets (stOpds . cgSymtab) - case Map.lookup arg opds of - Just (ConstantOperand constant) -> return constant - Just other -> shouldnt $ "cgenArgConst with " ++ show other - Nothing -> do - opd <- cgenArgConst' arg - addOperand arg $ ConstantOperand opd - return opd - -cgenArgConst' :: PrimArg -> Codegen C.Constant -cgenArgConst' arg@(ArgInt val _) = do - toTy <- lift2 $ argLLVMType arg - case toTy of - IntegerType bs -> return $ C.Int bs val - _ -> consCast (C.Int (fromIntegral wordSize) val) toTy -cgenArgConst' arg@(ArgFloat val _) = do - toTy <- lift2 $ argLLVMType arg - case toTy of - FloatingPointType DoubleFP -> return $ C.Float $ F.Double val - _ -> consCast (C.Float $ F.Double val) toTy -cgenArgConst' (ArgString s WybeString ty) = do - conPtr <- snd <$> addStringConstant s - let strType = struct_t [address_t, address_t] - let strStruct = C.Struct Nothing False - [ C.Int (fromIntegral wordSize) (fromIntegral $ length s) - , C.PtrToInt conPtr address_t ] - strName <- addGlobalConstant strType strStruct - let strPtr = C.GlobalReference (ptr_t strType) strName - let strElem = C.GetElementPtr True strPtr [C.Int 32 0, C.Int 32 0] - consCast strElem address_t -cgenArgConst' (ArgString s CString _) = do - (_, conPtr) <- addStringConstant s - let strElem = C.GetElementPtr True conPtr [C.Int 32 0, C.Int 32 0] - consCast strElem address_t -cgenArgConst' arg@(ArgChar c _) = do - let val = integerOrd c - toTy <- lift2 $ argLLVMType arg - case toTy of - IntegerType bs -> return $ C.Int bs val - _ -> consCast (C.Int (fromIntegral wordSize) val) toTy -cgenArgConst' arg@(ArgUndef _) = do - llty <- lift2 $ argLLVMType arg - return $ C.Undef llty -cgenArgConst' (ArgClosure ps args ty) = do - fnRef <- cgenFuncRef ps - args' <- neededFreeArgs ps args - constArgs <- mapM cgenArgConst (setArgType intType <$> args') - let arrElems = fnRef:constArgs - let arrTy = array_t (fromIntegral $ length arrElems) address_t - let arr = C.Array address_t arrElems - conArrPtr <- C.GlobalReference (ptr_t arrTy) <$> addGlobalConstant arrTy arr - let rawElem = C.GetElementPtr True conArrPtr [C.Int 32 0, C.Int 32 0] - consCast rawElem address_t -cgenArgConst' arg = shouldnt $ "cgenArgConst of " ++ show arg - - -cgenFuncRef :: ProcSpec -> Codegen C.Constant -cgenFuncRef ps = do - addExternProc ps - let fName = LLVMAST.Name $ fromString $ show ps - psType <- HigherOrderType defaultProcModifiers . (primParamTypeFlow <$>) - <$> primActualParams ps - psTy <- llvmFuncType psType - logCodegen $ " with type " ++ show psType - let conFn = C.GlobalReference psTy fName - return $ C.PtrToInt conFn address_t - -castVar :: PrimVarName -> TypeSpec -> PrimFlow -> Codegen Operand -castVar nm ty flow = do - toTy <- llvmType' ty flow - lift2 $ logBlocks $ "Coercing var " ++ show nm ++ " to " ++ show ty - varOp <- getVar (show nm) - doCast varOp toTy - - -primActualParams :: ProcSpec -> Codegen [PrimParam] -primActualParams pspec = lift2 $ do - primParams <- protoRealParams . procImplnProto . procImpln - =<< getProcDef pspec - ifM (isClosureProc pspec) - (let nonFree = List.filter ((/= Free) . primParamFlowType) primParams - in return $ setPrimParamType AnyType <$> envPrimParam : nonFree) - (return primParams) - - -neededFreeArgs :: ProcSpec -> [PrimArg] -> Codegen [PrimArg] -neededFreeArgs pspec args = lift2 $ do - params <- List.filter ((==Free) . primParamFlowType) . primProtoParams - . procImplnProto . procImpln <$> getProcDef pspec - List.map snd <$> filterM (paramIsReal . fst) (zip params args) - - -addExternProc :: ProcSpec -> Codegen () -addExternProc ps@(ProcSpec mod _ _ _) = do - args <- (primParamToArg <$>) <$> primActualParams ps - thisMod <- lift2 getModuleSpec - fileMod <- lift2 $ getModule modRootModSpec - unless (thisMod == mod || maybe False (`List.isPrefixOf` mod) fileMod) - $ addExtern $ PrimCall 0 ps Pure args univGlobalFlows - - -addStringConstant :: String -> Codegen (LLVMAST.Type, C.Constant) -addStringConstant s = do - let strCon = makeStringConstant s - let conType = array_t (fromIntegral $ length s + 1) char_t - let ptrConType = ptr_t conType - globalConst <- addGlobalConstant conType strCon - return (ptrConType, C.GlobalReference ptrConType globalConst) - - -getBits :: LLVMAST.Type -> Word32 -getBits (IntegerType bs) = bs -getBits (PointerType ty _) = getBits ty -getBits (FloatingPointType HalfFP) = 16 -getBits (FloatingPointType FloatFP) = 32 -getBits (FloatingPointType DoubleFP) = 64 -getBits (FloatingPointType FP128FP) = 128 -getBits (FloatingPointType X86_FP80FP) = 80 -getBits (FloatingPointType PPC_FP128FP) = 128 -getBits ty = fromIntegral wordSize - - --- | Convert a string into a constant array of constant integers. -makeStringConstant :: String -> C.Constant -makeStringConstant s = C.Array char_t cs - where ns = List.map integerOrd (s ++ "\00") - cs = List.map (C.Int 8) ns - - --- | 'integerOrd' performs ord but returns an Integer type -integerOrd :: Char -> Integer -integerOrd = toInteger . ord - ----------------------------------------------------------------------------- --- Symbol Table -- ----------------------------------------------------------------------------- - --- | Store a local variable on the front of the symbol table. --- | --- | If the local variable happens to be an outByReference parameter of the --- | current function we're generating, then we instead "write" the variable --- | using a store instruction. -assign :: String -> Operand -> Codegen () -assign var op = do - params <- gets (primProtoParams . cgProto) - let outByRefParamNames = List.map (show . primParamName) $ List.filter (\param -> FlowOutByReference == primParamFlow param) params - if var `elem` outByRefParamNames then do - logCodegen $ "assign outByReference " ++ var ++ " = " ++ show op ++ ":" ++ show (typeOf op) - locOp <- getVar var - locOp' <- doCast locOp (ptr_t (typeOf op)) - store locOp' op - -- also store this operand in the symtab, for the case where - -- we access this outByReference param later on in the proc - modifySymtab var op - else modifySymtab var op - ----------------------------------------------------------------------------- --- Instruction maps -- ----------------------------------------------------------------------------- - - --- | A map of arithmetic binary operations supported through LLVM to --- their Codegen module counterpart. -llvmMapBinop :: Map String - (Operand -> Operand -> Instruction, - TypeFamily, TypeRepresentation -> TypeRepresentation) -llvmMapBinop = - Map.fromList [ - -- Integer arithmetic - ("add", (iadd, IntFamily, id)), - ("sub", (isub, IntFamily, id)), - ("mul", (imul, IntFamily, id)), - ("udiv", (idiv, IntFamily, id)), - ("sdiv", (sdiv, IntFamily, id)), - ("urem", (urem, IntFamily, id)), - ("srem", (srem, IntFamily, id)), - -- Integer comparisions - ("icmp_eq", (icmp IP.EQ, IntFamily, const $ Bits 1)), - ("icmp_ne", (icmp IP.NE, IntFamily, const $ Bits 1)), - ("icmp_ugt", (icmp IP.UGT, IntFamily, const $ Bits 1)), - ("icmp_uge", (icmp IP.UGE, IntFamily, const $ Bits 1)), - ("icmp_ult", (icmp IP.ULT, IntFamily, const $ Bits 1)), - ("icmp_ule", (icmp IP.ULE, IntFamily, const $ Bits 1)), - ("icmp_sgt", (icmp IP.SGT, IntFamily, const $ Bits 1)), - ("icmp_sge", (icmp IP.SGE, IntFamily, const $ Bits 1)), - ("icmp_slt", (icmp IP.SLT, IntFamily, const $ Bits 1)), - ("icmp_sle", (icmp IP.SLE, IntFamily, const $ Bits 1)), - -- Bitwise operations - ("shl", (shl, IntFamily, id)), - ("lshr", (lshr, IntFamily, id)), - ("ashr", (ashr, IntFamily, id)), - ("or", (lOr, IntFamily, id)), - ("and", (lAnd, IntFamily, id)), - ("xor", (lXor, IntFamily, id)), - - -- Floating point arithmetic - ("fadd", (fadd, FloatFamily, id)), - ("fsub", (fsub, FloatFamily, id)), - ("fmul", (fmul, FloatFamily, id)), - ("fdiv", (fdiv, FloatFamily, id)), - ("frem", (frem, FloatFamily, id)), - -- Floating point comparisions - ("fcmp_eq", (fcmp FP.OEQ, FloatFamily, const $ Bits 1)), - ("fcmp_ne", (fcmp FP.ONE, FloatFamily, const $ Bits 1)), - ("fcmp_slt", (fcmp FP.OLT, FloatFamily, const $ Bits 1)), - ("fcmp_sle", (fcmp FP.OLE, FloatFamily, const $ Bits 1)), - ("fcmp_sgt", (fcmp FP.OGT, FloatFamily, const $ Bits 1)), - ("fcmp_sge", (fcmp FP.OGE, FloatFamily, const $ Bits 1)) - ] - --- | A map of unary llvm operations wrapped in the 'Codegen' module. -llvmMapUnop :: Map String - (Operand -> Type -> Instruction, TypeFamily, TypeFamily) -llvmMapUnop = - Map.fromList [ - ("uitofp", (uitofp, IntFamily, FloatFamily)), - ("sitofp", (sitofp, IntFamily, FloatFamily)), - ("fptoui", (fptoui, FloatFamily, IntFamily)), - ("fptosi", (fptosi, FloatFamily, IntFamily)) - ] - - - ----------------------------------------------------------------------------- --- Helpers -- ----------------------------------------------------------------------------- - - -llvmType :: TypeSpec -> PrimFlow -> Compiler LLVMAST.Type -llvmType ty flow = repLLVMType flow <$> typeRep ty - -llvmType' :: TypeSpec -> PrimFlow -> Codegen LLVMAST.Type -llvmType' ty flow = lift2 $ llvmType ty flow - -primParamLLVMType :: PrimParam -> Compiler LLVMAST.Type -primParamLLVMType param = llvmType (primParamType param) (primParamFlow param) - -argLLVMType :: PrimArg -> Compiler LLVMAST.Type -argLLVMType arg = llvmType (argType arg) (argFlowDirection arg) - -llvmFuncType :: TypeSpec -> Codegen LLVMAST.Type -llvmFuncType ty = do - tyRep <- typeRep' ty - case tyRep of - Func ins outs -> do - let inTys = _repLLVMType <$> ins - let outTys = _repLLVMType <$> outs - outTy <- lift2 $ primReturnLLVMType outTys - return $ ptr_t $ FunctionType outTy inTys False - _ -> shouldnt $ "llvmFuncType of " ++ show ty - - -llvmClosureType :: TypeSpec -> Codegen LLVMAST.Type -llvmClosureType (HigherOrderType mods@ProcModifiers{modifierDetism=detism} tys) - = llvmFuncType - $ HigherOrderType mods{modifierDetism=Det} - $ setTypeFlowType AnyType - <$> TypeFlow AnyType ParamIn : tys - ++ [TypeFlow AnyType ParamOut | detism == SemiDet] - -llvmClosureType ty = shouldnt $ "llvmClosureType on " ++ show ty - - - -typeRep :: TypeSpec -> Compiler TypeRepresentation -typeRep ty = - let err = shouldnt $ "llvmType applied to InvalidType or unknown type (" - ++ show ty - ++ ")" - in fromMaybe err <$> lookupTypeRepresentation ty - -typeRep' :: TypeSpec -> Codegen TypeRepresentation -typeRep' = lift2 . typeRep - - --- |The LLVM type of the specified module spec; error if it's not a type. -moduleLLVMType :: ModSpec -> Compiler LLVMAST.Type -moduleLLVMType mspec = - _repLLVMType . trustFromJust "moduleLLVMType of non-type" <$> lookupModuleRepresentation mspec - -repLLVMType :: PrimFlow -> TypeRepresentation -> LLVMAST.Type -repLLVMType FlowOutByReference tyRep = ptr_t $ _repLLVMType tyRep -repLLVMType FlowTakeReference tyRep = ptr_t $ _repLLVMType tyRep -repLLVMType _ tyRep = _repLLVMType tyRep - -_repLLVMType :: TypeRepresentation -> LLVMAST.Type -_repLLVMType Address = address_t -_repLLVMType (Bits bits) - | bits == 0 = void_t - | bits > 0 = int_c $ fromIntegral bits - | otherwise = shouldnt $ "unsigned type with negative width " - ++ show bits -_repLLVMType (Signed bits) - | bits > 0 = int_c $ fromIntegral bits - | otherwise = shouldnt $ "signed type with non-positive width " - ++ show bits -_repLLVMType (Floating 16) = FloatingPointType HalfFP -_repLLVMType (Floating 32) = FloatingPointType FloatFP -_repLLVMType (Floating 64) = FloatingPointType DoubleFP -_repLLVMType (Floating 80) = FloatingPointType X86_FP80FP -_repLLVMType (Floating 128) = FloatingPointType FP128FP -_repLLVMType (Floating b) = shouldnt $ "unknown floating point width " - ++ show b -_repLLVMType (Func _ _) = address_t - - ------------------------------------------------------------------------------- --- -- Creating LLVM AST module from global definitions -- ------------------------------------------------------------------------------- - --- | Initialize and fill a new LLVMAST.Module with the translated --- global definitions (extern declarations and defined functions) --- of LPVM procedures in a module. -newLLVMModule :: String -> String -> [ProcDefBlock] -> TranslationState - -> [ResourceSpec] -> Compiler LLVMAST.Module -newLLVMModule name fname blocks (TranslationState _ consts vars exts) ress = do - let defs = List.map blockDef blocks - varDefs = LLVMAST.GlobalDefinition <$> Map.elems vars - constDefs = LLVMAST.GlobalDefinition <$> Map.elems consts - resDefs <- catMaybes <$> mapM globalResourceExtern ress - extDefs <- mapM declareExtern exts - let exs' = uniqueExterns (resDefs ++ varDefs ++ constDefs) - ++ uniqueExterns (extDefs ++ [mallocExtern] ++ intrinsicExterns) - return $ modWithDefinitions name fname $ exs' ++ defs - - -globalResourceExtern :: ResourceSpec -> Compiler (Maybe LLVMAST.Definition) -globalResourceExtern res = do - resMbTy <- canonicaliseResourceSpec Nothing "newLLVMModule" res - case resMbTy of - (res', Just ty) -> - ifM (typeIsPhantom ty) - (return Nothing) - (typeRep ty >>= makeGlobalResourceVariable res' . _repLLVMType - <&> Just . LLVMAST.GlobalDefinition) - _ -> shouldnt $ "globalResourceExtern " ++ show res - - --- | Filter out non-unique externs -uniqueExterns :: [LLVMAST.Definition] -> [LLVMAST.Definition] -uniqueExterns exs = List.nubBy sameDef exs - where - sameDef (LLVMAST.GlobalDefinition g1) (LLVMAST.GlobalDefinition g2) - = G.name g1 == G.name g2 - sameDef _ _ = False - - --- | Create a new LLVMAST.Module with the given name, and fill it with the --- given global definitions. -modWithDefinitions :: String -> String -> [LLVMAST.Definition] -> LLVMAST.Module -modWithDefinitions nm filename defs = - LLVMAST.Module (toSBString nm) (toSBString filename) Nothing Nothing defs - - --- | Build an extern declaration definition from a given LPVM primitive. -declareExtern :: Prim -> Compiler LLVMAST.Definition -declareExtern (PrimForeign "c" name _ args) = do - let (inArgs,outArgs) = partitionArgs args - fnargs <- mapM makeExArg $ zip [1..] inArgs - retty <- primReturnType outArgs - let ex = externalC retty name fnargs - return ex - -declareExtern (PrimForeign otherlang name _ _) = - shouldnt $ "Don't know how to declare extern foreign function " ++ name - ++ " in language " ++ otherlang - -declareExtern (PrimHigher _ var _ _) = - shouldnt $ "Don't know how to declare extern function var " ++ show var - -declareExtern (PrimCall _ pspec@(ProcSpec m n _ _) _ args _) = do - let (inArgs,outArgs) = partitionArgs args - retty <- primReturnType outArgs - fnargs <- mapM makeExArg $ zip [1..] inArgs - return $ externalWybe retty (show pspec) fnargs - - --- | Helper to make arguments for an extern declaration. -makeExArg :: (Word, PrimArg) -> Compiler (Type, LLVMAST.Name) -makeExArg (index,arg) = do - ty <- argLLVMType arg - let nm = LLVMAST.UnName index - return (ty, nm) - - --- | An extern for wybe_malloc -mallocExtern :: LLVMAST.Definition -mallocExtern = - let ext_arg = [(LLVMAST.IntegerType 32, LLVMAST.Name $ toSBString "size")] - in externalC (ptr_t (int_c 8)) "wybe_malloc" ext_arg - - --- | Externs for any intrinsics we might need. For now, just memcpy. --- Intrinsics are built in to LLVM, so they're always available. -intrinsicExterns :: [LLVMAST.Definition] -intrinsicExterns = - [externalC void_t "llvm.memcpy.p0i8.p0i8.i32" [ - (ptr_t (int_c 8), LLVMAST.Name $ toSBString "dest"), - (ptr_t (int_c 8), LLVMAST.Name $ toSBString "src"), - (int_t, LLVMAST.Name $ toSBString "len"), - (int_c 1, LLVMAST.Name $ toSBString "isvolatile")] - ] - - ----------------------------------------------------------------------------- --- Block Modification -- ----------------------------------------------------------------------------- - - --- | Concat the LLVMAST.Module implementations of a list of loaded modules --- to the LLVMAST.Module implementation ModSpec passed as the first --- parameter. --- It is assumed and required that all these modules are loaded and compiled --- to their LLVM stage (so that the modLLVM field will exist) --- Concatenation involves uniquely appending the LLVMAST.Definition lists. -concatLLVMASTModules :: ModSpec -- ^ Module to append to - -> [ModSpec] -- ^ Modules to append - -> Compiler LLVMAST.Module -concatLLVMASTModules thisMod mspecs = do - -- pull LLVMAST.Module implementations of appending modspecs - logBlocks $ "Concatenating LLVM code from modules " - ++ showModSpecs (thisMod:mspecs) - let trustMsg = "LLVMAST.Module implementation not generated." - llmods <- mapM - ((trustFromJust trustMsg . modLLVM <$>) . getLoadedModuleImpln) - mspecs - let defs = List.map LLVMAST.moduleDefinitions llmods - -- pull LLVMAST.Module implementation of the modspec to append to - thisLLMod <- - trustFromJust trustMsg . modLLVM <$> getLoadedModuleImpln thisMod - let updatedLLMod = List.foldl addUniqueDefinitions thisLLMod defs - return updatedLLMod - - --- | Extend the LLVMAST.Definition list of the first module with the --- LLVMAST.Definition list passed as the second parameter. The concatenation --- must be unique. -addUniqueDefinitions :: LLVMAST.Module -> [LLVMAST.Definition] - -> LLVMAST.Module -addUniqueDefinitions (LLVMAST.Module n fn l t ds) defs = - LLVMAST.Module n fn l t newDefs - where - newDefs = List.nub $ ds ++ defs - - -------------------------------------------------------------------------------- --- Memory Interface -- -------------------------------------------------------------------------------- - --- $ functions - --- | Call "wybe_malloc" from external C shared lib. Returns an i8* pointer. --- XXX What will be the type of 'size' we pass to extern C's malloc? -callWybeMalloc :: PrimArg -> Codegen Operand -callWybeMalloc size = do - let outTy = ptr_t (int_c 8) - let fnName = LLVMAST.Name $ toSBString "wybe_malloc" - sizeOp <- cgenArg size - logCodegen $ "callWybeMalloc casting size " ++ show sizeOp - ++ " to " ++ show int_t - inops <- (:[]) <$> doCast sizeOp int_t - let ins = - callC - (externf (ptr_t (FunctionType outTy (typeOf <$> inops) False)) fnName) - inops - instr outTy ins - - --- | Invoke the LLVM memcpy intrinsic to copy a specified number of bytes of --- memory from a source address to a non-overlapping destination address. -callMemCpy :: Operand -> Operand -> PrimArg -> Codegen () -callMemCpy dst src bytes = do - let fnName = LLVMAST.Name $ toSBString "llvm.memcpy.p0i8.p0i8.i32" - let charptr_t = ptr_t (int_c 8) - dstCast <- doCast dst charptr_t - srcCast <- doCast src charptr_t - bytesOp <- cgenArg bytes - bytesCast <- doCast bytesOp int_t - -- dstCast <- instr charptr_t $ LLVMAST.BitCast dst charptr_t [] - -- srcCast <- instr charptr_t $ LLVMAST.BitCast src charptr_t [] - -- bytesOp <- cgenArg bytes - -- bytesCast <- instr int_t $ LLVMAST.BitCast bytesOp int_t [] - let inops = [dstCast, srcCast, bytesCast, - cons (C.Int 1 0)] - let ins = - callC - (externf (ptr_t (FunctionType void_t (typeOf <$> inops) False)) - fnName) - inops - voidInstr ins - - --- | Call the external C-library function for malloc and return --- the bitcasted pointer to that location. -gcAllocate :: PrimArg -> LLVMAST.Type -> Codegen Operand -gcAllocate size castTy = do - voidPtr <- callWybeMalloc size - doCast voidPtr castTy - - --- | Index and return the value in the memory field referenced by the pointer --- at the given offset. --- If expected return type/value at that location is a pointer, then --- the instruction inttoptr should precede the load instruction. -gcAccess :: Operand -> LLVMAST.Type -> Codegen Operand -gcAccess ptr outTy = do - logCodegen $ "gcAccess " ++ show ptr ++ " " ++ show outTy - let ptrTy = ptr_t outTy - ptr' <- doCast ptr ptrTy - logCodegen $ "doCast produced " ++ show ptr' - let loadInstr = load ptr' - logCodegen $ "loadInstr = " ++ show loadInstr - instr outTy loadInstr - - --- | Index the pointer at the given offset and store the given operand value --- in that indexed location. --- If the operand to be stored is a pointer, the ptrtoint instruction should --- precede the store instruction, with the int value of the pointer stored. -gcMutate :: Operand -> PrimArg -> PrimArg -> Codegen () -gcMutate baseAddr offsetArg valArg = do - logCodegen $ "gcMutate " ++ show baseAddr ++ " " ++ show offsetArg - ++ " " ++ show valArg - finalAddr <- offsetAddr baseAddr iadd offsetArg - valTy <- lift2 $ argLLVMType valArg - let ptrTy = ptr_t valTy - ptr' <- inttoptr finalAddr ptrTy - logCodegen $ "inttoptr " ++ show finalAddr ++ " " ++ show ptrTy - logCodegen $ "inttoptr produced " ++ show ptr' - - val <- cgenArg valArg - store ptr' val - - --- | Get the LLVMAST.Type the given pointer type points to. -pullFromPointer :: LLVMAST.Type -> LLVMAST.Type -pullFromPointer (PointerType ty _) = ty -pullFromPointer pty = shouldnt $ "Not a pointer: " ++ show pty - - - --- Convert string to ShortByteString -toSBString :: [Char] -> BSS.ShortByteString -toSBString string = BSS.pack $ unsafeCoerce <$> string - ----------------------------------------------------------------------------- --- Logging -- ----------------------------------------------------------------------------- - --- | Logging from the Compiler monad to Blocks. -logBlocks :: String -> Compiler () -logBlocks = logMsg Blocks - - --- | Log with a wrapping line of replicated characters above and below. -logWrapWith :: Char -> String -> Compiler () -logWrapWith ch s = do - logMsg Blocks (replicate 65 ch) - logMsg Blocks s - logMsg Blocks (replicate 65 ch) - - -logCodegen :: String -> Codegen () -logCodegen s = lift2 $ logBlocks s diff --git a/src/BodyBuilder.hs b/src/BodyBuilder.hs index bf87e1280..e88c37638 100644 --- a/src/BodyBuilder.hs +++ b/src/BodyBuilder.hs @@ -251,12 +251,14 @@ buildBody :: Int -> VarSubstitution -> [PrimParam] -> BodyBuilder a buildBody tmp oSubst params builder = do logMsg BodyBuilder "<<<< Beginning to build a proc body" (a, st) <- runStateT builder $ initState tmp oSubst params + let tmp = tmpCount st logMsg BodyBuilder ">>>> Finished building a proc body" logMsg BodyBuilder " Final state:" logMsg BodyBuilder $ fst $ showState 8 st + logMsg BodyBuilder $ " tmpCount = " ++ show tmp st' <- fuseBodies st - (tmp', used, stored, varFlows, body) <- currBody (ProcBody [] NoFork) st' - return (a, tmp', used, stored, varFlows, body) + (_, used, stored, varFlows, body) <- currBody (ProcBody [] NoFork) st' + return (a, tmp, used, stored, varFlows, body) -- |Start a new fork on var of type ty @@ -273,8 +275,9 @@ buildFork var ty = do Unforked -> do logBuild $ " (expands to " ++ show var' ++ ")" case var' of - ArgInt n _ -> -- fork variable value known at compile-time + ArgInt n _ -> do -- fork variable value known at compile-time put $ childState st $ Forked var ty (Just n) False [] Nothing False + gets tmpCount >>= logBuild . (" tmpCount = "++) . show ArgVar{argVarName=var'',argVarType=varType} -> do -- statically unknown result consts <- gets forkConsts @@ -284,6 +287,7 @@ buildFork var ty = do ++ (if fused then "WILL " else "will NOT ") ++ "be fused with parent" put $ st {buildState=Forked var'' ty Nothing fused [] Nothing False} + gets tmpCount >>= logBuild . (" tmpCount = "++) . show _ -> shouldnt "switch on non-integer variable" logState @@ -299,6 +303,7 @@ completeFork = do shouldnt "Completing an un-built fork" Forked var ty val fused bods deflt False -> do logBuild $ ">>>> ending fork on " ++ show var + gets tmpCount >>= logBuild . (" tmpCount = "++) . show let allBods = bods ++ maybeToList deflt -- let branchMap = List.foldr1 (Map.intersectionWith Set.union) -- (Map.map Set.singleton @@ -1125,17 +1130,17 @@ simplifyOp "fdiv" _ [ArgFloat n1 ty, ArgFloat n2 _, output] = simplifyOp "fdiv" _ [arg, ArgFloat 1 _, output] = primMove arg output -- Float comparisons -simplifyOp "fcmp_eq" _ [ArgFloat n1 _, ArgFloat n2 _, output] = +simplifyOp "fcmp_oeq" _ [ArgFloat n1 _, ArgFloat n2 _, output] = primMove (boolConstant $ n1==n2) output -simplifyOp "fcmp_ne" _ [ArgFloat n1 _, ArgFloat n2 _, output] = +simplifyOp "fcmp_one" _ [ArgFloat n1 _, ArgFloat n2 _, output] = primMove (boolConstant $ n1/=n2) output -simplifyOp "fcmp_slt" _ [ArgFloat n1 _, ArgFloat n2 _, output] = +simplifyOp "fcmp_olt" _ [ArgFloat n1 _, ArgFloat n2 _, output] = primMove (boolConstant $ n1n2) output -simplifyOp "fcmp_sge" _ [ArgFloat n1 _, ArgFloat n2 _, output] = +simplifyOp "fcmp_oge" _ [ArgFloat n1 _, ArgFloat n2 _, output] = primMove (boolConstant $ n1>=n2) output simplifyOp name flags args = PrimForeign "llvm" name flags args diff --git a/src/Builder.hs b/src/Builder.hs index 7a1f53354..413398158 100644 --- a/src/Builder.hs +++ b/src/Builder.hs @@ -194,8 +194,6 @@ module Builder (buildTargets) where import Analysis import AST import ASTShow (logDump, logDumpWith) -import Blocks (blockTransformModule, - concatLLVMASTModules) import Callers (collectCallers) import Clause (compileProc) import Config @@ -237,11 +235,12 @@ import Util (sccElts, useLocalCacheFileIfPossible import Snippets import Text.Parsec.Error import BinaryFactory +import LLVM (writeLLVM) import qualified Data.ByteString.Char8 as BS -import qualified LLVM.AST as LLVMAST import Debug.Trace import LastCallAnalysis (lastCallAnalyseMod) +import Data.Ord (comparing, Down (..)) ------------------------ Handling dependencies ------------------------ @@ -251,10 +250,7 @@ buildTargets targets = do mapM_ buildTarget targets showMessages stopOnError "building outputs" - dumpOpt <- option optDumpOptLLVM - let dumper = if dumpOpt then logDumpWith ((Just <$>) . extractLLVM) - else logDump - dumper FinalDump FinalDump "EVERYTHING" + logDumpWith writeLLVM FinalDump FinalDump "EVERYTHING" @@ -280,7 +276,7 @@ buildTarget target = do ++ " Module: " ++ showModSpec modspec -- target should be in the working directory, lib dir will be added -- later - depGraph <- loadAllNeededModules modspec True + depGraph <- loadAllNeededModules modspec True (tType == ExecutableFile) [(dir,False)] -- topological sort (bottom-up) @@ -328,6 +324,8 @@ buildTarget target = do (emitMod emitBitcodeFile bitcodeExtension) targets AssemblyFile -> mapM_ (emitMod emitAssemblyFile assemblyExtension) targets + NativeAssemblyFile -> mapM_ + (emitMod emitNativeAssemblyFile nativeAssemblyExtension) targets -- ArchiveFile -> do -- mapM_ (uncurry emitObjectFile) targets -- buildArchive target @@ -360,10 +358,10 @@ loadAllNeededModules modspec isTarget isExec possDirs = do let possDirs' = if isTarget then possDirs ++ ((,True) <$> optLibDirs opts) else possDirs - mods' <- if isExec + mods' <- if isExec then do cmdLineMods <- loadModuleIfNeeded force cmdLineModSpec possDirs' - return $ nub $ cmdLineMods ++ mods + return $ nub $ cmdLineMods ++ mods else return mods logBuild $ "Loading module " ++ showModSpec modspec ++ " ... got " ++ showModSpecs mods' @@ -653,7 +651,7 @@ loadLPVMFromObjFile objFile required = do Left err -> return $ Left $ "Error decoding object file data: " ++ err Right modBS -> do logBuild "No error decoding object file data." - logBuild $ "Extracted LPVM data" + logBuild "Extracted LPVM data" (List.map (\m -> m { modOrigin = objFile } ) <$>) <$> decodeModule required modBS @@ -783,7 +781,7 @@ prepareToCompileModSCC modSCC = do Error "Source: " ++ src ++ " has been changed during " ++ "the compilation." else - loadModuleFromSrcFile rootM src Nothing >> return () + void (loadModuleFromSrcFile rootM src Nothing) else Error "Unable to find corresponding source for object: " ++ obj ++ ". Failed to reload modules:" ++ showModSpecs ms @@ -1024,7 +1022,7 @@ buildExecutable orderedSCCs targetMod target = do -- depends = sortOn (modTopoOrder topoMap . fst) dependsUnsorted -- order each SCC such that submodules come before their parents - let orderedSCCs' = List.map (reverse . sort) orderedSCCs + let orderedSCCs' = List.map (sortBy (comparing Data.Ord.Down)) orderedSCCs let depends = concat orderedSCCs' if "" `elem` procs || "<0>" `elem` procs then do @@ -1052,7 +1050,6 @@ buildExecutable orderedSCCs targetMod target = do let tmpMainOFile = tmpDir "tmpMain.o" -- main module only contain a single proc that doesn't have a specz -- version, we build it first. - blockTransformModule mainMod stopOnError $ "translating " ++ showModSpecs [mainMod] emitObjectFile mainMod tmpMainOFile @@ -1088,25 +1085,28 @@ emitObjectFilesIfNeeded depends = do logBuild $ "Unchanged Set: " ++ show unchangedSet mapM (\m -> do reenterModule m - -- package (directory mod) won't be included in "depends", no need to - -- handle it - subMods <- Map.elems <$> getModuleImplementationField modSubmods - source <- getSource - let objFile = source -<.> objectExtension - logBuild $ "Ready to emit module: " ++ showModSpec m ++ - " with sub-modules: " ++ showModSpecs subMods - let changed = List.any (`Set.notMember` unchangedSet) (m:subMods) - if changed - then do - logBuild $ "emitting to: " ++ objFile - emitObjectFile m objFile - else - logBuild $ "unchanged, skip it: " ++ objFile - reexitModule + rootMod <- getModule modRootModSpec + if rootMod == Just m then do + -- package (directory mod) won't be included in "depends", no need to + -- handle it + subMods <- Map.elems <$> getModuleImplementationField modSubmods + source <- getSource + let objFile = source -<.> objectExtension + logBuild $ "Ready to emit module: " ++ showModSpec m ++ + " with sub-modules: " ++ showModSpecs subMods + let changed = List.any (`Set.notMember` unchangedSet) (m:subMods) + if changed + then do + logBuild $ "emitting to: " ++ objFile + emitObjectFile m objFile + else + logBuild $ "unchanged, skip it: " ++ objFile + reexitModule - -- we might use the local cache file instead of the actual file - -- check and overwrite the file name - liftIO $ useLocalCacheFileIfPossible objFile + -- we might use the local cache file instead of the actual file + -- check and overwrite the file name + liftIO $ useLocalCacheFileIfPossible objFile + else return [] ) depends @@ -1162,21 +1162,21 @@ sccInits mods = do logBuild $ "Collecting initialisations for modules: " ++ showModSpecs mods initialisedRes <- mapM (initialisedResources `inModule`) mods logBuild $ "Initialised resources: " ++ show initialisedRes - let initRes = concat (Map.keys <$> initialisedRes) + let initRes = concatMap Map.keys initialisedRes let resInits = [maybePlace (ForeignCall "llvm" "move" [] [initVal, Unplaced (varSet resName)]) (resourcePos def) - | (spec,def) <- concat $ Map.toList <$> initialisedRes - , let resName = resourceName spec + | (spec,def) <- concatMap Map.toList initialisedRes + , let resName = resourceName spec , let maybeInit = resourceInit def , isJust maybeInit , let initVal = fromJust maybeInit] - initMods <- filterM + initMods <- filterM ((isJust . Map.lookup "" <$> getModuleImplementationField modProcs) `inModule`) mods - let initProcCalls = [Unplaced + let initProcCalls = [Unplaced $ ProcCall (First modSpec "" Nothing) Det True [] | modSpec <- initMods ] @@ -1274,7 +1274,7 @@ multiSpeczTopDownPass orderedSCCs = do -- XXX we can do a bit better by handling modules that has llvm code -- with some new specz versions. let scc' = List.filter (`Set.notMember` unchanged) scc - mapM_ blockTransformModule scc' + -- mapM_ blockTransformModule scc' logBuild $ "Finished block transform SCC: " ++ showModSpecs scc' stopOnError $ "translating: " ++ showModSpecs scc' ) (List.reverse orderedSCCs) @@ -1410,7 +1410,8 @@ isModuleDirectory path = do -- |The different sorts of files that could be specified on the -- command line. data TargetType = ObjectFile | BitcodeFile | AssemblyFile - | ArchiveFile | ExecutableFile | UnknownFile + | NativeAssemblyFile | ExecutableFile + | ArchiveFile | UnknownFile deriving (Show,Eq) @@ -1418,12 +1419,13 @@ data TargetType = ObjectFile | BitcodeFile | AssemblyFile -- file need not exist. targetType :: FilePath -> TargetType targetType filename - | ext == objectExtension = ObjectFile - | ext == bitcodeExtension = BitcodeFile - | ext == assemblyExtension = AssemblyFile - | ext == archiveExtension = ArchiveFile - | ext == executableExtension = ExecutableFile - | otherwise = UnknownFile + | ext == objectExtension = ObjectFile + | ext == bitcodeExtension = BitcodeFile + | ext == assemblyExtension = AssemblyFile + | ext == nativeAssemblyExtension = NativeAssemblyFile + | ext == archiveExtension = ArchiveFile + | ext == executableExtension = ExecutableFile + | otherwise = UnknownFile where ext = dropWhile (=='.') $ takeExtension filename diff --git a/src/Callers.hs b/src/Callers.hs index 286e25b44..751e630c0 100644 --- a/src/Callers.hs +++ b/src/Callers.hs @@ -105,19 +105,16 @@ getSccProcs thisMod = do let ordered = stronglyConnComp [(pspec,pspec, - nub $ concatMap (localBodyCallees thisMod . procBody) procDefs) + nub $ concatMap + ( localBodyCallees thisMod + . trustFromJust "Analysing un-compiled code" + . procBody) procDefs) | (name,procDefs) <- procs, (n,def) <- zip [0..] procDefs, let pspec = ProcSpec thisMod name n generalVersion ] return ordered -procBody :: ProcDef -> ProcBody -procBody def = - case procImpln def of - ProcDefSrc _ -> shouldnt "Analysing un-compiled code" - ProcDefPrim{procImplnBody = body} -> body - -- |Finding all procs called by a given proc body localBodyCallees :: ModSpec -> ProcBody -> [ProcSpec] diff --git a/src/Codegen.hs b/src/Codegen.hs deleted file mode 100644 index 045fd8d8a..000000000 --- a/src/Codegen.hs +++ /dev/null @@ -1,724 +0,0 @@ --- File : Codegen.hs --- Author : Ashutosh Rishi Ranjan --- Purpose : Generate and emit LLVM from basic blocks of a module --- Copyright: (c) 2016 Peter Schachte. All rights reserved. --- License : Licensed under terms of the MIT license. See the file --- : LICENSE in the root directory of this project. - -{-# LANGUAGE OverloadedStrings #-} - -module Codegen ( - Codegen(..), CodegenState(..), BlockState(..), - Translation(..), TranslationState(..), SymbolTable(..), - emptyModule, addExtern, addGlobalConstant, getGlobalResource, - emptyCodegen, emptyTranslation, - -- * Blocks - createBlocks, setBlock, addBlock, entryBlockName, - callWybe, callC, externf, ret, globalDefine, externalC, externalWybe, - phi, br, cbr, switch, retNothing, freshUnName, - -- * Symbol storage - alloca, store, addOperand, load, modifySymtab, getVar, maybeGetVar, localVar, preservingSymtab, - makeGlobalResourceVariable, doAlloca, doLoad, - bitcast, cbitcast, inttoptr, cinttoptr, ptrtoint, cptrtoint, - trunc, ctrunc, zext, czext, sext, csext, - -- * Types - int_t, phantom_t, float_t, char_t, ptr_t, void_t, string_t, array_t, - struct_t, address_t, byte_ptr_t, - -- * Custom Types - int_c, float_c, - -- * Instructions - instr, voidInstr, - iadd, isub, imul, idiv, fadd, fsub, fmul, fdiv, sdiv, urem, srem, frem, - cons, uitofp, sitofp, fptoui, fptosi, - icmp, fcmp, lOr, lAnd, lXor, shl, lshr, ashr, - constInttoptr, - -- * Structure instructions - insertvalue, extractvalue, - -- * GetElementPtr - getElementPtrInstr - - -- * Testing - - ) where - -import Data.Function -import Data.List -import qualified Data.Map as Map -import Data.Maybe (fromMaybe, isJust) -import Data.String -import Data.Word - -import Control.Applicative -import Control.Monad.Except -import Control.Monad.Extra (whenM) -import Control.Monad.State - -import LLVM.AST -import qualified LLVM.AST as LLVMAST -import LLVM.AST.Global -import qualified LLVM.AST.Global as G - -import LLVM.AST.AddrSpace -import qualified LLVM.AST.Attribute as A -import qualified LLVM.AST.CallingConvention as CC -import qualified LLVM.AST.Constant as C -import qualified LLVM.AST.FloatingPointPredicate as FP -import qualified LLVM.AST.IntegerPredicate as IP -import LLVM.Context -import LLVM.Module -import LLVM.AST.Linkage (Linkage(External)) - -import Util (lift2) -import AST hiding (Stmt(..)) -import Options (LogSelection (Blocks,Codegen)) -import Config (wordSize, functionDefSection) -import Unsafe.Coerce -import Debug.Trace -import LLVM.AST.Typed (Typed(typeOf)) -import qualified Data.ByteString.Lazy as BL -import qualified Data.ByteString.Short as BS -import Data.ByteString.Char8 hiding (cons, map) -import LLVM.AST.FunctionAttribute (FunctionAttribute) - ----------------------------------------------------------------------------- --- Types -- ----------------------------------------------------------------------------- - -int_t :: Type -int_t = IntegerType 32 - -ptr_t :: Type -> Type -ptr_t ty = PointerType ty (AddrSpace 0) - -phantom_t :: Type -phantom_t = VoidType - -string_t :: Word64 -> Type -string_t size = ArrayType size char_t - -void_t :: Type -void_t = VoidType - -float_t :: Type -float_t = FloatingPointType DoubleFP - -char_t :: Type -char_t = IntegerType 8 - -array_t :: Word64 -> Type -> Type -array_t = ArrayType - -struct_t :: [LLVMAST.Type] -> LLVMAST.Type -struct_t types = LLVMAST.StructureType False types - -address_t :: Type -address_t = int_c $ fromIntegral wordSize - -byte_ptr_t :: Type -byte_ptr_t = ptr_t char_t - --- Custom Types -int_c :: Word32 -> Type -int_c = IntegerType - -float_c :: Word32 -> Type -float_c 16 = FloatingPointType HalfFP -float_c 32 = FloatingPointType FloatFP -float_c 64 = FloatingPointType DoubleFP -float_c 128 = FloatingPointType FP128FP -float_c 80 = FloatingPointType X86_FP80FP -float_c n = error $ "Invalid floating point width " ++ show n - - ----------------------------------------------------------------------------- --- Codegen State -- ----------------------------------------------------------------------------- --- | 'SymbolTable' is a simple mapping of scope variable names and their --- representation as an LLVM.AST.Operand.Operand. - - --- | A Map of all the assigned names to assist in supplying new unique names. -type Names = Map.Map String Int - - --- | 'CodegenState' will hold a global Definition level code. -data CodegenState - = CodegenState { - cgCurrentBlock :: Name -- ^ Name of the active block to append to - , cgBlocks :: Map.Map Name BlockState - -- ^ Blocks for function - , cgBlockCount :: Int - , cgNames :: Names -- ^ Name supply - , cgSymtab :: SymbolTable - -- ^ Local symbol table of a function - , cgUnNameCount :: Word -- ^ Count of UnNames - , cgProto :: PrimProto -- ^ Proto of current proc - } deriving Show - --- | 'BlockState' will generate the code for basic blocks inside of --- function definitions. --- A LLVM function consists of a sequence of basic blocks containing a --- stack of Named/Unnamed instructions. During compilation basic blocks --- will roughly correspond to labels in the native assembly output. -data BlockState - = BlockState { - idx :: Int -- ^ Block - , stack :: [Named Instruction] - , term :: Maybe (Named Terminator) - } deriving Show - - --- | SymbolTable state. --- Stores assignments and generated operands -data SymbolTable - = SymbolTable { - stVars :: Map.Map String Operand - - -- ^ Assigned names - , stOpds :: Map.Map PrimArg Operand - -- ^ Previously generated operands - } deriving Show - - --- | The 'Codegen' state monad will hold the state of the code generator --- That is, a map of block names to their 'BlockState' representation --- newtype Codegen a = Codegen { runCodegen :: StateT CodegenState Compiler a } --- deriving (Functor, Applicative, Monad, MonadState CodegenState) - -type Codegen = StateT CodegenState Translation - --- | TranslationState --- Stores data required across tranlating an LPVM module into an LLVm module -data TranslationState - = TranslationState { - txConstCount :: Word -- ^ Count of constants - , txConsts :: Map.Map (C.Constant, Type) Global - -- ^ Needed global constants - , txVars :: Map.Map GlobalInfo Global - -- ^ Needed global variables - , txExterns :: [Prim] -- ^ Primitives which need to be declared - } deriving Show - - -type Translation = StateT TranslationState Compiler - -emptyTranslation :: TranslationState -emptyTranslation = TranslationState 0 Map.empty Map.empty [] - - --- | Gets a fresh UnName -freshUnName :: Codegen Name -freshUnName = do - count <- gets cgUnNameCount - modify $ \s -> s { cgUnNameCount=count + 1 } - return $ UnName count - - --- | Update the list of externs which will be needed. The 'Prim' will be --- converted to an extern declaration later. -addExtern :: Prim -> Codegen () -addExtern prim = lift $ modify $ \s -> s { txExterns=prim:txExterns s} - - --- | Creates a Global value for a constant, given the type and appends it --- to the CodegenState list. This list will be used to convert these Global --- values into Global module level definitions. A UnName is generated too --- for reference. -addGlobalConstant :: LLVMAST.Type -> C.Constant -> Codegen Name -addGlobalConstant ty con = do - modName <- lift2 $ showModSpec <$> getModuleSpec - consts <- lift $ gets txConsts - case Map.lookup (con, ty) consts of - Just global -> return $ name global - Nothing -> lift $ do - count <- gets txConstCount - modify $ \s -> s{txConstCount = count + 1} - let ref = Name $ fromString $ modName ++ "." ++ show count - let gvar = globalVariableDefaults { name = ref - , isConstant = True - , G.type' = ty - , initializer = Just con } - modify $ \s -> s {txConsts=Map.insert (con, ty) gvar $ txConsts s} - return ref - - -getGlobalResource :: ResourceSpec -> Type -> Codegen Operand -getGlobalResource spec@(ResourceSpec mod nm) ty = do - vars <- lift $ gets txVars - let info = GlobalResource spec - nm <- case Map.lookup info vars of - Nothing -> do - global <- lift2 $ makeGlobalResourceVariable spec ty - lift $ modify $ \s -> s {txVars=Map.insert info global vars} - return $ G.name global - Just ref -> return $ G.name ref - return $ ConstantOperand $ C.GlobalReference (ptr_t ty) nm - - -makeGlobalResourceVariable :: ResourceSpec -> Type -> Compiler Global -makeGlobalResourceVariable spec@(ResourceSpec mod nm) ty = do - when (ty == VoidType) - $ shouldnt $ "global resource " ++ show spec ++ " cant have voidtype" - let ref = Name $ fromString $ makeGlobalResourceName spec - rootMod <- getModule modRootModSpec - resRoot <- (>>= modRootModSpec) <$> getLoadingModule mod - let init = if isJust rootMod && rootMod == resRoot - then Just $ C.Undef ty - else Nothing - -- XXX this may be affected by multiprocessing - let linkage = External - return globalVariableDefaults { name = ref - , isConstant = False - , G.type' = ty - , G.linkage = linkage - , initializer = init - } - --- | Create an empty LLVMAST.Module which would be converted into --- LLVM IR once the moduleDefinitions field is filled. -emptyModule :: String -> LLVMAST.Module -emptyModule label = defaultModule { moduleName = fromString label } - - --- | Create a global Function Definition to store in the LLVMAST.Module. --- A Definition body is a list of BasicBlocks. A LPVM procedure roughly --- correspond to this global function definition. isForeign means the --- function will be called from foreign code, so it should use C calling --- conventions. -globalDefine :: Bool -> Type -> String -> [(Type, Name)] - -> [FunctionAttribute] -> [BasicBlock] -> Definition -globalDefine isForeign rettype label argtypes attrs body - = GlobalDefinition $ functionDefaults { - G.callingConvention = if isForeign then CC.C else CC.Fast - , name = Name $ fromString label - , parameters = ([Parameter ty nm [] | (ty, nm) <- argtypes], False) - , returnType = rettype - , G.functionAttributes = Right <$> attrs - , basicBlocks = body - , section = fromString <$> functionDefSection label - } - - --- | create a global declaration of an external function for the specified --- calling convention -externalFunction :: CC.CallingConvention -> Type -> String -> [(Type, Name)] - -> Definition -externalFunction cconv rettype label argtypes - = GlobalDefinition $ functionDefaults { - G.callingConvention = cconv - , name = Name $ fromString label - , parameters = ([Parameter ty nm [] | (ty, nm) <- argtypes], False) - , returnType = rettype - , basicBlocks = [] - } - - --- | 'externalC' creates a global declaration of an external C function -externalC :: Type -> String -> [(Type, Name)] -> Definition -externalC = externalFunction CC.C - - --- | 'externalWybe' creates a global declaration of an external Wybe function -externalWybe :: Type -> String -> [(Type, Name)] -> Definition -externalWybe = externalFunction CC.Fast - - ----------------------------------------------------------------------------- --- Blocks -- ----------------------------------------------------------------------------- - --- | Sample name for the 'entry' block. (Usually 'entry') -entryBlockName :: String -entryBlockName = "entry" - --- | Initializes an empty new block -emptyBlock :: Int -> BlockState -emptyBlock i = BlockState i [] Nothing - --- | Initialize an empty CodegenState for a new Definition. -emptyCodegen :: PrimProto -> CodegenState -emptyCodegen proto = CodegenState{ cgCurrentBlock=Name $ fromString entryBlockName - , cgBlocks=Map.empty - , cgBlockCount=0 - , cgSymtab=SymbolTable Map.empty Map.empty - , cgNames=Map.empty - , cgUnNameCount=0 - , cgProto=proto - } - - --- | 'addBlock' creates and adds a new block to the current blocks -addBlock :: String -> Codegen Name -addBlock blockName = do - -- Retrieving the current field values - blks <- gets cgBlocks - idx <- gets cgBlockCount - name <- uniqueName blockName - -- updating with new block appended - modify $ \s -> s { cgBlocks = Map.insert name (emptyBlock idx) blks - , cgBlockCount=idx+1 } - return name - --- | Set the current block label. -setBlock :: Name -> Codegen () -setBlock bname = modify $ \s -> s { cgCurrentBlock = bname } - - --- | Replace the current block with a 'new' block -modifyBlock :: BlockState -> Codegen () -modifyBlock new = do - active <- gets cgCurrentBlock - modify $ \s -> s { cgBlocks = Map.insert active new (cgBlocks s) } - - --- | Find the current block in the list of blocks (Map of blocks) -current :: Codegen BlockState -current = do - curr <- gets cgCurrentBlock - blks <- gets cgBlocks - case Map.lookup curr blks of - Just x -> return x - Nothing -> error $ "No such block found: " ++ show curr - - --- | Generate the list of BasicBlocks added to the CodegenState for a global --- definition. This list would be in order of execution. This list forms the --- body of a global function definition. -createBlocks :: CodegenState -> [BasicBlock] -createBlocks m = map makeBlock $ sortBlocks $ Map.toList (cgBlocks m) - --- | Convert our BlockState to the LLVM BasicBlock Type. -makeBlock :: (Name, BlockState) -> BasicBlock -makeBlock (l, BlockState _ s t) = BasicBlock l s (maketerm t) - where - maketerm (Just x) = x - maketerm Nothing = error $ "Block has no terminator: " ++ show l - --- | Sort the blocks on their ids. Blocks do get out of order since any block --- can be brought to be the 'currentBlock'. -sortBlocks :: [(Name, BlockState)] -> [(Name, BlockState)] -sortBlocks = sortBy (compare `on` (idx . snd)) - ----------------------------------------------------------------------------- --- Names supply -- ----------------------------------------------------------------------------- - --- | 'uniqueName' checks a name supply to generate a unique name by --- adding a number suffix (which is incremental) to a name which has already --- been used. -uniqueName :: String -> Codegen Name -uniqueName base = do - names <- gets cgNames - let name = base ++ maybe "" show (Map.lookup base names) - modify $ \s -> s{ cgNames=Map.alter (Just . maybe 1 (+1)) base names } - return $ Name $ fromString name - - ----------------------------------------------------------------------------- --- Name Referencing -- ----------------------------------------------------------------------------- - --- | Create an extern referencing Operand -externf :: Type -> Name -> Operand -externf ty = ConstantOperand . C.GlobalReference ty - --- | Create a new Local Operand (prefixed with % in LLVM) -localVar :: Type -> String -> Operand -localVar t s = LocalReference t $ LLVMAST.Name $ fromString s - -globalVar :: Type -> String -> C.Constant -globalVar t s = C.GlobalReference t $ LLVMAST.Name $ fromString s - ----------------------------------------------------------------------------- --- Symbol Table -- ----------------------------------------------------------------------------- - --- | Store a local variable on the front of the symbol table. -modifySymtab :: String -> Operand -> Codegen () -modifySymtab var op = do - logCodegen $ "SYMTAB: " ++ var ++ " <- " ++ show op ++ ":" ++ show (typeOf op) - st <- gets cgSymtab - modify $ \s -> s { cgSymtab=st{stVars=Map.insert var op $ stVars st} } - --- | Find and return the local operand by its given name from the symbol --- table. Only the first find will be returned so new names can shadow --- the same older names. -getVar :: String -> Codegen Operand -getVar var = do - let err = shouldnt $ "Local variable not in scope: " ++ show var - maybeOp <- maybeGetVar var - return $ fromMaybe err maybeOp - --- | Find and return the local operand by its given name from the symbol --- table. Only the first find will be returned so new names can shadow --- the same older names. Returns Nothing if var was not found. -maybeGetVar :: String -> Codegen (Maybe Operand) -maybeGetVar var = do - lcls <- gets (stVars . cgSymtab) - return $ Map.lookup var lcls - --- | Evaluate nested code generating code, and reset the symtab to its original --- state afterwards. Other parts of the Codegen state are allowed to change. --- This is needed when generating a branch, because symtabs in one branch won't --- apply an another branch. -preservingSymtab :: Codegen a -> Codegen a -preservingSymtab code = do - oldSymtab <- gets cgSymtab - result <- code - modify $ \s -> s { cgSymtab=oldSymtab } - return result - -addOperand :: PrimArg -> Operand -> Codegen () -addOperand arg opd = do - st <- gets cgSymtab - modify $ \s -> s { cgSymtab=st{stOpds=Map.insert arg opd $ stOpds st} } - - ----------------------------------------------------------------------------- --- Instructions -- ----------------------------------------------------------------------------- - - - --- | Append an unnamed instruction to the instruction stack of the current --- BasicBlock. The temp name is generated using a fresh word counter. -instr :: Type -> Instruction -> Codegen Operand -instr ty ins = do - reg <- freshUnName - addInstr $ reg := ins - return $ LocalReference ty reg - - --- | Append a void instruction to the instruction stack of the current --- BasicBlock. -voidInstr :: Instruction -> Codegen () -voidInstr inst = addInstr $ Do inst - - --- | Append an instruction to the instruction stack of the current BasicBlock. -addInstr :: Named Instruction -> Codegen () -addInstr namedIns = do - blk <- current - let i = stack blk - modifyBlock $ blk { stack = i ++ [namedIns] } - logCodegen $ "add instruction " ++ show namedIns - - --- | 'terminator' provides the last instruction of a basic block. -terminator :: Named Terminator -> Codegen (Named Terminator) -terminator trm = do - blk <- current - modifyBlock $ blk { term = Just trm } - return trm - - --- * Integer arithmetic operations (Binary) - -iadd :: Operand -> Operand -> Instruction -iadd a b = Add False False a b [] - -isub :: Operand -> Operand -> Instruction -isub a b = Sub False False a b [] - -imul :: Operand -> Operand -> Instruction -imul a b = Mul False False a b [] - -idiv :: Operand -> Operand -> Instruction -idiv a b = UDiv True a b [] - -sdiv :: Operand -> Operand -> Instruction -sdiv a b = SDiv True a b [] - -urem :: Operand -> Operand -> Instruction -urem a b = URem a b [] - -srem :: Operand -> Operand -> Instruction -srem a b = SRem a b [] - --- * Floating point arithmetic operations (Binary) - -fadd :: Operand -> Operand -> Instruction -fadd a b = FAdd noFastMathFlags a b [] - -fsub :: Operand -> Operand -> Instruction -fsub a b = FSub noFastMathFlags a b [] - -fmul :: Operand -> Operand -> Instruction -fmul a b = FMul noFastMathFlags a b [] - -fdiv :: Operand -> Operand -> Instruction -fdiv a b = FDiv noFastMathFlags a b [] - -frem :: Operand -> Operand -> Instruction -frem a b = FRem noFastMathFlags a b [] - --- * Bitwise Binary Operations -shl :: Operand -> Operand -> Instruction -shl a b = Shl False False a b [] - -lshr :: Operand -> Operand -> Instruction -lshr a b = LShr False a b [] - -ashr :: Operand -> Operand -> Instruction -ashr a b = AShr False a b [] - -lOr :: Operand -> Operand -> Instruction -lOr a b = Or a b [] - -lAnd :: Operand -> Operand -> Instruction -lAnd a b = And a b [] - -lXor :: Operand -> Operand -> Instruction -lXor a b = Xor a b [] - - --- * Comparisions - -fcmp :: FP.FloatingPointPredicate -> Operand -> Operand -> Instruction -fcmp p a b = FCmp p a b [] - -icmp :: IP.IntegerPredicate -> Operand -> Operand -> Instruction -icmp p a b = ICmp p a b [] - --- * Unary - -uitofp :: Operand -> Type -> Instruction -uitofp a ty = UIToFP a ty [] - -sitofp :: Operand -> Type -> Instruction -sitofp a ty = SIToFP a ty [] - -fptoui :: Operand -> Type -> Instruction -fptoui a ty = FPToUI a ty [] - -fptosi :: Operand -> Type -> Instruction -fptosi a ty = FPToSI a ty [] - --- | Create a constant operand (function parameters). -cons :: C.Constant -> Operand -cons = ConstantOperand - --- * Memory effecting instructions - --- | The 'call' instruction represents a simple function call to wybe code -callWybe :: Maybe TailCallKind -> Operand -> [Operand] -> Instruction -callWybe tailCallKind fn args = Call tailCallKind CC.Fast [] (Right fn) (toArgs args) [] [] - --- | A foreign call instruction, using C calling conventions -callC :: Operand -> [Operand] -> Instruction -callC fn args = Call (Just LLVMAST.Tail) CC.C [] (Right fn) (toArgs args) [] [] - - -toArgs :: [Operand] -> [(Operand, [A.ParameterAttribute])] -toArgs xs = map (\x -> (x, [])) xs - - --- | The ‘alloca‘ function wraps LLVM's alloca instruction. The 'alloca' --- instruction is pushed on the instruction stack (unnamed) and referenced with --- a *type operand. The Alloca LLVM instruction allocates memory on the stack --- frame of the currently executing function, to be automatically released when --- this function returns to its caller. -alloca :: Type -> Instruction -alloca ty = Alloca ty Nothing 0 [] - --- | The 'store' instruction is used to write to write to memory. yields void. -store :: Operand -> Operand -> Codegen () -store ptr val = voidInstr $ Store False ptr val Nothing 0 [] - --- | The 'load' function wraps LLVM's load instruction with defaults. -load :: Operand -> Instruction -load ptr = Load False ptr Nothing 0 [] - - -bitcast :: Operand -> LLVMAST.Type -> Codegen Operand -bitcast op ty = instr ty $ BitCast op ty [] - -cbitcast :: C.Constant -> LLVMAST.Type -> Codegen C.Constant -cbitcast op ty = return $ C.BitCast op ty - -inttoptr :: Operand -> LLVMAST.Type -> Codegen Operand -inttoptr op ty = instr ty $ IntToPtr op ty [] - -cinttoptr :: C.Constant -> LLVMAST.Type -> Codegen C.Constant -cinttoptr op ty = return $ C.IntToPtr op ty - -ptrtoint :: Operand -> LLVMAST.Type -> Codegen Operand -ptrtoint op ty = instr ty $ PtrToInt op ty [] - -cptrtoint :: C.Constant -> LLVMAST.Type -> Codegen C.Constant -cptrtoint op ty = return $ C.PtrToInt op ty - --- constBitcast :: Operand -> LLVMAST.Type -> Operand --- constBitcast (ConstantOperand c) ty = cons $ C.BitCast c ty - -constInttoptr :: C.Constant -> LLVMAST.Type -> Operand -constInttoptr c ty = cons $ C.IntToPtr c ty - --- constPtrtoint :: Operand -> LLVMAST.Type -> Operand --- constPtrtoint (ConstantOperand c) ty = cons $ C.PtrToInt c ty - -trunc :: Operand -> LLVMAST.Type -> Codegen Operand -trunc op ty = instr ty $ Trunc op ty [] - -ctrunc :: C.Constant -> LLVMAST.Type -> Codegen C.Constant -ctrunc op ty = return $ C.Trunc op ty - -zext :: Operand -> LLVMAST.Type -> Codegen Operand -zext op ty = instr ty $ ZExt op ty [] - -czext :: C.Constant -> LLVMAST.Type -> Codegen C.Constant -czext op ty = return $ C.ZExt op ty - -sext :: Operand -> LLVMAST.Type -> Codegen Operand -sext op ty = instr ty $ SExt op ty [] - -csext :: C.Constant -> LLVMAST.Type -> Codegen C.Constant -csext op ty = return $ C.SExt op ty - - --- Helpers for allocating, storing, loading -doAlloca :: Type -> Codegen Operand -doAlloca (PointerType ty _) = instr (ptr_t ty) $ Alloca ty Nothing 0 [] -doAlloca ty = instr (ptr_t ty) $ Alloca ty Nothing 0 [] - -doLoad :: Type -> Operand -> Codegen Operand -doLoad ty ptr = instr ty $ Load False ptr Nothing 0 [] - - --- * Structure operations -insertvalue :: Operand -> Operand -> Word32 -> Instruction -insertvalue st op i = InsertValue st op [i] [] - -extractvalue :: Operand -> Word32 -> Instruction -extractvalue st i = ExtractValue st [i] [] - - --- * GetElementPtr helper -getElementPtrInstr :: Operand -> [Integer] -> LLVMAST.Instruction -getElementPtrInstr op idxs = - LLVMAST.GetElementPtr False op (cons . C.Int (fromIntegral wordSize) <$> idxs) [] - - --- * Control Flow operations - -br :: Name -> Codegen (Named Terminator) -br val = terminator $ Do $ Br val [] - -cbr :: Operand -> Name -> Name -> Codegen (Named Terminator) -cbr cond tr fl = terminator $ Do $ CondBr cond tr fl [] - -switch :: Operand -> Name -> [(C.Constant, Name)] -> Codegen (Named Terminator) -switch op0 deflt dests = terminator $ Do $ Switch op0 deflt dests [] - -ret :: Maybe Operand -> Codegen (Named Terminator) -ret val = terminator $ Do $ Ret val [] - -retNothing :: Codegen (Named Terminator) -retNothing = terminator $ Do $ Ret Nothing [] - -phi :: Type -> [(Operand, Name)] -> Codegen Operand -phi ty incoming = instr ty $ Phi ty incoming [] - - -logCodegen :: String -> Codegen () -logCodegen s = lift2 $ logMsg Codegen s diff --git a/src/Compiler.ipe b/src/Compiler.ipe index bb56cb542..30803f3d8 100644 --- a/src/Compiler.ipe +++ b/src/Compiler.ipe @@ -1,7 +1,7 @@ - - + + @@ -238,29 +238,16 @@ h h - - - - - - + + + + + - - - - - - - - - - - - @@ -268,44 +255,57 @@ h + + + - - - + + + + + + + + + - - - - - - - - - - - - - - - + + + - + + + + - - - - - + + + + + + + + + + + + + + + + + + @@ -384,17 +384,8 @@ h 320 672 m 352 672 l - -352 720 m -352 624 l -416 624 l -416 720 l -h - code generation -Blocks.hs -Codegen.hs BinaryFactory.hs 64 608 m @@ -416,5 +407,20 @@ h LPVM Compilation Optimisation +LLVM.hs + +448 720 m +448 624 l +512 624 l +512 720 l +h + + +448 720 m +448 624 l +512 624 l +512 720 l +h + diff --git a/src/Compiler.png b/src/Compiler.png index 2540962865dddab0b5cdc330b7bc43b45920c5d4..bc85eded4e38a8f13dfc459732fb997ffa76b65c 100644 GIT binary patch literal 13886 zcmeHucT`hP*KQK33WV}gl-?uVLX#>QP+9_ll+Zy+04XX}N&*TAhzLrrhTf4HsZkLX z1f+wMM3CNlPj2*m?^^fI@0M@fvhK=RnKg6H%$YN@XYW1Fvj=MkyTg2z>ns2OVAi<{ zy$1k*h5!Iy1S37QP<|74}F09Ze=o8Tu+pm(|D+s>vi3N%zSiAhs*Kv07w61$Bl_Gdvn}`yZf|p|>^N zncEi)Gtl;TBl7ImCidfq#SOiyivgv_doBL0+4GBqO_EuUm!1q&!ZJ(NXet=|v=c;h z?p@~uJv9Tb(9riU_x*y!i|8cCMe76kXq`>tQeI8*gPfUMqN#;>MtNX!3$NdJdwtBG zXT&a<=uxYS{@;)wGChDi4EmP}cDrd`(mOX?S!EJ>X!%55t9<;;-QL=rQ$2zWbAd+q zS9kJHu=(}$xmDzWviuxTJ$76)gwnecGQc&^(>WZ^4d$WGptqvQpbJJ#@h%szBPY1b zWkaUwX}Xr)Y!aTL0txpCi-dUSAaGA(N0*^@ z`>&+vt!!s0>MxHAmapea>o@tP?J-*$7%lq=_8ZfpB~f0ADP%v=8Pdz0qdRGot9BH* zZiay>|G^Z>Z@IO@#p9bnA;lfFcOJ}~8$g#1RB3=T=#ui*%|IMnc`cUF4;vM$bdH+6 zxVLSA!MKiUW&3MaG^Dp>Nb>~dcE46|Kp?n(Y*E#(<|OTuk1KY4Ze2jJe^1;|li#R7 zZ^^*UP#Wobl`~?=lv%W>74J6MK~N)n+zFA`U}D>t>)>E0rhJP$|KX#w{IIWdDLn^~ z!4$;c^r-`QCx4OLqWQBaKhD*_D&j5OPz)xiW68<)qlHOlzASgEWYrtYIk&pJ;r`+$ ze#&u^Qf=2XeHFtP-pAL&FP-C}AM&HTlH)pIJqX@A?IJukVR@wjHWFje-y=>g}=<79vp|DtK_^qJUBj;&SA|OO3%|v%2{zE)gULMYF~ZPUi4^Cbx#~ITn<+3sx0$7Wm&qkq^@<_ zPOmO6eobmRK@RFj5N>aEACX(R=%As%q7?5cnwHfaCb{7*Aw5LX{$aLOZk1R>JHg3b ze%FN+IOYho8@-c1TbS*dcq-0@SJUCCf{B2>X(25F^>!o0dG}d04eA`mXb7`VjS&bY zf>&Il3v~{o_tUHZX`9i%_oa5q5%W4c3cXyCbSlMmx0@!(7^#^BrM)1D$_BK3>%Ui! zA9VIzxlC8&YI@RBJB5|sZ|a+6*Kc-y5f+C(kK>pm=?CF)D~{43isoz5|NmfcP_*NtX`&8K`yLndRL>Ye=j{ z-E&n1U6-a=i%G3q{mgaeL(TU|ZVNr@If&GdXt$c(+9yu$Ei0LRcX*O*G5wigT-3-A~y!dP|(bAl#Hq zIS;PBPRq$J+dMzPCCQ-Vf{|UQz%>GCxKf93n{c@J)aTnVu4I;()eO=K-|3UFg4gba zz0tk0=~X-2T~Kt#t26TaxFQ&2IobMnV4kC9k(d$5dvhkIaZDlN!zAaHQ(anI(D?E8 z;SHaNb68}ikd&cSQ+Z3Xisb~SK5=xUXdekv)nfo6=1GsuqV zs_BIw>IJgi7~->CuS#^B3b$xL(&zN;9+J)xS`4;=oc0d0cGP3=-y{e9J$pu zt6?}IUZc7(p>Iy_ceRQfTk+($uqPAEuHf?n)mLrLhH{x_sLP6lXT@MkX`jzR6=V0= z;O(PW{O?Tv@voW8&B?B6PZ>v38Q)~38$1pRvW@Am(XXYo$z*PlXz{u;SQ>2pZpC?A zQFf#Y^N2`)U>s4a3UePXOETRy@_H((m%Y3z%Lo6xPWCWwQLUdYS$UkhWo0363t0-5 zcIsMxdttawUon(nm&rF9r!ZEC=y$E6#m6tKy_00iv(}`I&?@cBAKP&OREi=T_aNa5 zU#d3)yLyaGSmv}O2Or>w^Yn|`i%`z^kGc03OUX751$_V%CZ7$j-|;Jt`5sK@)Hd=P z@C3s_Yho-FudzwfGZ^)J#dmHooJ^jdySnVo`gmI>F>`mG|DKK+uAJT#r)L;^K7d7e z@;e+$(S#bgq_znm2*mh;knsE4eouqK>@%HC;$6qmwP{7*&ND|PQ*TdKk8kb;It1C) z3_nXXZLp9opUa)vlL55{ozB^6$~8)Vjbs*$d+yg&^8>4Ft2ef_{02s$Dv{1VN`$K8 zYg6F0`fbsSgB2nyOWDGpf~Xo~uLxpX{mv8HBG1z?!Q*DVG(TWsYh)pNG6qbqZeXR| z+64WnakKVXtng7j%V(Q*;O@og2M)qG`GdRDSk4-31)Z0m3}?eYTKy{};5SP?+w1L5 z>Zg^bQK14p!efE$-wdQBF|Bwn$X1wUEYb^dG#8qI7kV|G=sMXH{dJz6kTiBME%sjJ zV&lo!Kok4!;+)v_n=xmnZ69Vf5&mx^?pcBG#a=cu-YxFA$b>J|jrZr9?t_00EfO`G zxDqQP2|3h>yqdibr<%xE!pWvcUQOwky}<7OJuKXHvbYt!)`leobK~?nBA~>MZR{}4 zv8XmWn=V*M+NH=ePmY&)MZ0$T){eYd>t`n^NMl~`v&#`13&Wws~! zcHWB5gF^MK6f`0On5HzL{5x(c019IFXXWP|GZmTu;aJ%~&K@y@u&wUSZbiLnzSCnN z!!cQdV@*;rG-so(HY3zQ<-5qyLReOj9w*CHepYzy*qH#{O&8v{>j!h+5r{EoINRh) zg_5)e5B03O0~+81nhn^rf32dCO%n}8GhY&3qdKhTV&SwL+|XJ1V`cwG=X(C@HkySA z>fHX0jZV;x@PR763XY;MJMh;##x8>OX0~X)S0G1wu{Zruj7hec1~m-t;8JU8ZP}g1 z?DY;q^Q|_Wq@2@oWLi1)j@hjL09+(XdE<)DnIk`3V#`$Ze!-&}JANMl>HbrF#JU`A zXv1N;e+|&*wZ+jsyUe{L^|aSxOe^rb;svTW^&B3!)Li>!8wQ(kS3Av(m+n8=zjl!D z^etZVoWr=R7%U)KhT$`_=lclEg;CXzHeA0M-}HlD#U3XiCNlmFO(F9Iy=KPZ$8==~ z+dUDOX>_{j+d~DKgG#xzk`gCoQU0NEZrt;R#^$7J2iSkQw?;2#t|qzo@^uX!YA=Rw z&5lq<#3T6aKwAWC)z~B*PI*;}2x3T#@Rc^knwB9HJt}o32Jsv|$>h7$XEskJc9&js zQAVB5uAa{B{6lhLA`#-^ui?x>yP+ahJS@@{XeeRL2a-;mu9D+p zB-pGYi&5d+;6=sc;Xl1_N-W;~WE7ffox3$;M?aKcDtR44CWJX`Odj7W?9ONRetG}# zrQ^Uih*=E@T|~KRHXiG9spZh!O{d?jGs#WIQHQ^LG6Uj!t30&Iv3u#&o#ONLCVGf+ zrXNR-z4NOZH&3SHoqfONnxtvgQT=d}g#U2T|7@pK-8)d0Lr5n4G0+cdtdh)I_haABlX^Y+GVN{LV(&ms{B`nKwT*E5;}xni(ZXX zyFq>;ec#iCGD+telrwu6j?4(bp&XNI?qE|nYab^PH_|pLW z30+zL?nK)ekWD`a^!K$3OvvNA1mIio6%s*W=ux5sTU2`gJdk8#H*+ERoo||pm)+}~ zK%(-%T0)1H%8tm0)jqd!t*XvF{~e_=&Zme zSqm4cscyDfxg(tPl(5g87pQ_e{uV9=&q^|5hp_kq&1jAl&0mTX-&r9GBIURNF#38x zJ*^+z91Yde8sIgri~0O?;7Sqk)REnryAOU0A$axUn~%RdCtQc#JULIgO7d@a`siQ* zXFsjfuogc3+{l3H!nO{<4Hs?Ic+Kgp0Kp*qHG|{n;pjUFgM!RWVJOYIyuODyJ4W+Zb^P<&XVyJM zj}*dq4`en>?J||O_1*2?8)Hy@779{r)n-zT*L-qk{&*4uVoCqVcj2*lYLhBxPQV?G z(w8(m2*pTvO@VWjAf__gp z#*+KHPg3x|HZM-6jxgj0o}1?=AN|6rcy}#r_|TrK0oF_N(o58_UFX9)!W|4COrh`d z?A(R$x7&&qN1 zrfAhqU$=uA8N9pnih56;xOR#~G~ z(RCQq6S;9(a|S#J-}D99XXgd*TksW9{v9Z3R>9LoK3cZDhV0L~^EC6~eJRU&k8Gcr zj#YE76KR6{rxd&PDjzN+sY zitQ^4@?II<>vsGmi`Hs^L8F3Gid=jn6n8t`h#Oz%PPsZGTSxu6wf4W(A@+Z#b%-1< zAovh!sUKzhS19EsoM|X5-&cHZDSysEP^CoT+ux)-1$e@WKZoZ!5UFzJQapbk<82uf z!kuzYe!ZB$Oh_fb?ssMVODF$@J`_Tgy>-(lO@t}JA~K-n(1nH*SP5Tll@AFsidoLi zDj+_#v$H!TlgY9D8wO}cGzD0ZX_!m+V?HOKBt__kDtI)5QB{#vJ+Z@p;Uy%zFOEi* z#)jnue5Qf6hem;Z%A)Qh8`uP#2Zhn7gI3NqgHm2eQ_5<;?-w4n0;C>Zqcjru2x|m7 z!hIxp71fO}r~E{cN0^wH%KAn|8kiRJwmlew`4<$6lKudW>!5o2J=(cKdk%C6iXsXc zR71rK;4M*)`>TqPQ#7cWfrH1W(}DSsyjebA@O9>6;wY6K|Z;^Sq$ddAk0lZ6L=rXm)we;;#V#OfRt$QOhQ}9)X(G^V_RUT_#Vmo zY6=d@5^a3;PlfLKIPfv*ya~t?Luh6!@rSLeuuh5#gqxz~X)M`*9`C+8kcEmo6~fp| zY!kY}?gV9zeLVT2^*OAe06qxpB8$jYTk2nNN=v1eqRFbbz9vZe=3#ETr!LyvB*jg! z8#-Y{uW*fR3}7oR%9f^aN}wM}ZgY}TL-;O!JkhJ^eT^Q+R*0H`6#qh~#i`Gs-p$ND z!a~r}wR2eRV+DaDePU`yi)srISO$Lr{5BtAP`}dDe_Twc9GGWD$ASE5_6ybzxBNXF z$C{heQ-!HJQ}f9$rAq;#eP0?Gm3ze+BY6y-6pn%pRI3>AtOq_^ zVN5=+r!`GH%nEb+;`drG{Bq0RRC)QLYOWvl65 z5^UKuC(JkOaapUQ%g;;#Ir|y{QH-~!o6Wa^;lB&}@j#L~eS;W3y%c=LlpW4`2~ck^ zvoAoMscj;7C9yk9ph}5*|I<#O>A7vM#K;yw%c-n~WnnXN9@*l?1yX5O9Xo6>kTk1| zt!sb@$9*u>0@O`^X&0Wa7i#oXeI0wuw^{pw6A;G^A6e+_$WG|cknKKZ?5i?Pfzwuw zvxEB&uCqP6tvYjLW5+S=6Vind2mwoklyY~sp>+AzKWg3o#MMpN_xKsO*uo!RtUJI( z;HCQZB06qEk4SUMGkgpc?pM}@3H)3y!qNiXSl8`hT6=6E;XgUqdke`AW40UIE^kvP z+?Q63rKzhfenkcsx7RcBHLzEaeQO+fX$X1!(|MDIn%7Iu->yAdT6_{3 z!@F-=w4#(gCfL2*FIZN2UMsc5o^ku-Y)<2VFH#FJ7j7z{Hlm&t7p-isPVbTybr*Sg) zl1b?@7v0e0ig5@NTNPXw;bD8O`AmR}cL3+ecnKYWp5VlbuxZ$8ViTSbf$sV?%A9Xy z^ceo-r0|G&qj@Jt#>X)Dnd|4Chq{C7j%aS|aK%Tc5Wa=iJd3%F=Rl^a?A)S^JHG4v z3%{kGu9eBRsc?KT0%pXbIAj4Y^`&C<0inVnM9FkN1#dPV-}&0w3a^6Q&=|&1s;RL_ zZ2N1L=vtHd<7L-(O&Z}=w9S`eHO{55G|P7@#^9A3L+Vd1LG@0op)seBOTn|nMu!TP zVUmGgGe4G0>amD&zDh%X8V|bB4s{FTIL*F_a=&+TIu!CQMMlHrC$Qh<-!fMn8vUwmipoKH@TRwq)~F zR1`NjXLKQuZ|Px_+jzd*sd7kmVywF1}WG4>w_TvxR zTaOGKH0b*BoxwQU{WQXT=()q*{sRs6FMqbP=v{OJkh@@$15IRQR&imqwr)KeEGn5C zfh{d{VILQeB|0yAiGtrlu;kT1>myn=!^*@tBI+_F6vtz0l~}pRT<}`^g{Lp&fMYY_ zl)g%()MhXJ?uth;EBeD?`|RgwkNUV#A1R^m_FPmH_9m-D@=lg$=;$_e^JSktv+rsD z6Wgx2@Zn9ihT;2mrNYlA3SEzVL*ekQbx3#tyl`C-U1)rx?Cy-00Lx{qv`_M8Ad!j~cbNNi7Jx`f2>s z(KD&X7(?^zo={FYbi47sRef;6!um0iYrdSS7wFgkVb_?$?r_;yIcvy;w7nWNb;(mz z*Y+3@!rzEl2&H`&%dfM&o)*b_oA$HTeq2mxr;l!0q3fbl=R+-tuH2#>4A*H*?#) zJcBdkE-Ws=osI@f=;7=ihOzBu^w=`$5d7}Gl#AHiYSUD;%mRxx?NnZ~!e&$U;|vbt zv43{UE?0^|TRNA=nA>ChsYH#cQEu~|X!ws{ix^B}FmE4D<))RdRAbnQKsxznS#Zqh zFKOhc6Vm!z|NbO4XE$x<7qY;m}W7 zuiAV%x0@A)iBjOemXI?M%U{nG?dVm)mX)SOoc2qC<`?B^Zn z-hEPeF}lciYlc5$EE87xcbbLDAJ=TQ*=+y|EkcnA^GhceRMryPUtR|bOqnEh07(&J z^C1}1?R*QqXk>5qur<#EmO^%nOhNx6n^GovlyULOkGXt%WB1>(#Km2qBK51>dvkIt z0EEUxtK0cfEN|<0!yrrd*qZePV8a(UKHTMNZjS7%mt4t?Y*7x;PzoW2yT(g_qGj_p zN7%}Jvk^q7#H_DBmmkomw+BY#H(2cMa=*~me=3z2G<>OA zN~xidqf=2FW}YS6L#~bCnstp8W+5e)m@$f!(JP4EbT-=G3xB$7Z{-b$FDbBTn=%dg-?L)vq%W3oPhQ zGDa8A4?JmvyOeIN23|7q8~+hBshp{6QJday&9}HJoYBO&YN`94O5r{)#*^j?yC$%G zc0q_)3#FV~luN~}m)RyYJbRK3<=8Guiy;!>LWqTEj(1~t76_?3ofilxrV!qHr1_npxVPBV*&o=EG&sfMn|A>En# zWAn$@&{A;TI_2(q@7vuY^RBz4$%ake$yrkk-y-iPTePmpV;Yayao~MV%Rd*zNx}d|o#)M(KWxuprtFC za+E%Qx59xQSn*VCul*2r8Q)j+h6G#J4C*?SDSO@F)b2E}Bsa%EdfpCv*yds0=N}|J zov^vHbLdI0L3ymRcf*#PX@bxkE~vgeUhS3^Upvs%V6=I$N*>wbDc!B!klyfiINwc? z{ZtR^=*>Sd&A##g7x(KA84Itu0bp3PiEL7;c}agKf1~;XZvDuo?Lwg&NRsP-M=Ix(EO^%Mdd2K zISWW`&}IN#l1F`}x0A zSid|QgG#PhVxIEz;T~UL2R;gAe=OCk(9X#?V&Y=()&H>{UT~e$;5=EK19!}eb!g1q+bnR+q!vyQQKvZPAT8_wqY>XH-&>*GQV1b}cTnzY6Q(2^#hhp>W2pL~A# zO#3%Oe6(^>{kE%Kx#m-7eQw>i(y@lESgPNWBY%f2x4m~Gn-+}6EBPb`;Vd9F5Gv>y)xPHCw6BfTTfk1E2?T#0wLx z-xtF92Hjb*ovJKc7;kuSziaiD1SHN@cx~w5qR+r+Ig~P~hdHu*V-X)U9o-qT^jlCd z&Q;J$OLBZAc5I8RvlG$X^?qT%;$*H~Abd(oyf@R(*;cWCNfZkB*-N@63EI(fT@%1* zPXFSXk$L+lu5%xQI+DY2Po`0Kg>B!qG(M8H5OE75lo2`d7ii|`KR)LlaNtx1Rj?J( zS{idg#5kj430I9i=1OxjpE_?~Uv=miqwIAE?2*QuC+Y8-d$vk4^#+O4^wveSZ)623 z6jq@bnD4@#fKw);))?%uU`gifC+=e{9eB6$IYF-$Sx)mD8faZ-a= z!fK8f6S>EuXU})ZdTyvu{nnTdZSRjSPVhG?$JQ+o@|k3a4F$;hf|f_!%UlLqqoqM- zHcg_Mzeg8-*LNPeCTVH2&xW3SE#E0=OU^RrERDl|G*j&>81`}l_Ss#%Ijh~PI{9=U z=rn?HG&?yY`(p`2JXRmVbz>2jiR4bW#~c^eiK%`X^i)-7ih7y2@>9 ze`YH&gHuqW#U9$V!Gp)=2AwsIs#P*!DVh^MuEuwQ53dMa{95>5C|93A@G7OrBEHpGr4=!-BUChnR$B0|bZLA$SZ?ZnvRjKtM%0P* zeQe^m?fzCgd}&F;*EMhQk-I51Qo)c4QRg4=pYQU#etAFL{eEi5B-Kb?!GDj2criI; z8^aqqOD#gA_PWc}BicB2y=v1nC!U=^5KV}yCUJdDp14eBL$zDG*NXTg>jh+L$clYO zdlER`-}Ba1E=?+H@fBv8yLSg-8VA1`hA+jtvD8Jl$&aiC-56{W=f`&ZYzPBF@Q}f6@ijmDyc`2sRdVfnl&f;HHq-h4j^77=I^*;WTEdRyD{P&PALnW~ojc2bKk&o@lsgR=M)bN1@^HPPnUHVSN z&@;_Cgzt^2e^S6av}MHc->xqj&j&CnagTD+c=%3f6CSpcS5yd|7wt;7=h%;HvQjWM3t|l+#RfI0L}x!H1l?-@*WG}mP#-W$VxZkYsjC5U`D+P z05UV4#hfVvuo4d3OL<^e?iVY}qRfGs!~%}(9ildk?1I)43a&m-H5wVFozkTprG~CO zVxW2bG+8cIkOM<Rp?>#p?n0QSUSTY1%D`TG`xC^QiW2G}y#V5x1|8?E#tYNEmS`M=Zs!rxU_%+wUZGhh7kodktDz3}zc& zrjkT=s}qKo#;z}(vXC?|^B;P2KB=pGN18tV!ZGeFvJ*xOA6^>O#buR?G`{1?U4@VZ+B4xy%D8Ukk=67#90S z@6ir~Q0?67g*z>I$=G{=^g~<{G)U$sXLPNJsU-C;3BBV+jc{5u*Vz$o1}kMU=1~R* z{y|DfER9J+QIBQ%x^FM#;o^4qF+qFA+OQE|Ebr;!sRS-76Rg@_GgwsmXF>3@?S8(A znB1|p6Ex~wqf&Zu3X||!R+}hvZR7j}lE*aoIa8h)2mO%S5a-iOK=}o7-N>0ADf_gW z6UgFpGCj`^Dj^qe7#B?i!0+k&#lio7^8eOIaP%Li5$0O-F{bbAD>;79Ejy@jBMbJG zf!0^(mdEaHXV^e;&N=@n9A5MVHIm*Fs;N5r{ORfG3`9T0@bLs~4*%#Gyt@)de$pM9!jbImE`O{eLD6^F;`j9HAJTJop1J7CgW#3yS10e+CKLu8LJc=Vr ze+mp*U^k;O?pRIo5|^L3-q%Z(X(<>%zWPg+Q$_Ya>x#?)A6(vuwt+yYZ{Yf63Q7iP z6!G;jlmR-x{{K2cu@GwaX$j3ib!o5Kwf+0Bh3*b8xi9Bx5Fo&NG(ni!yIA!Q=tOhg z@K>LI2NJAY{ll9k=wACjC`tRVOnbMVu}Wbh40Q*^;r4=f=>Sl5!<*at>V`WBD@SIu z(~g*x1;8q~s8M@zSHO7pqBF@Nu{<<{h!)s0k=-9n*pOdxsb?ATl#fshy11r}kgjMr(zp zmrgy!1`GgS$AjgedV6H3o#n)fgIKOE55*#N0q(sdISa zbgW6#xKWc&%FwQDi}u{j=#e?X0MuKR?m&obWiAUC3ZM8oD*Y6=4tNQ)Vex>fzWx1G zroxzd3W0nWlQ%Rpj!9?fE#e|8ZO+R)1yQtB6K9lgTE|?t#2{HxIidHb)x0W6XFBq$ za}oz!BrsZ+)TX`}prO;x_<%~-mgaV0*Z5}KU#Or)75Q{kx7PekvIegLPBH`XrhdxL zJsdop@xw_nP)Y8gNsYaN{?lBrQWXB`Ba|y|+r^Y&2eODxrW19#C5pkLOaZ*5R>KL005$n$^cT1tC0H3HaMce+JgrFm>+m1AFL3GKghVyIcU v5@~v8GjIl=nR7IB^!2~i_s9s>0R^xU!Cvm#!+bzJ5C+iEfVS zog|+3d0qcJ_j5njb-(V{^W3i2OTUZL>HGbBkK?_LL!gG5;_jUXb`l7L-RG1PE)ocv zYVqH5#Lf6@U~y0t|7XX_>opWqB{N*bE) z`3HwRz25Xq|DB4zvdf0!vvhLRk2g-sKit&Ac*-bUd>%e}L`xuehg}nlqoAPJDoeAK z!_dgcbL0cPhlj_x7F@OKK70H5@o~$Z=(EIMzkbEV#hr6dCJ}C>amHu5DNGBt4>+)7&eq7Y5N9oUxP3*FQ6upXSYHG|iM-LxXvY94aiBR1{@ZR=0GKnyD zPA&0N(Y1Oi35oJxM*eNvwoUbv*;o7RVB|Ntb^ErXgTpNgiycH_KydK(XS*^t;yj$0nW>qjw*SBZX}2X+ zUER)4pZLVZUA|3v+m*EQrE-o(A)YN_&*REaD(1^&)G{Zq(y_%YuI`Hs_X6-(O z8S3`~HbjEL{NLri?OV6@FTD?C+8_;4_fYNL?J+w@VZ|otZ1eL|;xPC6`g$oXE31`> z$>*M)5H?mZ8*hW*-@g-LV*I;{i;E8(I-O#XdV2JXj6S?{wYPoP@9$>1-)&`Ob@%Sw(!aAqirU)RcJ_31bb5MvJ?o?K z)^{em?$LZ`XgJKr*YWjh-QTdVFg)6tA(eCIo;`au;ECTnSNU^hpvJhuwNA98wzf7y zCB~|+^6x}$m6g++DtFYW%X)hIt+rE8*p?aiwU*irHKY+zQlGXPed*_7<7xs(X+E>YHUhtilA=rTH(Bei`PXvej`1tsbH!e|; zk)N~Flgl@>_4QS_l`RiOM@MtBDXXZ=J4=q&uCL9v^!Hz}x3}kr`pL9AynkTe-GB`` z1*aY#8++r{t)77t0%2KIR`HyQih7*jp;M+ah*Qf$ltr)WJ>h0U1e;T)~_6-NqJjuNEJUctP=w>G? z9>nqEq1N15?r9Gc_wLzqQAg*!SwV?)pOLY#jMw^_dMM#-)>{e9)~ohEKUKKQo7vkJ z;79R*n&U;AK71f~=D%xfJaX{hlfuG6uZ{I~&++a?w8O4_Cr+O~e|ur9?cTk6?Oz{1 zetb$Oqb*HwVrawz% zrgF2h-517aSEu!L?excM?sTuNuHyQ8^RH8uHFlR+fBEu-LNrx6`}y;o)YSEfw{PE; z_ote4FnwF4$M4tr;nA^Y%aH^cwab@R>w+1ZqL0_G9eNZK(-JF?W?bdz{$g>myCglm zwyo{K?<0JCcWiB4a1Z59(^I|WS=rgYr>4SaOit{xAN?q9KdNeBVIeCktEU(D^5yNb zXYVH`8=IMBzIpQoWf>l>e(BOB7niaJ4=!B2I`GbSJDaro)0C9ABX-nm(raUFoaii0 z&NLkO-#^PS4|Io!#bzhmQzDId4L`P3g+@}9+WMrg|kI%xw0uaY*@vCm{ ze)U%S$sZN*ACq_a(fHTUdUmsVt2Hz?-?p+65fFH=pg^Eu+~zAgs$TkW`(R{J5>?#Z zHMi4(6hit%mS2bJ!{g)Qw^K16{#8b3_2@TFBQ!HJGox(n?d%x%4F36L_PEWD#l^+X zx$Yz=5e!DRfOhbufBl&yRy8v{3nV1f77a z_tW7uhMSiEfxG`i-~Z>&R3AQkh)lx8EhqtbQ&I?>Cm-?g^H?EJTR>Z+sq0CqF=R_s*R=mzI|NsaQ_AlVI~6VjF};LWMF`!G%O}Yx61Rc<;|NCqBVtuLJYx0u8ZTJ zZd0B1$BQ<5tL5e8?bx-8i>;cH$-v z95|pBCwRs{cGCt`gsQBrl*j4}S?abnG&IC7XOr;^VVv#F*V59uRdOD(BOoNC zHf}FRI$$v;C#-w_{{6V3*RNlbQq$5n*GukJdi?QRBiZ)9z00W>=3r;HhdHXz^f_p* zI4DT@|6nl?XGf#&_Wr8=#3L!YqZ$i~i*>ZL3QI~_K7C?6apkn4qVr7uCeIS3gEGC! z=g$55lGV~%?lfD|)pa@laPIy4_ag+rwT-Abq40WnqKmULuhE-JfU`Q2mj-2@-@Qvs z)1>gG=F&WUQd3jY!s1tK>^_`CZw{5KD?iW4VHGg(D=HH9R1%?)!=sgZ z|1i?>=bXyr%cr=w(zCNen$5uV6_u5q>uW33Keu_?;IM9Vbad!I43$_L`$dF=>=M3P z>9t`*Dn{vmRNT`B-jB7VtuP1+3p=_-{%0;pWZn4>E{QBI7O7m0mzI|1JR9o;9EjM{r-}y)W)`&WR_rHU;tp3ZU9DcL3QyTf%)h=00uuOlT0c*{q>6mT~;9%f$h6-t8=F!84_{Py=$5fP+4=^zm_0O$Y@I z4GkR~vzs^LqoePPwWe;TW)%_rBe$Y&7y;K9JppD}T9NBH?6a>j>- z=olDujEt;IO||~-f7W3Y6fEC<5gUBfRQyP_U#h%s=hA$-@?ng zji$=r5JIb_l*`=Kjct3=a9o+0XFtzFcqjQcnjYA{e?VlYK)VgR;Lgx<5@3A*RQ3Pk z^Qpr)ch{YU)uw`!J9iTE?vhTsvrE$?tEawKeEsIl8nghaA~H#vCoVo7bscQ&9uRIr z!#2P!UHvy|kTaC#^Or9tPo9h#dsunnpI?@B_xn>{yM5~4QQ^NN%Jf50n+WR_o40JC zmHVeQLhD1>G1ePF$Dvee1q4%koH7YYXN|}oNiSYZ4AupMN(>DQcr#fHE8X{tN_(z7 zefhGtqk}t>#iMcQ_jmi5e%ZXK&0w&|+27w!9(lI0wn^==&^dW|d1f~YE2~P+zo)F4 z8XD5GvX%kR%o3~B%}G-6^+SPMb?Mjo3=pW zFExwyNqVe0jC^>+!NGxgeE04hD=RBRH+%|IJ77wIc!-OOW-BcdQ~A}J`(VN!l^#sF zeXXrF0BGOs)S2n&Z*UjmUtd5t!{P)p94AwDOpGG&FEAP%;=674>iCP?kIl`8_6O$- z%sMNEG3UK{b@=Gf$0yA{K?UyGy&Li*`ndjmno}-w>4Aag%*?or%JTEcN-6DZs4J}2 zbL|&561KfLNpV_m8x`|D1_tPHGfPWL3yT$)G(U}t7eB{~T91B=E4cMN-?047`DAI2 z;f4peAb=4r0$2dh;ANO-k=aln3JVF5{`@Jplx^`PGf~WTGlxQs^|fnXa*eCn+uM(5 zX6|AZYlU|M`+ZJ72fOGz{ZC(uLjvU^xpm3H z;)vYS{QQf$y2}7PVk-1MfB_%q3U(NtlA-98=oT1W2z3oa3oW zr7$RR>sv%Z0y7Is;=_l-laq;Yar@cWlH=pcp>x#LTX@uy@Gj|@nYgEEsP&1?Tyo3|w4TUKC#9Xod5p18TWQ5Lw_@87@E@u)2D7`v-iVk6%-bJ{O|!vbiA*s3N@VW+ja>5{8^ghWV7lirR6Za zc{7;J)y0Lw?|nF16--{w{1S3a?O~U>LTlhPPZ4<>@+90vpU4?458cgyUrn@MYt@$c> z#sD;>veOovmVyZ6#ODGsHmt=uPm_% zeyvP&7fQ>^hxmV7^~sHa)|GZ$7&G?zn~|CdobpPLaH86fD71l)06c@2nW+>}Sj~@x z@qa6TaI1cLygEP?4Y$12TMHWXTMlQEh{{SzPodxbyv_wAH@x`sw8{6pH4CkhGrs;VI~^kc`( zXY^=kX|KHx2@DOD@>+MlbZMWlO?7oO`U`YM%_@-@8M7-@c7a zPbbI5I$%1`6x=EEJN84HAT zPEI^kmxE|td;BSW{P=)>%{e8dnS}+ezD^!4u2f5HkAHsT&R?i6C`F-j5@t6Bgn)Oe=8DvEXDk|2y%#YsgeeH;> zV!E%Yq@={j-kx*5ytsG?!G_tVgfg@|ZYX~3pu48#7sOI}ydCDtP0KynIy$Q>D`ylH zQ6ZOS0yFtCk__F=FWmXZ$Bi2|OlB6A!6FXCv)w=>^%gM=E^YLTI?=rXLoQevMJ9k9F>*4-*h);@( z8TdbUbU;*a6Q4jNKAc4n5`DzbgvGbJVJ)BeBx zG>Fv@n$bw+8WhR@&X2lGz0wq;J!td4Dwhg7Ees=~W**d#rqyNN;;d!}~n+*uupO!&Bd zaZiO?40}LluCe*`>*8W!0ejdge|~CeqRf5c`F9mfP|5Sy`iRS&9Z6?!$isXy7M#v@ zJ2QC)W;uv*?M|7{T`JMM12$sFdcj7S9dG1_$d+>udOv^uJR^f5SLQ}5`#(HY&c23a znhQUUUt|Qgj0_J;y3EzW`YkYS0fQLi&~iL{_z=F-)ZARu{8K_o3cG>IHa8p*`WD(` z{aNG#(;W>jbaPLMiNOVgvqJ`g04rOMV zkqD@xHm`8QnKuUqE?wC2&1!*0E|KzzXzg}L*b~CSET^jNN!&z2V zHXw7>;7tv(^x9g}x*+;eOSaW%@gv{*=rLx1NaayW_*U-3?>Punb6H;>)Prn8zPAof ziqGgx0FCSNRB!(~-!sg~(`7?1lIoWg=8qq0$x%-{BletBNGmB$q1j;`_*hk5P7XSq zRt~1&=+UF?k98rORnMRAg@;A!Mm5$ZtIQedQI@r4@ zyU_!ytbm5I!cVS2=#b3o{9;0G-MBHfx?>s1cMpgHUT=VsN{{2XfWRy~aA07ddrb1e zdj$;yE}%Y~92)BUdL~8R#C6^G^|{|jCTw1N?$HPe38i2X!tWiC=AwQyHKU@U zzCcsq(c=w~kPi(GqAu<1?9lSxZrwp5Y-4j`@hSocR3pANH$RUTJ`KiGfEiAE`t)0C z>npf&6k1z2gfDf~(MT!yejec?N1h?4EiEfMZd~c!nj&l3sN@%MrBTU;eP##ao;~@v z**2cj(Cd$oV#mb%oSZbgd|7$78j>LpDK44!_;H~1QBF>In%ae5U&t{?cw-jABy+q3 zvJ1)0{LhxY;@eDehq<^+fwaoX%B02oFTVA4bu8j`3OYK`btb>Y#@0wf;UxQTa8@!@ zgz+iNK*E~MqHLi|IjC0}qj&&O>dML&wX~R}T!n-k;9HQtLJ>mlis_gV{y;NWEg+@M z$jHDb;72MUNLX46?E^Daol6!)q9;y>d9IaaXWuG67Dcf%_)f9>dqM(n&#U~}&K&fF(Yo}{F-wpm0KX?2YZ4houm+?Vi0 zV9f-WxCXVlN+Pv)b_SPnR{pg5ySi8(#!|Dm4S{*{vVvxewAXrqWH~863ZsLD2b_q# z;4PHb+rVY*bbF}z#!vnTbn`LEzgn}cr+?PjRA0<5;@-V8U`M<&(Fc)O5Bk%n5Q7fH z-?UrrTDQLXehc$0A9gu;c_)m2Ix!-tIo4lp2!R9_3SzOgu;3sL;t}_hBsMjuRc24D7H%W^CzB`G}n;5`Wv= zoRNhkREFz@r6t)ABV98wc``$yF_c~@-{iQyQD!`IZ!JLw{q4C4gA7(__tL`!m|Rq? z%{776;ckDE<4^!StDvdUwQCqe{La=Z*t2I(Pj4?Q2j&vHcI_&L+XO)((nrd@7f^NU z)*7-+vR*5*|LN-LiewUi6&D-(^!fAApFeXA%JS1@p-^vjWS7|v-4EEUND^Wr%+%T0*aQRy{;KsVi;jtT0W*9} zc|%Uag3X&X*S_!UnTLH#1jFsq|8nRcp%=5g&i35XASDQ}EZaBx_ma)fpQmxJL?;7g4;MJ>dRbF07N)5=Oi=C#87Je~O zKOY+#L()!Z?B8tG@>uwVJ>Afj#=XKKA`Fa-$zrzEpFXK!^oFpbeNc*k3sxM8ijBQw zY^=_(4WyfZ*d}Y-VvgQ<r-M4+;+M_L%LzW^Jv0Jo5`5L+~M3+0+&Hom^iw*olJ(jmZfviZ$ifuD z)nVcL)MZrT1V=zq2tWYSC;j&>=@Wj{xh;nd^wR=H}*xA18OkpwDL5UXJ1V z-wn-vyCo7_hp>Q0V#SDwG~RKImw~eCSXT5ko*0M@41iJO{G_7vUPpylbyC*fGr{)9*%TEFbS+?+$%{0nXXUBfPxBHe$%lq^@n8%-zA0GKQY#%*)sMsA0QIDho7Ryh3kwRq zw6>PojePLiLDyxdxOcH^0%s^ z(k#vCPrHY%UB8}@k}`ul5Mu~G4Tv)&EIC=vGBOTbQjf}g#a*P8)6ahfdCd<{+3a9l z=^gXFN{_~_L=Z*w1o69Wd1b`BIYzvt*?p*SUmqW`td{A!=^GOAadmN`&1<3qJ`OlA zJ#207;_3=flw(}Aj@Wy+!JS`sGKVwBOHME&I3d9R1X{ViI)N0=^Uq`nX=GJJg<;Ru zSz5JP(usW`Z{NPfdIZjPd9pjEeh7@WpNYxqc@lTg+ZVpRTZ**!q8ho5*`c~d0T&7i zFiH-ZlWMcIKMRlxtpxdOHDZDy1v4s!vl{B@ea}*7gH*!Mx2(KeQ9%K*wZZu}#l;$3jfH8CqUFu{mSs%G2`AaHu`UuSaN+}x>q z>c;G}xEFb@i`ABYKU|&3y+H8hzu@6fQB}18X9Pn49R%S8-0zxt?6&m#K~z+Cp@n9r z(+9JHa8{{RAfl6r{?%z!{mYk;OM#xPVLsuTKdGr}2{ACF>)yGugi@}ksGyaD1$?3N z5*-W_+*e5ChxG9Yw1|sjQbZ~)O`*qH_vqXXH*?p&tB!Ev+qZA`Yeh(Xs$@%B-lc2|B!k@e z6HnL;EAjK^B6+qGOMr_5uZ`k&GUSDQLZSiz%)-KgwIEtKcr?`B-_?oSa_JZRCk+tn zB!)er8GaXJG(c(!Q5OY*-O&_1EV^^71tZJs_Vr{4hDR0ItQw1?s-Y z&VFMvP>tE9QKfsC!>^0R#>P@o73j-dY|=d+J_H#QT7D&CJMukT4L2(>QpZeHHs$i)!@@bd9-_a$pmU&HS@ckbL1w!lmH zCsE1`n>34{UDNAZ$4_>`NJ7Q3iQAdNA|NwBDiRtVE@MBst50m#wjn4KB!i|sPi^-} z+~IY3gH)e$yRN1tT?qYnbpfA_Pu}1krhu?8ZtD7P-}WVQ;Wj!xf5rmSX&ajv{1U85 zDN2<$yhA#KH6>8Vc`4DSdDT2em+F$#5^IKL{nqM2_n*AaU$AgvQpcmW%1frGi&ahu zSqt`v&Ys;Cb9QldR$h;5zT=Ehy^RJyz>E7y1BR@0Sq*#9kH97oP2Pt#`Y13j>Mcoz&$)EfcPTIsl@SE-Pqk3!+fmLvbJ4*U5nndvLIMN zM{Hdy`zgJ6)$o^RbbcFkiP9bi%o*Hww|~KK0R-&R<@=&?@VRekml5_&GBdg50(i5M zv3GL$^5f{}Q7qWqx|M(_^>8B{?gfL|=GLs|r5BIQ0ihAgpo2t2MZNBPs*bccbB1hy z#hBGlTbRz%lE>NaC}_59-i%pG=SzLXNyH1kZ~trx_8>@#+554u77xl9V9-ze1#KMrp!<4kBNyHXKOGf zEn1xprSIz_toCJ9_8x8Uxo~hGN>M4hLAYw>%d<4x@(#0T*3j(LAhwGyDi8YE6iH!8 z2G7usCZ?%QSdpw6M@G=Rz!sqL&*u1gQ$g&Y)szr(KkB+rJIyT)*}20sKj{&tjsD*) zduis{D)f^VeF<}TlmIuWo?J~!OKt@=Y+>b~U;i^19XmWDZ=t+di9&4o8 zG{x}O<>frw+!q-I;#Bj4Zh{DPbUJ`{Gre4u>#?!1`beZ8$qQtD`1|#pd=wpx)EJW| zPwe`w6CG>r??#9UABcBePYVm@tvdAD1-2>z>AyH9j zg2SbtWFYUmxN~9-sD-*?Cte6sa0hB55rG`nR;QIRN$U-FGk{v~oxnGvB}T+E^!-$P45eRM-))ue^jw`0Uq( zmpM7>drYAAorW7|D=*Dzb7o2}CO`KfM=6#Mk>-;lf`S6XN;da~)axK5Z9B5{d}ded z)UwouB5$GVV~35E^RYQ=ymw6n_U+31 zWZW|p%v7r=hT*Z4s5DxIbT6y4)EUz$lT%yA*EV*P=z@x=SK@Vhw^gcP7%t>(`d@rL zy^QICI2J)5y^(=>Zv0(V_t5@D9&F5hkMup*!L`@ptyL7LCs-~cJ>A*O&D_+~!9$hG zKP@ZE2_PO25CFM>s3B+K+Ql;p3cQA|7c^Bk;x@OQheL64GJbXCE+h!NGJGeL7f&f> zjN0z*l2%^D!zqV_cSs0bDG?ABuB+RMPzX$*3P$tOP*eK^sUsmZ8Y^%O5seuH2*4M; zwBv|f&|&@)Pq5^3`R2`utY|qwij;URZf}HkRCxgX>QP6%@M+XBftpI-T+qZA1 zZ~uGuAX@O@fB!z#HShySbm%ztvam>D+5o$5Y}|*vOsF3>S63Zv?FYxuD|Pkt^^kJ@ z{-Df;h6apCfa3@Kx>#Q2<+b(o$sjpHR%5^y!;H%M3%lLBKN|WpB7(+%w)ySbE6Dqh zp~>wGDk(1ZEdFLMEBg*X@6&sWq&KdMh~6EnX4LPR?mR8p*wmz{t$m1X34?Q4*;G8# zu0jjMtPl-`c_#Oe{bN}rDCh$e3Q(yr(l`0J_BX5Za+M|?(9wICBXaqkT-niVrKzEj zg279Ax*ttYc)0Ov2Mf%iF>(PRmfY^f9*jQ?fE&L52gWZbAXC#}VDr*+-v-DgA|e9T z0GB%TEzcL3_a=l5n6U#QuyE4w@^O4Tkb6HXYf@}1vdr~07Z|hnX3zQ2X0RjOo;`d9 zrQS3LxA&FVXZ1G_Q<1P>?O-5qp!0cue?P_~*qipYN_+XzP)kce8mrFeIvq_-dE&Wq ze}D2{P*Djs$ihJRg0g&({tKES-KZH&ie1mP?CdzRrsbh-ds09^54A+LGYuUb>S{T^R@j>Kj0~(WP_aqhx_Pr{X!cD-#d%d#AdHr_Hnwe1U@azjGu~MK zB9*7Nzr?a5VpWhiz%ZPKY*z(MiNSSUxPipP#L&?5Kq^fC#Yvzo3dOU;#t$E`B}Spn zD=Ny!A!Je;Anmcru9Qh|V8RDRNTVOXN}#VHOF!hUwTW0Nf`j{KM44;mSzfgBT>EBU zpSsnp+xKP%f17&MOIAGY`+8f?*+Y zx#ZUvD?J41U}m1fkF0~})6mkA`|R1fa(3e8s-*~D%CL{30tQ9=WFP<7M~;W!5M@;1 zO0j)AI`mU@^%D$WUcYw5vVijiv>~!Tc*~L!(Wpi^byJ9__Gd^QHEkQ;VYYkcCjHW6 zx9%(Mt7>XgMVFG{jQhRa9cd|!F%0f`KR8dCy=Jf?ikpPdfD$i7TsMIYLOgeR1_qD~ znK(Xv%zpZ`p{>pKt@kEX?)j2F&!(0Zuf=itl@)DQ*He{re^GddKhZMiO`zwv4njjH z=dYhXBSgZJ!UX+-hDJkUqqxIZE1(8B8LqrOl!=jvNrg%+Yz@~44~7VIt9p3CKE7qi ztJQuR;q?AB9Im{!Eo_6F-)HM4DFee1{*p#p>5Y}#rAH9wA>Kq!38_7k=hP&79D>rm z_~!SERfnV=Bq?G&0AmDqnF^j~53o#5*l{iI5)5Nx(wT4};1IvLsk8Zifvo=qeIv{S z;{ZAj7KC2ojC9<6<=y>!NyP25v{T7@*|5;MiI1*V9{g(%dO>w3B_)Tn-06S3Vp%+ad`I3-O@P5g$hO|7lN zb<45D8yp-Q6-6f(P(SqYQl8JLfQ*b0q;JSH%7>H)Bq8#Wv$lpt|KQ*rR#qdd;!pA) zKaN%C_uuI_xQ-nwC+|Fr+Lf7dpCJO6Fk|jU>to}`y&O9hbe+F9(d_5aWH&riuZr@ z3hSpfA08fYU|}SsY6hy|2sOnS+CwJ7d%*^}U7`0r#e!Y}s?_T&U zS~)mC^4iYN@U7l0cbnYV`M{_6!xuw^TH ztlSCGlzj7dOZPG|Mv=E~Q&LWVG`+nEYp<}mDk2j7x)O907Dg3HH#0wv^(!3B9Y@E| zz`z}plxem$1QK=!Q{)inW@pa8O&h<6swyu`8_E`NAP5Y7}QobC=rMhF)QAl$dhC?)(S#GLU0jr)z}W_Ja`Z$ zpu~B05D}%3n%Wf9D0vYA!4f8A;NmAw2A%pm6j^>kjY5}^7x%CSfCOZ8YD(I)f#%H^ zIok{k-AzUHsi8s4c94wrI0D`5O9MkgQOU_wsALw2JJ{Ym8K)`|-;2Fx)D?RAjuZRa zsvTQ6Y6on{Yj{#v)E~Qweu*Rh+0MWJ)2#pa-7$7jq71e<54z3`@4%me$)3P?1(e1m mg|``ViB;v!@wrd4Ds$Pe%688QdLF!#aPEwnLXO-OpZ^7iEj}m! diff --git a/src/Config.hs b/src/Config.hs index c0ad7e955..e6a5a9f7f 100644 --- a/src/Config.hs +++ b/src/Config.hs @@ -9,16 +9,19 @@ -- |Compiler configuration parameters. These may vary between -- OSes. module Config (sourceExtension, objectExtension, executableExtension, - bitcodeExtension, assemblyExtension, archiveExtension, - moduleDirectoryBasename, currentModuleAlias, + bitcodeExtension, assemblyExtension, nativeAssemblyExtension, + archiveExtension, moduleDirectoryBasename, currentModuleAlias, specialChar, specialName, specialName2, initProcName, wordSize, wordSizeBytes, availableTagBits, tagMask, smallestAllocatedAddress, minimumSwitchCases, magicVersion, - linkerDeadStripArgs, functionDefSection, removeLPVMSection, + linkerDeadStripArgs, removeLPVMSection, + llvmToBitcodeCommand, llvmToNativeAssemblerCommand, + llvmToObjectCommand, lpvmSectionName, localCacheLibDir) where +import Options import Data.Word import qualified Data.List as List import Distribution.System (buildOS, OS (..)) @@ -28,6 +31,7 @@ import System.Process import System.FilePath import System.Directory.Extra (getHomeDirectory) + -- |The file extension for source files. sourceExtension :: String sourceExtension = "wybe" @@ -48,11 +52,16 @@ bitcodeExtension :: String bitcodeExtension = "bc" --- |The file extension for assembly files. +-- |The file extension for LLVM assembly files. assemblyExtension :: String assemblyExtension = "ll" +-- |The file extension for native assembly files. +nativeAssemblyExtension :: String +nativeAssemblyExtension = "s" + + -- |The file extension for object archive files. archiveExtension :: String archiveExtension = "a" @@ -143,7 +152,7 @@ localCacheLibDir = do -- | Magic version number for the current iteration of LPVM. magicVersion :: [Word8] magicVersion = - let magicStr = "WB01" + let magicStr = "WB02" in List.map (fromIntegral . fromEnum) magicStr @@ -157,24 +166,40 @@ linkerDeadStripArgs = os -> error $ "Unsupported OS: " ++ show os --- | Given the name of a function and return which section to store it, --- Nothing means the default section. For now, we put functions in separate --- sections on Linux to fit the "-Wl,--gc-sections" above. -functionDefSection :: String -> Maybe String -functionDefSection label = +-- | Command and switches to compile a .ll file to bitcode. +llvmToBitcodeCommand :: FilePath -> FilePath -> Options -> (String, [String]) +llvmToBitcodeCommand llFile bcFile _ = case buildOS of - OSX -> Nothing - Linux -> Just $ ".text." ++ label + OSX -> ("llvm-as", ["-o", bcFile, llFile]) + Linux -> ("llvm-as", ["-o", bcFile, llFile]) + os -> error $ "Unsupported OS: " ++ show os + + +-- | Command and switches to compile a .ll file to native assembler. +llvmToNativeAssemblerCommand :: FilePath -> FilePath -> Options + -> (String, [String]) +llvmToNativeAssemblerCommand llFile sFile options = + let opt = "-O" ++ show (optLLVMOptLevel options) + in case buildOS of + OSX -> ("llc", ["--filetype=asm", opt, "-o", sFile, llFile]) + Linux -> ("llc", ["--filetype=asm", opt, "-o", sFile, llFile]) + os -> error $ "Unsupported OS: " ++ show os + + +-- | Command and switches to compile a .ll file to an object file. +llvmToObjectCommand :: FilePath -> FilePath -> Options -> (String, [String]) +llvmToObjectCommand llFile oFile options = + let opt = "-O" ++ show (optLLVMOptLevel options) + in case buildOS of + OSX -> ("llc", ["--filetype=obj", opt, "-o", oFile, llFile]) + Linux -> ("llc", ["--filetype=obj", opt, "-o", oFile, llFile]) os -> error $ "Unsupported OS: " ++ show os -- | The section name of the LPVM object file section. This includes the -- segment name, as well, and the format varies depending on object file format. lpvmSectionName :: String -lpvmSectionName = case buildOS of - OSX -> "__LPVM,__lpvm" - Linux -> "__LPVM.__lpvm" - os -> error $ "Unsupported OS: " ++ show os +lpvmSectionName = "__LPVM,__lpvm" -- | Remove the lpvm section from the given file. It's only effective on Linux, @@ -184,7 +209,7 @@ removeLPVMSection target = case buildOS of OSX -> return $ Right () Linux -> do - let args = ["--remove-section", "__LPVM.__lpvm", target] + let args = ["--remove-section", lpvmSectionName, target] (exCode, _, serr) <- readCreateProcessWithExitCode (proc "objcopy" args) "" case exCode of diff --git a/src/Emit.hs b/src/Emit.hs index 84b80f71e..cd6c6ca9e 100644 --- a/src/Emit.hs +++ b/src/Emit.hs @@ -1,22 +1,28 @@ -- File : Emit.hs --- Author : Rishi Ranjan, Modified by Zed(Zijun) Chen. +-- Author : Rishi Ranjan, Modified by Zed(Zijun) Chen and Peter Schachte. -- Purpose : Emit LLVM code -- Copyright: (c) 2016 Peter Schachte. All rights reserved. -- License : Licensed under terms of the MIT license. See the file -- : LICENSE in the root directory of this project. module Emit (emitObjectFile, emitBitcodeFile, emitAssemblyFile, - makeArchive, makeExec, - logLLVMString, extractLLVM + emitNativeAssemblyFile, makeArchive, makeExec, extractLLVM, + logLLVMString ) where import AST import BinaryFactory (encodeModule) -import Blocks (concatLLVMASTModules) -import Config -import Control.Monad ( (>=>), unless ) -import Control.Monad.Trans (liftIO) +import Config (objectExtension, bitcodeExtension, + assemblyExtension, + nativeAssemblyExtension, + linkerDeadStripArgs, + llvmToBitcodeCommand, + llvmToNativeAssemblerCommand, + llvmToObjectCommand, + removeLPVMSection) +import Control.Monad ( (>=>), unless ) +import Control.Monad.Trans (liftIO, lift) import Control.Monad.Trans.Except import Control.Monad.Trans.State import qualified Data.ByteString as BS @@ -26,28 +32,28 @@ import Data.List as List import Data.Map as Map import qualified Data.Text.Lazy as TL import Distribution.System (buildOS, OS (..)) -import qualified LLVM.AST as LLVMAST -import LLVM.Context -import LLVM.Module as Mod -import LLVM.PassManager -import LLVM.Pretty (ppllvm) -import LLVM.Target -import LLVM.Analysis (verify) import ObjectInterface -import Options (LogSelection (Blocks,Builder,Emit), +import Options (LogSelection (LLVM,Builder,Emit), Options(..), optNoVerifyLLVM, optLLVMOptLevel, optimisationEnabled, OptFlag(LLVMOpt)) +import qualified Version import System.Exit (ExitCode (..)) -import System.Process +import System.IO (openFile, hClose, Handle, + IOMode (WriteMode), hPutStrLn) +import System.Process (proc, readCreateProcessWithExitCode) import System.FilePath ((-<.>)) -import System.Directory (getPermissions, writable, doesFileExist) +import System.Directory (getPermissions, writable, doesFileExist, removeFile) import Util (createLocalCacheFile) -import LLVM.AST (Module(moduleDefinitions), Definition (GlobalDefinition), Type (ArrayType, IntegerType)) -import LLVM.AST.Global -import qualified LLVM.AST.Global as G -import qualified LLVM.AST.Constant as C +import LLVM import Data.String -import Config (lpvmSectionName) + +---------------------------------------------------------------------------- +-- For now, make placebo definitions of LLVM-related types +---------------------------------------------------------------------------- + +type LLVMModule = () +type Definition = () +type PassSetSpec = [String] -- This does not check the permission if the file does not exists. @@ -62,20 +68,14 @@ _haveWritePermission file = do else return True --- | With the LLVM AST representation of a LPVM Module, create a --- target object file, embedding the 'AST.Module' serialised bytestring --- into the '__lpvm' section of the Macho-O object file. +-- | With a LPVM Module, create a target object file, including the serialised +-- bytestring of the LPVM module. emitObjectFile :: ModSpec -> FilePath -> Compiler () emitObjectFile m f = do - let filename = f -<.> objectExtension - logEmit $ "Creating object file for *" ++ showModSpec m ++ "*" ++ - " @ '" ++ filename ++ "'" - logEmit $ "Encoding and wrapping Module *" ++ showModSpec m - ++ "* in a wrapped object." - logEmit $ "Running passmanager on the generated LLVM for *" - ++ showModSpec m ++ "*." - modBS <- encodeModule m - llmod <- descendentModuleLLVM m + let filename = f -<.> Config.objectExtension + llFilename <- emitAssemblyFile m f + logEmit $ "===> Producing object file " ++ filename + userOptions <- gets options filename <- do writable <- liftIO $ _haveWritePermission filename if writable @@ -84,85 +84,79 @@ emitObjectFile m f = do logEmit $ "Do not have write permission on file " ++ filename ++ ", use local cache file instead" liftIO $ createLocalCacheFile filename - logEmit $ "===> Writing object file " ++ filename - makeWrappedObjFile filename llmod modBS + let (cmd,cmdLine) = llvmToObjectCommand llFilename filename userOptions + runOSCmd cmd cmdLine + lift $ removeFile llFilename -- | With the LLVM AST representation of a LPVM Module, create a -- target LLVM Bitcode file. emitBitcodeFile :: ModSpec -> FilePath -> Compiler () emitBitcodeFile m f = do - let filename = f -<.> bitcodeExtension - logEmit $ "Creating wrapped bitcode file for *" ++ showModSpec m ++ "*" - ++ " @ '" ++ filename ++ "'" + let filename = f -<.> Config.bitcodeExtension + llFilename <- emitAssemblyFile m f -- astMod <- getModule id - logEmit $ "Encoding and wrapping Module *" ++ showModSpec m - ++ "* in a wrapped bitcodefile." - -- modBS <- encodeModule astMod - modBS <- encodeModule m - llmod <- descendentModuleLLVM m - logEmit $ "===> Writing bitcode file " ++ filename - opts <- gets options - liftIO $ makeWrappedBCFile opts filename llmod modBS + logEmit $ "===> Producing bitcode file " ++ filename + userOptions <- gets options + let (cmd,cmdLine) = llvmToBitcodeCommand llFilename filename userOptions + runOSCmd cmd cmdLine + lift $ removeFile llFilename --- | With the LLVM AST representation of a LPVM Module, create a --- target LLVM Assembly file. -emitAssemblyFile :: ModSpec -> FilePath -> Compiler () +-- | Create a target LLVM Assembly (.ll) file. This function forms the basis +-- for all LLVM code generation. +emitAssemblyFile :: ModSpec -> FilePath -> Compiler FilePath emitAssemblyFile m f = do - let filename = f -<.> assemblyExtension + let filename = f -<.> Config.assemblyExtension logEmit $ "Creating assembly file for " ++ showModSpec m ++ ", with optimisations." - llmod <- descendentModuleLLVM m - logEmit $ "===> Writing assembly file " ++ filename + logEmit $ "===> Writing LLVM assembly file " ++ filename opts <- gets options - let withMod = if optimisationEnabled LLVMOpt opts then withOptimisedModule else withModule - liftIO $ withMod opts llmod - (\mm -> withHostTargetMachineDefault $ \_ -> - writeLLVMAssemblyToFile (File filename) mm) - --- | Concatenate the LLVMAST.Module implementations of the descendents of --- the given module. -descendentModuleLLVM :: ModSpec -> Compiler LLVMAST.Module -descendentModuleLLVM mspec = do - someMods <- sameOriginModules mspec - unless (List.null someMods) $ - logEmit $ "### Combining descendents of " ++ showModSpec mspec - ++ ": " ++ showModSpecs someMods - llmod <- concatLLVMASTModules mspec someMods - modBS <- encodeModule mspec - logEmit $ "### flattened LPVM module to " ++ show modBS - addLPVMtoLLVM mspec llmod modBS - - --- | Create a definition to hold the encoded LPVM for a module as LLVM data -lpvmDefine :: ModSpec -> BL.ByteString -> Definition -lpvmDefine mspec modBS - = GlobalDefinition $ globalVariableDefaults { - name = LLVMAST.Name $ fromString $ show mspec - , isConstant = True - , G.type' = ArrayType (fromIntegral $ BL.length modBS) (IntegerType 8) - , initializer = Just $ C.Array (IntegerType 8) - $ List.map (C.Int 8 . fromIntegral) - $ BL.unpack modBS - , section = Just $ fromString lpvmSectionName - } - - --- | Inject the linearised LPVM byte string into the LLVM code, so that it can --- later be extracted from the generated object file. -addLPVMtoLLVM :: ModSpec -> LLVMAST.Module -> BL.ByteString -> Compiler LLVMAST.Module -addLPVMtoLLVM mspec llmod modBS = do - return $ llmod { moduleDefinitions = lpvmDefine mspec modBS:moduleDefinitions llmod} + handle <- liftIO $ openFile filename WriteMode + writeLLVM handle m True True + liftIO $ hClose handle + return filename + + +-- | With the LLVM AST representation of a LPVM Module, create a target native +-- assembly language file. +emitNativeAssemblyFile :: ModSpec -> FilePath -> Compiler () +emitNativeAssemblyFile m f = do + let filename = f -<.> Config.nativeAssemblyExtension + llFilename <- emitAssemblyFile m f + -- astMod <- getModule id + logEmit $ "===> Producing bitcode file " ++ filename + userOptions <- gets options + let (cmd,cmdLine) = + llvmToNativeAssemblerCommand llFilename filename userOptions + runOSCmd cmd cmdLine + lift $ removeFile llFilename + + +-- | Compile the specified .ll file to the specified output file, using the +-- the configured LLVM assembler with the specified switches. +runOSCmd :: String -- OS command to run + -> [String] -- commandline arguments + -> Compiler () +runOSCmd cmd cmdLine = do + logEmit $ "Running command: " ++ cmd ++ concatMap (" "++) cmdLine + (exCode, _, serr) <- liftIO $ + readCreateProcessWithExitCode (proc cmd cmdLine) "" + case exCode of + ExitSuccess -> do + logEmit $ "completed successfully" + ++ "\nstderr:\n" ++ serr + ++ "\n-------\n" + _ -> Error serr -- | Handle the ExceptT monad. If there is an error, it is better to fail. liftError :: ExceptT String IO a -> IO a liftError = runExceptT >=> either fail return --- | Return string form LLVM IR represenation of a LLVMAST.Module -codeemit :: Options -> LLVMAST.Module -> IO BS.ByteString -codeemit opts llmod = withOptimisedModule opts llmod moduleLLVMAssembly +-- | Return string form LLVM IR represenation of a LLVMModule +-- codeemit :: Options -> LLVMModule -> IO BS.ByteString +-- codeemit opts llmod = withOptimisedModule opts llmod moduleLLVMAssembly -- codeemit noVerify llmod = withModule noVerify llmod moduleLLVMAssembly @@ -173,12 +167,13 @@ codeemit opts llmod = withOptimisedModule opts llmod moduleLLVMAssembly -- | Setup the set of passes for optimisations. -- Currently using the curated set provided by LLVM. passes :: Word -> PassSetSpec -passes lvl = defaultCuratedPassSetSpec { optLevel = Just lvl } +-- passes lvl = defaultCuratedPassSetSpec { optLevel = Just lvl } +passes lvl = ["-O" ++ show lvl] --- -- | Return a string LLVM IR representation of a LLVMAST.Module after +-- -- | Return a string LLVM IR representation of a LLVMModule after -- -- a curated set of passes has been executed on the C++ Module form. --- codeEmitWithPasses :: LLVMAST.Module -> IO BS.ByteString +-- codeEmitWithPasses :: LLVMModule -> IO BS.ByteString -- codeEmitWithPasses llmod = -- withContext $ \context -> -- withModuleFromAST context llmod $ \m -> @@ -189,7 +184,7 @@ passes lvl = defaultCuratedPassSetSpec { optLevel = Just lvl } -- else error "Running of optimisation passes not successful!" -- -- | Testing function to analyse optimisation passes. --- testOptimisations :: LLVMAST.Module -> IO () +-- testOptimisations :: LLVMModule -> IO () -- testOptimisations llmod = do -- llstr <- codeEmitWithPasses llmod -- putStrLn $ replicate 80 '-' @@ -200,93 +195,66 @@ passes lvl = defaultCuratedPassSetSpec { optLevel = Just lvl } -- | Using a bracket pattern, perform an action on the C++ Module --- representation of a LLVMAST.Module after the C++ module has been through +-- representation of a LLVMModule after the C++ module has been through -- a set of curated passes. -withOptimisedModule :: Options -> LLVMAST.Module -> (Mod.Module -> IO a) -> IO a -withOptimisedModule opts@Options{optLLVMOptLevel=lvl} llmod action = - withModule opts llmod $ \m -> do - withPassManager (passes lvl) $ \pm -> do - success <- runPassManager pm m - if success - then action m - else error "Running of optimisation passes not successful" - - --- | Bracket pattern to run an [action] on the [LLVMAST.Module]. -withModule :: Options -> LLVMAST.Module -> (Mod.Module -> IO a) -> IO a -withModule Options{optNoVerifyLLVM=noVerify} llmod action = - withContext $ \context -> - withModuleFromAST context llmod $ \m -> do - unless noVerify $ verify m - action m - - - ----------------------------------------------------------------------------- --- Target Emitters -- ----------------------------------------------------------------------------- - --- | Use the bitcode wrapper structure to wrap both the AST.Module --- (serialised) and the bitcode generated for the Module -makeWrappedBCFile :: Options -> FilePath -> LLVMAST.Module -> BL.ByteString -> IO () -makeWrappedBCFile opts file llmod modBS = - withOptimisedModule opts llmod $ \m -> do - bc <- moduleBitcode m - let wrapped = getWrappedBitcode (BL.fromStrict bc) modBS - BL.writeFile file wrapped - --- | Create a Macho-O object file and embed a 'AST.Module' bytestring --- representation into the '__lpvm' section in it. -makeWrappedObjFile :: FilePath -> LLVMAST.Module -> BL.ByteString -> Compiler () -makeWrappedObjFile file llmod modBS = do - tmpDir <- gets tmpDir - opts <- gets options - liftIO $ withContext $ \_ -> - withOptimisedModule opts llmod $ \m -> do - withHostTargetMachineDefault $ \tm -> - writeObjectToFile tm (File file) m +-- withOptimisedModule :: Options -> LLVMModule -> (LLVMModule -> IO a) -> IO a +-- withOptimisedModule opts@Options{optLLVMOptLevel=lvl} llmod action = +-- withModule opts llmod $ \m -> do +-- withPassManager (passes lvl) $ \pm -> do +-- success <- runPassManager pm m +-- if success +-- then action m +-- else error "Running of optimisation passes not successful" + + +-- -- | Bracket pattern to run an [action] on the [LLVMModule]. +-- withModule :: Options -> LLVMModule -> (LLVMModule -> IO a) -> IO a +-- withModule Options{optNoVerifyLLVM=noVerify} llmod action = +-- withContext $ \context -> +-- withModuleFromAST context llmod $ \m -> do +-- unless noVerify $ verify m +-- action m ---------------------------------------------------------------------------- -- -- * Linking -- ---------------------------------------------------------------------------- --- * Link time dead code elimination -- More detail can be found here: https://github.com/pschachte/wybe/issues/60 --- There are two goals: (1) remove unused code. (2) remove the lpvm section --- On macOS (1) (2) are done by using linker arg: `-dead_strip` --- On Linux (1) is done by using linker arg: `--gc-sections` (requires separate --- ELF section for each function). (2) is done by calling `objcopy` after the --- linker build the executable. +-- * Link time dead code elimination -- More detail can be found here: +-- https://github.com/pschachte/wybe/issues/60 There are two goals: (1) remove +-- unused code. (2) remove the lpvm section. On macOS, (1) (2) are done by +-- using linker arg: `-dead_strip`. On Linux, (1) is done by using linker arg: +-- `--gc-sections` (requires separate ELF section for each function). (2) is +-- done by calling `objcopy` after the linker build the executable. -- XXX it's better to use the linker to remove the lpvm section. -- | Remove OSX Ld warnings of incompatible built object file version. - suppressLdWarnings :: String -> String suppressLdWarnings s = intercalate "\n" $ List.filter notWarning $ lines s where notWarning l = not ("ld: warning:" `List.isPrefixOf` l) --- | With the `ld` linker, link the object files and create target --- executable. +-- | Using `cc` as a linker, link the object files and create target executable. makeExec :: [FilePath] -- Object Files -> FilePath -- Target File -> Compiler () makeExec ofiles target = do - let options = ["-no-pie"] ++ linkerDeadStripArgs + let options = "-no-pie" : Config.linkerDeadStripArgs -- let options = linkerDeadStripArgs - let args = options ++ ofiles ++ ["-o", target] + let args = List.filter (not . List.null) + $ options ++ ofiles ++ ["-o", target] logEmit $ "Generating final executable with command line: cc " ++ unwords args (exCode, _, serr) <- liftIO $ readCreateProcessWithExitCode (proc "cc" args) "" case exCode of ExitSuccess -> do - logMsg Blocks $ "--- CC ---\n" + logMsg LLVM $ "--- CC ---\n" ++ "$ cc " ++ unwords args ++ "\nCC Log:\n" ++ suppressLdWarnings serr ++ "\n-------\n" - result <- liftIO $ removeLPVMSection target + result <- liftIO $ Config.removeLPVMSection target case result of Right () -> return () Left serr -> Error serr @@ -319,26 +287,27 @@ logEmit = logMsg Emit -- | Log LLVM IR representation of the given module. logLLVMString :: ModSpec -> Compiler () logLLVMString thisMod = do - reenterModule thisMod - maybeLLMod <- getModuleImplementationField modLLVM - case maybeLLMod of - (Just llmod) -> do - let llstr = ppllvm llmod - logEmit $ replicate 80 '-' - logEmit $ TL.unpack llstr - logEmit $ replicate 80 '-' - Nothing -> error "No LLVM Module Implementation" - reexitModule + -- reenterModule thisMod + -- maybeLLMod <- getModuleImplementationField modLLVM + -- case maybeLLMod of + -- (Just llmod) -> do + -- let llstr = ppllvm llmod + -- logEmit $ replicate 80 '-' + -- logEmit $ TL.unpack llstr + -- logEmit $ replicate 80 '-' + -- Nothing -> error "No LLVM Module Implementation" + -- reexitModule return () -- | Pull the LLVMAST representation of the module and generate the LLVM -- IR String for it, if it exists. extractLLVM :: AST.Module -> Compiler String extractLLVM thisMod = do - opts <- gets options - case modImplementation thisMod >>= modLLVM of - Just llmod -> liftIO $ B8.unpack <$> codeemit opts llmod - Nothing -> return "No LLVM IR generated." + return "No LLVM generation yet" + -- opts <- gets options + -- case modImplementation thisMod >>= modLLVM of + -- Just llmod -> liftIO $ B8.unpack <$> codeemit opts llmod + -- Nothing -> return "No LLVM IR generated." -- | Log the LLVMIR strings for all the modules compiled, except the standard -- library. diff --git a/src/LLVM.hs b/src/LLVM.hs new file mode 100644 index 000000000..9cf25a26d --- /dev/null +++ b/src/LLVM.hs @@ -0,0 +1,2199 @@ +-- File : LLVM.hs +-- Author : Peter Schachte, based on work by Ashutosh Rishi Ranjan +-- Purpose : Generate LLVM code from LPVM form +-- Copyright: (c) 2024 Peter Schachte. All rights reserved. +-- License : Licensed under terms of the MIT license. See the file +-- : LICENSE in the root directory of this project. + + +module LLVM ( llvmMapBinop, llvmMapUnop, writeLLVM, BinOpInfo(..) ) where + +import AST +import ASTShow +import Resources +import BinaryFactory +import Config +import Options +import Version +import CConfig +import Snippets +import Util ((|||), showArguments, sameLength) +import System.IO +import Data.Char (isAlphaNum) +import Data.Set as Set +import qualified Data.Map as Map +import Data.Map (Map) +import Data.List as List +import Data.List.Extra +import Data.Maybe +import Control.Monad.Trans +import Control.Monad.Trans.State +import Control.Monad +import Control.Monad.Extra +import Control.Monad.IO.Class +import Data.Tuple.HT +import qualified Data.ByteString as B +import qualified Data.ByteString.Lazy as BL +import qualified Data.ByteString.Internal as BI +import Distribution.TestSuite (TestInstance(name)) + + +-- BEGIN MAJOR DOC +-- +-- # Generating LLVM code +-- +-- We generate a `.ll` text file directly for each Wybe `.wybe` file, compiling +-- this as necessary to build `.o`, `.bc` `.s`, or executable files. For each +-- generated `.ll` file, we produce the following, in order: +-- +-- * **Prologue** — contains an introductory comment and any configuration info +-- needed for LLVM. +-- +-- * **Constants** — LLVM definitions of the manifest constants used in this +-- module; mostly used for strings. +-- +-- * **Global variables** — LLVM declarations of the global variables used to +-- implement the resources defined in this module. +-- +-- * **Externs** — Extern declarations for all symbols used, but not defined, +-- in this module; this includes imported Wybe procedures, C functions, and +-- global variables. +-- +-- * **Definitions** — Definitions of the procs of this module. +-- +-- * **Exports** — Everything needed by the Wybe compiler to compile users of +-- this module; currently this is represented as a serialisation of the +-- Module data structure, placed in the LLVM section. +-- +-- END MAJOR DOC + + + +---------------------------------------------------------------------------- +-- Instruction maps +-- +-- What we need to know about LLVM instructions +---------------------------------------------------------------------------- + + +-- | How to determine the sizes of the inputs of a binary llvm instruction. The +-- compiler handles arguments of different sizes, which may be different from +-- the output size. Both arguments in the generated instruction must have the +-- same size. If the specified LLVMArgSize of an instruction is SizeFromOutput, +-- then both arguments must be converted to the type of the output before the +-- instruction. If it is SizeFromInputs, then both arguments must be converted +-- to the type of the larger input argument. For SizeFromLargest, both inputs +-- must be converted to the type of the largest of the inputs and output, and +-- the result must be converted (truncated if necessary) to the expected output +-- type. +data LLVMArgSize = SizeFromOutput | SizeFromInputs | SizeFromLargest + deriving Eq + + +-- | Determine the type representations of the inputs of a binary LLVM +-- instruction, given the LLVMArgSize policy, the representation of the output, +-- and the representations of the inputs. These instructions require both +-- arguments to be the same size. +resolveLLVMArgType :: LLVMArgSize -> TypeRepresentation -> [TypeRepresentation] + -> TypeRepresentation +resolveLLVMArgType SizeFromOutput outTy _ = outTy +resolveLLVMArgType SizeFromInputs _ inTys = List.foldr1 maxSizeRep inTys +resolveLLVMArgType SizeFromLargest outTy inTys = + List.foldr maxSizeRep outTy inTys + + +-- | Pick the larger of two compatible types; an error if the types are not +-- compatible. +maxSizeRep :: TypeRepresentation -> TypeRepresentation -> TypeRepresentation +maxSizeRep (Bits sz1) (Bits sz2) = Bits (max sz1 sz2) +maxSizeRep (Bits sz1) (Signed sz2) = Bits (max sz1 sz2) +maxSizeRep (Bits sz) Pointer = Pointer +maxSizeRep Pointer (Bits sz) = Pointer +maxSizeRep (Signed sz1) (Bits sz2) = Bits (max sz1 sz2) +maxSizeRep (Signed sz1) (Signed sz2) = Signed (max sz1 sz2) +maxSizeRep (Signed sz) Pointer = Pointer +maxSizeRep Pointer (Signed sz) = Pointer +maxSizeRep (Floating sz1) (Floating sz2) = Floating (max sz1 sz2) +maxSizeRep rep1 rep2 | rep1 == rep2 = rep1 +maxSizeRep rep1 rep2 = + shouldnt $ "Generating LLVM instruction with incompatible types " + ++ show rep1 ++ " and " ++ show rep2 + + +data BinOpInfo = BinOpInfo { + binOpInstr :: String, -- ^ full llvm instruction + binOpFamily :: TypeFamily, -- ^ Type family of inputs + binOpArgSize :: LLVMArgSize, -- ^ How to convert arguments and result + binOpResultFn :: TypeRepresentation -> TypeRepresentation + -- ^ Determine result representation from + -- (common) argument representation +} + +-- | Create a mapping for a binary instruction given its argument family, how to +-- convert the arguments, and whether the operation returns a Boolean (otherwise +-- it returns the same type as the arguments). +binaryInstr :: String -> TypeFamily -> LLVMArgSize -> Bool -> (String,BinOpInfo) +binaryInstr instr family argSize toBool = + (instr, BinOpInfo (unwords $ wordsBy (=='_') instr) family argSize + $ if toBool then const $ Bits 1 else id) + + +-- | A map of arithmetic binary operations supported by LLVM to the info we need +-- to know to compile calls to them. +llvmMapBinop :: Map Ident BinOpInfo +llvmMapBinop = + Map.fromList [ + -- Integer arithmetic + binaryInstr "add" IntFamily SizeFromLargest False, + binaryInstr "sub" IntFamily SizeFromLargest False, + binaryInstr "mul" IntFamily SizeFromLargest False, + binaryInstr "udiv" IntFamily SizeFromLargest False, + binaryInstr "sdiv" IntFamily SizeFromLargest False, + binaryInstr "urem" IntFamily SizeFromLargest False, + binaryInstr "srem" IntFamily SizeFromLargest False, + -- Integer comparisions + binaryInstr "icmp_eq" IntFamily SizeFromInputs True, + binaryInstr "icmp_ne" IntFamily SizeFromInputs True, + binaryInstr "icmp_ugt" IntFamily SizeFromInputs True, + binaryInstr "icmp_uge" IntFamily SizeFromInputs True, + binaryInstr "icmp_ult" IntFamily SizeFromInputs True, + binaryInstr "icmp_ule" IntFamily SizeFromInputs True, + binaryInstr "icmp_sgt" IntFamily SizeFromInputs True, + binaryInstr "icmp_sge" IntFamily SizeFromInputs True, + binaryInstr "icmp_slt" IntFamily SizeFromInputs True, + binaryInstr "icmp_sle" IntFamily SizeFromInputs True, + -- Bitwise operations + binaryInstr "shl" IntFamily SizeFromOutput False, + binaryInstr "lshr" IntFamily SizeFromInputs False, + binaryInstr "ashr" IntFamily SizeFromInputs False, + binaryInstr "or" IntFamily SizeFromOutput False, + binaryInstr "and" IntFamily SizeFromOutput False, + binaryInstr "xor" IntFamily SizeFromOutput False, + + -- Floating point arithmetic + binaryInstr "fadd" FloatFamily SizeFromLargest False, + binaryInstr "fsub" FloatFamily SizeFromLargest False, + binaryInstr "fmul" FloatFamily SizeFromLargest False, + binaryInstr "fdiv" FloatFamily SizeFromLargest False, + binaryInstr "frem" FloatFamily SizeFromLargest False, + -- Floating point comparisions + binaryInstr "fcmp_false" FloatFamily SizeFromInputs True, + binaryInstr "fcmp_oeq" FloatFamily SizeFromInputs True, + binaryInstr "fcmp_one" FloatFamily SizeFromInputs True, + binaryInstr "fcmp_olt" FloatFamily SizeFromInputs True, + binaryInstr "fcmp_ole" FloatFamily SizeFromInputs True, + binaryInstr "fcmp_ogt" FloatFamily SizeFromInputs True, + binaryInstr "fcmp_oge" FloatFamily SizeFromInputs True, + binaryInstr "fcmp_ord" FloatFamily SizeFromInputs True, + binaryInstr "fcmp_ueq" FloatFamily SizeFromInputs True, + binaryInstr "fcmp_une" FloatFamily SizeFromInputs True, + binaryInstr "fcmp_ult" FloatFamily SizeFromInputs True, + binaryInstr "fcmp_ule" FloatFamily SizeFromInputs True, + binaryInstr "fcmp_ugt" FloatFamily SizeFromInputs True, + binaryInstr "fcmp_uge" FloatFamily SizeFromInputs True, + binaryInstr "fcmp_uno" FloatFamily SizeFromInputs True, + binaryInstr "fcmp_true" FloatFamily SizeFromInputs True + ] + + +-- | Create a mapping for a unary instruction given its input and output +-- argument families. +unaryInstr :: String -> TypeFamily -> TypeFamily + -> (String,(TypeFamily,TypeFamily)) +unaryInstr instr inFamily outFamily = (instr, (inFamily,outFamily)) + + +-- | A map of unary llvm operations wrapped in the 'Codegen' module. +llvmMapUnop :: Map String (TypeFamily, TypeFamily) +llvmMapUnop = + Map.fromList [ + unaryInstr "uitofp" IntFamily FloatFamily, + unaryInstr "sitofp" IntFamily FloatFamily, + unaryInstr "fptoui" FloatFamily IntFamily, + unaryInstr "fptosi" FloatFamily IntFamily + ] + + +---------------------------------------------------------------------------- +-- Generating LLVM for a module +---------------------------------------------------------------------------- + +-- | Generate LLVM code for the specified module and all its submodules, based +-- on its LPVM code, and write it to the specified file handle. The specified +-- ModSpec is the "root" module of the file. +writeLLVM :: Handle -> ModSpec -> Bool -> Bool -> Compiler () +writeLLVM handle modSpec withLPVM recursive = do + allMods <- + if recursive + then (modSpec:) <$> sameOriginModules modSpec + else return [modSpec] + logMsg LLVM $ "*** Generating LLVM for module(s) " ++ showModSpecs allMods + mod <- gets $ trustFromJust "writeLLVM of unknown module" + <$> Map.lookup modSpec . modules + logWrapWith '-' $ show mod + reenterModule modSpec + flip execStateT (initLLVMState handle) $ do + forEachModule allMods preScanProcs + writeAssemblyPrologue + writeAssemblyConstants + writeAssemblyExterns + forEachModule allMods writeAssemblyGlobals + forEachModule allMods writeAssemblyProcs + when withLPVM $ do + writeAssemblyExports + reexitModule + logMsg LLVM $ "*** Finished generating LLVM for " ++ showModSpecs allMods + + +-- | Execute the specified monadic computation in each of the specified modules. +forEachModule :: [ModSpec] -> LLVM () -> LLVM () +forEachModule mods code = + forM_ mods $ \m -> do + lift $ reenterModule m + code + lift reexitModule + + +---------------------------------------------------------------------------- +-- Scanning the module in preparation +---------------------------------------------------------------------------- + +-- | Scan proc bodies to find and record whatever we need to later produce the +-- llvm assembly code for the current module. Currently we collect string +-- constants and extern declarations for foreign procs and imported Wybe procs +-- used by the module. +preScanProcs :: LLVM () +preScanProcs = do + thisMod <- llvmGetModule modSpec + mod <- fromMaybe thisMod <$> llvmGetModule modRootModSpec + procss <- lift $ getModuleImplementationField (Map.elems . modProcs) + logLLVM $ "preScanProcs: " + ++ intercalate ", " (concatMap (List.map (show.procName)) procss) + let bodies = concatMap (concatMap allProcBodies) procss + mapM_ (mapLPVMBodyM (recordExtern mod) prescanArg) bodies + + +-- | What's needed to identify a manifest constant string in generated LLVM +-- code. Wybe string constants (usually) consist of a size and a pointer to a C +-- string, while C strings are C pointers to 0-terminated packed arrays of +-- bytes. +data StaticConstSpec = CStringSpec String + | WybeStringSpec String + | ClosureSpec ProcSpec [PrimArg] + deriving (Eq,Ord) + +instance Show StaticConstSpec where + show (CStringSpec str) = 'c' : show str + show (WybeStringSpec str) = show str + show (ClosureSpec pspec args) = show pspec ++ showArguments args + + +-- | If the specified PrimArg is a string constant or closure with only constant +-- arguments, add it to the set. For Wybe strings, add both the Wybe string and +-- the C string, since the Wybe string constant refers to the C string. +prescanArg :: PrimArg -> LLVM () +prescanArg (ArgString str WybeString _) = do + recordConst $ WybeStringSpec str + recordConst $ CStringSpec str +prescanArg (ArgString str CString _) = + recordConst $ CStringSpec str +prescanArg (ArgClosure pspec args _) = do + args' <- neededFreeArgs pspec args + if all argIsConst args' + then + recordConst $ ClosureSpec pspec args + else + recordExternSpec externAlloc +prescanArg _ = return () + + +-- | Record that the specified constant needs to be declared in this LLVM module +recordConst :: StaticConstSpec -> LLVM () +recordConst spec = + modify $ \s -> s {allConsts=Set.insert spec $ allConsts s} + + + +-- | If needed, add an extern declaration for a prim to the set. +recordExtern :: ModSpec -> Prim -> LLVM () +recordExtern mod (PrimCall _ pspec _ args _) = do + logLLVM $ "Check if " ++ show pspec ++ " is extern to " ++ showModSpec mod + unless (mod /= [] && mod `isPrefixOf` procSpecMod pspec) $ do + logLLVM " ... it is" + let (nm,cc) = llvmProcName pspec + recordExternFn cc nm args +recordExtern _ PrimHigher{} = return () +recordExtern _ (PrimForeign "llvm" _ _ _) = return () +recordExtern _ (PrimForeign "lpvm" "alloc" _ _) = + recordExternSpec externAlloc +recordExtern mod (PrimForeign "lpvm" "load" _ [ArgGlobal glob ty,_]) = + recordExternVar mod glob ty +recordExtern mod (PrimForeign "lpvm" "store" _ [_,ArgGlobal glob ty]) = + recordExternVar mod glob ty +recordExtern _ (PrimForeign "lpvm" "mutate" _ (_:_:destr:_)) = + case destr of + ArgInt 1 _ -> return () + _ -> recordExternSpec externAlloc +recordExtern _ (PrimForeign "lpvm" _ _ _) = return () +recordExtern _ (PrimForeign "c" name _ args) = + recordExternFn "ccc" (llvmForeignName name) args +recordExtern _ (PrimForeign other name _ args) = + shouldnt $ "Unknown foreign language " ++ other + + +recordExternSpec :: ExternSpec -> LLVM () +recordExternSpec spec = do + logLLVM $ "Recording external " ++ show spec + name <- externID spec + modify $ \s -> s {allExterns=Map.insert name spec $ allExterns s} + + +externCFunction :: String -> [String] -> String -> ExternSpec +externCFunction name argTypes resultType = + let convert t = Representation + $ trustFromJust ("unknown C type " ++ t) + $ cTypeRepresentation t + typeReps = List.map convert argTypes + resultRep = convert resultType + in ExternFunction "ccc" name typeReps [resultRep] + + +-- | An extern spec for the wybe_malloc function. +externAlloc :: ExternSpec +externAlloc = externCFunction (llvmForeignName mallocFn) ["int"] "pointer" + + +-- | Record the fact that the named function is an external function using the +-- specified calling convention and taking the specified (input and output) +-- argument types. +recordExternFn :: String -> LLVMName -> [PrimArg] -> LLVM () +recordExternFn cc fName args = + let (ins,outs,oRefs,iRefs) = partitionByFlow argFlowDirection args + extern = ExternFunction cc fName + ((argType <$> ins) ++ (Representation CPointer <$ oRefs)) + (argType <$> outs) + in if List.null iRefs + then recordExternSpec extern + else shouldnt $ "Function " ++ fName + ++ " has TakeReference parameter(s) " ++ show iRefs + + +-- | Insert the fact that the named function is an external function with the +-- specified argument types in the provided set, returning the resulting set. +-- Only add the spec if it's for an external global var. +recordExternVar :: ModSpec -> GlobalInfo -> TypeSpec -> LLVM () +recordExternVar mspec global ty = + unless (globalIsLocal mspec global) + $ recordExternSpec (ExternVariable global ty) + + +-- | Test if the GlobalInfo specifies a global variable defined in the current +-- file, determined by whether is from (a submodule of) the current module. +globalIsLocal :: ModSpec -> GlobalInfo -> Bool +globalIsLocal mspec (GlobalResource (ResourceSpec mod _)) = + notNull mspec && mspec `isPrefixOf` mod +globalIsLocal _ _ = False + + +---------------------------------------------------------------------------- +-- Writing the prologue +---------------------------------------------------------------------------- + +-- | Write out some boilerplate at the beginning of a generated .ll file. +-- Included are a comment identifying the source of the file and the information +-- required for the file to be compilable. +writeAssemblyPrologue :: LLVM () +writeAssemblyPrologue = do + logLLVM "writeAssemblyPrologue" + mod <- llvmGetModule modSpec + srcFile <- llvmGetModule modOrigin + llvmPutStrLn $ ";; FILE GENERATED BY wybemk " + ++ Version.version + ++ " -- see https://github.com/pschachte/wybe" + llvmPutStrLn $ "; ModuleID = '" ++ showModSpec mod ++ "'" + llvmBlankLine + llvmPutStrLn $ "source_filename = \"" ++ srcFile ++ "\"" + llvmPutStrLn $ "target triple = \"" ++ Version.defaultTriple ++ "\"" + llvmBlankLine + return () + + +---------------------------------------------------------------------------- +-- Writing the constant definitions +---------------------------------------------------------------------------- + +-- | Write out definitions of manifest constants used in generated code for this +-- module. This assumes that sets are converted to lists such that the CStrings +-- appear before the WybeStrings. +writeAssemblyConstants :: LLVM () +writeAssemblyConstants = do + logLLVM "writeAssemblyConstants" + strings <- gets $ Set.toList . allConsts + zipWithM_ writeConstDeclaration strings [0..] + llvmBlankLine + + +-- | Write out a declaration for a string and record its name. This code +-- assumes that the CString that a WybeString refers to has already been +-- declared and recorded. This will happen because sets are sorted +-- alphabetically, and CString comes before WybeString. +writeConstDeclaration :: StaticConstSpec -> Int -> LLVM () +writeConstDeclaration spec@(WybeStringSpec str) n = do + let stringName = specialName2 "string" $ show n + modify $ \s -> s { constNames=Map.insert spec stringName + $ constNames s} + textName <- lookupConstant $ CStringSpec str + declareStructConstant stringName + [ (ArgInt (fromIntegral $ length str) (Representation $ Bits wordSize) + , Bits wordSize) + , (ArgGlobal (GlobalVariable textName) (Representation CPointer) + , Pointer)] + Nothing +writeConstDeclaration spec@(CStringSpec str) n = do + let textName = specialName2 "cstring" $ show n + modify $ \s -> s { constNames=Map.insert spec textName + $ constNames s} + declareStringConstant textName str Nothing +writeConstDeclaration spec@(ClosureSpec pspec args) n = do + let closureName = specialName2 "closure" $ show n + modify $ \s -> s { constNames=Map.insert spec closureName $ constNames s} + let pname = show pspec + argReps <- mapM argTypeRep args + declareStructConstant closureName + ((ArgGlobal (GlobalVariable pname) (Representation CPointer), CPointer) + : zip args argReps) + Nothing + + +-- | Find the global constant that holds the value of the specified string +-- constant. +lookupConstant :: StaticConstSpec -> LLVM Ident +lookupConstant spec = + trustFromJust ("lookupConstant " ++ show spec) <$> tryLookupConstant spec + + +-- | Find the global constant that holds the value of the specified string +-- constant. +tryLookupConstant :: StaticConstSpec -> LLVM (Maybe Ident) +tryLookupConstant spec = + gets $ Map.lookup spec . constNames + + +---------------------------------------------------------------------------- +-- Writing the global variable definitions +---------------------------------------------------------------------------- + +-- | Write out definitions of global variables to implement the resources of +-- this module. +writeAssemblyGlobals :: LLVM () +writeAssemblyGlobals = do + logLLVM "writeAssemblyGlobals" + resDefs <- modResources . trustFromJust "writeAssemblyGlobals" + <$> llvmGetModule modImplementation + let ress = concatMap Map.keys (Map.elems resDefs) + mapM_ defGlobalResource ress + + +-- | Generate a global declaration for a resource, if it's not a phantom. +defGlobalResource :: ResourceSpec -> LLVM () +defGlobalResource res = do + (name, rep) <- llvmResource res + if repIsPhantom rep + then return () + else llvmPutStrLn $ name ++ " = global " ++ llvmTypeRep rep ++ " undef" + + +---------------------------------------------------------------------------- +-- Writing extern declarations +---------------------------------------------------------------------------- + +-- | Write out extern declarations for all procs and resources imported from +-- other modules and used by this one. +writeAssemblyExterns :: LLVM () +writeAssemblyExterns = do + logLLVM "writeAssemblyExterns" + copyFn <- llvmGlobalName <$> llvmMemcpyFn + let spec = ExternFunction "ccc" copyFn + (Representation <$> [CPointer,CPointer,Bits wordSize,Bits 1]) [] + externs <- Map.elems <$> gets allExterns + mapM_ declareExtern externs + declareExtern spec + + +declareExtern :: ExternSpec -> LLVM () +declareExtern (ExternFunction cc name ins outs) = do + outs' <- lift $ filterM (notM . typeIsPhantom) outs + ins' <- lift $ filterM (notM . typeIsPhantom) ins + outTy <- llvmReturnType outs' + argTypes <- (llvmTypeRep <$>) <$> mapM typeRep ins' + llvmPutStrLn $ "declare external " ++ cc ++ " " + ++ outTy ++ " " ++ name ++ "(" + ++ intercalate ", " argTypes ++ ")" +declareExtern (ExternVariable glob ty) = do + rep <- typeRep ty + unless (repIsPhantom rep) $ do + name <- llvmGlobalInfoName glob + llvmPutStrLn $ name ++ " = external global " ++ llvmTypeRep rep + + +---------------------------------------------------------------------------- +-- Writing procedure definitions +---------------------------------------------------------------------------- + +-- | Generate and write out the LLVM code for all the procs defined in this +-- module. +writeAssemblyProcs :: LLVM () +writeAssemblyProcs = do + logLLVM "writeAssemblyProcs" + mod <- llvmGetModule modSpec + procs <- lift $ getModuleImplementationField + (concatMap (`zip` [0..]) . Map.elems . modProcs) + mapM_ (uncurry writeProcLLVM) procs + + +-- | Generate and write out the LLVM code for the given proc with its proc +-- number and all its specialisations. +writeProcLLVM :: ProcDef -> Int -> LLVM () +writeProcLLVM def procNum = + case procImpln def of + ProcDefPrim {procImplnProcSpec=pspec, procImplnProto=proto, + procImplnBody=body, procImplnSpeczBodies=specz} -> do + (proto', body') <- if isClosureVariant $ procVariant def + then do + logLLVM $ "Compiling closure variant for proc " + ++ showProcName (procName def) ++ ":" + let (p',b') = closeClosure proto body + logLLVM $ "Params: " ++ show p' + logLLVM $ "Body : " ++ show b' + return (p',b') + else return (proto, body) + let params = primProtoParams proto' + let tmpCount = procTmpCount def + -- XXX overriding procSpeczVersion should not be needed, but it is! + writeProcSpeczLLVM pspec{procSpeczVersion=Set.empty} + tmpCount params body' + let msg = "Required specialisations should be generated by now" + let specz' = List.map (mapSnd (trustFromJust msg)) + $ Map.toList specz + -- Make sure there aren't collision in specz version id. If this + -- happens, we should increase the length of id (see AST.hs). + let hasDuplicates l = List.length l /= (Set.size . Set.fromList) l + when (hasDuplicates (List.map fst specz')) + $ shouldnt $ "Specialisation version hash conflicts" + ++ show (List.map fst specz') + mapM_ (\(speczVersion, speczBody) -> do + -- rename this version of proc + let pspec' = pspec{procSpeczVersion=speczVersion} + writeProcSpeczLLVM pspec' tmpCount params speczBody + ) specz' + + _ -> shouldnt $ "Generating assembly code for uncompiled proc " + ++ showProcName (procName def) + + +-- | Updates a PrimProto and ProcBody as though the Free Params are accessed +-- via the closure environment +closeClosure :: PrimProto -> ProcBody -> (PrimProto, ProcBody) +closeClosure proto@PrimProto{primProtoParams=params} + body@ProcBody{bodyPrims=prims} = + (proto{primProtoParams=envPrimParam:genericParams}, + body{bodyPrims=unpacker ++ inwardConverter ++ prims ++ outwardConverter}) + where + (free, actualParams) = List.partition ((==Free) . primParamFlowType) params + genericParams = [p {primParamType=AnyType + ,primParamName=genericVarName (primParamName p)} + | p <- actualParams] + neededFree = List.filter (not . paramInfoUnneeded + . primParamInfo) free + unpacker = Unplaced <$> + [ primAccess (ArgVar envParamName AnyType FlowIn Ordinary False) + (ArgInt (i * toInteger wordSizeBytes) intType) + (ArgInt (toInteger wordSize) intType) + (ArgInt 0 intType) + (ArgVar genName AnyType FlowOut Free False) + | (i,PrimParam nm ty _ _ _) <- zip [1..] neededFree + , let genName = genericVarName nm] + inwardConverter = Unplaced <$> + [ PrimForeign "llvm" "move" [] [ + ArgVar (genericVarName nm) AnyType FlowIn Ordinary False, + ArgVar nm ty FlowOut Ordinary False] + | PrimParam nm ty FlowIn _ _ <- actualParams ++ neededFree ] + outwardConverter = Unplaced <$> + [ PrimForeign "llvm" "move" [] [ + ArgVar nm ty FlowIn Ordinary False, + ArgVar (genericVarName nm) AnyType FlowOut Ordinary False] + | PrimParam nm ty FlowOut _ _ <- actualParams ] + +-- | Create a name for the generic type version of a variable/parameter +genericVarName :: PrimVarName -> PrimVarName +genericVarName p@PrimVarName{primVarName=v} = p {primVarName="generic#" ++ v} + + +-- | Write out the LLVM code for a single LPVM proc specialisation (including no +-- specialisation), given the ProcSpec, temp variable count, parameter list, and +-- body. +writeProcSpeczLLVM :: ProcSpec -> Int -> [PrimParam] -> ProcBody -> LLVM () +writeProcSpeczLLVM pspec tmpCount params body = do + logLLVM $ "Generating LLVM for proc " ++ show pspec + initialiseLLVMForProc tmpCount + let (name,cc) = llvmProcName pspec + (ins,outs,oRefs,iRefs) <- partitionParams params + unless (List.null iRefs) + $ nyi $ "take-reference parameter for proc " ++ show pspec + setRenaming $ Set.fromList $ primParamName <$> outs + returnType <- llvmReturnType $ List.map primParamType outs + oRefParams <- mapM recordProcOutByRef oRefs + llParams <- mapM llvmParameter $ ins ++ oRefParams + llvmBlankLine + llvmPutStrLn $ + "define external " ++ cc ++ " " ++ returnType ++ " " + ++ name ++ "(" ++ intercalate ", " llParams ++ ")" + ++ " {" + writeAssemblyBody outs body + llvmPutStrLn "}" + + + +-- | Create an opaque pointer parameter for each out-by-reference parameter, and +-- record the correspondence, so we can translate assignments to the +-- out-by-reference parameter into a store through the opaque pointer. +recordProcOutByRef :: PrimParam -> LLVM PrimParam +recordProcOutByRef param@PrimParam{primParamName=p, primParamType=ty} = do + tmp <- makeTemp + let readCPtrArg = ArgVar tmp (Representation CPointer) FlowIn Ordinary True + let actualParam = convertOutByRefParam param{primParamName=tmp} + addOutByRefPointer p readCPtrArg ty + return actualParam + + +-- | Generate and write out the LLVM code for an LPVM body +writeAssemblyBody :: [PrimParam] -> ProcBody -> LLVM () +writeAssemblyBody outs ProcBody{bodyPrims=prims, bodyFork=fork} = do + logLLVM $ "Generating LLVM body with outs " ++ show outs + mapM_ (placedApply writeAssemblyPrim) prims + case fork of + NoFork -> do + releaseDeferredCall + writeAssemblyReturn outs + PrimFork{forkVar=v, forkVarType=ty, forkBodies=branches, + forkDefault=dflt} -> do + rep <- typeRep ty + case (rep,branches,dflt) of + (Bits 0,_,_) -> shouldnt "Switch on a phantom!" + (_,[single],Nothing) -> writeAssemblyBody outs single + (Bits 1, [els,thn],Nothing) -> writeAssemblyIfElse outs v thn els + (Bits _, cases, dflt) -> writeAssemblySwitch outs v rep cases dflt + (Signed _, cases, dflt) -> writeAssemblySwitch outs v rep cases dflt + (rep,_,_) -> shouldnt $ "Switching on " ++ show rep ++ " type " + ++ show ty + + +-- | Generate and write out an LLVM if-then-else (switch on an i1 value) +writeAssemblyIfElse :: [PrimParam] -> PrimVarName -> ProcBody -> ProcBody + -> LLVM () +writeAssemblyIfElse outs v thn els = do + releaseDeferredCall + [thnlbl,elslbl] <- freshLables ["if.then.","if.else."] + llvar <- varToRead v + llvmPutStrLnIndented $ "br i1 " ++ llvar + ++ ", " ++ llvmLabelName thnlbl + ++ ", " ++ llvmLabelName elslbl + llvmPutStrLn $ thnlbl ++ ":" + writeAssemblyBody outs thn + llvmPutStrLn $ elslbl ++ ":" + writeAssemblyBody outs els + + +-- | Generate and write out an LLVM multi-way switch +writeAssemblySwitch :: [PrimParam] -> PrimVarName -> TypeRepresentation + -> [ProcBody] -> Maybe ProcBody -> LLVM () +writeAssemblySwitch outs v rep cases dflt = do + releaseDeferredCall + let prefixes = ["case."++show n++".switch." | n <- [0..length cases-1]] + (dfltLabel,numLabels) <- if isJust dflt + then do + (dfltLabel:numLabels) <- freshLables $ "default.switch.":prefixes + return (dfltLabel,numLabels) + else do + labels <- freshLables prefixes + return (last labels, labels) -- if no default, use last case + let llType = llvmTypeRep rep + llvar <- varToRead v + logLLVM $ "Switch on " ++ llvar ++ " with cases " ++ show cases + llvmPutStrLnIndented $ "switch " ++ makeLLVMArg llType llvar ++ ", " + ++ llvmLabelName dfltLabel ++ " [\n " + ++ intercalate "\n " + [makeLLVMArg llType (show n) ++ ", " ++ llvmLabelName lbl + | (lbl,n) <- zip numLabels [0..]] + ++ " ]" + zipWithM_ + (\lbl cs -> llvmPutStrLn (lbl ++ ":") >> writeAssemblyBody outs cs) + numLabels cases + case dflt of + Nothing -> return () + Just dfltCode -> do + llvmPutStrLn $ dfltLabel ++ ":" + -- I don't think the Nothing case ever happens, but just in case... + writeAssemblyBody outs dfltCode + + +---------------------------------------------------------------------------- +-- Generating and emitting LLVM for a single LPVM Prim instruction +---------------------------------------------------------------------------- + + +-- | Generate and write out the LLVM code for a single LPVM prim +writeAssemblyPrim :: Prim -> OptPos -> LLVM () +writeAssemblyPrim instr@(PrimCall _ proc _ args _) pos = do + releaseDeferredCall + logLLVM $ "* Translating Wybe call " ++ show instr + writeWybeCall proc args pos +writeAssemblyPrim instr@(PrimHigher _ fn _ args) pos = do + releaseDeferredCall + logLLVM $ "* Translating HO call " ++ show instr + writeHOCall fn args pos +writeAssemblyPrim instr@(PrimForeign "llvm" op flags args) pos = do + releaseDeferredCall + logLLVM $ "* Translating LLVM instruction " ++ show instr + writeLLVMCall op flags args pos +writeAssemblyPrim instr@(PrimForeign "lpvm" op flags args) pos = do + -- Some of these must be handled before releasing deferred calls + logLLVM $ "* Translating LPVM instruction " ++ show instr + writeLPVMCall op flags args pos +writeAssemblyPrim instr@(PrimForeign "c" cfn flags args) pos = do + releaseDeferredCall + logLLVM $ "* Translating C call " ++ show instr + writeCCall cfn flags args pos +writeAssemblyPrim instr@(PrimForeign lang op flags args) pos = do + shouldnt $ "unknown foreign language " ++ lang + ++ " in instruction " ++ show instr + + +-- | Generate a Wybe proc call instruction, or defer it if necessary. +writeWybeCall :: ProcSpec -> [PrimArg] -> OptPos -> LLVM () +writeWybeCall wybeProc args pos = do + (ins,outs,oRefs,iRefs) <- partitionArgsWithRefs args + unless (List.null iRefs) + $ shouldnt $ "Wybe call " ++ show wybeProc ++ " with take-reference arg" + tailKind <- tailMarker False + if List.null oRefs then + writeActualCall wybeProc ins outs tailKind + else + deferCall wybeProc ins outs oRefs + + +-- | Generate a Wybe proc call instruction, or defer it if necessary. +writeHOCall :: PrimArg -> [PrimArg] -> OptPos -> LLVM () +writeHOCall (ArgClosure pspec closed _) args pos = do + -- NB: this case doesn't seem to ever occur + pspec' <- fromMaybe pspec <$> lift (maybeGetClosureOf pspec) + logLLVM $ "Compiling HO call as first order call to " ++ show pspec' + ++ " closed over " ++ show closed + writeWybeCall pspec' (closed ++ args) pos +writeHOCall closure args pos = do + (ins,outs,oRefs,iRefs) <- partitionArgsWithRefs $ closure:args + unless (List.null oRefs && List.null iRefs) + $ nyi $ "Higher order call with out-by-ref or take-ref argument " + ++ show (PrimHigher 0 closure Pure args) + allPhantoms <- and <$> lift (mapM argIsPhantom outs) + let ty = argVarType closure + unless (allPhantoms && not (isResourcefulHigherOrder ty) + && modifierImpurity (higherTypeModifiers ty) <= Pure) $ do + outTy <- llvmReturnType $ List.map argType outs + (writeFnPtr,readFnPtr) <- freshTempArgs $ Representation CPointer + llvmLoad closure writeFnPtr + fnVar <- llvmValue readFnPtr + argList <- llvmArgumentList ins + prefix <- tailMarker False + llvmAssignResults outs $ + prefix ++ "call fastcc " ++ outTy ++ " " ++ fnVar ++ argList + + +-- | Work out the appropriate prefix for a call: tail, musttail, or nothing. +-- The input specifies whether this call is has had out-by-ref arguments +-- converted to input pointers. +tailMarker :: Bool -> LLVM String +tailMarker must = do + didAlloca <- gets doesAlloca + return $ case (didAlloca, must) of + (True,_) -> "" + (False,True) -> "musttail " + (False,False) -> "tail " + + +-- | Actually generate a Wybe proc call. tailKind indicates what degree of LLVM +-- tail call optimisation we want. +writeActualCall :: ProcSpec -> [PrimArg] -> [PrimArg] -> String -> LLVM () +writeActualCall wybeProc ins outs tailKind = do + params <- lift $ getPrimParams wybeProc + (inPs,outPs,oRefPs,iRefPs) <- partitionParams params + unless (List.null iRefPs) + $ shouldnt $ "take-reference parameter(s) " ++ show iRefPs + let allInPs = inPs ++ List.map convertOutByRefParam oRefPs + unless (sameLength allInPs ins) + $ shouldnt $ "in call to " ++ show wybeProc + ++ ", argument count " ++ show (length ins) + ++ " does not match parameter count " ++ show (length allInPs) + ++ "\n " ++ show ins + ++ " vs. " ++ show allInPs + unless (sameLength outPs outs) + $ shouldnt $ "in call to " ++ show wybeProc + ++ ", output argument count " ++ show (length outs) + ++ " does not match output parameter count " ++ show (length outPs) + ++ "\n " ++ show outs + ++ " vs. " ++ show outPs + paramTypes <- mapM (typeRep . primParamType) allInPs + argList <- llvmStringArgList <$> zipWithM typeConvertedArg paramTypes ins + outReps <- mapM (typeRep . primParamType) outPs + let outTy = llvmRepReturnType outReps + let (name,cc) = llvmProcName wybeProc + llvmAssignConvertedResults outs outReps $ + tailKind ++ "call " ++ cc ++ " " ++ outTy ++ " " ++ name ++ argList + + +-- | Generate a native LLVM instruction +writeLLVMCall :: ProcName -> [Ident] -> [PrimArg] -> OptPos -> LLVM () +writeLLVMCall op flags args pos = do + (ins,outs) <- partitionArgs ("llvm " ++ op ++ " instruction") args + logLLVM $ "llvm instr args " ++ show args ++ " => ins " + ++ show ins ++ " ; outs " ++ show outs + case (ins,outs) of + ([],[]) -> return () -- eliminate if all data flow was phantoms + ([arg],[out@ArgVar{}]) -> + if op == "move" then + typeConvert arg out + else if op `Map.member` llvmMapUnop then do + outTy <- llvmTypeRep <$> argTypeRep out + llvmArg <- llvmArgument arg + llvmAssignResults outs $ op ++ " " ++ llvmArg ++ " to " ++ outTy + else shouldnt $ "unknown unary llvm op " ++ op + ([_,_],[out]) -> do + let BinOpInfo {binOpInstr=instr,binOpArgSize=argSize, + binOpResultFn=resultFn} = + trustFromJust ("unknown binary llvm op " ++ op) + $ Map.lookup op llvmMapBinop + (argList,outRep) <- llvmInstrArgumentList argSize out ins resultFn + llvmAssignConvertedResult out outRep $ instr ++ " " ++ argList + _ -> shouldnt $ "unknown llvm op " ++ op ++ " (arity " + ++ show (length ins) ++ ")" + + +-- | Generate LPVM (memory management) instruction +writeLPVMCall :: ProcName -> [Ident] -> [PrimArg] -> OptPos -> LLVM () +writeLPVMCall "alloc" _ args pos = do + releaseDeferredCall + args' <- partitionArgs "lpvm alloc instruction" args + case args' of + ([sz],[out]) -> heapAlloc out sz pos + _ -> shouldnt $ "lpvm alloc with arguments " ++ show args +writeLPVMCall "cast" _ args pos = do + releaseDeferredCall + args' <- partitionArgs "lpvm cast instruction" args + case args' of + ([],[]) -> return () + ([val],[var]) -> do + typeConvert val var + (ins, outs) -> + shouldnt $ "lpvm cast with arguments " ++ show ins ++ " and outputs " + ++ show outs +writeLPVMCall "load" _ args pos = do + releaseDeferredCall + args' <- partitionArgs "lpvm load instruction" args + case args' of + ([],[]) -> return () + ([global],[outVar]) -> llvmLoad global outVar + (ins, outs) -> + shouldnt $ "lpvm load with inputs " ++ show ins ++ " and outputs " + ++ show outs +writeLPVMCall "store" _ args pos = do + -- TODO We could actually support take-reference for this op + releaseDeferredCall + args' <- partitionArgs "lpvm store instruction" args + case args' of + ([],[]) -> return () + ([val,ptr],[]) -> llvmStore ptr val + (ins, outs) -> + shouldnt $ "lpvm store with inputs " ++ show ins ++ " and outputs " + ++ show outs +writeLPVMCall "access" _ args pos = do + releaseDeferredCall + args' <- partitionArgs "lpvm access instruction" args + case args' of + ([struct, offset, _, _], outs@[member]) -> do + logLLVM $ "llvm access offset = " ++ show offset + addrArg <- case offset of + ArgInt 0 _ -> return struct + _ -> do + (writeArg,readArg) <- freshTempArgs $ argType struct + writeLLVMCall "add" [] [struct,offset,writeArg] Nothing + return readArg + lltype <- llvmTypeRep <$> argTypeRep member + arg <- typeConvertedArg CPointer addrArg + llvmAssignResults outs $ "load " ++ lltype ++ ", " ++ arg + (ins,outs) -> + shouldnt $ "lpvm access with inputs " ++ show ins ++ " and outputs " + ++ show outs +writeLPVMCall "mutate" _ args pos = do + args' <- partitionArgsWithRefs args + case args' of + (_,_,_:_,_) -> + shouldnt $ "LPVM mutate instruction with out-by-reference arg: " + ++ show args + (struct:offset:destr:size:startOffset:restIns, + [struct2@ArgVar{argVarName=struct2Name}],_,iRefs) -> do + when (List.null iRefs) releaseDeferredCall + case destr of + ArgInt 1 _ -> do + logLLVM "lpvm mutate destructive case" + typeConvert struct struct2 + ArgInt 0 _ -> do + logLLVM "lpvm mutate non-destructive case" + duplicateStruct struct startOffset size struct2 + _ -> + nyi "lpvm mutate instr with non-const destructive flag" + ptrArg <- case offset of + ArgInt 0 _ -> return struct2 + _ -> do + (writeArg,readArg) <- freshTempArgs $ argType struct2 + writeLLVMCall "add" [] + [setArgFlow FlowIn struct2,offset,writeArg] Nothing + return readArg + logLLVM $ "address to store into is held by " ++ show ptrArg + case (restIns,iRefs) of + ([member],[]) -> do + logLLVM "Normal (non-take-reference) case" + llvmStore ptrArg member + ([],[takeRef]) -> do + -- FlowTakeReference case: generate and record a fresh + -- local variable to hold the pointer to the location the + -- value should be written in, once it's generated. + logLLVM "Special take-reference case" + (writeCPtrArg,readCPtrArg) <- + freshTempArgs $ Representation CPointer + let takeRefVar = argVar "in lpvm mutate" takeRef + addTakeRefPointer takeRefVar readCPtrArg (argType takeRef) + takeRefs <- gets takeRefVars + logLLVM $ "take-ref pointers = " ++ show takeRefs + typeConvert ptrArg writeCPtrArg + _ -> + shouldnt $ "lpvm mutate with inputs " + ++ show (struct:offset:destr:size:startOffset:restIns) + ++ " and output " ++ show struct2 + (ins,outs,oRefs,iRefs) -> + shouldnt $ "lpvm mutate with inputs " ++ show ins ++ " and outputs " + ++ show outs +writeLPVMCall op flags args pos = + shouldnt $ "unknown lpvm operation: " ++ op + + +-- | Generate C function call +writeCCall :: ProcName -> [Ident] -> [PrimArg] -> OptPos -> LLVM () +writeCCall cfn flags args pos = do + (ins,outs) <- partitionArgs ("call to C function " ++ cfn) args + outTy <- llvmReturnType $ List.map argType outs + argList <- llvmArgumentList ins + llvmAssignResults outs $ "call ccc " ++ outTy ++ " " ++ llvmGlobalName cfn + ++ argList + + +-- | Generate C function call with inputs and outputs type converted as needed. +marshalledCCall :: ProcName -> [Ident] -> [PrimArg] -> [String] -> OptPos + -> LLVM () +marshalledCCall cfn flags args ctypes pos = do + (ins,outs) <- partitionArgTuples cfn $ zip args ctypes + argList <- llvmStringArgList <$> mapM (uncurry marshallArgument) ins + let instr = llvmGlobalName cfn ++ argList + case outs of + [] -> llvmPutStrLnIndented $ "call ccc void " ++ instr + [(out,cType)] -> marshallCallResult out cType instr + _ -> shouldnt "C function call with multiple outputs" + + +-- | Generate and write out the LLVM return statement. +writeAssemblyReturn :: [PrimParam] -> LLVM () +writeAssemblyReturn [] = llvmPutStrLnIndented "ret void" +writeAssemblyReturn [PrimParam{primParamName=v, primParamType=ty}] = do + llty <- llvmTypeRep <$> typeRep ty + llvar <- varToRead v + llvmPutStrLnIndented $ "ret " ++ makeLLVMArg llty llvar +writeAssemblyReturn params = do + retType <- llvmReturnType $ List.map primParamType params + tuple <- buildTuple retType "undef" 0 params + llvmPutStrLnIndented $ "ret " ++ makeLLVMArg retType tuple + + +-- | Generate code to build a tuple to return for multi-output functions. +-- Returns the last variable generated. +-- Generated code looks like %"temp#25" = insertvalue {i64, i1} undef, i64 %8, 0 +buildTuple :: LLVMType -> LLVMName -> Int -> [PrimParam] -> LLVM LLVMName +buildTuple _ tuple _ [] = return tuple +buildTuple outType tuple argNum + (PrimParam{primParamName=v, primParamType=ty}:params) = do + llty <- llvmTypeRep <$> typeRep ty + llvar <- varToRead v + nextVar <- llvmLocalName <$> makeTemp + llvmPutStrLnIndented $ nextVar ++ " = insertvalue " ++ outType ++ " " + ++ tuple ++ ", " ++ makeLLVMArg llty llvar + ++ ", " ++ show argNum + buildTuple outType nextVar (argNum+1) params + + +---------------------------------------------------------------------------- +-- Writing the export information ("header" file equivalent) +---------------------------------------------------------------------------- + +-- | Write out data needed for wybemk to compile users of this module. This +-- includes all the declared types and other submodules, resources, interfaces +-- of all public procs, and definitions of inline public procs, written as a +-- large constant string in the LPVM section of the file. +writeAssemblyExports :: LLVM () +writeAssemblyExports = do + logLLVM "writeAssemblyExports" + llvmBlankLine + m <- llvmGetModule modSpec + modBS <- lift $ List.map BI.w2c . BL.unpack <$> encodeModule m + let constName = "##MODULE:" ++ showModSpec m + declareStringConstant constName modBS $ Just lpvmSectionName + + +-- | Emit an LLVM declaration for a string constant, optionally specifying a +-- file section. +declareStringConstant :: LLVMName -> String -> Maybe String -> LLVM () +declareStringConstant name str section = do + llvmPutStrLn $ llvmGlobalName name + ++ " = private unnamed_addr constant " + ++ showLLVMString str True + ++ maybe "" ((", section "++) . show) section + ++ ", align " ++ show wordSizeBytes + + +-- | Emit an LLVM declaration for a string constant, optionally specifying a +-- file section. +declareStructConstant :: LLVMName -> [ConstSpec] -> Maybe String -> LLVM () +declareStructConstant name fields section = do + llvmFields <- llvmConstStruct fields + llvmPutStrLn $ llvmGlobalName name + ++ " = private unnamed_addr constant " ++ llvmFields + ++ maybe "" ((", section "++) . show) section + ++ ", align " ++ show wordSizeBytes + + +-- | Build a string giving the body of an llvm constant structure declaration +llvmConstStruct :: [ConstSpec] -> LLVM String +llvmConstStruct fields = do + llvmVals <- mapM (uncurry convertedConstantArg) fields + return $ llvmStructType (snd <$> fields) + ++ " { " ++ intercalate ", " llvmVals ++ " }" + + +---------------------------------------------------------------------------- +-- Support code +---------------------------------------------------------------------------- + +-- | Generate an LLVM load instruction to load from the specified address into +-- the specified variable +llvmLoad :: PrimArg -> PrimArg -> LLVM () +llvmLoad ptr outVar = do + lltype <- llvmTypeRep <$> argTypeRep outVar + arg <- typeConvertedArg CPointer ptr + llvmAssignResult outVar $ "load " ++ lltype ++ ", " ++ arg + + +-- | Generate an LLVM store instruction to store the specified PrimArg into the +-- specified address. +llvmStore :: PrimArg -> PrimArg -> LLVM () +llvmStore ptr toStore = llvmArgument toStore >>= llvmStoreValue ptr + + +-- | Generate an LLVM store instruction to store the specified LLVM argument +-- into the specified address. +llvmStoreValue :: PrimArg -> LLVMArg -> LLVM () +llvmStoreValue ptr llVal = do + cptr <- typeConvertedArg CPointer ptr + llvmAssignResults [] $ "store " ++ llVal ++ ", " ++ cptr + + +-- | Generate LLVM store instructions to store all elements of the specified +-- list into words of memory beginning with the specified pointer. +llvmStoreArray :: PrimArg -> [LLVMArg] -> LLVM () +llvmStoreArray ptr [] = return () +llvmStoreArray ptr (llVal:llVals) = do + llvmStoreValue ptr llVal + foldM_ (\p v -> do + cptr <- pointerOffset p wordSizeBytes + llvmStoreValue cptr llVal + return cptr + ) ptr llVals + + +-- | Compute the specified offset to a pointer, returning the result as a +-- CPointer ready to use for loading or storing. The input pointer can be a +-- Pointer or CPointer. +pointerOffset :: PrimArg -> Int -> LLVM PrimArg +pointerOffset ptr 0 = typeConvertedPrim CPointer ptr +pointerOffset ptr offset = do + addr <- typeConvertedPrim Pointer ptr + addrArg <- llvmArgument addr + (writePtr,readPtr) <- freshTempArgs $ Representation Pointer + llvmAssignConvertedResult writePtr Pointer + $ "add " ++ addrArg ++ ", " ++ show offset + return readPtr + + +-- | Generate code to copy a structure, given a tagged pointer, the tag, the +-- size of the structure, and the variable to write the new tagged pointer into. +duplicateStruct :: PrimArg -> PrimArg -> PrimArg -> PrimArg -> LLVM () +duplicateStruct struct startOffset size newStruct = do + start <- case startOffset of + ArgInt 0 _ -> return struct + _ -> do + (writeStart,readStart) <- freshTempArgs $ Representation Pointer + writeLLVMCall "sub" [] [struct,startOffset,writeStart] Nothing + return readStart + (writeStartCPtr,readStartCPtr) <- freshTempArgs $ Representation CPointer + llvmStart <- llvmArgument start + typeConvert start writeStartCPtr + (writeCPtr,readCPtr) <- freshTempArgs $ Representation CPointer + marshalledCCall mallocFn [] [size,writeCPtr] ["int","pointer"] Nothing + copyfn <- llvmMemcpyFn + let nonvolatile = ArgInt 0 $ Representation $ Bits 1 + writeCCall copyfn [] [readCPtr,readStartCPtr,size,nonvolatile] Nothing + (writePtr,readPtr) <- freshTempArgs $ Representation Pointer + typeConvert readCPtr writePtr + case startOffset of + ArgInt 0 _ -> typeConvert readPtr newStruct + _ -> writeLLVMCall "add" [] [readPtr,startOffset,newStruct] Nothing + + +---------------------------------------------------------------------------- +-- Handling parameters and arguments +---------------------------------------------------------------------------- + +-- | The LLVM parameter declaration for the specified Wybe input parameter as a +-- pair of LLVM type and variable name. +llvmParameter :: PrimParam -> LLVM String +llvmParameter PrimParam{primParamName=name, primParamType=ty, + primParamFlow=FlowIn} = do + let llname = llvmLocalName name + tyRep <- typeRep ty + let lltype = llvmTypeRep tyRep + modify $ \s -> s { varTypes=Map.insert llname tyRep $ varTypes s } + return $ makeLLVMArg lltype llname +llvmParameter PrimParam{primParamName=name, + primParamFlow=FlowOutByReference} = do + let llname = llvmLocalName name + return $ "ptr " ++ llname +llvmParameter param = + shouldnt $ "parameter " ++ show param ++ " should be an input" + + +-- | The LLVM translation of the specified call instruction argument list +llvmArgumentList :: [PrimArg] -> LLVM String +llvmArgumentList inputs = llvmStringArgList <$> mapM llvmArgument inputs + + +llvmStringArgList :: [String] -> String +llvmStringArgList = ('(':). (++")") . intercalate ", " + + +-- | The LLVM translation of the specified LLVM instruction argument list. +-- Since all arguments of these instructions must have the same types, the type +-- is only shown once, at the front. +llvmInstrArgumentList :: LLVMArgSize -> PrimArg -> [PrimArg] + -> (TypeRepresentation -> TypeRepresentation) + -> LLVM (String,TypeRepresentation) +llvmInstrArgumentList argSize output inputs repFn = do + (outTy : inTys) <- mapM argTypeRep $ output : inputs + let typeRep = resolveLLVMArgType argSize outTy inTys + let outTyRep = repFn typeRep + let llArgTyRep = llvmTypeRep typeRep + argsString <- intercalate ", " <$> mapM (typeConverted typeRep) inputs + return (makeLLVMArg llArgTyRep argsString, outTyRep) + + +-- | Write the LLVM translation of the specified output argument list as target +-- for the specified instruction. For multiple outputs, we must unpack a tuple. +llvmAssignResults :: [PrimArg] -> String -> LLVM () +llvmAssignResults [] instr = llvmPutStrLnIndented instr +llvmAssignResults [arg] instr = do + llvmAssignResult arg instr +llvmAssignResults multiOuts instr = do + tuple <- llvmLocalName <$> makeTemp + retType <- llvmReturnType $ argVarType <$> multiOuts + llvmPutStrLnIndented $ tuple ++ " = " ++ instr + -- This uses llvmAssignSingleResult to store each individual tuple element + zipWithM_ (unpackArg retType tuple) multiOuts [0..] + + +-- | Write the LLVM translation of the specified single output argument as +-- target for the specified instruction. +llvmAssignResult :: PrimArg -> String -> LLVM () +llvmAssignResult arg@ArgVar{argVarName=varName,argVarType=ty} instr = do + tyRep <- typeRep ty + let llty = llvmTypeRep tyRep + llVar <- varToWrite varName llty + logLLVM $ "Assigning variable " ++ show varName ++ " (=> " ++ llVar ++ ")" + llvmPutStrLnIndented $ llVar ++ " = " ++ instr + varValue <- llvmArgument arg + storeValueIfNeeded varName varValue + knownType <- gets $ Map.lookup llVar . varTypes + when (isJust knownType) $ + shouldnt $ "Error generating LLVM: reassigning LLVM variable " ++ llVar + modify $ \s -> s { varTypes = Map.insert llVar tyRep $ varTypes s} +llvmAssignResult notAVar instr = do + shouldnt $ "llvmAssignResult into non-variable " ++ show notAVar + + +-- | Write the LLVM translation of the specified variables as target for the +-- specified instruction, converting from the specified type representations if +-- necessary. +llvmAssignConvertedResults :: [PrimArg] -> [TypeRepresentation] -> String + -> LLVM () +llvmAssignConvertedResults [] _ instr = llvmPutStrLnIndented instr +llvmAssignConvertedResults [arg] (actualRep:_) instr = + llvmAssignConvertedResult arg actualRep instr +llvmAssignConvertedResults multiOuts multiReps instr = do + tuple <- llvmLocalName <$> makeTemp + let retType = llvmRepReturnType multiReps + llvmPutStrLnIndented $ tuple ++ " = " ++ instr + -- This uses llvmAssignResult to store each individual tuple element + sequence_ + $ zipWith3 (unpackConvertedArg retType tuple) multiOuts multiReps [0..] + + +-- | Write the LLVM translation of the specified single output variable as +-- target for the specified instruction, converting from the specified type +-- representation if necessary. +llvmAssignConvertedResult :: PrimArg -> TypeRepresentation -> String -> LLVM () +llvmAssignConvertedResult arg@ArgVar{argVarName=varName,argVarType=ty} + actualRep instr = do + neededRep <- typeRep ty + if equivLLTypes neededRep actualRep + then do + llvmAssignResult arg instr + else do + (writeArg,readArg) <- freshTempArgs $ Representation actualRep + llvmAssignResult writeArg instr + typeConvert readArg arg +llvmAssignConvertedResult notAVar _ _ = + shouldnt $ "llvmAssignConvertedResult into non-variable " ++ show notAVar + + +-- | Split parameter list into separate list of input, output, out-by-reference, +-- and take-reference arguments, ignoring any phantom parameters. +partitionParams :: [PrimParam] + -> LLVM ([PrimParam],[PrimParam],[PrimParam],[PrimParam]) +partitionParams params = do + partitionByFlow primParamFlow <$> lift (realParams params) + + +-- | Split argument list into separate list of inputs and outputs, after +-- eliminating phantom arguments. Report an error if there are any +-- out-by-reference or take-reference arguments. +partitionArgs :: String -> [PrimArg] -> LLVM ([PrimArg],[PrimArg]) +partitionArgs op args = do + (ins,outs,oRefs,iRefs) <- partitionArgsWithRefs args + unless (List.null oRefs) $ shouldnt $ "out-by-reference argument of " ++ op + unless (List.null iRefs) $ shouldnt $ "take-reference argument of " ++ op + return (ins,outs) + + +-- | Split the provided list of arguments into input, output, out-by-reference, +-- and take-reference arguments, after eliminating phantom arguments. +partitionArgsWithRefs :: [PrimArg] + -> LLVM ([PrimArg],[PrimArg],[PrimArg],[PrimArg]) +partitionArgsWithRefs args = do + realArgs <- lift $ filterM argIsReal args + return $ partitionByFlow argFlowDirection realArgs + + +-- | Split list of pairs of argument and something else into separate lists of +-- input, output, out-by-reference, and take-reference arguments, after +-- eliminating phantom arguments. +partitionArgTuples :: String -> [(PrimArg,a)] + -> LLVM ([(PrimArg,a)],[(PrimArg,a)]) +partitionArgTuples cfn args = do + realArgs <- lift $ filterM (notM . argIsPhantom . fst) args + let (ins,outs,oRefs,iRefs) = + partitionByFlow (argFlowDirection . fst) realArgs + unless (List.null oRefs) + $ nyi $ "out-by-reference argument in call to C function " ++ cfn + unless (List.null iRefs) + $ nyi $ "take-reference argument in call to C function " ++ cfn + return (ins,outs) + + +-- | Split the provided list into input, output, out-by-reference, and +-- take-reference arguments, given a function to determine the flow direction of +-- each element. Out-by-reference means the flow is FlowOutByReference, which +-- denotes an argument that is notionally an output, but actually a reference +-- input that points to the location to write the output. Take-reference +-- denotes a notional input argument that in actually produces the reference to +-- pass as an out-by-reference argument. The key benefit of these flows comes +-- when the call with the out-by-reference argument precedes the one with the +-- take-reference argument (ie, the former notionally produces the value to use +-- in the latter): if no other dependency forces this order of execution, +-- making these out-by-reference and take-reference allows us to swap their +-- order, potentially allowing last call optimisation. The LastCallAnalysis +-- module contains the analysis and transformation introducing these flows. +partitionByFlow :: (a -> PrimFlow) -> [a] -> ([a],[a],[a],[a]) +partitionByFlow fn lst = + (List.filter ((==FlowIn) . fn) lst, + List.filter ((==FlowOut) . fn) lst, + List.filter ((==FlowOutByReference) . fn) lst, + List.filter ((==FlowTakeReference) . fn) lst) + + +-- | Marshall data returned by C code. Emits a C call instruction, which +-- returns its result in the specified type representation, leaving its +-- output in the specified output variable with its expected type +-- representation, type converting it if necessary. +marshallCallResult :: PrimArg -> String -> String -> LLVM () +marshallCallResult outArg@ArgVar{argVarName=varName} cType instr = do + let inTypeRep = trustFromJust + ("marshalling output with unknown C type " ++ cType) + $ cTypeRepresentation cType + outTypeRep <- argTypeRep outArg + let instr' = "call ccc " ++ llvmTypeRep inTypeRep ++ " " ++ instr + if equivLLTypes inTypeRep outTypeRep then llvmAssignResult outArg instr' + else do + (writeTmp,readTmp) <- freshTempArgs $ Representation inTypeRep + llvmAssignResult writeTmp instr' + typeConvert readTmp outArg +marshallCallResult outArg inTypeRep instr = + shouldnt $ "Can't marshall result into non-variable " ++ show outArg + + +-- | Write an LLVM instruction to unpack one argument from a tuple. +-- instruction looks like: %var = extractvalue {i64, i1} %0, 0 +unpackArg :: LLVMType -> LLVMName -> PrimArg -> Int -> LLVM () +unpackArg typ tuple arg argNum = do + logLLVM $ "Extracting arg " ++ show argNum ++ " into " ++ show arg + llvmAssignResult arg $ "extractvalue " ++ typ + ++ tuple ++ ", " ++ show argNum + +-- | Write an LLVM instruction to unpack one argument from a tuple. +-- instruction looks like: %var = extractvalue {i64, i1} %0, 0 +unpackConvertedArg :: LLVMType -> LLVMName -> PrimArg -> TypeRepresentation + -> Int -> LLVM () +unpackConvertedArg typ tuple arg tyRep argNum = do + logLLVM $ "Extracting arg " ++ show argNum + ++ " (representation " ++ show tyRep ++ ") into " ++ show arg + llvmAssignConvertedResult arg tyRep $ "extractvalue " ++ typ + ++ tuple ++ ", " ++ show argNum + + +-- | Marshall data being passed to C code. Emits code to transform the argument +-- to the expected format for C code, and returns the llvm argument to actually +-- pass to the C function. +marshallArgument :: PrimArg -> String -> LLVM LLVMArg +marshallArgument arg cType = do + let outTypeRep = trustFromJust + ("marshalling argument with unknown C type " ++ cType) + $ cTypeRepresentation cType + inTypeRep <- argTypeRep arg + if inTypeRep == outTypeRep then llvmArgument arg + else typeConvertedArg outTypeRep arg + + +-- | The LLVM type of the specified argument. Wybe strings are Wybe pointers; C +-- strings are also Wybe pointers, because we do address arithmetic on them; +-- globals are C pointers. Other kinds of args are represented however their +-- types say they are. +argTypeRep :: PrimArg -> LLVM TypeRepresentation +argTypeRep (ArgString _ WybeString _) = return Pointer +argTypeRep (ArgString _ CString _) = return Pointer +argTypeRep ArgGlobal{} = return CPointer +argTypeRep ArgClosure{} = return CPointer +argTypeRep arg = typeRep $ argType arg + + +-- | The LLVM argument for the specified PrimArg as an LLVM type and value +llvmArgument :: PrimArg -> LLVM LLVMArg +llvmArgument arg = do + tyRep <- argTypeRep arg + let lltype = llvmTypeRep tyRep + llVal <- llvmValue arg + return $ makeLLVMArg lltype llVal + + +makeLLVMArg :: LLVMType -> String -> LLVMArg +makeLLVMArg ty val = ty ++ " " ++ val + + +-- | A PrimArg as portrayed in LLVM code +llvmValue :: PrimArg -> LLVM String +llvmValue argVar@ArgVar{argVarName=var, argVarType=ty} = do + realVar <- varToRead var + thisRep <- typeRep ty + currRep <- gets $ Map.lookup realVar . varTypes + case (currRep,thisRep) of + (Nothing,_) -> do + logLLVM $ "Using unknown LLVM variable " ++ realVar + return realVar + (Just defRep, useRep) | equivLLTypes defRep useRep -> return realVar + (Just defRep, useRep) -> + typeConverted thisRep argVar{argVarType=Representation defRep} +llvmValue (ArgInt val _) = return $ show val +llvmValue (ArgFloat val _) = return $ show val +llvmValue (ArgString str stringVariant _) = do + let spec = case stringVariant of + WybeString -> WybeStringSpec str + CString -> CStringSpec str + glob <- lookupConstant spec + convertedConstant + (ArgGlobal (GlobalVariable glob) $ Representation CPointer) Pointer +llvmValue (ArgChar val _) = return $ show $ fromEnum val +llvmValue arg@(ArgClosure pspec args ty) = do + logLLVM $ "llvmValue of " ++ show arg + -- See if we've already allocated a constant for this closure + glob <- tryLookupConstant $ ClosureSpec pspec args + case glob of + Just constName -> + return $ llvmGlobalName constName + Nothing -> do + (writePtr,readPtr) <- freshTempArgs $ Representation CPointer + let fnRef = funcRef pspec + let sizeVar = + ArgInt (fromIntegral (wordSizeBytes * (1 + length args))) + intType + logLLVM "Creating closure" + heapAlloc writePtr sizeVar Nothing + llArgs <- mapM llvmArgument args + llvmStoreArray readPtr (fnRef:llArgs) + logLLVM $ "Finished creating closure; result is " ++ show readPtr + rep <- typeRep ty + logLLVM $ "Converting to representation " ++ show rep + llvmValue readPtr +llvmValue (ArgGlobal val _) = llvmGlobalInfoName val +llvmValue (ArgUnneeded val _) = return "undef" +llvmValue (ArgUndef _) = return "undef" + + +-- | The LLVMArg translation of a ProcSpec. +funcRef :: ProcSpec -> LLVMArg +funcRef pspec = "ptr " ++ llvmGlobalName (show pspec) + + +-- | The variable name of a PrimArg; report an error if not a variable. +argVar :: String -> PrimArg -> PrimVarName +argVar _ ArgVar{argVarName=var} = var +argVar msg _ = shouldnt $ "variable argument expected " ++ msg + + +neededFreeArgs :: ProcSpec -> [PrimArg] -> LLVM [PrimArg] +neededFreeArgs pspec args = lift $ do + params <- List.filter ((==Free) . primParamFlowType) . primProtoParams + . procImplnProto . procImpln <$> getProcDef pspec + List.map snd <$> filterM (paramIsReal . fst) (zip params args) + + + +---------------------------------------------------------------------------- +-- Converting Wybe types to LLVM types +---------------------------------------------------------------------------- + +-- | Return the representation for the specified type +typeRep :: TypeSpec -> LLVM TypeRepresentation +typeRep ty = + trustFromJust ("lookupTypeRepresentation of unknown type " ++ show ty) + <$> lift (lookupTypeRepresentation ty) + + +-- | Return the LLMV name and type representation of the specified resource. +llvmResource :: ResourceSpec -> LLVM (LLVMName, TypeRepresentation) +llvmResource res = do + (res', ty) <- + mapSnd (trustFromJust $ "defGlobalResource " ++ show res) + <$> lift (canonicaliseResourceSpec Nothing "newLLVMModule" res) + rep <- typeRep ty + return (llvmGlobalName (makeGlobalResourceName res'), rep) + + +-- | The LLVM representation of a Wybe type based on its TypeRepresentation +llvmTypeRep :: TypeRepresentation -> LLVMType +llvmTypeRep (Bits bits) = "i" ++ show bits +llvmTypeRep (Signed bits) = "i" ++ show bits +llvmTypeRep (Floating 16) = "half" +llvmTypeRep (Floating 32) = "float" +llvmTypeRep (Floating 64) = "double" +llvmTypeRep (Floating 128) = "fp128" +llvmTypeRep (Floating n) = shouldnt $ "invalid float size " ++ show n +llvmTypeRep (Func _ _) = llvmTypeRep Pointer +llvmTypeRep Pointer = llvmTypeRep $ Bits wordSize +llvmTypeRep CPointer = "ptr" + + +-- | The LLVM return type for proc with the specified list of output type specs. +llvmRepReturnType :: [TypeRepresentation] -> LLVMType +llvmRepReturnType [] = "void" +llvmRepReturnType [ty] = llvmTypeRep ty +llvmRepReturnType tys = llvmStructType tys + + +-- | An LLVM structure type based on a list of LLVM type representations +llvmStructType :: [TypeRepresentation] -> LLVMType +llvmStructType tys = "{" ++ intercalate ", " (List.map llvmTypeRep tys) ++ "}" + + +-- | The LLVM return type for proc with the specified list of output type specs. +llvmReturnType :: [TypeSpec] -> LLVM LLVMType +llvmReturnType specs = llvmRepReturnType <$> mapM typeRep specs + + +---------------------------------------------------------------------------- +-- LLVM Type conversion +-- +-- We convert between LLVM types in a few contexts: +-- +-- * To pass Wybe values to C or return C values to Wybe +-- +-- * To convert typed values to generic ones or vice versa +-- +-- * To make LLVM binary operation argument types consistent (eg, to add an +-- int to a char) +-- +-- * To convert between CPointer and Pointer types for address arithmetic +-- +-- * To implement the lpvm cast operation +-- +-- This excludes explicit conversion, such as float:float or float:iround, which +-- are handled by explicitly using LLVM intrinsics or instructions. +---------------------------------------------------------------------------- + +-- | Emit an instruction to convert the specified input argument to the +-- specified output argument. +typeConvert :: PrimArg -> PrimArg -> LLVM () +typeConvert fromArg toArg = do + toTy <- argTypeRep toArg + fromTy <- argTypeRep fromArg + fromVal <- llvmValue fromArg + logLLVM $ "typeConvert " ++ fromVal ++ " from " ++ show fromTy + ++ " to " ++ show toTy + case toArg of + ArgVar{argVarName=varName} | equivLLTypes fromTy toTy -> + renameVariable varName fromVal $ llvmTypeRep fromTy + _ -> + llvmAssignResult toArg + $ typeConvertOp fromTy toTy ++ " " + ++ makeLLVMArg (llvmTypeRep fromTy) fromVal + ++ " to " ++ llvmTypeRep toTy + + +-- | Convert the specified PrimArg to a PrimArg with the specified +-- representation. +typeConvertedPrim :: TypeRepresentation -> PrimArg -> LLVM PrimArg +typeConvertedPrim toTy fromArg = do + logLLVM $ "Converting PrimArg " ++ show fromArg ++ " to " ++ show toTy + argRep <- argTypeRep fromArg + if equivLLTypes argRep toTy + then return fromArg + else do + (writeArg,readArg) <- freshTempArgs $ Representation toTy + typeConvert fromArg writeArg + return readArg + + +-- | LLVM code to convert PrimArg fromVal to representation toTy, returning an +-- LLVMArg holding the converted value. +typeConvertedArg :: TypeRepresentation -> PrimArg -> LLVM LLVMArg +typeConvertedArg toTy fromArg + | argIsConst fromArg = convertedConstantArg fromArg toTy + | otherwise = typeConvertedPrim toTy fromArg >>= llvmArgument + + +-- | LLVM code to convert PrimArg fromVal to representation toTy, returning a +-- LLVMName (ie, without type prefix) holding the converted value. +typeConverted :: TypeRepresentation -> PrimArg -> LLVM LLVMName +typeConverted toTy fromArg + | argIsConst fromArg = convertedConstant fromArg toTy + | otherwise = do + argRep <- argTypeRep fromArg + if equivLLTypes argRep toTy + then llvmValue fromArg + else do + (writeArg,readArg) <- freshTempArgs $ Representation toTy + typeConvert fromArg writeArg + llvmValue readArg + + +-- | An LLVM constant expression of the specified type toTy, when the constant +-- is initially of the specified type fromTy. This may take the form of an +-- LLVM type conversion expression, which is fully evaluated at compile-time, so +-- it cannot involve conversion instructions. +convertedConstant :: PrimArg -> TypeRepresentation -> LLVM LLVMName +convertedConstant arg toTy = do + -- XXX should verify that arg is constant, if ArgGlobal is considered const + logLLVM $ "Converting constant " ++ show arg ++ " to type " ++ show toTy + fromTy <- argTypeRep arg + logLLVM $ " conversion " ++ show fromTy ++ " -> " ++ show toTy + ++ (if trivialConstConversion fromTy toTy then " IS" else " is NOT") + ++ " trivial" + if trivialConstConversion fromTy toTy + then llvmValue arg + else do + fromArg <- llvmArgument arg + return $ typeConvertOp fromTy toTy ++ "( " + ++ fromArg ++ " to " ++ llvmTypeRep toTy ++ " )" + + +-- | An LLVM constant expression of the specified type toTy, when the constant +-- is initially of the specified type fromTy. This may take the form of an +-- LLVM type conversion expression, which is fully evaluated at compile-time, so +-- it cannot involve conversion instructions. +convertedConstantArg :: PrimArg -> TypeRepresentation -> LLVM LLVMArg +convertedConstantArg arg toTy = do + -- XXX should verify that arg is constant, if ArgGlobal is considered const + makeLLVMArg (llvmTypeRep toTy) <$> convertedConstant arg toTy + + + +-- Converting constants from the first type to the second is completely trivial, +-- because the constant is automatically considered to have both types. +trivialConstConversion :: TypeRepresentation -> TypeRepresentation -> Bool +trivialConstConversion ty1 ty2 | ty1 == ty2 = True +trivialConstConversion (Bits _) (Bits _) = True +trivialConstConversion (Bits _) (Signed _) = True +trivialConstConversion (Bits _) Pointer = True +trivialConstConversion (Signed _) (Signed _) = True +trivialConstConversion (Signed _) (Bits _) = True +trivialConstConversion (Signed _) Pointer = True +trivialConstConversion (Floating _) (Floating _) = True +trivialConstConversion Pointer (Bits b) = b == wordSize +trivialConstConversion Pointer (Signed b) = b == wordSize +trivialConstConversion _ _ = False + + +-- | Are two type representations the same in LLVM (and hence need no +-- conversion)? +equivLLTypes :: TypeRepresentation -> TypeRepresentation -> Bool +equivLLTypes Pointer (Bits b) = b == wordSize +equivLLTypes Pointer (Signed b) = b == wordSize +equivLLTypes (Bits b) Pointer = b == wordSize +equivLLTypes (Signed b) Pointer = b == wordSize +equivLLTypes (Signed b1) (Bits b2) = b1 == b2 +equivLLTypes (Bits b1) (Signed b2) = b1 == b2 +equivLLTypes Func{} Func{} = True -- Since LLVM just considers them ptrs +equivLLTypes Pointer Func{} = True +equivLLTypes Func{} Pointer = True +equivLLTypes t1 t2 = t1 == t2 + + +-- | The appropriate type conversion operator to convert from fromTy to toTy +typeConvertOp :: TypeRepresentation -> TypeRepresentation -> String +typeConvertOp fromTy toTy + | fromTy == toTy = "bitcast" -- use bitcast for no-op conversion +typeConvertOp Pointer toTy = typeConvertOp (Bits wordSize) toTy +typeConvertOp fromTy Pointer = typeConvertOp fromTy (Bits wordSize) +typeConvertOp Func{} toTy = typeConvertOp (Bits wordSize) toTy +typeConvertOp fromTy Func{} = typeConvertOp fromTy (Bits wordSize) +typeConvertOp (Bits m) (Bits n) + | m < n = "zext" + | n < m = "trunc" + | otherwise = shouldnt "no-op unsigned conversion" +typeConvertOp (Bits m) (Signed n) + | m < n = "sext" + | n < m = "trunc" + | otherwise = -- no instruction actually needed, but one is expected + "bitcast" +typeConvertOp (Bits _) CPointer = "inttoptr" +typeConvertOp (Signed m) (Bits n) + | m < n = "zext" + | n < m = "trunc" + | otherwise = -- no instruction actually needed, but one is expected + "bitcast" +typeConvertOp (Signed m) (Signed n) + | m < n = "sext" + | n < m = "trunc" + | otherwise = shouldnt "no-op signed int conversion" +typeConvertOp (Floating m) (Floating n) + | m < n = "fpext" + | n < m = "fptrunc" + | otherwise = shouldnt "no-op floating point conversion" +typeConvertOp CPointer (Bits _) = "ptrtoint" +-- These don't change representation, or change any bits. They just +-- re-interpret a FP number as an integer or vice versa. This ensures we don't +-- lose precision or waste time on round trip conversion. +typeConvertOp (Bits m) (Floating n) = "bitcast" +typeConvertOp (Signed m) (Floating n) = "bitcast" +typeConvertOp (Floating m) (Bits n) = "bitcast" +typeConvertOp (Floating m) (Signed n) = "bitcast" +typeConvertOp repIn toTy = + shouldnt $ "Don't know how to convert from " ++ show repIn + ++ " to " ++ show toTy + + +---------------------------------------------------------------------------- +-- The LLVM Monad and LLVM code generation and manipulation -- +---------------------------------------------------------------------------- + + +-- At least for now, we represent LLVM info as strings + +-- | An LLVM type name, such as i8 +type LLVMType = String + +-- | An LLVM global name, such as a function, variable or constant name, which must +-- begin with @; or an LLVM local variable name, which must begin with %; or an LLVM +-- constant value. +type LLVMName = String + +-- | An LLVM value (constant or LLVMName), preceded by and LLVMType +type LLVMArg = String + +-- | Information we collect about external things referenced by this module, so +-- we can declare them. For functions, this includes the LLVM calling +-- convention, the LLVM name of the function, and the input and output argument +-- types. +data ExternSpec = + -- | An external function we call + ExternFunction { + extFnCC :: String, -- ^ The function's calling convention + extFnName :: LLVMName, -- ^ The function's LLVM name (with @) + extFnArgs :: [TypeSpec], -- ^ The function's input argument types + extFnOut :: [TypeSpec] -- ^ The function's result (tuple) types + } + -- | An external global variable we refer to + | ExternVariable { + extVarName :: GlobalInfo, -- ^ The global variable to declare + extVarType :: TypeSpec -- ^ The variable's Wybe type + } + deriving (Eq,Ord,Show) + + +-- | Return the name of the thing that the EsternSpec declares +externID :: ExternSpec -> LLVM LLVMName +externID ExternFunction{extFnName=name} = return name +externID ExternVariable{extVarName=name} = llvmGlobalInfoName name + + +-- | Information needed to specify one constant value, giving the representation +-- to be stored and the (constant) value itself. +type ConstSpec = (PrimArg,TypeRepresentation) + + +-- | The LLVM State monad +data LLVMState = LLVMState { + -- These values apply to a whole module (and submodules) + allConsts :: Set StaticConstSpec, + -- ^ Static constants appearing in module + constNames :: Map StaticConstSpec Ident, + -- ^ local name given to static constants + allExterns :: Map String ExternSpec, + -- ^ Extern declarations needed by module + fileHandle :: Handle, -- ^ The file handle we're writing to + -- These values apply to the single proc being translated + tmpCounter :: Int, -- ^ Next temp var to make for current proc + labelCounter :: Int, -- ^ Next label number to use + varDefRenaming :: Set PrimVarName, + -- ^ Vars to rename on definition + varUseRenaming :: Map PrimVarName LLVMName, + -- ^ New action for some variables to read + varTypes :: Map LLVMName TypeRepresentation, + -- ^ The LLVM type rep of defined vars + deferredCall :: Maybe (ProcSpec, [PrimArg], [PrimArg], [PrimArg]), + -- ^ Wybe proc call deferred for + -- out-by-reference arg, with in, out, and + -- out-by-ref args + takeRefVars :: Map PrimVarName (PrimArg,TypeSpec), + -- ^ arg to read each take-reference ptr, + -- plus the type of the original variable + outByRefVars :: Map PrimVarName (PrimArg,TypeSpec), + -- ^ ptr to write each out-by-reference var + -- to, when the var is written, plus the + -- type of the var + doesAlloca :: Bool -- Does current body do alloca? +} + + +-- | Set up LLVM monad to translate a module into the given file handle +initLLVMState :: Handle -> LLVMState +initLLVMState h = LLVMState Set.empty Map.empty Map.empty h 0 0 Set.empty + Map.empty Map.empty Nothing Map.empty Map.empty False + + +-- | Reset the LLVM monad in preparation for translating a proc definition with +-- the specified temp counter. +initialiseLLVMForProc :: Int -> LLVM () +initialiseLLVMForProc tmpCount = do + modify $ \s -> s { tmpCounter = tmpCount + , labelCounter = 0 + , varDefRenaming = Set.empty + , varUseRenaming = Map.empty + , varTypes = Map.empty + , deferredCall = Nothing + , takeRefVars = Map.empty + , outByRefVars = Map.empty + , doesAlloca = False + } + + +type LLVM = StateT LLVMState Compiler + + +-- | Apply some function to (access some member of) the current module from +-- within the LLVM monad. +llvmGetModule :: (Module -> a) -> LLVM a +llvmGetModule fn = lift $ getModule fn + + +-- | Write a string followed by a newline to the current LLVM output file handle +llvmPutStrLn :: String -> LLVM () +llvmPutStrLn str = do + logLLVM $ "EMIT: " ++ str + h <- gets fileHandle + liftIO $ hPutStrLn h str + + +-- | Write an indented string to the current LLVM output file handle. +llvmPutStrLnIndented :: String -> LLVM () +llvmPutStrLnIndented str = llvmPutStrLn $ " " ++ str + + +-- | Write a blank line to the current LLVM output file handle +llvmBlankLine :: LLVM () +llvmBlankLine = llvmPutStrLn "" + + +-- | Return labels made unique by adding the next label suffix +freshLables :: [String] -> LLVM [String] +freshLables bases = do + nxt <- gets labelCounter + modify $ \s -> s {labelCounter = nxt+1} + return $ List.map (++show nxt) bases + + +-- |Return a fresh prim variable name. +makeTemp :: LLVM PrimVarName +makeTemp = do + ctr <- gets tmpCounter + modify (\s -> s { tmpCounter = ctr + 1 }) + return $ PrimVarName (mkTempName ctr) 0 + + +-- |Return a pair of PrimArgs to write and read, respectively, a fresh temp +-- variable of the specified type, along with the variable name. +freshTempArgs :: TypeSpec -> LLVM (PrimArg, PrimArg) +freshTempArgs ty = do + tmp <- makeTemp + let writeArg = ArgVar tmp ty FlowOut Ordinary False + let readArg = ArgVar tmp ty FlowIn Ordinary True + return (writeArg,readArg) + + +-- | Set the set of variables that need to be renamed to convert to SSA. +-- LPVM is a (dynamic) single assignment language, but LLVM demands static +-- single assignment. We generate LPVM that is in SSA form, except for output +-- parameters, so here we rename all output parameters as they are assigned, +-- and then use the new names when we return the outputs. +setRenaming :: Set PrimVarName -> LLVM () +setRenaming vars = do + logLLVM $ "Recording variables needing renaming = " ++ show vars + modify $ \s -> s { varDefRenaming = vars } + + +-- | Replace the specified variable with the specified new value in all +-- following code. +renameVariable :: PrimVarName -> LLVMName -> LLVMType -> LLVM () +renameVariable var val llty = do + modify $ \s -> s { varUseRenaming = Map.insert var val $ varUseRenaming s } + storeValueIfNeeded var $ makeLLVMArg llty val + + +-- | The LLVM name for a variable we are about to assign. If this is one of the +-- output parameters, rename it, otherwise leave it alone, and in either case, +-- transform it to an LLVM local variable name. +varToWrite :: PrimVarName -> LLVMType -> LLVM LLVMName +varToWrite v llty = do + mustRename <- Set.member v <$> gets varDefRenaming + logLLVM $ "varToWrite " ++ show v ++ "; mustRename = " ++ show mustRename + vdr <- gets varDefRenaming + logLLVM $ "varDefRenaming = " ++ show vdr + if mustRename then do + tmp <- llvmLocalName <$> makeTemp + renameVariable v tmp llty + return tmp + else do + -- rename v next time we try to assign it. This can happen because LPVM + -- isn't quite *static* single assignment, so the same variable name can + -- be assigned in multiple branches. In that case, rename later + -- assignments. + modify $ \s -> s { varDefRenaming = Set.insert v $ varDefRenaming s } + return $ llvmLocalName v + + +-- | The LLVM name for a variable we are about to read. +varToRead :: PrimVarName -> LLVM LLVMName +varToRead v = do + renaming <- gets varUseRenaming + return $ fromMaybe (llvmLocalName v) $ Map.lookup v renaming + + +---------------------------------------------------------------------------- +-- Handling deferred calls and FlowOutByReference +-- +-- This module handles FlowOutByReference and FlowTakeReference arguments as +-- follows. First, Wybe calls with any FlowOutByReference arguments are +-- deferred, allowing following instructions with FlowTakeReference arguments to +-- be handled first. Before any other instruction without a FlowTakeReference +-- argument is handled (or at the end of the proc body), any deferred +-- instruction is generated, as described below. +-- +-- An instruction with a FlowTakeReference argument is transformed into an +-- instruction that stores the address the instruction would write the value +-- into, were it not FlowTakeReference, in a fresh temp variable, that is then +-- associated with that argument variable. +-- +-- When a deferred call with a FlowOutByReference argument is generated, we +-- first check whether any temp variable has previously been associated with it +-- when handling a FlowTakeReference argument. If not, we create such a +-- variable and generate an alloca instruction to assign the variable. Then we +-- generate the call as usual, except that we pass the temp variable as input to +-- the call in place of the FlowOutByReference argument. Following the call, +-- for each temp variable that was not previously assigned for a +-- FlowTakeReference instruction, we generate an instruction to load the +-- variable from the associated temp variable. +-- +-- FlowOutByReference arguments appear in two contexts: in what will become a +-- tail call after the following instructions with FlowTakeReference arguments, +-- and in other calls to the same proc. In the latter case, it is necessary to +-- create a (stack) memory location to hold the output of the call, and then to +-- load the variable with the value produced. In the former case, this is not +-- necessary, because the procedure never actually uses the value of the +-- FlowOutByReference variable. +-- +---------------------------------------------------------------------------- + + +-- | Record the specified instruction to be emitted later, after any +-- instructions with FlowTakeReference instructions have been handled. +deferCall :: ProcSpec -> [PrimArg] -> [PrimArg] -> [PrimArg] -> LLVM () +deferCall wybeProc ins outs oRefs = do + logLLVM $ "deferring call to " ++ show wybeProc + ++ " with out-by-reference argument(s): " ++ show oRefs + currDeferred <- gets deferredCall + unless (isNothing currDeferred) + $ shouldnt "deferring a call when one is already deferred" + modify $ \s -> s{ deferredCall = Just (wybeProc, ins, outs, oRefs) } + + +-- | Record llvar as the llvm variable that holds the pointer to the value to +-- write to the FlowTakeReference variable takeRef when we see its +-- FlowOutByReference use. +addTakeRefPointer :: PrimVarName -> PrimArg -> TypeSpec -> LLVM () +addTakeRefPointer takeRefVar readPtrArg ty = do + logLLVM $ "Recording take-ref pointer " ++ show readPtrArg + ++ " as replacement for output to " ++ show takeRefVar + ++ ":" ++ show ty + modify $ \s -> s{ takeRefVars = + Map.insert takeRefVar (readPtrArg,ty) $ takeRefVars s } + + +-- | Record readPtrArg as the variable that holds the pointer to the place to +-- store the value assigned when a value is assigned to var, along with the type +-- of the value. +addOutByRefPointer :: PrimVarName -> PrimArg -> TypeSpec -> LLVM () +addOutByRefPointer var readPtrArg ty = do + logLLVM $ "Recording out-by-ref pointer " ++ show readPtrArg + ++ " as place to store values assigned to " ++ show var + ++ ":" ++ show ty + modify $ \s -> s{ outByRefVars = + Map.insert var (readPtrArg,ty) $ outByRefVars s } + + +-- | The specified value is to be assigned to the specified variable. If that +-- variable is recorded as an out-by-reference, then store the value where we've +-- recorded it should be stored. +storeValueIfNeeded :: PrimVarName -> LLVMArg -> LLVM () +storeValueIfNeeded var val = do + rec <- gets $ Map.lookup var . outByRefVars + case rec of + Nothing -> return () + Just (readPtrArg,ty) -> do + logLLVM $ "Storing value " ++ show val ++ ":" ++ show ty + ++ " through pointer " ++ show readPtrArg + llvmStoreValue readPtrArg val + + +-- | Emit the deferred instruction, if there is one. If not, do nothing. This +-- must be done before handling every instruction other than one that has a +-- FlowTakeReference argument. +releaseDeferredCall :: LLVM () +releaseDeferredCall = do + deferred <- gets deferredCall + case deferred of + Nothing -> return () + Just (wybeProc, ins, outs, oRefs) -> do + logLLVM $ "releasing deferred call to " ++ show wybeProc + (refIns,old) <- mapAndUnzipM convertOutByRefArg oRefs + takeRefs <- gets takeRefVars + logLLVM $ "take-ref pointers = " ++ show takeRefs + logLLVM $ "new ref args: " ++ show refIns ++ "; old = " ++ show old + let allOld = and old + tailKind <- tailMarker allOld + writeActualCall wybeProc (ins++refIns) outs tailKind + unless allOld $ zipWithM_ (\refIn oRef -> do + let byRefArg = setArgFlow FlowOut oRef + llvmLoad refIn byRefArg + ) refIns oRefs + modify $ \s -> s{ deferredCall = Nothing, takeRefVars = Map.empty } + + +-- | Convert a FlowOutByeReference argument into an input CPointer arg. If +-- we've already created a variable for the pointer, use that, otherwise alloca +-- space for the value and return an argument holding a pointer to it. Also +-- return a Boolean indicating whether the variable was already created. +convertOutByRefArg :: PrimArg -> LLVM (PrimArg,Bool) +convertOutByRefArg ArgVar{argVarName=name, argVarType=ty, + argVarFlow=FlowOutByReference} = do + logLLVM $ "Converting out-by-ref var " ++ show name + maybePtrArg <- gets $ Map.lookup name . takeRefVars + case maybePtrArg of + Just (ptrArg,_) -> do + logLLVM $ " -> already a take-reference: returning " ++ show ptrArg + return (ptrArg,True) + Nothing -> do + logLLVM " -> Not a take-reference, checking for out-by-reference" + maybeOBRVar <- gets $ Map.lookup name . outByRefVars + case maybeOBRVar of + Just (ptrArg,_) -> do + logLLVM $ " -> already out-by-reference: returning " + ++ show ptrArg + return (ptrArg,True) + Nothing -> do + logLLVM " -> Not out-by-reference: making fresh alloca ptr" + (writeArg,readArg) <- freshTempArgs $ Representation CPointer + stackAlloc writeArg wordSizeBytes + addTakeRefPointer name readArg ty + return (readArg,False) +convertOutByRefArg other = + shouldnt $ "Expected out-by-reference argument: " ++ show other + + +-- | Convert an out-by-reference parameter into an input parameter that points +-- to the place to write the actual output. +convertOutByRefParam :: PrimParam -> PrimParam +convertOutByRefParam param = + param{primParamType=Representation CPointer, primParamFlow=FlowIn} + + +-- | Generate code to allocate heap memory, with the size in bytes specified as +-- a PrimArg, so it can be a variable. The result will be converted to the type +-- of the result variable. +heapAlloc :: PrimArg -> PrimArg -> OptPos -> LLVM () +heapAlloc result sizeVar = + marshalledCCall mallocFn [] [sizeVar,result] ["int","pointer"] + + +-- | Generate code to allocate memory on the stack (alloca), with the size in +-- bytes specified as an Int, so it must be a constant. The result will be +-- converted to the type of the result variable. +stackAlloc :: PrimArg -> Int -> LLVM () +stackAlloc result size = do + llvmAssignResult result $ "alloca i8, i64 " ++ show size + ++ ", align " ++ show wordSizeBytes + modify $ \s -> s { doesAlloca = True } + + +---------------------------------------------------------------------------- +-- Formatting for LLVM -- +---------------------------------------------------------------------------- + +-- | The LLVM name for a Wybe proc, with its LLVM calling convention. +llvmProcName :: ProcSpec -> (LLVMName,String) +llvmProcName ProcSpec{procSpecMod=[],procSpecName=""} = + (llvmGlobalName "main", "ccc") +llvmProcName pspec = (llvmGlobalName $ show pspec, "fastcc") + + +-- | Make a suitable LLVM name for a global variable or constant. We prefix it +-- with @, enclose the rest in quotes, and escape any special characters. +llvmGlobalName :: String -> LLVMName +llvmGlobalName s = + '@' : llvmQuoteIfNecessary s + + +-- | Wrap quotes around the specified string, using character escapes for any +-- special characters, if it contains any characters but alphanumerics, +-- underscores, or period characters. +llvmQuoteIfNecessary :: String -> String +llvmQuoteIfNecessary s = + if all ((=='_')|||(=='.')|||isAlphaNum) s + then s + else '"' : concatMap showLLVMChar s ++ "\"" + + +-- | Produce a suitable LLVM global name based on a GlobalInfo +llvmGlobalInfoName :: GlobalInfo -> LLVM LLVMName +llvmGlobalInfoName (GlobalResource res) = + fst <$> llvmResource res +llvmGlobalInfoName (GlobalVariable var) = return $ llvmGlobalName var + + +-- | Make a suitable LLVM name for a foreign (e.g., C) function. +llvmForeignName :: String -> LLVMName +llvmForeignName s = '@' : llvmQuoteIfNecessary s + + +-- | Make a suitable LLVM name for a local variable. We prefix it +-- with %, enclose the rest in quotes, and escape any special characters. +llvmLocalName :: PrimVarName -> LLVMName +llvmLocalName varName = + '%' : llvmQuoteIfNecessary (show varName) + + +-- | Make an LLVM reference to the specified label. +llvmLabelName :: String -> String +llvmLabelName varName = "label %" ++ llvmQuoteIfNecessary varName + + +-- | Format a string as an LLVM string; the Bool indicates whether to add +-- a zero terminator. +showLLVMString :: String -> Bool -> String +showLLVMString str zeroTerminator = + let suffix = if zeroTerminator then "\0" else "" + len = length str + length suffix + in "[ " ++ show len ++ " x i8 ] c\"" + ++ concatMap showLLVMChar str ++ concatMap showLLVMChar suffix ++ "\"" + + +-- | Format a single character as a character in an LLVM string. +showLLVMChar :: Char -> String +showLLVMChar char + | char == '\\' = "\\\\" + | char == '"' = "\\22" + | char >= ' ' && char <= '~' = [char] + | otherwise = + let ascii = fromEnum char + hexChar i = if i < 10 then toEnum $ fromEnum '0' + i + else toEnum $ fromEnum 'A' + i - 10 + in ['\\', hexChar (ascii `div` 16), hexChar (ascii `mod` 16)] + + +-- | The name of the LLVM memcpy intrinsic that applies to 2 CPointers and one +-- Wybe int type argument (there's also a Boolean flag). +llvmMemcpyFn :: LLVM String +llvmMemcpyFn = ("llvm.memcpy.p0.p0." ++) . llvmTypeRep <$> typeRep intType + + +-- | The malloc function we call. Currently wybe_malloc, which just calls +-- GC_malloc. +mallocFn :: Ident +mallocFn = "wybe_malloc" + + +---------------------------------------------------------------------------- +-- Logging -- +---------------------------------------------------------------------------- + +-- | Logging from the LLVM monad. +logLLVM :: String -> LLVM () +logLLVM = lift . logMsg LLVM + + +-- | Log with a wrapping line of replicated characters above and below. +logWrapWith :: Char -> String -> Compiler () +logWrapWith ch s = do + logMsg LLVM (replicate 65 ch) + logMsg LLVM s + logMsg LLVM (replicate 65 ch) diff --git a/src/LastCallAnalysis.hs b/src/LastCallAnalysis.hs index a67989877..fa4356046 100644 --- a/src/LastCallAnalysis.hs +++ b/src/LastCallAnalysis.hs @@ -19,12 +19,51 @@ import Data.Foldable (foldrM) import Data.List.Predicate (allUnique) import Callers (getSccProcs) import Data.Graph (SCC (AcyclicSCC, CyclicSCC)) -import Control.Monad.State (StateT (runStateT), MonadTrans (lift), execStateT, execState, runState, MonadState (get, put), gets, modify, unless, MonadPlus (mzero)) -import Control.Monad ( liftM, (>=>), when ) +import Control.Monad.State (StateT (runStateT), MonadTrans (lift), execStateT, execState, runState, MonadState (get, put), gets, modify) +import Control.Monad ( liftM, (>=>), when, unless, MonadPlus (mzero) ) import Data.Set (Set) import qualified Data.Set as Set import Control.Monad.Trans.Maybe (MaybeT (runMaybeT)) + +-- BEGIN MAJOR DOC +-- +-- # Last Call Optimisation +-- +-- The compiler relies on the LLVM compiler to perform last call optimisation, +-- turning the last call in a procedure body into a jump, if no other +-- instructions follow the last call. This module tries to increase the number +-- of procedures where this optimisation applies by moving code that follows the +-- last call before it, whenever all the inputs to those instructions are +-- available before the last call. +-- +-- One particular trick employed to make this possible is +-- last-call-module-construction optimisation. The idea here is to invert the +-- direction of data flow, turing an output into an input, by passing in the +-- address to which to write the output. When the instruction following the +-- last call in a body simply writes an output of that call into one memory +-- location, without using it in any other way, and when the called procedure is +-- defined in the module currently being compiled (so we can transform it), we +-- can change that output argument into a pointer input, and modify the +-- procedure definition to write the output value to memory through that +-- pointer. This is done by changing that parameter from FlowOut to +-- FlowOutByReference, and similarly changing the corresponding argument in all +-- calls to that procedure. Likewise, we change the instruction intended to +-- write the procedure output to memory from FlowIn to FlowTakeReference. +-- +-- Note that this transformation leaves the call that notionally produces the +-- output before the instruction that notionally writes the value to memory, +-- despite the fact that now the latter actually takes the address to be written +-- to, and the former actually passes that address into a procedure call. +-- Therefore, when the LLVM code is actually generated, the procedure call must +-- be deferred until after the address is taken. This is performed by the LLVM +-- module. +-- +-- END MAJOR DOC + + + + -- | Perform last call analysis on a single module. -- Internally, we perform analysis bottom-up on proc SCCs. lastCallAnalyseMod :: ModSpec -> Compiler () @@ -165,7 +204,7 @@ primUsesOutputsOfOtherPrims p ps = in -- if the prim refers to any global variables, then skip reordering (conservative approximation for now) -- otherwise, check it doesn't refer to any outputs from `otherPrims` - not (gFlows == emptyGlobalFlows) || any (`elem` otherPrimOutputs) vars + (gFlows /= emptyGlobalFlows) || any (`elem` otherPrimOutputs) vars -- | Finds outputs which are the final result of a mutate chain -- and modifies them to be `FlowOutByReference` instead of `FlowOut` @@ -283,7 +322,8 @@ tryAddToMutateChain lastCall chains0 mut1 (chain@(mut:muts):chains) = chains' <- tryAddToMutateChain lastCall chains0 mut1 chains return $ chain:chains' tryAddToMutateChain lastCall chains0 mut' [] = let inputArg = inputName mut' in - if inputArg `elem` varsInPrim FlowOut (content lastCall) || any ((==inputArg) . outputName) (concat chains0) + if inputArg `elem` varsInPrim FlowOut (content lastCall) + || any (any ((==inputArg) . outputName)) chains0 then Left "Input arg is either generated by the last call, or by reusing an intermediate output from an existing mutate-chain." else @@ -344,6 +384,7 @@ mapProcLeavesM f leafBlock@ProcBody { bodyPrims = prims, bodyFork = NoFork } = d prims <- f prims return leafBlock { bodyPrims = prims } mapProcLeavesM f current@ProcBody { bodyFork = fork@PrimFork{forkBodies = bodies} } = do + -- XXX must map over default, too bodies' <- mapM (mapProcLeavesM f) bodies return current { bodyFork = fork { forkBodies = bodies' } } @@ -353,6 +394,7 @@ mapProcPrimsM fn body@ProcBody { bodyPrims = prims, bodyFork = NoFork } = do prims' <- mapM fn prims return body { bodyPrims = prims' } mapProcPrimsM fn body@ProcBody { bodyPrims = prims, bodyFork = fork@PrimFork{forkBodies = bodies } } = do + -- XXX must map over default, too prims' <- mapM fn prims bodies <- mapM (mapProcPrimsM fn) bodies return body { bodyPrims = prims', bodyFork = fork { forkBodies = bodies } } diff --git a/src/Normalise.hs b/src/Normalise.hs index c565af1d9..35b2bfc26 100644 --- a/src/Normalise.hs +++ b/src/Normalise.hs @@ -22,7 +22,7 @@ import Data.List as List import Data.Map as Map import Data.Maybe import Data.Set as Set -import Data.Bits +import Data.Bits (complement, bit, shiftL) import Data.Graph import Data.Tuple.HT import Data.Tuple.Select @@ -297,7 +297,7 @@ completeTypeSCC (CyclicSCC modTypeDefs) = do logNormalise $ " " ++ showModSpec mod ++ " = " ++ show typedef) modTypeDefs -- First set representations to addresses, then layout types - mapM_ ((setTypeRep Address `inModule`) . fst) modTypeDefs + mapM_ ((setTypeRep Pointer `inModule`) . fst) modTypeDefs mapM_ (uncurry completeType) modTypeDefs @@ -456,7 +456,7 @@ typeRepresentation :: [TypeRepresentation] -> Int -> TypeRepresentation typeRepresentation [] numConsts = Bits $ ceiling $ logBase 2 $ fromIntegral numConsts typeRepresentation [rep] 0 = rep -typeRepresentation _ _ = Address +typeRepresentation _ _ = Pointer ---------------------------------------------------------------- @@ -612,12 +612,12 @@ nonConstCtorItems uniq typeSpec numConsts numNonConsts tagBits tagLimit let (fields,size) = layoutRecord paramInfos tag tagLimit logNormalise $ "Laid out structure size " ++ show size ++ ": " ++ show fields - let ptrCount = length $ List.filter ((==Address) . paramInfoTypeRep) paramInfos + let ptrCount = length $ List.filter ((==Pointer) . paramInfoTypeRep) paramInfos logNormalise $ "Structure contains " ++ show ptrCount ++ " pointers, " ++ show numConsts ++ " const constructors, " ++ show numNonConsts ++ " non-const constructors" let params = paramInfoParam <$> paramInfos - return (Address, + return (Pointer, constructorItems vis ctorName typeSpec params fields size tag tagLimit pos ++ deconstructorItems uniq vis ctorName typeSpec params numConsts @@ -795,9 +795,9 @@ boxedGetterSetterStmts vis rectype numConsts numNonConsts ptrCount size let startOffset = if tag > tagLimit then tagLimit+1 else tag detism = deconstructorDetism numConsts numNonConsts -- Set the "noalias" flag when all other fields (exclude the one - -- that is being changed) in this struct aren't [Address]. + -- that is being changed) in this struct aren't [Pointer]. -- This flag is used in [AliasAnalysis.hs] - otherPtrCount = if rep == Address then ptrCount-1 else ptrCount + otherPtrCount = if rep == Pointer then ptrCount-1 else ptrCount flags = ["noalias" | otherPtrCount == 0] in [( field , GetterSetterInfo pos vis fieldtype @@ -843,8 +843,11 @@ unboxedConstructorItems vis ctorName typeSpec tag nonConstBit fields pos = -- Shift each field into place and or with the result List.concatMap (\(FieldInfo var pPos _ ty _ shift sz) -> - [maybePlace (ForeignCall "llvm" "shl" [] - [castFromTo ty typeSpec (varGet var) `maybePlace` pPos, + [maybePlace (ForeignCall "lpvm" "cast" [] + [varGetTyped var ty `maybePlace` pPos, + varSetTyped tmpName1 typeSpec `maybePlace` pos]) pos, + maybePlace (ForeignCall "llvm" "shl" [] + [varGetTyped tmpName1 typeSpec `maybePlace` pPos, iVal shift `castTo` typeSpec `maybePlace` pos, varSetTyped tmpName1 typeSpec `maybePlace` pos]) pos, maybePlace (ForeignCall "llvm" "or" [] @@ -922,32 +925,35 @@ unboxedGetterSetterStmts vis recType numConsts numNonConsts tag tagBits in [ ( field , GetterSetterInfo pos vis fieldType (tagCheck pos numConsts numNonConsts tag tagBits (wordSizeBytes-1) Nothing recName) - [maybePlace (ForeignCall "llvm" "lshr" [] -- The getter: - [varGetTyped recName recType `maybePlace` pos, - iVal shift `withType` recType `maybePlace` pos, - varSetTyped recName recType `maybePlace` pos]) pos, - -- XXX Don't need to do this for the most significant field: - maybePlace (ForeignCall "llvm" "and" [] - [varGetTyped recName recType `maybePlace` pos, - iVal fieldMask `withType` recType `maybePlace` pos, - varSetTyped fieldName recType `maybePlace` pos]) pos, - maybePlace (ForeignCall "lpvm" "cast" [] - [varGetTyped fieldName recType `maybePlace` pos, - varSetTyped outputVariableName fieldType `maybePlace` pos]) pos - ] - [maybePlace (ForeignCall "llvm" "and" [] - [varGetTyped recName recType `maybePlace` pos, - iVal shiftedHoleMask `withType` recType `maybePlace` pos, - varSetTyped recName recType `maybePlace` pos]) pos, - maybePlace (ForeignCall "llvm" "shl" [] - [castFromTo fieldType recType (varGet fieldName) `maybePlace` pos, - iVal shift `castTo` recType `maybePlace` pos, - varSetTyped tmpName1 recType `maybePlace` pos]) pos, - maybePlace (ForeignCall "llvm" "or" [] - [varGetTyped tmpName1 recType `maybePlace` pos, - varGetTyped recName recType `maybePlace` pos, - varSetTyped recName recType `maybePlace` pos]) pos - ] + [ForeignCall "llvm" "lshr" [] -- The getter: + [varGetTyped recName recType `maybePlace` pos, + iVal shift `withType` recType `maybePlace` pos, + varSetTyped recName recType `maybePlace` pos] `maybePlace` pos, + -- XXX Don't need to do this for the most significant field: + ForeignCall "llvm" "and" [] + [varGetTyped recName recType `maybePlace` pos, + iVal fieldMask `withType` recType `maybePlace` pos, + varSetTyped fieldName recType `maybePlace` pos] `maybePlace` pos, + ForeignCall "lpvm" "cast" [] + [varGetTyped fieldName recType `maybePlace` pos, + varSetTyped outputVariableName fieldType `maybePlace` pos] `maybePlace` pos + ] + [ForeignCall "llvm" "and" [] + [varGetTyped recName recType `maybePlace` pos, + iVal shiftedHoleMask `withType` recType `maybePlace` pos, + varSetTyped recName recType `maybePlace` pos] `maybePlace` pos, + ForeignCall "lpvm" "cast" [] + [varGetTyped fieldName fieldType `maybePlace` pos, + varSetTyped tmpName1 recType `maybePlace` pos] `maybePlace` pos, + ForeignCall "llvm" "shl" [] + [varGetTyped tmpName1 recType `maybePlace` pos, + iVal shift `castTo` recType `maybePlace` pos, + varSetTyped tmpName1 recType `maybePlace` pos] `maybePlace` pos, + ForeignCall "llvm" "or" [] + [varGetTyped tmpName1 recType `maybePlace` pos, + varGetTyped recName recType `maybePlace` pos, + varSetTyped recName recType `maybePlace` pos] `maybePlace` pos + ] )] diff --git a/src/ObjectInterface.hs b/src/ObjectInterface.hs index 976242a59..10b8ce893 100644 --- a/src/ObjectInterface.hs +++ b/src/ObjectInterface.hs @@ -10,6 +10,7 @@ module ObjectInterface (extractLPVMData, getWrappedBitcode) where import AST import Options (LogSelection(Builder)) import BinaryFactory +import Config (lpvmSectionName) import Control.Monad import Data.Binary import Data.Binary.Get @@ -71,7 +72,7 @@ extractLPVMDataLinux tmpDir objFile = do let lpvmFile = tmpDir modFile -- [objcopy] tries to write to the file even we only need read permission. -- We force it to write to /dev/null so it's "read-only". - let args = ["--dump-section", "__LPVM.__lpvm=" ++ lpvmFile] ++ [objFile] + let args = ["--dump-section", lpvmSectionName ++ "=" ++ lpvmFile] ++ [objFile] ++ ["/dev/null"] (exCode, _, serr) <- readCreateProcessWithExitCode (proc "objcopy" args) "" case exCode of diff --git a/src/Options.hs b/src/Options.hs index de820b4d8..afc736ae4 100644 --- a/src/Options.hs +++ b/src/Options.hs @@ -18,7 +18,7 @@ module Options (Options(..), defaultOptions) where import Data.List as List -import Data.List.Extra +import Data.List.Extra (lower) import Data.Map as Map import Data.Set as Set import Data.Either as Either @@ -50,7 +50,6 @@ data Options = Options , optVerbose :: Bool -- ^Be verbose in compiler output , optNoFont :: Bool -- ^Disable ISO font change codes in messages , optNoVerifyLLVM :: Bool -- ^Don't run LLVM verification - , optDumpOptLLVM :: Bool -- ^Dump optimised LLVM code , optErrors :: Set String -- ^Erroneous flag error messages } deriving Show @@ -73,7 +72,6 @@ defaultOptions = Options , optVerbose = False , optNoFont = False , optNoVerifyLLVM = False - , optDumpOptLLVM = False , optErrors = Set.empty } @@ -95,7 +93,7 @@ class (Ord a) => Toggleable a where data LogSelection = All | AST | BodyBuilder | Builder | Clause | Expansion | FinalDump | Flatten | Normalise | Optimise | Resources | Types - | Unbranch | Codegen | Blocks | Emit | Analysis | Transform | Uniqueness + | Unbranch | LLVM | Emit | Analysis | Transform | Uniqueness | LastCallAnalysis deriving (Eq, Ord, Bounded, Enum, Show, Read) @@ -147,10 +145,8 @@ logSelectionDescription Types = "Log type checking" logSelectionDescription Unbranch = "Log transformation of loops and selections into clausal form" -logSelectionDescription Codegen +logSelectionDescription LLVM = "Log generation of LLVM code" -logSelectionDescription Blocks - = "Log translation of LPVM procedures into LLVM" logSelectionDescription Emit = "Log emission of LLVM IR from the definitions created" logSelectionDescription Analysis @@ -167,6 +163,11 @@ logSelectionDescription LastCallAnalysis data OptFlag = LLVMOpt | MultiSpecz | TailCallModCons deriving (Eq, Ord, Enum, Bounded, Show) +-- | Default optimisations enabled: all of them +defaultOptFlags :: Set OptFlag +defaultOptFlags = Set.fromList [minBound..maxBound] + + instance Toggleable OptFlag where parseFlag flag = maybe (Left flag) Right $ optMap Map.!? lower flag where @@ -188,11 +189,6 @@ optimisationEnabled :: OptFlag -> Options -> Bool optimisationEnabled flag Options{optOptimisations=opts} = flag `Set.member` opts --- | Default optimisations enabled -defaultOptFlags :: Set OptFlag -defaultOptFlags = Set.fromList [minBound..maxBound] - - -- | Description of an OptFlag optimisationFlagDesc :: OptFlag -> String optimisationFlagDesc flag @@ -258,9 +254,6 @@ options = , Option [] ["no-verify-llvm"] (NoArg (\opts -> opts { optNoVerifyLLVM = True })) "disable verification of generated LLVM code" - , Option [] ["dump-opt-llvm"] - (NoArg (\opts -> opts { optDumpOptLLVM = True })) - "dump optimised LLVM code" ] diff --git a/src/Parser.hs b/src/Parser.hs index b0db3c7c5..f0c4c4141 100644 --- a/src/Parser.hs +++ b/src/Parser.hs @@ -14,7 +14,7 @@ import AST hiding (option) import Data.Set as Set import Data.List as List import Data.Maybe as Maybe -import Data.Bits +import Data.Bits (complement) import Data.Either.Extra (mapLeft) import Control.Monad.Identity (Identity) import Scanner @@ -159,7 +159,8 @@ typeImpln = do -- | Type declaration body where representation and items are given typeRep :: Parser TypeRepresentation typeRep = do - ident "address" $> Address + ident "address" $> Pointer + <|> ident "opaque" $> CPointer <|> do bits <- option wordSize (fromIntegral . content <$> intLiteral <* ident "bit") ident "unsigned" $> Bits bits diff --git a/src/README.md b/src/README.md index cedec9224..550d9e8d7 100644 --- a/src/README.md +++ b/src/README.md @@ -18,67 +18,58 @@ optimisation. This part can be seen in more detail as several separate passes: # Wybe compiler source directory The source files in this directory and their purposes are: -| File | Purpose | -| ---------------------------- | -------------------------------------------------------- | -| [AliasAnalysis.hs](#AliasAnalysis)| Alias analysis for a single module | -| [Analysis.hs](#Analysis) | Entry point of all kinds of analysis for a single module | -| [AST.hs](#AST) | Wybe Abstract Syntax Tree and LPVM representation | -| [ASTShow.hs](#ASTShow) | Show Wybe intermediate representation | -| [BinaryFactory.hs](#BinaryFactory)| Deriving AST Types to be Binary instances | -| [Blocks.hs](#Blocks) | Transform a clausal form (LPVM) module to LLVM | -| [BodyBuilder.hs](#BodyBuilder)| A monad to build up a procedure Body, with copy propagation | -| [Builder.hs](#Builder) | Handles compilation at the module level. | -| [Callers.hs](#Callers) | Find all callers for each proc and count static calls per caller | -| [Clause.hs](#Clause) | Convert Wybe code to clausal (LPVM) form | -| [Codegen.hs](#Codegen) | Generate and emit LLVM from basic blocks of a module | -| [Config.hs](#Config) | Configuration for wybe compiler | -| [Emit.hs](#Emit) | Emit LLVM code | -| [Expansion.hs](#Expansion) | Replace certain procedure calls with others | -| [Flatten.hs](#Flatten) | Flatten function calls (expressions) into procedure calls | -| [Macho.hs](#Macho) | Extended version of parser for Mach-O object format files | -| [Normalise.hs](#Normalise) | Convert parse tree into an AST | -| [ObjectInterface.hs](#ObjectInterface)| Parse and edit a object file. | -| [Optimise.hs](#Optimise) | Framework to optimise a single module | -| [Options.hs](#Options) | Handle compiler options/switches | -| [Parser.hs](#Parser) | Parser for the Wybe language using Parsec. | -| [Resources.hs](#Resources) | Resource checker for Wybe | -| [Scanner.hs](#Scanner) | Lexical scanner for the Wybe language | -| [Snippets.hs](#Snippets) | Convenience functions for generation of Wybe AST | -| [Transform.hs](#Transform) | Transform LPVM after alias analysis | -| [Types.hs](#Types) | Type checker/inferencer for Wybe | -| [Unbranch.hs](#Unbranch) | Turn loops and conditionals into separate procedures | -| [Unique.hs](#Unique) | The unique typing system for Wybe | -| [UnivSet.hs](#UnivSet) | Provide a set type supporting the universal set. | -| [Util.hs](#Util) | Various small utility functions | -| [wybemk.hs](#wybemk) | Wybe compiler/builder main code | +| File | Purpose | +| ---- | -------------------------------------------- | +| [AST.hs](#AST) | Wybe Abstract Syntax Tree and LPVM representation | +| [ASTShow.hs](#ASTShow) | Show Wybe intermediate representation | +| [AliasAnalysis.hs](#AliasAnalysis) | Alias analysis for a single module | +| [Analysis.hs](#Analysis) | Entry point of all kinds of analysis for a single module | +| [BinaryFactory.hs](#BinaryFactory) | Deriving AST Types to be Binary instances | +| [BodyBuilder.hs](#BodyBuilder) | A monad to build up a procedure Body, with copy propagation | +| [Builder.hs](#Builder) | Handles compilation at the module level. | +| [CConfig.hs](#CConfig) | Relate C types to Wybe types for foreign interface | +| [Callers.hs](#Callers) | Find all callers for each proc and count static calls per caller | +| [Clause.hs](#Clause) | Convert Wybe code to clausal (LPVM) form | +| [Config.hs](#Config) | Configuration for wybe compiler | +| [Emit.hs](#Emit) | Emit LLVM code | +| [Expansion.hs](#Expansion) | Replace certain procedure calls with others | +| [Flatten.hs](#Flatten) | Flatten function calls (expressions) into procedure calls | +| [LLVM.hs](#LLVM) | Generate LLVM code from LPVM form | +| [LastCallAnalysis.hs](#LastCallAnalysis) | Transform proc bodies and their output arguments so that | +| [Macho.hs](#Macho) | Extended version of parser for Mach-O object format files | +| [Normalise.hs](#Normalise) | Convert parse tree into an AST | +| [ObjectInterface.hs](#ObjectInterface) | Parse and edit a object file. | +| [Optimise.hs](#Optimise) | Framework to optimise a single module | +| [Options.hs](#Options) | Handle compiler options/switches | +| [Parser.hs](#Parser) | Parser for the Wybe language using Parsec. | +| [Resources.hs](#Resources) | Resource checker for Wybe | +| [Scanner.hs](#Scanner) | Lexical scanner for the Wybe language | +| [Snippets.hs](#Snippets) | Convenience functions for generation of Wybe AST | +| [Transform.hs](#Transform) | Transform LPVM after alias analysis | +| [Types.hs](#Types) | Type checker/inferencer for Wybe | +| [Unbranch.hs](#Unbranch) | Turn loops and conditionals into separate procedures | +| [Unique.hs](#Unique) | The unique typing system for Wybe | +| [UnivSet.hs](#UnivSet) | Provide a set type supporting the universal set. | +| [Util.hs](#Util) | Various small utility functions | +| [wybemk.hs](#wybemk) | Wybe compiler/builder main code | # Modules in more detail -## AliasAnalysis -- Alias analysis for a single module +## AST +## ASTShow -## Analysis -- Entry point of all kinds of analysis for a single module +## AliasAnalysis +## Analysis -## AST -- Wybe Abstract Syntax Tree and LPVM representation +## BinaryFactory +## BodyBuilder -## ASTShow -- Show Wybe intermediate representation - - -## BinaryFactory -- Deriving AST Types to be Binary instances - - -## Blocks -- Transform a clausal form (LPVM) module to LLVM - - -## BodyBuilder -- A monad to build up a procedure Body, with copy propagation - - -## Builder -- Handles compilation at the module level. - +## Builder The wybe compiler handles module dependencies, and builds executables by itself, without the need for build tools like make. The function buildTarget is responsible for determining @@ -257,26 +248,19 @@ order, we call compileModSCC, which does the following: 2. Optimise procs (Optimise) -## Callers -- Find all callers for each proc and count static calls per caller +## CConfig +## Callers -## Clause -- Convert Wybe code to clausal (LPVM) form +## Clause +## Config -## Codegen -- Generate and emit LLVM from basic blocks of a module +## Emit +## Expansion -## Config -- Configuration for wybe compiler - - -## Emit -- Emit LLVM code - - -## Expansion -- Replace certain procedure calls with others - - -## Flatten -- Flatten function calls (expressions) into procedure calls - +## Flatten We transform away all expression types except for constants and variables. Where, let, conditional, and function call expressions are turned into statements that bind a variable, and @@ -302,67 +286,106 @@ the initial value of the expression, and a second to assign it the specified new value. For example, a statement p(f(!x,y),z) is transformed to f(x,y,?t); p(!t,z); f(!x,y,t). -## Macho -- Extended version of parser for Mach-O object format files +## LLVM + +# Generating LLVM code +We generate a `.ll` text file directly for each Wybe `.wybe` file, compiling +this as necessary to build `.o`, `.bc` `.s`, or executable files. For each +generated `.ll` file, we produce the following, in order: -## Normalise -- Convert parse tree into an AST +* **Prologue** — contains an introductory comment and any configuration info + needed for LLVM. +* **Constants** — LLVM definitions of the manifest constants used in this + module; mostly used for strings. -## ObjectInterface -- Parse and edit a object file. +* **Global variables** — LLVM declarations of the global variables used to + implement the resources defined in this module. +* **Externs** — Extern declarations for all symbols used, but not defined, + in this module; this includes imported Wybe procedures, C functions, and + global variables. -## Optimise -- Framework to optimise a single module +* **Definitions** — Definitions of the procs of this module. +* **Exports** — Everything needed by the Wybe compiler to compile users of + this module; currently this is represented as a serialisation of the + Module data structure, placed in the LLVM section. -## Options -- Handle compiler options/switches +## LastCallAnalysis -## Parser -- Parser for the Wybe language using Parsec. +# Last Call Optimisation +The compiler relies on the LLVM compiler to perform last call optimisation, +turning the last call in a procedure body into a jump, if no other +instructions follow the last call. This module tries to increase the number +of procedures where this optimisation applies by moving code that follows the +last call before it, whenever all the inputs to those instructions are +available before the last call. -## Resources -- Resource checker for Wybe +One particular trick employed to make this possible is +last-call-module-construction optimisation. The idea here is to invert the +direction of data flow, turing an output into an input, by passing in the +address to which to write the output. When the instruction following the +last call in a body simply writes an output of that call into one memory +location, without using it in any other way, and when the called procedure is +defined in the module currently being compiled (so we can transform it), we +can change that output argument into a pointer input, and modify the +procedure definition to write the output value to memory through that +pointer. This is done by changing that parameter from FlowOut to +FlowOutByReference, and similarly changing the corresponding argument in all +calls to that procedure. Likewise, we change the instruction intended to +write the procedure output to memory from FlowIn to FlowTakeReference. +Note that this transformation leaves the call that notionally produces the +output before the instruction that notionally writes the value to memory, +despite the fact that now the latter actually takes the address to be written +to, and the former actually passes that address into a procedure call. +Therefore, when the LLVM code is actually generated, the procedure call must +be deferred until after the address is taken. This is performed by the LLVM +module. + + +## Macho + +## Normalise + +## ObjectInterface + +## Optimise + +## Options + +## Parser + +## Resources ### Resource Transformations. -There are three passes related to resources within the Wybe compiler. +There are two passes related to resources within the Wybe compiler. The first pass canonicalises the `use` declarations in procedure prototypes. This resolves the module which each resource refers to. The second, performed after type checking, transforms resource usage into -regular parameters/arguments. Here, each procedure is modifed to include -parameters corresponding to each resource and respective flow. -Each call is also transformed to include the resources as arguments. -The order of arguments is dictated by the ordering of the `ResourceSpec` -type, ordering by module then name. `use` blocks are also transformed to -contain LPVM `move` instructions of respectively used resources, to save -and subsequently restore the value of each resource variable. - -The final pass tranforms resource into global variables. This pass must be -performed after uniqueness checking, as uniqueness checking assumes only the -second pass has been performed. The additional parameters and arguments -introduced in the second pass are removed here, as they are now passed in -global variables. Each reference to an in scope resource by name is -transformed into a load (input) or a store (output), or both (in/out). +references to global variables. Each reference to an in scope resource by +name is transformed into a load (input) or a store (output), or both (in/out). Finally, `use` blocks are also transformed to save (load) and then restore (store) each out-of-scope resource. -The final two passes assume that type and mode checking has occured. Type +The final pass assume that type and mode checking has occured. Type checking ensures that resources have the correct types, and mode checking ensures that resources, where applicable are in scope. -## Scanner -- Lexical scanner for the Wybe language - +## Scanner -## Snippets -- Convenience functions for generation of Wybe AST +## Snippets +## Transform -## Transform -- Transform LPVM after alias analysis - - -## Types -- Type checker/inferencer for Wybe - +## Types ### Type Checking Module SCCs Our type inference is flow sensitive, that is, types flow from callees to @@ -393,8 +416,7 @@ be transformed. Therefore, type checking must be prepared to handle both calls that have had resources transformed to parameters and calls that haven't. -## Unbranch -- Turn loops and conditionals into separate procedures - +## Unbranch This code transforms loops into fresh recursive procs, and ensures that all conditionals are the last statements in their respective bodies. Note that conditionals can be nested, but at the end of @@ -449,17 +471,13 @@ AST form with the following requirements: TestBool, and whose branches are bodies satisfying these same conditions. -## Unique -- The unique typing system for Wybe - - -## UnivSet -- Provide a set type supporting the universal set. - - -## Util -- Various small utility functions +## Unique +## UnivSet -## wybemk -- Wybe compiler/builder main code +## Util +## wybemk # This Document diff --git a/src/Resources.hs b/src/Resources.hs index f41db5ccc..5a3a941aa 100644 --- a/src/Resources.hs +++ b/src/Resources.hs @@ -24,7 +24,6 @@ import Data.Either as Either import Data.Either.Extra (mapLeft) import Data.Tuple.HT (mapFst, mapSnd) import Data.Tuple.Extra ((***)) -import LLVM.Prelude (ifM) import Options (LogSelection (Resources)) import Snippets import Util diff --git a/src/Types.hs b/src/Types.hs index 576619381..8a533c47b 100644 --- a/src/Types.hs +++ b/src/Types.hs @@ -34,7 +34,7 @@ import Resources import Util import Config import Snippets -import Blocks (llvmMapBinop, llvmMapUnop) +import LLVM (llvmMapBinop, llvmMapUnop, BinOpInfo(..)) import Data.Tuple.HT (mapSnd) @@ -1493,10 +1493,8 @@ typecheckCalls [] residue False foreigns = do case List.filter (List.null . typingErrs) $ snd <$> typings' of [typing] -> put typing _ -> do - typeErrors $ overloadErr - <$> case residue of - [] -> [] - (e:_) -> [e] + -- 1st equation handles empty residue case + typeError $ overloadErr $ head residue typecheckCalls [] [] False foreigns typecheckCalls (stmtTyping@(StmtTypings pstmt typs):calls) residue chg foreigns = do @@ -2788,12 +2786,11 @@ validateForeignCall "llvm" "move" _ [inRep,outRep] stmt pos | otherwise = typeError (ReasonWrongOutput "move" outRep inRep pos) validateForeignCall "llvm" "move" _ argReps stmt pos = typeError (ReasonForeignArity "move" (length argReps) 2 pos) -validateForeignCall "llvm" name flags argReps stmt pos = do - let arity = length argReps +validateForeignCall "llvm" name flags argReps stmt pos = case argReps of [inRep1,inRep2,outRep] -> case Map.lookup name llvmMapBinop of - Just (_,fam,outTy) -> do + Just (BinOpInfo _ fam _ outTy) -> do reportErrorUnless (ReasonWrongFamily name 1 fam pos) (fam == typeFamily inRep1) reportErrorUnless (ReasonWrongFamily name 2 fam pos) @@ -2802,22 +2799,23 @@ validateForeignCall "llvm" name flags argReps stmt pos = do (compatibleReps inRep1 inRep2) Nothing -> if isJust $ Map.lookup name llvmMapUnop - then typeError (ReasonForeignArity name arity 2 pos) + then typeError (ReasonForeignArity name 3 2 pos) else typeError (ReasonBadForeign "llvm" name pos) [inRep,outRep] -> case Map.lookup name llvmMapUnop of - Just (_,famIn,famOut) -> + Just (famIn,famOut) -> reportErrorUnless (ReasonWrongFamily name 1 famIn pos) (famIn == typeFamily inRep) Nothing -> if isJust $ Map.lookup name llvmMapBinop - then typeError (ReasonForeignArity name arity 3 pos) + then typeError (ReasonForeignArity name 2 3 pos) else typeError (ReasonBadForeign "llvm" name pos) - _ -> if isJust $ Map.lookup name llvmMapBinop - then typeError (ReasonForeignArity name arity 3 pos) - else if isJust $ Map.lookup name llvmMapUnop - then typeError (ReasonForeignArity name arity 2 pos) - else typeError (ReasonBadForeign "llvm" name pos) + _ -> let arity = length argReps + in if isJust $ Map.lookup name llvmMapBinop + then typeError (ReasonForeignArity name arity 3 pos) + else if isJust $ Map.lookup name llvmMapUnop + then typeError (ReasonForeignArity name arity 2 pos) + else typeError (ReasonBadForeign "llvm" name pos) validateForeignCall "lpvm" name flags argReps stmt pos = checkLPVMArgs name flags argReps stmt pos validateForeignCall lang name flags argReps stmt pos = @@ -2825,35 +2823,48 @@ validateForeignCall lang name flags argReps stmt pos = -- | Are two types compatible for use as inputs to a binary LLVM op? --- Used for type checking LLVM instructions. +-- Used for type checking LLVM instructions. LLVM code generation will inject +-- instructions to convert types or extend or truncate as necessary, so we can +-- be a bit forgiving here. compatibleReps :: TypeRepresentation -> TypeRepresentation -> Bool -compatibleReps Address Address = True -compatibleReps Address (Bits bs) = bs == wordSize -compatibleReps Address (Signed bs) = bs == wordSize -compatibleReps Address (Floating _) = False -compatibleReps Address (Func _ _) = True -compatibleReps (Bits bs) Address = bs == wordSize -compatibleReps (Bits m) (Bits n) = m == n -compatibleReps (Bits m) (Signed n) = m == n -compatibleReps (Bits _) (Floating _) = False -compatibleReps (Bits bs) (Func _ _) = bs == wordSize -compatibleReps (Signed bs) Address = bs == wordSize -compatibleReps (Signed m) (Bits n) = m == n -compatibleReps (Signed m) (Signed n) = m == n -compatibleReps (Signed _) (Floating _) = False -compatibleReps (Signed bs) (Func _ _) = bs == wordSize -compatibleReps (Floating _) Address = False -compatibleReps (Floating _) (Bits _) = False -compatibleReps (Floating _) (Signed _) = False -compatibleReps (Floating m) (Floating n) = m == n -compatibleReps (Floating _) (Func _ _) = False -compatibleReps (Func _ _) Address = True +compatibleReps Pointer Pointer = True +compatibleReps Pointer Bits{} = True +compatibleReps Pointer Signed{} = True +compatibleReps Pointer Floating{} = False +compatibleReps Pointer (Func _ _) = True +compatibleReps Pointer CPointer = True +compatibleReps Bits{} Pointer = True +compatibleReps Bits{} Bits{} = True +compatibleReps Bits{} Signed{} = True +compatibleReps Bits{} Floating{} = False +compatibleReps Bits{} Func{} = False +compatibleReps Bits{} CPointer = True +compatibleReps Signed{} Pointer = True +compatibleReps Signed{} Bits{} = True +compatibleReps Signed{} Signed{} = True +compatibleReps Signed{} Floating{} = False +compatibleReps Signed{} Func{} = False +compatibleReps Signed{} CPointer = True +compatibleReps Floating{} Pointer = False +compatibleReps Floating{} Bits{} = False +compatibleReps Floating{} Signed{} = False +compatibleReps Floating{} Floating{} = True +compatibleReps Floating{} Func{} = False +compatibleReps Floating{} CPointer = False +compatibleReps Func{} Pointer = True compatibleReps (Func i1 o1) (Func i2 o2) = sameLength i1 i2 && sameLength o1 o2 && and (zipWith compatibleReps i1 i2) && and (zipWith compatibleReps o1 o2) -compatibleReps (Func _ _) (Bits bs) = bs == wordSize -compatibleReps (Func _ _) (Signed bs) = bs == wordSize -compatibleReps (Func _ _) (Floating _) = False +compatibleReps Func{} Bits{} = False +compatibleReps Func{} Signed{} = False +compatibleReps Func{} Floating{} = False +compatibleReps Func{} CPointer = False +compatibleReps CPointer Pointer = True +compatibleReps CPointer Bits{} = True +compatibleReps CPointer Signed{} = True +compatibleReps CPointer Floating{} = False +compatibleReps CPointer Func{} = True +compatibleReps CPointer CPointer = True -- | Check arg types of an LPVM instruction @@ -2863,12 +2874,12 @@ checkLPVMArgs "alloc" _ [sz,struct] stmt pos = do reportErrorUnless (ReasonForeignArgRep "alloc" 1 sz "integer" pos) (integerTypeRep sz) reportErrorUnless (ReasonForeignArgRep "alloc" 2 struct "address" pos) - (struct == Address) + (struct == Pointer) checkLPVMArgs "alloc" _ args stmt pos = typeError (ReasonForeignArity "alloc" (length args) 2 pos) checkLPVMArgs "access" _ [struct,offset,size,startOffset,val] stmt pos = do reportErrorUnless (ReasonForeignArgRep "access" 1 struct "address" pos) - (struct == Address) + (struct == Pointer) reportErrorUnless (ReasonForeignArgRep "access" 2 offset "integer" pos) (integerTypeRep offset) reportErrorUnless (ReasonForeignArgRep "access" 3 size "integer" pos) @@ -2879,9 +2890,9 @@ checkLPVMArgs "access" _ args stmt pos = typeError (ReasonForeignArity "access" (length args) 5 pos) checkLPVMArgs "mutate" _ [old,new,offset,destr,sz,start,val] stmt pos = do reportErrorUnless (ReasonForeignArgRep "mutate" 1 old "address" pos) - (old == Address) + (old == Pointer) reportErrorUnless (ReasonForeignArgRep "mutate" 2 new "address" pos) - (new == Address) + (new == Pointer) reportErrorUnless (ReasonForeignArgRep "mutate" 3 offset "integer" pos) (integerTypeRep offset) reportErrorUnless (ReasonForeignArgRep "mutate" 4 destr "boolean" pos) diff --git a/src/Unbranch.hs b/src/Unbranch.hs index 19c8fa878..df1adbd5e 100644 --- a/src/Unbranch.hs +++ b/src/Unbranch.hs @@ -82,7 +82,6 @@ import Data.Maybe import Data.Tuple.HT (mapFst) import Options (LogSelection(Unbranch)) import Util -import LLVM.Internal.Function (getPrefixData) -- |Transform away all loops, and all conditionals other than as the final @@ -471,7 +470,7 @@ unbranchStmt stmt@(ProcCall func calldetism r args) pos stmts = do Terminal -> return [maybePlace stmt' pos] -- no execution after Terminal Failure -> return [maybePlace stmt' pos] -- no execution after Failure Det -> leaveStmtAsIs stmt' pos stmts - SemiDet -> shouldnt "SemiDet case already covered!" + -- SemiDet case already covered unbranchStmt stmt@(ForeignCall l nm fs args) pos stmts = do alt <- gets brAlternate logUnbranch $ "Unbranching foreign call " ++ showStmt 4 stmt diff --git a/src/UnivSet.hs b/src/UnivSet.hs index 9c5fc8e18..a2384e745 100644 --- a/src/UnivSet.hs +++ b/src/UnivSet.hs @@ -11,6 +11,7 @@ module UnivSet ( UnivSet(..), UnivSet.union, UnivSet.intersection, subtractUnivSet, UnivSet.member, isEmpty, isUniv, emptyUnivSet, UnivSet.singleton, + UnivSet.insert, UnivSet.fromList, UnivSet.toList, UnivSet.toSet, UnivSet.fromSet, showUnivSet, showSet, mapFromUnivSetM, @@ -84,6 +85,12 @@ singleton :: a -> UnivSet a singleton = FiniteSet . S.singleton +-- | Insert an element into a UnivSet +insert :: Ord a => a -> UnivSet a -> UnivSet a +insert _ UniversalSet = UniversalSet +insert elt (FiniteSet s) = FiniteSet $ S.insert elt s + + -- | Make a finite UnivSet from a list of elements fromList :: Ord a => [a] -> UnivSet a fromList = FiniteSet . S.fromList diff --git a/src/Util.hs b/src/Util.hs index 9cb5dfccc..eee1d3bd2 100644 --- a/src/Util.hs +++ b/src/Util.hs @@ -235,11 +235,13 @@ intersectMapIdentity = merge dropMissing dropMissing (zipWithMaybeMatched $ \_ v1 v2 -> if v1 == v2 then Just v1 else Nothing) + -- | a `orElse` b returns a if it's a Just, otherwise b orElse :: Maybe a -> Maybe a -> Maybe a orElse Nothing b = b orElse a@Just{} _ = a + -- | apply two functions to the same input and combine the results apply2way :: (a->b->c) -> (d->a) -> (d->b) -> d -> c apply2way combine f1 f2 input = combine (f1 input) (f2 input) @@ -318,7 +320,7 @@ _getFileHash file = do -- | Given a file path and return the actual file that should be used. --- It can the original file or a local cache file. +-- It can be the original file or a local cache file. useLocalCacheFileIfPossible :: FilePath -> IO FilePath useLocalCacheFileIfPossible file = do (cacheFile, meta) <- _localCachePathOfFile file @@ -339,7 +341,7 @@ useLocalCacheFileIfPossible file = do return file --- | Given a file path and return the file path to the local cache +-- | Given a file path, return the file path to the local cache -- file of the actual file. createLocalCacheFile :: FilePath -> IO FilePath createLocalCacheFile file = do diff --git a/src/c_config.c b/src/c_config.c new file mode 100644 index 000000000..16e1d0c43 --- /dev/null +++ b/src/c_config.c @@ -0,0 +1,39 @@ +/* File : c_config.c + * Author : Peter Schachte + * Purpose : Determine configuration for Wybe -> C interface + * Copyright: (c) 2024 Peter Schachte. All rights reserved. + * License : Licensed under terms of the MIT license. See the file + * : LICENSE in the root directory of this project. + * + * Generate Haskell source code defining Wybe interpretation of standard + * C types. + * + * NB: This code assumes a byte-addressed architecture, and that a byte + * is 8 bits. + **/ + +#include + +int main() { + int i; + float f; + double d; + char c; + void *p; + printf("-- AUTOMATICALLY GENERATED BY c_config.c\n-- DO NOT EDIT!\n\n"); + printf("-- Purpose : Relate C types to Wybe types for foreign interface\n\n"); + printf("module CConfig (cTypeRepresentation, cPointerSize) where\n"); + printf("\nimport AST (TypeRepresentation(..))\n\n"); + printf("cTypeRepresentation :: String -> Maybe TypeRepresentation\n"); + printf("cTypeRepresentation \"int\" = Just $ Signed %lu\n", 8*sizeof(i)); + printf("cTypeRepresentation \"float\" = Just $ Floating %lu\n", 8*sizeof(f)); + printf("cTypeRepresentation \"double\" = Just $ Floating %lu\n", 8*sizeof(d)); + printf("cTypeRepresentation \"char\" = Just $ Bits %lu\n", 8*sizeof(c)); + printf("cTypeRepresentation \"pointer\" = Just $ CPointer\n"); + printf("cTypeRepresentation \"void\" = Just $ Bits 0\n"); + printf("cTypeRepresentation \"intrinsic_bool\" = Just $ Bits 1\n"); + printf("cTypeRepresentation other = Nothing\n\n"); + printf("cPointerSize :: Int\n"); + printf("cPointerSize = %lu\n", 8*sizeof(p)); + return 0; +} \ No newline at end of file diff --git a/stack.yaml b/stack.yaml index 14c01d2a6..ee9560281 100644 --- a/stack.yaml +++ b/stack.yaml @@ -15,7 +15,7 @@ # resolver: # name: custom-snapshot # location: "./custom-snapshot.yaml" -resolver: lts-16.7 +resolver: lts-22.21 # User packages to be built. # Various formats can be used as shown in the example below. @@ -40,8 +40,6 @@ packages: # Dependency packages to be pulled from upstream that are not in the resolver # (e.g., acme-missiles-0.3) extra-deps: - - llvm-hs-pretty-0.9.0.0 - # Override default flag values for local packages and extra-deps # flags: {} @@ -69,8 +67,3 @@ require-stack-version: ">=1.6" ghc-options: "$everything": -fwarn-incomplete-patterns -O2 - - -flags: - llvm-hs: - shared-llvm: true diff --git a/test-cases/complex-test.py b/test-cases/complex-test.py index 44f3284dc..ab0293776 100644 --- a/test-cases/complex-test.py +++ b/test-cases/complex-test.py @@ -24,7 +24,7 @@ def main() -> None: exp_file_path = "./complex/exp/{}.exp".format(test_name) with open(out_file_path, "w") as out_file: with tempfile.TemporaryDirectory() as tmp_dir: - ctx = utils.Context(tmp_dir, out_file) + ctx = utils.Context(tmp_dir, os.path.dirname(root_path), out_file) # execute test case try: test_func(ctx) @@ -40,7 +40,10 @@ def main() -> None: # the behavior of other scripts. We should consider using # things like "filecmp.cmp" for portability and efficiency. code = subprocess.run( - ["diff", "-q", out_file_path, exp_file_path], + ["diff", "-q", + "-I", "^source_filename *=.*", + "-I", "^target triple *=.*", + out_file_path, exp_file_path], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL).returncode if code == 0: print(".", end="") diff --git a/test-cases/complex/exp/testcase_multi_specz-drone.exp b/test-cases/complex/exp/testcase_multi_specz-drone.exp index a5b2696cb..54ff14923 100644 --- a/test-cases/complex/exp/testcase_multi_specz-drone.exp +++ b/test-cases/complex/exp/testcase_multi_specz-drone.exp @@ -23,7 +23,10 @@ ---------------------------------------------------------------------- ====================================================================== AFTER BUILDING MAIN: - Module + + +-------------------------------------------------- + Module *main* module representation : (not a type) public submods : public resources: @@ -46,6 +49,7 @@ AFTER BUILDING MAIN: use wybe.list use wybe.machine_word use wybe.memory_management + use wybe.opaque_pointer use wybe.phantom use wybe.predicate use wybe.range @@ -54,7 +58,7 @@ AFTER BUILDING MAIN: procs : module top-level code > {terminal,inline,impure} (0 calls) -0: .<0> +0: *main* module.<0> (%argc##0:wybe.int, %argv##0:wybe.array.raw_array, %?exit_code##1:wybe.int)<{}; {<>}; {}>: AliasPairs: [] InterestingCallProperties: [] @@ -73,7 +77,8 @@ module top-level code > {terminal,inline,impure} (0 calls) foreign llvm move(0:wybe.int, ?%exit_code##1:wybe.int) foreign c {semipure,terminal} exit(0:wybe.int) -LLVM code : None + LLVM code : + -------------------------------------------------- Module command_line @@ -120,68 +125,7 @@ set_exit_code(code##0:wybe.int)<{}; {<>}; {}>: LLVM code : -; ModuleID = 'command_line' - - - - - -@"resource#command_line.argc" = global i64 undef - - -@"resource#command_line.arguments" = global i64 undef - - -@"resource#command_line.argv" = global i64 undef - - -@"resource#command_line.command" = global i64 undef - - -@"resource#command_line.exit_code" = global i64 undef - - -@command_line.1 = constant [?? x i8] c"Erroneous program argument vector\00" - -@command_line.0 = constant [?? x i8] c"command_line:18:15\00" - - -declare external ccc void @error_exit(i64, i64) - - -declare external fastcc {i64, i64, i1} @"wybe.array.[|]<0>"(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"command_line.<0>"() { -entry: - %0 = load i64, i64* @"resource#command_line.arguments" - %1 = tail call fastcc {i64, i64, i1} @"wybe.array.[|]<0>"(i64 %0) - %2 = extractvalue {i64, i64, i1} %1, 0 - %3 = extractvalue {i64, i64, i1} %1, 1 - %4 = extractvalue {i64, i64, i1} %1, 2 - br i1 %4, label %if.then, label %if.else -if.then: - store i64 %3, i64* @"resource#command_line.arguments" - store i64 %2, i64* @"resource#command_line.command" - ret void -if.else: - tail call ccc void @error_exit(i64 ptrtoint (i8* getelementptr inbounds ([?? x i8], [?? x i8]* @command_line.0, i32 0, i32 0) to i64), i64 ptrtoint (i8* getelementptr inbounds ([?? x i8], [?? x i8]* @command_line.1, i32 0, i32 0) to i64)) - ret void -} - - -define external fastcc void @"command_line.set_exit_code<0>"(i64 %"code##0") alwaysinline { -entry: - store i64 %"code##0", i64* @"resource#command_line.exit_code" - ret void -} -------------------------------------------------- Module drone representation : (not a type) @@ -438,11 +382,12 @@ print_info(d##0:drone.drone_info)<{<>}; {<>}; {}>: foreign c putchar('\n':wybe.char, ~tmp#19##0:wybe.phantom, ?tmp#21##0:wybe.phantom) @drone:nn:nn foreign lpvm store(~%tmp#21##0:wybe.phantom, <>:wybe.phantom) @drone:nn:nn -LLVM code : None + LLVM code : + -------------------------------------------------- Module drone.drone_info - representation : address + representation : pointer public submods : public resources: public procs : drone.drone_info.=<0> @@ -616,11 +561,14 @@ proc ~= > public {inline} (0 calls) -LLVM code : None + LLVM code : ====================================================================== AFTER EVERYTHING: - Module + + +-------------------------------------------------- + Module *main* module representation : (not a type) public submods : public resources: @@ -643,6 +591,7 @@ AFTER EVERYTHING: use wybe.list use wybe.machine_word use wybe.memory_management + use wybe.opaque_pointer use wybe.phantom use wybe.predicate use wybe.range @@ -651,7 +600,7 @@ AFTER EVERYTHING: procs : module top-level code > {terminal,inline,impure} (0 calls) -0: .<0> +0: *main* module.<0> (%argc##0:wybe.int, %argv##0:wybe.array.raw_array, %?exit_code##1:wybe.int)<{}; {<>}; {}>: AliasPairs: [] InterestingCallProperties: [] @@ -672,69 +621,46 @@ module top-level code > {terminal,inline,impure} (0 calls) LLVM code : -; ModuleID = '' - - - - - -@"resource#command_line.argc" = external global i64 - - -@"resource#command_line.arguments" = external global i64 - - -@"resource#command_line.argv" = external global i64 - - -@"resource#command_line.command" = external global i64 - - -@"resource#command_line.exit_code" = external global i64 - - -@.0 = constant [?? x i8] c"\00" - - -declare external ccc void @exit(i64) - - -declare external fastcc void @"command_line.<0>"() - - -declare external fastcc void @"drone.<0>"() - - -declare external ccc void @gc_init() - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external ccc i64 @main(i64 %"argc##0", i64 %"argv##0") alwaysinline { -entry: - store i64 %"argc##0", i64* @"resource#command_line.argc" - store i64 %"argv##0", i64* @"resource#command_line.argv" - tail call ccc void @gc_init() - tail call fastcc void @"drone.<0>"() - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"argc##0", i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"argv##0", i64* %5 - store i64 %2, i64* @"resource#command_line.arguments" - store i64 ptrtoint (i8* getelementptr inbounds ([?? x i8], [?? x i8]* @.0, i32 0, i32 0) to i64), i64* @"resource#command_line.command" - store i64 0, i64* @"resource#command_line.exit_code" - tail call fastcc void @"command_line.<0>"() - tail call ccc void @exit(i64 0) - ret i64 0 +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe +; ModuleID = '*main* module' + +source_filename = "/private!TMP!/drone" +target triple = ??? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c"\00", align 8 + +declare external fastcc void @"command_line.<0>"() +declare external fastcc void @"drone.<0>"() +@"resource#command_line.argc" = external global i64 +@"resource#command_line.arguments" = external global i64 +@"resource#command_line.argv" = external global i64 +@"resource#command_line.command" = external global i64 +@"resource#command_line.exit_code" = external global i64 +declare external ccc void @exit(i64) +declare external ccc void @gc_init() +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external ccc i64 @main(i64 %"argc##0", i64 %"argv##0") { + store i64 %"argc##0", ptr @"resource#command_line.argc" + store i64 %"argv##0", ptr @"resource#command_line.argv" + call ccc void @gc_init() + tail call fastcc void @"drone.<0>"() + %"tmp#11##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#9##0" = ptrtoint ptr %"tmp#11##0" to i64 + %"tmp#12##0" = inttoptr i64 %"tmp#9##0" to ptr + store i64 %"argc##0", ptr %"tmp#12##0" + %"tmp#13##0" = add i64 %"tmp#9##0", 8 + %"tmp#14##0" = inttoptr i64 %"tmp#13##0" to ptr + store i64 %"argv##0", ptr %"tmp#14##0" + store i64 %"tmp#9##0", ptr @"resource#command_line.arguments" + store i64 ptrtoint( ptr @"cstring#0" to i64 ), ptr @"resource#command_line.command" + store i64 0, ptr @"resource#command_line.exit_code" + tail call fastcc void @"command_line.<0>"() + call ccc void @exit(i64 0) + ret i64 0 } + -------------------------------------------------- Module command_line representation : (not a type) @@ -780,68 +706,45 @@ set_exit_code(code##0:wybe.int)<{}; {<>}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'command_line' - - - - -@"resource#command_line.argc" = global i64 undef - - -@"resource#command_line.arguments" = global i64 undef - - -@"resource#command_line.argv" = global i64 undef - - -@"resource#command_line.command" = global i64 undef - - -@"resource#command_line.exit_code" = global i64 undef - - -@command_line.1 = constant [?? x i8] c"Erroneous program argument vector\00" - - -@command_line.0 = constant [?? x i8] c"command_line:18:15\00" - - -declare external ccc void @error_exit(i64, i64) - - -declare external fastcc {i64, i64, i1} @"wybe.array.[|]<0>"(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"command_line.<0>"() { -entry: - %0 = load i64, i64* @"resource#command_line.arguments" - %1 = tail call fastcc {i64, i64, i1} @"wybe.array.[|]<0>"(i64 %0) - %2 = extractvalue {i64, i64, i1} %1, 0 - %3 = extractvalue {i64, i64, i1} %1, 1 - %4 = extractvalue {i64, i64, i1} %1, 2 - br i1 %4, label %if.then, label %if.else -if.then: - store i64 %3, i64* @"resource#command_line.arguments" - store i64 %2, i64* @"resource#command_line.command" - ret void -if.else: - tail call ccc void @error_exit(i64 ptrtoint (i8* getelementptr inbounds ([?? x i8], [?? x i8]* @command_line.0, i32 0, i32 0) to i64), i64 ptrtoint (i8* getelementptr inbounds ([?? x i8], [?? x i8]* @command_line.1, i32 0, i32 0) to i64)) - ret void +source_filename = "!ROOT!/wybelibs/command_line.o" +target triple = ??? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c"Erroneous program argument vector\00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c"command_line:18:15\00", align 8 + +declare external fastcc {i64, i64, i1} @"wybe.array.[|]<0>"(i64) +declare external ccc void @error_exit(i64, i64) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) +@"resource#command_line.argc" = global i64 undef +@"resource#command_line.arguments" = global i64 undef +@"resource#command_line.argv" = global i64 undef +@"resource#command_line.command" = global i64 undef +@"resource#command_line.exit_code" = global i64 undef + +define external fastcc void @"command_line.<0>"() { + %"arguments##0" = load i64, ptr @"resource#command_line.arguments" + %"tmp#11##0" = tail call fastcc {i64, i64, i1} @"wybe.array.[|]<0>"(i64 %"arguments##0") + %"command##1" = extractvalue {i64, i64, i1}%"tmp#11##0", 0 + %"arguments##2" = extractvalue {i64, i64, i1}%"tmp#11##0", 1 + %"tmp#8##0" = extractvalue {i64, i64, i1}%"tmp#11##0", 2 + br i1 %"tmp#8##0", label %if.then.0, label %if.else.0 +if.then.0: + store i64 %"arguments##2", ptr @"resource#command_line.arguments" + store i64 %"command##1", ptr @"resource#command_line.command" + ret void +if.else.0: + call ccc void @error_exit(i64 ptrtoint( ptr @"cstring#1" to i64 ), i64 ptrtoint( ptr @"cstring#0" to i64 )) + ret void } - -define external fastcc void @"command_line.set_exit_code<0>"(i64 %"code##0") alwaysinline { -entry: - store i64 %"code##0", i64* @"resource#command_line.exit_code" - ret void +define external fastcc void @"command_line.set_exit_code<0>"(i64 %"code##0") { + store i64 %"code##0", ptr @"resource#command_line.exit_code" + ret void } + -------------------------------------------------- Module drone representation : (not a type) @@ -891,7 +794,7 @@ proc #cont#1 > {semipure} (2 calls) proc do_action > (2 calls) -0: drone.do_action<0>[410bae77d3] +0: drone.do_action<0> do_action(d##0:drone.drone_info, ?d##2:drone.drone_info, action##0:wybe.char, ?success##2:wybe.bool)<{}; {}; {}>: AliasPairs: [(d##0,d##2)] InterestingCallProperties: [InterestingUnaliased 0] @@ -1036,7 +939,7 @@ do_action(d##0:drone.drone_info, ?d##2:drone.drone_info, action##0:wybe.char, ?s proc do_action#cont#1 > (7 calls) -0: drone.do_action#cont#1<0>[410bae77d3] +0: drone.do_action#cont#1<0> do_action#cont#1(d##0:drone.drone_info, success##0:wybe.bool, ?d##1:drone.drone_info, [?success##0:wybe.bool])<{}; {}; {}>: AliasPairs: [(d##0,d##1)] InterestingCallProperties: [InterestingUnaliased 0] @@ -1074,7 +977,7 @@ drone_init(?#result##0:drone.drone_info)<{}; {}; {}>: proc loop > (2 calls) -0: drone.loop<0>[410bae77d3] +0: drone.loop<0> loop(d##0:drone.drone_info, ch##0:wybe.char)<{<>}; {<>}; {}>: AliasPairs: [] InterestingCallProperties: [InterestingUnaliased 0] @@ -1183,7 +1086,7 @@ loop(d##0:drone.drone_info, ch##0:wybe.char)<{<>}; {<>}; proc loop#cont#1 > (4 calls) -0: drone.loop#cont#1<0>[6dacb8fd25] +0: drone.loop#cont#1<0> loop#cont#1([ch##0:wybe.char], d##0:drone.drone_info)<{<>}; {<>}; {}>: AliasPairs: [] InterestingCallProperties: [InterestingUnaliased 1] @@ -1242,539 +1145,466 @@ print_info(d##0:drone.drone_info)<{<>}; {<>}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'drone' - - - - -@drone.3 = constant {i64, i64} { i64 1, i64 ptrtoint ([?? x i8]* @drone.2 to i64) } - - -@drone.5 = constant {i64, i64} { i64 2, i64 ptrtoint ([?? x i8]* @drone.4 to i64) } - - -@drone.7 = constant {i64, i64} { i64 3, i64 ptrtoint ([?? x i8]* @drone.6 to i64) } - - -@drone.9 = constant {i64, i64} { i64 15, i64 ptrtoint ([?? x i8]* @drone.8 to i64) } - - -@drone.1 = constant {i64, i64} { i64 17, i64 ptrtoint ([?? x i8]* @drone.0 to i64) } - - -@drone.2 = constant [?? x i8] c"(\00" - - -@drone.6 = constant [?? x i8] c") #\00" - - -@drone.0 = constant [?? x i8] c"** malloc count: \00" - - -@drone.4 = constant [?? x i8] c", \00" - - -@drone.8 = constant [?? x i8] c"invalid action!\00" - - -declare external ccc void @putchar(i8) - - -declare external ccc void @print_int(i64) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc i8 @read_char() - - -declare external ccc i64 @malloc_count() - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"drone.<0>"() { -entry: - %0 = tail call fastcc i64 @"drone.drone_init<0>"() - %1 = tail call ccc i8 @read_char() - %2 = icmp ne i8 %1, trunc i64 -1 to i8 - br i1 %2, label %if.then, label %if.else -if.then: - tail call fastcc void @"drone.loop<0>[410bae77d3]"(i64 %0, i8 %1) - musttail call fastcc void @"drone.#cont#1<0>"() - ret void -if.else: - musttail call fastcc void @"drone.#cont#1<0>"() - ret void +source_filename = "/private!TMP!/drone.wybe" +target triple = ??? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c"(\00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c") #\00", align 8 +@"cstring#2" = private unnamed_addr constant [ ?? x i8 ] c"** malloc count: \00", align 8 +@"cstring#3" = private unnamed_addr constant [ ?? x i8 ] c", \00", align 8 +@"cstring#4" = private unnamed_addr constant [ ?? x i8 ] c"invalid action!\00", align 8 +@"string#5" = private unnamed_addr constant {i64, i64} { i64 1, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +@"string#6" = private unnamed_addr constant {i64, i64} { i64 3, i64 ptrtoint( ptr @"cstring#1" to i64 ) }, align 8 +@"string#7" = private unnamed_addr constant {i64, i64} { i64 17, i64 ptrtoint( ptr @"cstring#2" to i64 ) }, align 8 +@"string#8" = private unnamed_addr constant {i64, i64} { i64 2, i64 ptrtoint( ptr @"cstring#3" to i64 ) }, align 8 +@"string#9" = private unnamed_addr constant {i64, i64} { i64 15, i64 ptrtoint( ptr @"cstring#4" to i64 ) }, align 8 + +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc i64 @malloc_count() +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc i8 @read_char() +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"drone.<0>"() { + %"tmp#0##0" = tail call fastcc i64 @"drone.drone_init<0>"() + %"ch##0" = call ccc i8 @read_char() + %"tmp#1##0" = trunc i64 -1 to i8 + %"tmp#2##0" = icmp ne i8 %"ch##0", %"tmp#1##0" + br i1 %"tmp#2##0", label %if.then.0, label %if.else.0 +if.then.0: + tail call fastcc void @"drone.loop<0>[410bae77d3]"(i64 %"tmp#0##0", i8 %"ch##0") + tail call fastcc void @"drone.#cont#1<0>"() + ret void +if.else.0: + tail call fastcc void @"drone.#cont#1<0>"() + ret void } - -define external fastcc void @"drone.#cont#1<0>"() { -entry: - %0 = tail call ccc i64 @malloc_count() - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @drone.1, i32 0, i32 0) to i64)) - tail call ccc void @print_int(i64 %0) - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"drone.#cont#1<0>"() { + %"mc##0" = call ccc i64 @malloc_count() + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#7" to i64 )) + call ccc void @print_int(i64 %"mc##0") + call ccc void @putchar(i8 10) + ret void } - -define external fastcc {i64, i1} @"drone.do_action<0>"(i64 %"d##0", i8 %"action##0") { -entry: - %0 = icmp eq i8 %"action##0", 110 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = add i64 %"d##0", 8 - %2 = inttoptr i64 %1 to i64* - %3 = load i64, i64* %2 - %4 = sub i64 %3, 1 - %5 = trunc i64 32 to i32 - %6 = tail call ccc i8* @wybe_malloc(i32 %5) - %7 = ptrtoint i8* %6 to i64 - %8 = inttoptr i64 %7 to i8* - %9 = inttoptr i64 %"d##0" to i8* - %10 = trunc i64 32 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %8, i8* %9, i32 %10, i1 0) - %11 = add i64 %7, 8 - %12 = inttoptr i64 %11 to i64* - store i64 %4, i64* %12 - %13 = tail call fastcc i64 @"drone.do_action#cont#1<0>[410bae77d3]"(i64 %7, i1 1) - %14 = insertvalue {i64, i1} undef, i64 %13, 0 - %15 = insertvalue {i64, i1} %14, i1 1, 1 - ret {i64, i1} %15 -if.else: - %16 = icmp eq i8 %"action##0", 115 - br i1 %16, label %if.then1, label %if.else1 -if.then1: - %17 = add i64 %"d##0", 8 - %18 = inttoptr i64 %17 to i64* - %19 = load i64, i64* %18 - %20 = add i64 %19, 1 - %21 = trunc i64 32 to i32 - %22 = tail call ccc i8* @wybe_malloc(i32 %21) - %23 = ptrtoint i8* %22 to i64 - %24 = inttoptr i64 %23 to i8* - %25 = inttoptr i64 %"d##0" to i8* - %26 = trunc i64 32 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %24, i8* %25, i32 %26, i1 0) - %27 = add i64 %23, 8 - %28 = inttoptr i64 %27 to i64* - store i64 %20, i64* %28 - %29 = tail call fastcc i64 @"drone.do_action#cont#1<0>[410bae77d3]"(i64 %23, i1 1) - %30 = insertvalue {i64, i1} undef, i64 %29, 0 - %31 = insertvalue {i64, i1} %30, i1 1, 1 - ret {i64, i1} %31 -if.else1: - %32 = icmp eq i8 %"action##0", 119 - br i1 %32, label %if.then2, label %if.else2 -if.then2: - %33 = inttoptr i64 %"d##0" to i64* - %34 = load i64, i64* %33 - %35 = sub i64 %34, 1 - %36 = trunc i64 32 to i32 - %37 = tail call ccc i8* @wybe_malloc(i32 %36) - %38 = ptrtoint i8* %37 to i64 - %39 = inttoptr i64 %38 to i8* - %40 = inttoptr i64 %"d##0" to i8* - %41 = trunc i64 32 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %39, i8* %40, i32 %41, i1 0) - %42 = inttoptr i64 %38 to i64* - store i64 %35, i64* %42 - %43 = tail call fastcc i64 @"drone.do_action#cont#1<0>[410bae77d3]"(i64 %38, i1 1) - %44 = insertvalue {i64, i1} undef, i64 %43, 0 - %45 = insertvalue {i64, i1} %44, i1 1, 1 - ret {i64, i1} %45 -if.else2: - %46 = icmp eq i8 %"action##0", 101 - br i1 %46, label %if.then3, label %if.else3 -if.then3: - %47 = inttoptr i64 %"d##0" to i64* - %48 = load i64, i64* %47 - %49 = add i64 %48, 1 - %50 = trunc i64 32 to i32 - %51 = tail call ccc i8* @wybe_malloc(i32 %50) - %52 = ptrtoint i8* %51 to i64 - %53 = inttoptr i64 %52 to i8* - %54 = inttoptr i64 %"d##0" to i8* - %55 = trunc i64 32 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %53, i8* %54, i32 %55, i1 0) - %56 = inttoptr i64 %52 to i64* - store i64 %49, i64* %56 - %57 = tail call fastcc i64 @"drone.do_action#cont#1<0>[410bae77d3]"(i64 %52, i1 1) - %58 = insertvalue {i64, i1} undef, i64 %57, 0 - %59 = insertvalue {i64, i1} %58, i1 1, 1 - ret {i64, i1} %59 -if.else3: - %60 = icmp eq i8 %"action##0", 117 - br i1 %60, label %if.then4, label %if.else4 -if.then4: - %61 = add i64 %"d##0", 16 - %62 = inttoptr i64 %61 to i64* - %63 = load i64, i64* %62 - %64 = add i64 %63, 1 - %65 = trunc i64 32 to i32 - %66 = tail call ccc i8* @wybe_malloc(i32 %65) - %67 = ptrtoint i8* %66 to i64 - %68 = inttoptr i64 %67 to i8* - %69 = inttoptr i64 %"d##0" to i8* - %70 = trunc i64 32 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %68, i8* %69, i32 %70, i1 0) - %71 = add i64 %67, 16 - %72 = inttoptr i64 %71 to i64* - store i64 %64, i64* %72 - %73 = tail call fastcc i64 @"drone.do_action#cont#1<0>[410bae77d3]"(i64 %67, i1 1) - %74 = insertvalue {i64, i1} undef, i64 %73, 0 - %75 = insertvalue {i64, i1} %74, i1 1, 1 - ret {i64, i1} %75 -if.else4: - %76 = icmp eq i8 %"action##0", 100 - br i1 %76, label %if.then5, label %if.else5 -if.then5: - %77 = add i64 %"d##0", 16 - %78 = inttoptr i64 %77 to i64* - %79 = load i64, i64* %78 - %80 = sub i64 %79, 1 - %81 = trunc i64 32 to i32 - %82 = tail call ccc i8* @wybe_malloc(i32 %81) - %83 = ptrtoint i8* %82 to i64 - %84 = inttoptr i64 %83 to i8* - %85 = inttoptr i64 %"d##0" to i8* - %86 = trunc i64 32 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %84, i8* %85, i32 %86, i1 0) - %87 = add i64 %83, 16 - %88 = inttoptr i64 %87 to i64* - store i64 %80, i64* %88 - %89 = tail call fastcc i64 @"drone.do_action#cont#1<0>[410bae77d3]"(i64 %83, i1 1) - %90 = insertvalue {i64, i1} undef, i64 %89, 0 - %91 = insertvalue {i64, i1} %90, i1 1, 1 - ret {i64, i1} %91 -if.else5: - %92 = tail call fastcc i64 @"drone.do_action#cont#1<0>"(i64 %"d##0", i1 0) - %93 = insertvalue {i64, i1} undef, i64 %92, 0 - %94 = insertvalue {i64, i1} %93, i1 0, 1 - ret {i64, i1} %94 +define external fastcc {i64, i1} @"drone.do_action<0>"(i64 %"d##0", i8 %"action##0") { + %"tmp#21##0" = icmp eq i8 %"action##0", 110 + br i1 %"tmp#21##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#64##0" = add i64 %"d##0", 8 + %"tmp#65##0" = inttoptr i64 %"tmp#64##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#65##0" + %"tmp#1##0" = sub i64 %"tmp#2##0", 1 + %"tmp#66##0" = inttoptr i64 %"d##0" to ptr + %"tmp#67##0" = call ccc ptr @wybe_malloc(i32 32) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#67##0", ptr %"tmp#66##0", i64 32, i1 0) + %"tmp#68##0" = ptrtoint ptr %"tmp#67##0" to i64 + %"tmp#69##0" = add i64 %"tmp#68##0", 8 + %"tmp#70##0" = inttoptr i64 %"tmp#69##0" to ptr + store i64 %"tmp#1##0", ptr %"tmp#70##0" + %"tmp#71##0" = tail call fastcc i64 @"drone.do_action#cont#1<0>[410bae77d3]"(i64 %"tmp#68##0", i1 1) + %"tmp#72##0" = insertvalue {i64, i1} undef, i64 %"tmp#71##0", 0 + %"tmp#73##0" = insertvalue {i64, i1} %"tmp#72##0", i1 1, 1 + ret {i64, i1} %"tmp#73##0" +if.else.0: + %"tmp#20##0" = icmp eq i8 %"action##0", 115 + br i1 %"tmp#20##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#74##0" = add i64 %"d##0", 8 + %"tmp#75##0" = inttoptr i64 %"tmp#74##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#75##0" + %"tmp#3##0" = add i64 %"tmp#4##0", 1 + %"tmp#76##0" = inttoptr i64 %"d##0" to ptr + %"tmp#77##0" = call ccc ptr @wybe_malloc(i32 32) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#77##0", ptr %"tmp#76##0", i64 32, i1 0) + %"tmp#78##0" = ptrtoint ptr %"tmp#77##0" to i64 + %"tmp#79##0" = add i64 %"tmp#78##0", 8 + %"tmp#80##0" = inttoptr i64 %"tmp#79##0" to ptr + store i64 %"tmp#3##0", ptr %"tmp#80##0" + %"tmp#81##0" = tail call fastcc i64 @"drone.do_action#cont#1<0>[410bae77d3]"(i64 %"tmp#78##0", i1 1) + %"tmp#82##0" = insertvalue {i64, i1} undef, i64 %"tmp#81##0", 0 + %"tmp#83##0" = insertvalue {i64, i1} %"tmp#82##0", i1 1, 1 + ret {i64, i1} %"tmp#83##0" +if.else.1: + %"tmp#19##0" = icmp eq i8 %"action##0", 119 + br i1 %"tmp#19##0", label %if.then.2, label %if.else.2 +if.then.2: + %"tmp#84##0" = inttoptr i64 %"d##0" to ptr + %"tmp#6##0" = load i64, ptr %"tmp#84##0" + %"tmp#5##0" = sub i64 %"tmp#6##0", 1 + %"tmp#85##0" = inttoptr i64 %"d##0" to ptr + %"tmp#86##0" = call ccc ptr @wybe_malloc(i32 32) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#86##0", ptr %"tmp#85##0", i64 32, i1 0) + %"tmp#87##0" = ptrtoint ptr %"tmp#86##0" to i64 + %"tmp#88##0" = inttoptr i64 %"tmp#87##0" to ptr + store i64 %"tmp#5##0", ptr %"tmp#88##0" + %"tmp#89##0" = tail call fastcc i64 @"drone.do_action#cont#1<0>[410bae77d3]"(i64 %"tmp#87##0", i1 1) + %"tmp#90##0" = insertvalue {i64, i1} undef, i64 %"tmp#89##0", 0 + %"tmp#91##0" = insertvalue {i64, i1} %"tmp#90##0", i1 1, 1 + ret {i64, i1} %"tmp#91##0" +if.else.2: + %"tmp#18##0" = icmp eq i8 %"action##0", 101 + br i1 %"tmp#18##0", label %if.then.3, label %if.else.3 +if.then.3: + %"tmp#92##0" = inttoptr i64 %"d##0" to ptr + %"tmp#8##0" = load i64, ptr %"tmp#92##0" + %"tmp#7##0" = add i64 %"tmp#8##0", 1 + %"tmp#93##0" = inttoptr i64 %"d##0" to ptr + %"tmp#94##0" = call ccc ptr @wybe_malloc(i32 32) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#94##0", ptr %"tmp#93##0", i64 32, i1 0) + %"tmp#95##0" = ptrtoint ptr %"tmp#94##0" to i64 + %"tmp#96##0" = inttoptr i64 %"tmp#95##0" to ptr + store i64 %"tmp#7##0", ptr %"tmp#96##0" + %"tmp#97##0" = tail call fastcc i64 @"drone.do_action#cont#1<0>[410bae77d3]"(i64 %"tmp#95##0", i1 1) + %"tmp#98##0" = insertvalue {i64, i1} undef, i64 %"tmp#97##0", 0 + %"tmp#99##0" = insertvalue {i64, i1} %"tmp#98##0", i1 1, 1 + ret {i64, i1} %"tmp#99##0" +if.else.3: + %"tmp#17##0" = icmp eq i8 %"action##0", 117 + br i1 %"tmp#17##0", label %if.then.4, label %if.else.4 +if.then.4: + %"tmp#100##0" = add i64 %"d##0", 16 + %"tmp#101##0" = inttoptr i64 %"tmp#100##0" to ptr + %"tmp#10##0" = load i64, ptr %"tmp#101##0" + %"tmp#9##0" = add i64 %"tmp#10##0", 1 + %"tmp#102##0" = inttoptr i64 %"d##0" to ptr + %"tmp#103##0" = call ccc ptr @wybe_malloc(i32 32) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#103##0", ptr %"tmp#102##0", i64 32, i1 0) + %"tmp#104##0" = ptrtoint ptr %"tmp#103##0" to i64 + %"tmp#105##0" = add i64 %"tmp#104##0", 16 + %"tmp#106##0" = inttoptr i64 %"tmp#105##0" to ptr + store i64 %"tmp#9##0", ptr %"tmp#106##0" + %"tmp#107##0" = tail call fastcc i64 @"drone.do_action#cont#1<0>[410bae77d3]"(i64 %"tmp#104##0", i1 1) + %"tmp#108##0" = insertvalue {i64, i1} undef, i64 %"tmp#107##0", 0 + %"tmp#109##0" = insertvalue {i64, i1} %"tmp#108##0", i1 1, 1 + ret {i64, i1} %"tmp#109##0" +if.else.4: + %"tmp#16##0" = icmp eq i8 %"action##0", 100 + br i1 %"tmp#16##0", label %if.then.5, label %if.else.5 +if.then.5: + %"tmp#110##0" = add i64 %"d##0", 16 + %"tmp#111##0" = inttoptr i64 %"tmp#110##0" to ptr + %"tmp#12##0" = load i64, ptr %"tmp#111##0" + %"tmp#11##0" = sub i64 %"tmp#12##0", 1 + %"tmp#112##0" = inttoptr i64 %"d##0" to ptr + %"tmp#113##0" = call ccc ptr @wybe_malloc(i32 32) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#113##0", ptr %"tmp#112##0", i64 32, i1 0) + %"tmp#114##0" = ptrtoint ptr %"tmp#113##0" to i64 + %"tmp#115##0" = add i64 %"tmp#114##0", 16 + %"tmp#116##0" = inttoptr i64 %"tmp#115##0" to ptr + store i64 %"tmp#11##0", ptr %"tmp#116##0" + %"tmp#117##0" = tail call fastcc i64 @"drone.do_action#cont#1<0>[410bae77d3]"(i64 %"tmp#114##0", i1 1) + %"tmp#118##0" = insertvalue {i64, i1} undef, i64 %"tmp#117##0", 0 + %"tmp#119##0" = insertvalue {i64, i1} %"tmp#118##0", i1 1, 1 + ret {i64, i1} %"tmp#119##0" +if.else.5: + %"tmp#120##0" = tail call fastcc i64 @"drone.do_action#cont#1<0>"(i64 %"d##0", i1 0) + %"tmp#121##0" = insertvalue {i64, i1} undef, i64 %"tmp#120##0", 0 + %"tmp#122##0" = insertvalue {i64, i1} %"tmp#121##0", i1 0, 1 + ret {i64, i1} %"tmp#122##0" } - -define external fastcc {i64, i1} @"drone.do_action<0>[410bae77d3]"(i64 %"d##0", i8 %"action##0") { -entry: - %0 = icmp eq i8 %"action##0", 110 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = add i64 %"d##0", 8 - %2 = inttoptr i64 %1 to i64* - %3 = load i64, i64* %2 - %4 = sub i64 %3, 1 - %5 = add i64 %"d##0", 8 - %6 = inttoptr i64 %5 to i64* - store i64 %4, i64* %6 - %7 = tail call fastcc i64 @"drone.do_action#cont#1<0>[410bae77d3]"(i64 %"d##0", i1 1) - %8 = insertvalue {i64, i1} undef, i64 %7, 0 - %9 = insertvalue {i64, i1} %8, i1 1, 1 - ret {i64, i1} %9 -if.else: - %10 = icmp eq i8 %"action##0", 115 - br i1 %10, label %if.then1, label %if.else1 -if.then1: - %11 = add i64 %"d##0", 8 - %12 = inttoptr i64 %11 to i64* - %13 = load i64, i64* %12 - %14 = add i64 %13, 1 - %15 = add i64 %"d##0", 8 - %16 = inttoptr i64 %15 to i64* - store i64 %14, i64* %16 - %17 = tail call fastcc i64 @"drone.do_action#cont#1<0>[410bae77d3]"(i64 %"d##0", i1 1) - %18 = insertvalue {i64, i1} undef, i64 %17, 0 - %19 = insertvalue {i64, i1} %18, i1 1, 1 - ret {i64, i1} %19 -if.else1: - %20 = icmp eq i8 %"action##0", 119 - br i1 %20, label %if.then2, label %if.else2 -if.then2: - %21 = inttoptr i64 %"d##0" to i64* - %22 = load i64, i64* %21 - %23 = sub i64 %22, 1 - %24 = inttoptr i64 %"d##0" to i64* - store i64 %23, i64* %24 - %25 = tail call fastcc i64 @"drone.do_action#cont#1<0>[410bae77d3]"(i64 %"d##0", i1 1) - %26 = insertvalue {i64, i1} undef, i64 %25, 0 - %27 = insertvalue {i64, i1} %26, i1 1, 1 - ret {i64, i1} %27 -if.else2: - %28 = icmp eq i8 %"action##0", 101 - br i1 %28, label %if.then3, label %if.else3 -if.then3: - %29 = inttoptr i64 %"d##0" to i64* - %30 = load i64, i64* %29 - %31 = add i64 %30, 1 - %32 = inttoptr i64 %"d##0" to i64* - store i64 %31, i64* %32 - %33 = tail call fastcc i64 @"drone.do_action#cont#1<0>[410bae77d3]"(i64 %"d##0", i1 1) - %34 = insertvalue {i64, i1} undef, i64 %33, 0 - %35 = insertvalue {i64, i1} %34, i1 1, 1 - ret {i64, i1} %35 -if.else3: - %36 = icmp eq i8 %"action##0", 117 - br i1 %36, label %if.then4, label %if.else4 -if.then4: - %37 = add i64 %"d##0", 16 - %38 = inttoptr i64 %37 to i64* - %39 = load i64, i64* %38 - %40 = add i64 %39, 1 - %41 = add i64 %"d##0", 16 - %42 = inttoptr i64 %41 to i64* - store i64 %40, i64* %42 - %43 = tail call fastcc i64 @"drone.do_action#cont#1<0>[410bae77d3]"(i64 %"d##0", i1 1) - %44 = insertvalue {i64, i1} undef, i64 %43, 0 - %45 = insertvalue {i64, i1} %44, i1 1, 1 - ret {i64, i1} %45 -if.else4: - %46 = icmp eq i8 %"action##0", 100 - br i1 %46, label %if.then5, label %if.else5 -if.then5: - %47 = add i64 %"d##0", 16 - %48 = inttoptr i64 %47 to i64* - %49 = load i64, i64* %48 - %50 = sub i64 %49, 1 - %51 = add i64 %"d##0", 16 - %52 = inttoptr i64 %51 to i64* - store i64 %50, i64* %52 - %53 = tail call fastcc i64 @"drone.do_action#cont#1<0>[410bae77d3]"(i64 %"d##0", i1 1) - %54 = insertvalue {i64, i1} undef, i64 %53, 0 - %55 = insertvalue {i64, i1} %54, i1 1, 1 - ret {i64, i1} %55 -if.else5: - %56 = tail call fastcc i64 @"drone.do_action#cont#1<0>[410bae77d3]"(i64 %"d##0", i1 0) - %57 = insertvalue {i64, i1} undef, i64 %56, 0 - %58 = insertvalue {i64, i1} %57, i1 0, 1 - ret {i64, i1} %58 +define external fastcc {i64, i1} @"drone.do_action<0>[410bae77d3]"(i64 %"d##0", i8 %"action##0") { + %"tmp#21##0" = icmp eq i8 %"action##0", 110 + br i1 %"tmp#21##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#64##0" = add i64 %"d##0", 8 + %"tmp#65##0" = inttoptr i64 %"tmp#64##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#65##0" + %"tmp#1##0" = sub i64 %"tmp#2##0", 1 + %"tmp#66##0" = add i64 %"d##0", 8 + %"tmp#67##0" = inttoptr i64 %"tmp#66##0" to ptr + store i64 %"tmp#1##0", ptr %"tmp#67##0" + %"tmp#68##0" = tail call fastcc i64 @"drone.do_action#cont#1<0>[410bae77d3]"(i64 %"d##0", i1 1) + %"tmp#69##0" = insertvalue {i64, i1} undef, i64 %"tmp#68##0", 0 + %"tmp#70##0" = insertvalue {i64, i1} %"tmp#69##0", i1 1, 1 + ret {i64, i1} %"tmp#70##0" +if.else.0: + %"tmp#20##0" = icmp eq i8 %"action##0", 115 + br i1 %"tmp#20##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#71##0" = add i64 %"d##0", 8 + %"tmp#72##0" = inttoptr i64 %"tmp#71##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#72##0" + %"tmp#3##0" = add i64 %"tmp#4##0", 1 + %"tmp#73##0" = add i64 %"d##0", 8 + %"tmp#74##0" = inttoptr i64 %"tmp#73##0" to ptr + store i64 %"tmp#3##0", ptr %"tmp#74##0" + %"tmp#75##0" = tail call fastcc i64 @"drone.do_action#cont#1<0>[410bae77d3]"(i64 %"d##0", i1 1) + %"tmp#76##0" = insertvalue {i64, i1} undef, i64 %"tmp#75##0", 0 + %"tmp#77##0" = insertvalue {i64, i1} %"tmp#76##0", i1 1, 1 + ret {i64, i1} %"tmp#77##0" +if.else.1: + %"tmp#19##0" = icmp eq i8 %"action##0", 119 + br i1 %"tmp#19##0", label %if.then.2, label %if.else.2 +if.then.2: + %"tmp#78##0" = inttoptr i64 %"d##0" to ptr + %"tmp#6##0" = load i64, ptr %"tmp#78##0" + %"tmp#5##0" = sub i64 %"tmp#6##0", 1 + %"tmp#79##0" = inttoptr i64 %"d##0" to ptr + store i64 %"tmp#5##0", ptr %"tmp#79##0" + %"tmp#80##0" = tail call fastcc i64 @"drone.do_action#cont#1<0>[410bae77d3]"(i64 %"d##0", i1 1) + %"tmp#81##0" = insertvalue {i64, i1} undef, i64 %"tmp#80##0", 0 + %"tmp#82##0" = insertvalue {i64, i1} %"tmp#81##0", i1 1, 1 + ret {i64, i1} %"tmp#82##0" +if.else.2: + %"tmp#18##0" = icmp eq i8 %"action##0", 101 + br i1 %"tmp#18##0", label %if.then.3, label %if.else.3 +if.then.3: + %"tmp#83##0" = inttoptr i64 %"d##0" to ptr + %"tmp#8##0" = load i64, ptr %"tmp#83##0" + %"tmp#7##0" = add i64 %"tmp#8##0", 1 + %"tmp#84##0" = inttoptr i64 %"d##0" to ptr + store i64 %"tmp#7##0", ptr %"tmp#84##0" + %"tmp#85##0" = tail call fastcc i64 @"drone.do_action#cont#1<0>[410bae77d3]"(i64 %"d##0", i1 1) + %"tmp#86##0" = insertvalue {i64, i1} undef, i64 %"tmp#85##0", 0 + %"tmp#87##0" = insertvalue {i64, i1} %"tmp#86##0", i1 1, 1 + ret {i64, i1} %"tmp#87##0" +if.else.3: + %"tmp#17##0" = icmp eq i8 %"action##0", 117 + br i1 %"tmp#17##0", label %if.then.4, label %if.else.4 +if.then.4: + %"tmp#88##0" = add i64 %"d##0", 16 + %"tmp#89##0" = inttoptr i64 %"tmp#88##0" to ptr + %"tmp#10##0" = load i64, ptr %"tmp#89##0" + %"tmp#9##0" = add i64 %"tmp#10##0", 1 + %"tmp#90##0" = add i64 %"d##0", 16 + %"tmp#91##0" = inttoptr i64 %"tmp#90##0" to ptr + store i64 %"tmp#9##0", ptr %"tmp#91##0" + %"tmp#92##0" = tail call fastcc i64 @"drone.do_action#cont#1<0>[410bae77d3]"(i64 %"d##0", i1 1) + %"tmp#93##0" = insertvalue {i64, i1} undef, i64 %"tmp#92##0", 0 + %"tmp#94##0" = insertvalue {i64, i1} %"tmp#93##0", i1 1, 1 + ret {i64, i1} %"tmp#94##0" +if.else.4: + %"tmp#16##0" = icmp eq i8 %"action##0", 100 + br i1 %"tmp#16##0", label %if.then.5, label %if.else.5 +if.then.5: + %"tmp#95##0" = add i64 %"d##0", 16 + %"tmp#96##0" = inttoptr i64 %"tmp#95##0" to ptr + %"tmp#12##0" = load i64, ptr %"tmp#96##0" + %"tmp#11##0" = sub i64 %"tmp#12##0", 1 + %"tmp#97##0" = add i64 %"d##0", 16 + %"tmp#98##0" = inttoptr i64 %"tmp#97##0" to ptr + store i64 %"tmp#11##0", ptr %"tmp#98##0" + %"tmp#99##0" = tail call fastcc i64 @"drone.do_action#cont#1<0>[410bae77d3]"(i64 %"d##0", i1 1) + %"tmp#100##0" = insertvalue {i64, i1} undef, i64 %"tmp#99##0", 0 + %"tmp#101##0" = insertvalue {i64, i1} %"tmp#100##0", i1 1, 1 + ret {i64, i1} %"tmp#101##0" +if.else.5: + %"tmp#102##0" = tail call fastcc i64 @"drone.do_action#cont#1<0>[410bae77d3]"(i64 %"d##0", i1 0) + %"tmp#103##0" = insertvalue {i64, i1} undef, i64 %"tmp#102##0", 0 + %"tmp#104##0" = insertvalue {i64, i1} %"tmp#103##0", i1 0, 1 + ret {i64, i1} %"tmp#104##0" } - -define external fastcc i64 @"drone.do_action#cont#1<0>"(i64 %"d##0", i1 %"success##0") { -entry: - br i1 %"success##0", label %if.then, label %if.else -if.then: - %0 = add i64 %"d##0", 24 - %1 = inttoptr i64 %0 to i64* - %2 = load i64, i64* %1 - %3 = add i64 %2, 1 - %4 = trunc i64 32 to i32 - %5 = tail call ccc i8* @wybe_malloc(i32 %4) - %6 = ptrtoint i8* %5 to i64 - %7 = inttoptr i64 %6 to i8* - %8 = inttoptr i64 %"d##0" to i8* - %9 = trunc i64 32 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %7, i8* %8, i32 %9, i1 0) - %10 = add i64 %6, 24 - %11 = inttoptr i64 %10 to i64* - store i64 %3, i64* %11 - ret i64 %6 -if.else: - ret i64 %"d##0" +define external fastcc i64 @"drone.do_action#cont#1<0>"(i64 %"d##0", i1 %"success##0") { + br i1 %"success##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#21##0" = add i64 %"d##0", 24 + %"tmp#22##0" = inttoptr i64 %"tmp#21##0" to ptr + %"tmp#15##0" = load i64, ptr %"tmp#22##0" + %"tmp#14##0" = add i64 %"tmp#15##0", 1 + %"tmp#23##0" = inttoptr i64 %"d##0" to ptr + %"tmp#24##0" = call ccc ptr @wybe_malloc(i32 32) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#24##0", ptr %"tmp#23##0", i64 32, i1 0) + %"tmp#25##0" = ptrtoint ptr %"tmp#24##0" to i64 + %"tmp#26##0" = add i64 %"tmp#25##0", 24 + %"tmp#27##0" = inttoptr i64 %"tmp#26##0" to ptr + store i64 %"tmp#14##0", ptr %"tmp#27##0" + ret i64 %"tmp#25##0" +if.else.0: + ret i64 %"d##0" } - -define external fastcc i64 @"drone.do_action#cont#1<0>[410bae77d3]"(i64 %"d##0", i1 %"success##0") { -entry: - br i1 %"success##0", label %if.then, label %if.else -if.then: - %0 = add i64 %"d##0", 24 - %1 = inttoptr i64 %0 to i64* - %2 = load i64, i64* %1 - %3 = add i64 %2, 1 - %4 = add i64 %"d##0", 24 - %5 = inttoptr i64 %4 to i64* - store i64 %3, i64* %5 - ret i64 %"d##0" -if.else: - ret i64 %"d##0" +define external fastcc i64 @"drone.do_action#cont#1<0>[410bae77d3]"(i64 %"d##0", i1 %"success##0") { + br i1 %"success##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#21##0" = add i64 %"d##0", 24 + %"tmp#22##0" = inttoptr i64 %"tmp#21##0" to ptr + %"tmp#15##0" = load i64, ptr %"tmp#22##0" + %"tmp#14##0" = add i64 %"tmp#15##0", 1 + %"tmp#23##0" = add i64 %"d##0", 24 + %"tmp#24##0" = inttoptr i64 %"tmp#23##0" to ptr + store i64 %"tmp#14##0", ptr %"tmp#24##0" + ret i64 %"d##0" +if.else.0: + ret i64 %"d##0" } - -define external fastcc i64 @"drone.drone_init<0>"() { -entry: - %0 = trunc i64 32 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 0, i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 0, i64* %5 - %6 = add i64 %2, 16 - %7 = inttoptr i64 %6 to i64* - store i64 0, i64* %7 - %8 = add i64 %2, 24 - %9 = inttoptr i64 %8 to i64* - store i64 0, i64* %9 - ret i64 %2 +define external fastcc i64 @"drone.drone_init<0>"() { + %"tmp#10##0" = call ccc ptr @wybe_malloc(i32 32) + %"tmp#5##0" = ptrtoint ptr %"tmp#10##0" to i64 + %"tmp#11##0" = inttoptr i64 %"tmp#5##0" to ptr + store i64 0, ptr %"tmp#11##0" + %"tmp#12##0" = add i64 %"tmp#5##0", 8 + %"tmp#13##0" = inttoptr i64 %"tmp#12##0" to ptr + store i64 0, ptr %"tmp#13##0" + %"tmp#14##0" = add i64 %"tmp#5##0", 16 + %"tmp#15##0" = inttoptr i64 %"tmp#14##0" to ptr + store i64 0, ptr %"tmp#15##0" + %"tmp#16##0" = add i64 %"tmp#5##0", 24 + %"tmp#17##0" = inttoptr i64 %"tmp#16##0" to ptr + store i64 0, ptr %"tmp#17##0" + ret i64 %"tmp#5##0" } - -define external fastcc void @"drone.loop<0>"(i64 %"d##0", i8 %"ch##0") { -entry: - %0 = icmp ne i8 %"ch##0", 32 - %1 = icmp ne i8 %"ch##0", 10 - %2 = and i1 %0, %1 - br i1 %2, label %if.then, label %if.else -if.then: - %3 = icmp eq i8 %"ch##0", 112 - br i1 %3, label %if.then1, label %if.else1 -if.else: - tail call fastcc void @"drone.loop#cont#1<0>"(i64 %"d##0") - ret void -if.then1: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @drone.3, i32 0, i32 0) to i64)) - %4 = inttoptr i64 %"d##0" to i64* - %5 = load i64, i64* %4 - tail call ccc void @print_int(i64 %5) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @drone.5, i32 0, i32 0) to i64)) - %6 = add i64 %"d##0", 8 - %7 = inttoptr i64 %6 to i64* - %8 = load i64, i64* %7 - tail call ccc void @print_int(i64 %8) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @drone.5, i32 0, i32 0) to i64)) - %9 = add i64 %"d##0", 16 - %10 = inttoptr i64 %9 to i64* - %11 = load i64, i64* %10 - tail call ccc void @print_int(i64 %11) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @drone.7, i32 0, i32 0) to i64)) - %12 = add i64 %"d##0", 24 - %13 = inttoptr i64 %12 to i64* - %14 = load i64, i64* %13 - tail call ccc void @print_int(i64 %14) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"drone.loop#cont#1<0>"(i64 %"d##0") - ret void -if.else1: - %15 = tail call fastcc {i64, i1} @"drone.do_action<0>"(i64 %"d##0", i8 %"ch##0") - %16 = extractvalue {i64, i1} %15, 0 - %17 = extractvalue {i64, i1} %15, 1 - %18 = icmp eq i1 %17, 0 - br i1 %18, label %if.then2, label %if.else2 -if.then2: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @drone.9, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"drone.loop#cont#1<0>"(i64 %16) - ret void -if.else2: - tail call fastcc void @"drone.loop#cont#1<0>"(i64 %16) - ret void +define external fastcc void @"drone.loop<0>"(i64 %"d##0", i8 %"ch##0") { + %"tmp#0##0" = icmp ne i8 %"ch##0", 32 + %"tmp#1##0" = icmp ne i8 %"ch##0", 10 + %"tmp#7##0" = and i1 %"tmp#0##0", %"tmp#1##0" + br i1 %"tmp#7##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#6##0" = icmp eq i8 %"ch##0", 112 + br i1 %"tmp#6##0", label %if.then.1, label %if.else.1 +if.then.1: + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#5" to i64 )) + %"tmp#35##0" = inttoptr i64 %"d##0" to ptr + %"tmp#22##0" = load i64, ptr %"tmp#35##0" + call ccc void @print_int(i64 %"tmp#22##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#8" to i64 )) + %"tmp#36##0" = add i64 %"d##0", 8 + %"tmp#37##0" = inttoptr i64 %"tmp#36##0" to ptr + %"tmp#25##0" = load i64, ptr %"tmp#37##0" + call ccc void @print_int(i64 %"tmp#25##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#8" to i64 )) + %"tmp#38##0" = add i64 %"d##0", 16 + %"tmp#39##0" = inttoptr i64 %"tmp#38##0" to ptr + %"tmp#28##0" = load i64, ptr %"tmp#39##0" + call ccc void @print_int(i64 %"tmp#28##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#6" to i64 )) + %"tmp#40##0" = add i64 %"d##0", 24 + %"tmp#41##0" = inttoptr i64 %"tmp#40##0" to ptr + %"tmp#31##0" = load i64, ptr %"tmp#41##0" + call ccc void @print_int(i64 %"tmp#31##0") + call ccc void @putchar(i8 10) + tail call fastcc void @"drone.loop#cont#1<0>"(i64 %"d##0") + ret void +if.else.1: + %"tmp#42##0" = tail call fastcc {i64, i1} @"drone.do_action<0>"(i64 %"d##0", i8 %"ch##0") + %"d##1" = extractvalue {i64, i1}%"tmp#42##0", 0 + %"success##0" = extractvalue {i64, i1}%"tmp#42##0", 1 + %"tmp#5##0" = icmp eq i1 %"success##0", 0 + br i1 %"tmp#5##0", label %if.then.2, label %if.else.2 +if.then.2: + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#9" to i64 )) + call ccc void @putchar(i8 10) + tail call fastcc void @"drone.loop#cont#1<0>"(i64 %"d##1") + ret void +if.else.2: + tail call fastcc void @"drone.loop#cont#1<0>"(i64 %"d##1") + ret void +if.else.0: + tail call fastcc void @"drone.loop#cont#1<0>"(i64 %"d##0") + ret void } - -define external fastcc void @"drone.loop<0>[410bae77d3]"(i64 %"d##0", i8 %"ch##0") { -entry: - %0 = icmp ne i8 %"ch##0", 32 - %1 = icmp ne i8 %"ch##0", 10 - %2 = and i1 %0, %1 - br i1 %2, label %if.then, label %if.else -if.then: - %3 = icmp eq i8 %"ch##0", 112 - br i1 %3, label %if.then1, label %if.else1 -if.else: - tail call fastcc void @"drone.loop#cont#1<0>[6dacb8fd25]"(i64 %"d##0") - ret void -if.then1: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @drone.3, i32 0, i32 0) to i64)) - %4 = inttoptr i64 %"d##0" to i64* - %5 = load i64, i64* %4 - tail call ccc void @print_int(i64 %5) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @drone.5, i32 0, i32 0) to i64)) - %6 = add i64 %"d##0", 8 - %7 = inttoptr i64 %6 to i64* - %8 = load i64, i64* %7 - tail call ccc void @print_int(i64 %8) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @drone.5, i32 0, i32 0) to i64)) - %9 = add i64 %"d##0", 16 - %10 = inttoptr i64 %9 to i64* - %11 = load i64, i64* %10 - tail call ccc void @print_int(i64 %11) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @drone.7, i32 0, i32 0) to i64)) - %12 = add i64 %"d##0", 24 - %13 = inttoptr i64 %12 to i64* - %14 = load i64, i64* %13 - tail call ccc void @print_int(i64 %14) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"drone.loop#cont#1<0>[6dacb8fd25]"(i64 %"d##0") - ret void -if.else1: - %15 = tail call fastcc {i64, i1} @"drone.do_action<0>[410bae77d3]"(i64 %"d##0", i8 %"ch##0") - %16 = extractvalue {i64, i1} %15, 0 - %17 = extractvalue {i64, i1} %15, 1 - %18 = icmp eq i1 %17, 0 - br i1 %18, label %if.then2, label %if.else2 -if.then2: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @drone.9, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"drone.loop#cont#1<0>[6dacb8fd25]"(i64 %16) - ret void -if.else2: - tail call fastcc void @"drone.loop#cont#1<0>[6dacb8fd25]"(i64 %16) - ret void +define external fastcc void @"drone.loop<0>[410bae77d3]"(i64 %"d##0", i8 %"ch##0") { + %"tmp#0##0" = icmp ne i8 %"ch##0", 32 + %"tmp#1##0" = icmp ne i8 %"ch##0", 10 + %"tmp#7##0" = and i1 %"tmp#0##0", %"tmp#1##0" + br i1 %"tmp#7##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#6##0" = icmp eq i8 %"ch##0", 112 + br i1 %"tmp#6##0", label %if.then.1, label %if.else.1 +if.then.1: + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#5" to i64 )) + %"tmp#35##0" = inttoptr i64 %"d##0" to ptr + %"tmp#22##0" = load i64, ptr %"tmp#35##0" + call ccc void @print_int(i64 %"tmp#22##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#8" to i64 )) + %"tmp#36##0" = add i64 %"d##0", 8 + %"tmp#37##0" = inttoptr i64 %"tmp#36##0" to ptr + %"tmp#25##0" = load i64, ptr %"tmp#37##0" + call ccc void @print_int(i64 %"tmp#25##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#8" to i64 )) + %"tmp#38##0" = add i64 %"d##0", 16 + %"tmp#39##0" = inttoptr i64 %"tmp#38##0" to ptr + %"tmp#28##0" = load i64, ptr %"tmp#39##0" + call ccc void @print_int(i64 %"tmp#28##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#6" to i64 )) + %"tmp#40##0" = add i64 %"d##0", 24 + %"tmp#41##0" = inttoptr i64 %"tmp#40##0" to ptr + %"tmp#31##0" = load i64, ptr %"tmp#41##0" + call ccc void @print_int(i64 %"tmp#31##0") + call ccc void @putchar(i8 10) + tail call fastcc void @"drone.loop#cont#1<0>[6dacb8fd25]"(i64 %"d##0") + ret void +if.else.1: + %"tmp#42##0" = tail call fastcc {i64, i1} @"drone.do_action<0>[410bae77d3]"(i64 %"d##0", i8 %"ch##0") + %"d##1" = extractvalue {i64, i1}%"tmp#42##0", 0 + %"success##0" = extractvalue {i64, i1}%"tmp#42##0", 1 + %"tmp#5##0" = icmp eq i1 %"success##0", 0 + br i1 %"tmp#5##0", label %if.then.2, label %if.else.2 +if.then.2: + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#9" to i64 )) + call ccc void @putchar(i8 10) + tail call fastcc void @"drone.loop#cont#1<0>[6dacb8fd25]"(i64 %"d##1") + ret void +if.else.2: + tail call fastcc void @"drone.loop#cont#1<0>[6dacb8fd25]"(i64 %"d##1") + ret void +if.else.0: + tail call fastcc void @"drone.loop#cont#1<0>[6dacb8fd25]"(i64 %"d##0") + ret void } - -define external fastcc void @"drone.loop#cont#1<0>"(i64 %"d##0") { -entry: - %0 = tail call ccc i8 @read_char() - %1 = icmp ne i8 %0, trunc i64 -1 to i8 - br i1 %1, label %if.then, label %if.else -if.then: - tail call fastcc void @"drone.loop<0>"(i64 %"d##0", i8 %0) - ret void -if.else: - ret void +define external fastcc void @"drone.loop#cont#1<0>"(i64 %"d##0") { + %"ch##1" = call ccc i8 @read_char() + %"tmp#3##0" = trunc i64 -1 to i8 + %"tmp#4##0" = icmp ne i8 %"ch##1", %"tmp#3##0" + br i1 %"tmp#4##0", label %if.then.0, label %if.else.0 +if.then.0: + tail call fastcc void @"drone.loop<0>"(i64 %"d##0", i8 %"ch##1") + ret void +if.else.0: + ret void } - -define external fastcc void @"drone.loop#cont#1<0>[6dacb8fd25]"(i64 %"d##0") { -entry: - %0 = tail call ccc i8 @read_char() - %1 = icmp ne i8 %0, trunc i64 -1 to i8 - br i1 %1, label %if.then, label %if.else -if.then: - tail call fastcc void @"drone.loop<0>[410bae77d3]"(i64 %"d##0", i8 %0) - ret void -if.else: - ret void +define external fastcc void @"drone.loop#cont#1<0>[6dacb8fd25]"(i64 %"d##0") { + %"ch##1" = call ccc i8 @read_char() + %"tmp#3##0" = trunc i64 -1 to i8 + %"tmp#4##0" = icmp ne i8 %"ch##1", %"tmp#3##0" + br i1 %"tmp#4##0", label %if.then.0, label %if.else.0 +if.then.0: + tail call fastcc void @"drone.loop<0>[410bae77d3]"(i64 %"d##0", i8 %"ch##1") + ret void +if.else.0: + ret void } - -define external fastcc void @"drone.print_info<0>"(i64 %"d##0") alwaysinline { -entry: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @drone.3, i32 0, i32 0) to i64)) - %0 = inttoptr i64 %"d##0" to i64* - %1 = load i64, i64* %0 - tail call ccc void @print_int(i64 %1) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @drone.5, i32 0, i32 0) to i64)) - %2 = add i64 %"d##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - tail call ccc void @print_int(i64 %4) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @drone.5, i32 0, i32 0) to i64)) - %5 = add i64 %"d##0", 16 - %6 = inttoptr i64 %5 to i64* - %7 = load i64, i64* %6 - tail call ccc void @print_int(i64 %7) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @drone.7, i32 0, i32 0) to i64)) - %8 = add i64 %"d##0", 24 - %9 = inttoptr i64 %8 to i64* - %10 = load i64, i64* %9 - tail call ccc void @print_int(i64 %10) - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"drone.print_info<0>"(i64 %"d##0") { + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#5" to i64 )) + %"tmp#22##0" = inttoptr i64 %"d##0" to ptr + %"tmp#0##0" = load i64, ptr %"tmp#22##0" + call ccc void @print_int(i64 %"tmp#0##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#8" to i64 )) + %"tmp#23##0" = add i64 %"d##0", 8 + %"tmp#24##0" = inttoptr i64 %"tmp#23##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#24##0" + call ccc void @print_int(i64 %"tmp#1##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#8" to i64 )) + %"tmp#25##0" = add i64 %"d##0", 16 + %"tmp#26##0" = inttoptr i64 %"tmp#25##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#26##0" + call ccc void @print_int(i64 %"tmp#2##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#6" to i64 )) + %"tmp#27##0" = add i64 %"d##0", 24 + %"tmp#28##0" = inttoptr i64 %"tmp#27##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#28##0" + call ccc void @print_int(i64 %"tmp#3##0") + call ccc void @putchar(i8 10) + ret void } + -------------------------------------------------- Module drone.drone_info - representation : address + representation : pointer public submods : public resources: public procs : drone.drone_info.=<0> @@ -1950,246 +1780,208 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'drone.drone_info' - - - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i1 @"drone.drone_info.=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = add i64 %"#left##0", 16 - %6 = inttoptr i64 %5 to i64* - %7 = load i64, i64* %6 - %8 = add i64 %"#left##0", 24 - %9 = inttoptr i64 %8 to i64* - %10 = load i64, i64* %9 - %11 = inttoptr i64 %"#right##0" to i64* - %12 = load i64, i64* %11 - %13 = add i64 %"#right##0", 8 - %14 = inttoptr i64 %13 to i64* - %15 = load i64, i64* %14 - %16 = add i64 %"#right##0", 16 - %17 = inttoptr i64 %16 to i64* - %18 = load i64, i64* %17 - %19 = add i64 %"#right##0", 24 - %20 = inttoptr i64 %19 to i64* - %21 = load i64, i64* %20 - %22 = icmp eq i64 %1, %12 - br i1 %22, label %if.then, label %if.else -if.then: - %23 = icmp eq i64 %4, %15 - br i1 %23, label %if.then1, label %if.else1 -if.else: - ret i1 0 -if.then1: - %24 = icmp eq i64 %7, %18 - br i1 %24, label %if.then2, label %if.else2 -if.else1: - ret i1 0 -if.then2: - %25 = icmp eq i64 %10, %21 - ret i1 %25 -if.else2: - ret i1 0 +source_filename = "/private!TMP!/drone.wybe" +target triple = ??? + + +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc i1 @"drone.drone_info.=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#15##0" = inttoptr i64 %"#left##0" to ptr + %"#left#x##0" = load i64, ptr %"tmp#15##0" + %"tmp#16##0" = add i64 %"#left##0", 8 + %"tmp#17##0" = inttoptr i64 %"tmp#16##0" to ptr + %"#left#y##0" = load i64, ptr %"tmp#17##0" + %"tmp#18##0" = add i64 %"#left##0", 16 + %"tmp#19##0" = inttoptr i64 %"tmp#18##0" to ptr + %"#left#z##0" = load i64, ptr %"tmp#19##0" + %"tmp#20##0" = add i64 %"#left##0", 24 + %"tmp#21##0" = inttoptr i64 %"tmp#20##0" to ptr + %"#left#count##0" = load i64, ptr %"tmp#21##0" + %"tmp#22##0" = inttoptr i64 %"#right##0" to ptr + %"#right#x##0" = load i64, ptr %"tmp#22##0" + %"tmp#23##0" = add i64 %"#right##0", 8 + %"tmp#24##0" = inttoptr i64 %"tmp#23##0" to ptr + %"#right#y##0" = load i64, ptr %"tmp#24##0" + %"tmp#25##0" = add i64 %"#right##0", 16 + %"tmp#26##0" = inttoptr i64 %"tmp#25##0" to ptr + %"#right#z##0" = load i64, ptr %"tmp#26##0" + %"tmp#27##0" = add i64 %"#right##0", 24 + %"tmp#28##0" = inttoptr i64 %"tmp#27##0" to ptr + %"#right#count##0" = load i64, ptr %"tmp#28##0" + %"tmp#1##0" = icmp eq i64 %"#left#x##0", %"#right#x##0" + br i1 %"tmp#1##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = icmp eq i64 %"#left#y##0", %"#right#y##0" + br i1 %"tmp#2##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#3##0" = icmp eq i64 %"#left#z##0", %"#right#z##0" + br i1 %"tmp#3##0", label %if.then.2, label %if.else.2 +if.then.2: + %"tmp#29##0" = icmp eq i64 %"#left#count##0", %"#right#count##0" + ret i1 %"tmp#29##0" +if.else.2: + ret i1 0 +if.else.1: + ret i1 0 +if.else.0: + ret i1 0 } - -define external fastcc i64 @"drone.drone_info.count<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = add i64 %"#rec##0", 24 - %1 = inttoptr i64 %0 to i64* - %2 = load i64, i64* %1 - ret i64 %2 +define external fastcc i64 @"drone.drone_info.count<0>"(i64 %"#rec##0") { + %"tmp#0##0" = add i64 %"#rec##0", 24 + %"tmp#1##0" = inttoptr i64 %"tmp#0##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"drone.drone_info.count<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 32 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 32 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = add i64 %2, 24 - %7 = inttoptr i64 %6 to i64* - store i64 %"#field##0", i64* %7 - ret i64 %2 +define external fastcc i64 @"drone.drone_info.count<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 32) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 32, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = add i64 %"tmp#2##0", 24 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 %"#field##0", ptr %"tmp#4##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"drone.drone_info.drone_info<0>"(i64 %"x##0", i64 %"y##0", i64 %"z##0", i64 %"count##0") alwaysinline { -entry: - %0 = trunc i64 32 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"x##0", i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"y##0", i64* %5 - %6 = add i64 %2, 16 - %7 = inttoptr i64 %6 to i64* - store i64 %"z##0", i64* %7 - %8 = add i64 %2, 24 - %9 = inttoptr i64 %8 to i64* - store i64 %"count##0", i64* %9 - ret i64 %2 +define external fastcc i64 @"drone.drone_info.drone_info<0>"(i64 %"x##0", i64 %"y##0", i64 %"z##0", i64 %"count##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 32) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"x##0", ptr %"tmp#1##0" + %"tmp#2##0" = add i64 %"#rec##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"y##0", ptr %"tmp#3##0" + %"tmp#4##0" = add i64 %"#rec##0", 16 + %"tmp#5##0" = inttoptr i64 %"tmp#4##0" to ptr + store i64 %"z##0", ptr %"tmp#5##0" + %"tmp#6##0" = add i64 %"#rec##0", 24 + %"tmp#7##0" = inttoptr i64 %"tmp#6##0" to ptr + store i64 %"count##0", ptr %"tmp#7##0" + ret i64 %"#rec##0" } - -define external fastcc {i64, i64, i64, i64} @"drone.drone_info.drone_info<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#result##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#result##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = add i64 %"#result##0", 16 - %6 = inttoptr i64 %5 to i64* - %7 = load i64, i64* %6 - %8 = add i64 %"#result##0", 24 - %9 = inttoptr i64 %8 to i64* - %10 = load i64, i64* %9 - %11 = insertvalue {i64, i64, i64, i64} undef, i64 %1, 0 - %12 = insertvalue {i64, i64, i64, i64} %11, i64 %4, 1 - %13 = insertvalue {i64, i64, i64, i64} %12, i64 %7, 2 - %14 = insertvalue {i64, i64, i64, i64} %13, i64 %10, 3 - ret {i64, i64, i64, i64} %14 +define external fastcc {i64, i64, i64, i64} @"drone.drone_info.drone_info<1>"(i64 %"#result##0") { + %"tmp#0##0" = inttoptr i64 %"#result##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + %"tmp#2##0" = add i64 %"#result##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#3##0" + %"tmp#5##0" = add i64 %"#result##0", 16 + %"tmp#6##0" = inttoptr i64 %"tmp#5##0" to ptr + %"tmp#7##0" = load i64, ptr %"tmp#6##0" + %"tmp#8##0" = add i64 %"#result##0", 24 + %"tmp#9##0" = inttoptr i64 %"tmp#8##0" to ptr + %"tmp#10##0" = load i64, ptr %"tmp#9##0" + %"tmp#11##0" = insertvalue {i64, i64, i64, i64} undef, i64 %"tmp#1##0", 0 + %"tmp#12##0" = insertvalue {i64, i64, i64, i64} %"tmp#11##0", i64 %"tmp#4##0", 1 + %"tmp#13##0" = insertvalue {i64, i64, i64, i64} %"tmp#12##0", i64 %"tmp#7##0", 2 + %"tmp#14##0" = insertvalue {i64, i64, i64, i64} %"tmp#13##0", i64 %"tmp#10##0", 3 + ret {i64, i64, i64, i64} %"tmp#14##0" } - -define external fastcc i64 @"drone.drone_info.x<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#rec##0" to i64* - %1 = load i64, i64* %0 - ret i64 %1 +define external fastcc i64 @"drone.drone_info.x<0>"(i64 %"#rec##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + ret i64 %"tmp#1##0" } - -define external fastcc i64 @"drone.drone_info.x<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 32 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 32 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = inttoptr i64 %2 to i64* - store i64 %"#field##0", i64* %6 - ret i64 %2 +define external fastcc i64 @"drone.drone_info.x<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 32) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 32, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"#field##0", ptr %"tmp#3##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"drone.drone_info.y<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = add i64 %"#rec##0", 8 - %1 = inttoptr i64 %0 to i64* - %2 = load i64, i64* %1 - ret i64 %2 +define external fastcc i64 @"drone.drone_info.y<0>"(i64 %"#rec##0") { + %"tmp#0##0" = add i64 %"#rec##0", 8 + %"tmp#1##0" = inttoptr i64 %"tmp#0##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"drone.drone_info.y<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 32 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 32 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = add i64 %2, 8 - %7 = inttoptr i64 %6 to i64* - store i64 %"#field##0", i64* %7 - ret i64 %2 +define external fastcc i64 @"drone.drone_info.y<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 32) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 32, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = add i64 %"tmp#2##0", 8 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 %"#field##0", ptr %"tmp#4##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"drone.drone_info.z<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = add i64 %"#rec##0", 16 - %1 = inttoptr i64 %0 to i64* - %2 = load i64, i64* %1 - ret i64 %2 +define external fastcc i64 @"drone.drone_info.z<0>"(i64 %"#rec##0") { + %"tmp#0##0" = add i64 %"#rec##0", 16 + %"tmp#1##0" = inttoptr i64 %"tmp#0##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"drone.drone_info.z<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 32 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 32 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = add i64 %2, 16 - %7 = inttoptr i64 %6 to i64* - store i64 %"#field##0", i64* %7 - ret i64 %2 +define external fastcc i64 @"drone.drone_info.z<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 32) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 32, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = add i64 %"tmp#2##0", 16 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 %"#field##0", ptr %"tmp#4##0" + ret i64 %"tmp#2##0" } - -define external fastcc i1 @"drone.drone_info.~=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = add i64 %"#left##0", 16 - %6 = inttoptr i64 %5 to i64* - %7 = load i64, i64* %6 - %8 = add i64 %"#left##0", 24 - %9 = inttoptr i64 %8 to i64* - %10 = load i64, i64* %9 - %11 = inttoptr i64 %"#right##0" to i64* - %12 = load i64, i64* %11 - %13 = add i64 %"#right##0", 8 - %14 = inttoptr i64 %13 to i64* - %15 = load i64, i64* %14 - %16 = add i64 %"#right##0", 16 - %17 = inttoptr i64 %16 to i64* - %18 = load i64, i64* %17 - %19 = add i64 %"#right##0", 24 - %20 = inttoptr i64 %19 to i64* - %21 = load i64, i64* %20 - %22 = icmp eq i64 %1, %12 - br i1 %22, label %if.then, label %if.else -if.then: - %23 = icmp eq i64 %4, %15 - br i1 %23, label %if.then1, label %if.else1 -if.else: - %29 = xor i1 0, 1 - ret i1 %29 -if.then1: - %24 = icmp eq i64 %7, %18 - br i1 %24, label %if.then2, label %if.else2 -if.else1: - %28 = xor i1 0, 1 - ret i1 %28 -if.then2: - %25 = icmp eq i64 %21, %10 - %26 = xor i1 %25, 1 - ret i1 %26 -if.else2: - %27 = xor i1 0, 1 - ret i1 %27 +define external fastcc i1 @"drone.drone_info.~=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#14##0" = inttoptr i64 %"#left##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#14##0" + %"tmp#15##0" = add i64 %"#left##0", 8 + %"tmp#16##0" = inttoptr i64 %"tmp#15##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#16##0" + %"tmp#17##0" = add i64 %"#left##0", 16 + %"tmp#18##0" = inttoptr i64 %"tmp#17##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#18##0" + %"tmp#19##0" = add i64 %"#left##0", 24 + %"tmp#20##0" = inttoptr i64 %"tmp#19##0" to ptr + %"tmp#6##0" = load i64, ptr %"tmp#20##0" + %"tmp#21##0" = inttoptr i64 %"#right##0" to ptr + %"tmp#7##0" = load i64, ptr %"tmp#21##0" + %"tmp#22##0" = add i64 %"#right##0", 8 + %"tmp#23##0" = inttoptr i64 %"tmp#22##0" to ptr + %"tmp#8##0" = load i64, ptr %"tmp#23##0" + %"tmp#24##0" = add i64 %"#right##0", 16 + %"tmp#25##0" = inttoptr i64 %"tmp#24##0" to ptr + %"tmp#9##0" = load i64, ptr %"tmp#25##0" + %"tmp#26##0" = add i64 %"#right##0", 24 + %"tmp#27##0" = inttoptr i64 %"tmp#26##0" to ptr + %"tmp#10##0" = load i64, ptr %"tmp#27##0" + %"tmp#11##0" = icmp eq i64 %"tmp#3##0", %"tmp#7##0" + br i1 %"tmp#11##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#12##0" = icmp eq i64 %"tmp#4##0", %"tmp#8##0" + br i1 %"tmp#12##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#13##0" = icmp eq i64 %"tmp#5##0", %"tmp#9##0" + br i1 %"tmp#13##0", label %if.then.2, label %if.else.2 +if.then.2: + %"tmp#0##0" = icmp eq i64 %"tmp#10##0", %"tmp#6##0" + %"tmp#28##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#28##0" +if.else.2: + %"tmp#29##0" = xor i1 0, 1 + ret i1 %"tmp#29##0" +if.else.1: + %"tmp#30##0" = xor i1 0, 1 + ret i1 %"tmp#30##0" +if.else.0: + %"tmp#31##0" = xor i1 0, 1 + ret i1 %"tmp#31##0" } ---------------------------------------------------------------------- diff --git a/test-cases/complex/exp/testcase_multi_specz-int_list.exp b/test-cases/complex/exp/testcase_multi_specz-int_list.exp index 7e23b6662..0abb73fa2 100644 --- a/test-cases/complex/exp/testcase_multi_specz-int_list.exp +++ b/test-cases/complex/exp/testcase_multi_specz-int_list.exp @@ -91,7 +91,10 @@ tests without alias ---------------------------------------------------------------------- ====================================================================== AFTER BUILDING MAIN: - Module + + +-------------------------------------------------- + Module *main* module representation : (not a type) public submods : public resources: @@ -115,6 +118,7 @@ AFTER BUILDING MAIN: use wybe.list use wybe.machine_word use wybe.memory_management + use wybe.opaque_pointer use wybe.phantom use wybe.predicate use wybe.range @@ -123,7 +127,7 @@ AFTER BUILDING MAIN: procs : module top-level code > {terminal,inline,impure} (0 calls) -0: .<0> +0: *main* module.<0> (%argc##0:wybe.int, %argv##0:wybe.array.raw_array, %?exit_code##1:wybe.int)<{}; {<>}; {}>: AliasPairs: [] InterestingCallProperties: [] @@ -142,7 +146,8 @@ module top-level code > {terminal,inline,impure} (0 calls) foreign llvm move(0:wybe.int, ?%exit_code##1:wybe.int) foreign c {semipure,terminal} exit(0:wybe.int) -LLVM code : None + LLVM code : + -------------------------------------------------- Module command_line @@ -189,68 +194,7 @@ set_exit_code(code##0:wybe.int)<{}; {<>}; {}>: LLVM code : -; ModuleID = 'command_line' - - - - - -@"resource#command_line.argc" = global i64 undef - - -@"resource#command_line.arguments" = global i64 undef - - -@"resource#command_line.argv" = global i64 undef - - -@"resource#command_line.command" = global i64 undef - - -@"resource#command_line.exit_code" = global i64 undef - - -@command_line.1 = constant [?? x i8] c"Erroneous program argument vector\00" - - -@command_line.0 = constant [?? x i8] c"command_line:18:15\00" - - -declare external ccc void @error_exit(i64, i64) - - -declare external fastcc {i64, i64, i1} @"wybe.array.[|]<0>"(i64) - - -declare external ccc i8* @wybe_malloc(i32) - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"command_line.<0>"() { -entry: - %0 = load i64, i64* @"resource#command_line.arguments" - %1 = tail call fastcc {i64, i64, i1} @"wybe.array.[|]<0>"(i64 %0) - %2 = extractvalue {i64, i64, i1} %1, 0 - %3 = extractvalue {i64, i64, i1} %1, 1 - %4 = extractvalue {i64, i64, i1} %1, 2 - br i1 %4, label %if.then, label %if.else -if.then: - store i64 %3, i64* @"resource#command_line.arguments" - store i64 %2, i64* @"resource#command_line.command" - ret void -if.else: - tail call ccc void @error_exit(i64 ptrtoint (i8* getelementptr inbounds ([?? x i8], [?? x i8]* @command_line.0, i32 0, i32 0) to i64), i64 ptrtoint (i8* getelementptr inbounds ([?? x i8], [?? x i8]* @command_line.1, i32 0, i32 0) to i64)) - ret void -} - - -define external fastcc void @"command_line.set_exit_code<0>"(i64 %"code##0") alwaysinline { -entry: - store i64 %"code##0", i64* @"resource#command_line.exit_code" - ret void -} -------------------------------------------------- Module int_list representation : (not a type) @@ -651,11 +595,12 @@ sort(lst##0:int_list.int_list, ?#result##0:int_list.int_list)<{}; {}; {}>: int_list.extend<0>[410bae77d3](~tmp#2##0:int_list.int_list, ~tmp#15##0:int_list.int_list, outByReference #result##0:int_list.int_list) #6 @int_list:nn:nn -LLVM code : None + LLVM code : + -------------------------------------------------- Module int_list.int_list - representation : address + representation : pointer public submods : public resources: public procs : int_list.int_list.=<0> @@ -812,7 +757,8 @@ proc ~= > public {inline} (0 calls) int_list.int_list.=<0>(~#left##0:int_list.int_list, ~#right##0:int_list.int_list, ?tmp#0##0:wybe.bool) #0 foreign llvm xor(~tmp#0##0:wybe.bool, 1:wybe.bool, ?#success##0:wybe.bool) -LLVM code : None + LLVM code : + -------------------------------------------------- Module int_list_test @@ -975,11 +921,14 @@ test_int_list(x##0:int_list.int_list, y##0:int_list.int_list, z##0:int_list.int_ foreign c putchar('\n':wybe.char, ~tmp#36##0:wybe.phantom, ?tmp#37##0:wybe.phantom) @int_list_test:nn:nn foreign lpvm store(~%tmp#37##0:wybe.phantom, <>:wybe.phantom) @int_list_test:nn:nn -LLVM code : None + LLVM code : ====================================================================== AFTER EVERYTHING: - Module + + +-------------------------------------------------- + Module *main* module representation : (not a type) public submods : public resources: @@ -1003,6 +952,7 @@ AFTER EVERYTHING: use wybe.list use wybe.machine_word use wybe.memory_management + use wybe.opaque_pointer use wybe.phantom use wybe.predicate use wybe.range @@ -1011,7 +961,7 @@ AFTER EVERYTHING: procs : module top-level code > {terminal,inline,impure} (0 calls) -0: .<0> +0: *main* module.<0> (%argc##0:wybe.int, %argv##0:wybe.array.raw_array, %?exit_code##1:wybe.int)<{}; {<>}; {}>: AliasPairs: [] InterestingCallProperties: [] @@ -1032,69 +982,46 @@ module top-level code > {terminal,inline,impure} (0 calls) LLVM code : -; ModuleID = '' - - - - - -@"resource#command_line.argc" = external global i64 - - -@"resource#command_line.arguments" = external global i64 - - -@"resource#command_line.argv" = external global i64 - - -@"resource#command_line.command" = external global i64 - - -@"resource#command_line.exit_code" = external global i64 - - -@.0 = constant [?? x i8] c"\00" - - -declare external ccc void @exit(i64) - - -declare external fastcc void @"command_line.<0>"() - - -declare external fastcc void @"int_list_test.<0>"() - - -declare external ccc void @gc_init() - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external ccc i64 @main(i64 %"argc##0", i64 %"argv##0") alwaysinline { -entry: - store i64 %"argc##0", i64* @"resource#command_line.argc" - store i64 %"argv##0", i64* @"resource#command_line.argv" - tail call ccc void @gc_init() - tail call fastcc void @"int_list_test.<0>"() - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"argc##0", i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"argv##0", i64* %5 - store i64 %2, i64* @"resource#command_line.arguments" - store i64 ptrtoint (i8* getelementptr inbounds ([?? x i8], [?? x i8]* @.0, i32 0, i32 0) to i64), i64* @"resource#command_line.command" - store i64 0, i64* @"resource#command_line.exit_code" - tail call fastcc void @"command_line.<0>"() - tail call ccc void @exit(i64 0) - ret i64 0 +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe +; ModuleID = '*main* module' + +source_filename = "/private!TMP!/int_list_test" +target triple = ??? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c"\00", align 8 + +declare external fastcc void @"command_line.<0>"() +declare external fastcc void @"int_list_test.<0>"() +@"resource#command_line.argc" = external global i64 +@"resource#command_line.arguments" = external global i64 +@"resource#command_line.argv" = external global i64 +@"resource#command_line.command" = external global i64 +@"resource#command_line.exit_code" = external global i64 +declare external ccc void @exit(i64) +declare external ccc void @gc_init() +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external ccc i64 @main(i64 %"argc##0", i64 %"argv##0") { + store i64 %"argc##0", ptr @"resource#command_line.argc" + store i64 %"argv##0", ptr @"resource#command_line.argv" + call ccc void @gc_init() + tail call fastcc void @"int_list_test.<0>"() + %"tmp#11##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#9##0" = ptrtoint ptr %"tmp#11##0" to i64 + %"tmp#12##0" = inttoptr i64 %"tmp#9##0" to ptr + store i64 %"argc##0", ptr %"tmp#12##0" + %"tmp#13##0" = add i64 %"tmp#9##0", 8 + %"tmp#14##0" = inttoptr i64 %"tmp#13##0" to ptr + store i64 %"argv##0", ptr %"tmp#14##0" + store i64 %"tmp#9##0", ptr @"resource#command_line.arguments" + store i64 ptrtoint( ptr @"cstring#0" to i64 ), ptr @"resource#command_line.command" + store i64 0, ptr @"resource#command_line.exit_code" + tail call fastcc void @"command_line.<0>"() + call ccc void @exit(i64 0) + ret i64 0 } + -------------------------------------------------- Module command_line representation : (not a type) @@ -1140,68 +1067,45 @@ set_exit_code(code##0:wybe.int)<{}; {<>}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'command_line' - - - - -@"resource#command_line.argc" = global i64 undef - - -@"resource#command_line.arguments" = global i64 undef - - -@"resource#command_line.argv" = global i64 undef - - -@"resource#command_line.command" = global i64 undef - - -@"resource#command_line.exit_code" = global i64 undef - - -@command_line.1 = constant [?? x i8] c"Erroneous program argument vector\00" - - -@command_line.0 = constant [?? x i8] c"command_line:18:15\00" - - -declare external ccc void @error_exit(i64, i64) - - -declare external fastcc {i64, i64, i1} @"wybe.array.[|]<0>"(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"command_line.<0>"() { -entry: - %0 = load i64, i64* @"resource#command_line.arguments" - %1 = tail call fastcc {i64, i64, i1} @"wybe.array.[|]<0>"(i64 %0) - %2 = extractvalue {i64, i64, i1} %1, 0 - %3 = extractvalue {i64, i64, i1} %1, 1 - %4 = extractvalue {i64, i64, i1} %1, 2 - br i1 %4, label %if.then, label %if.else -if.then: - store i64 %3, i64* @"resource#command_line.arguments" - store i64 %2, i64* @"resource#command_line.command" - ret void -if.else: - tail call ccc void @error_exit(i64 ptrtoint (i8* getelementptr inbounds ([?? x i8], [?? x i8]* @command_line.0, i32 0, i32 0) to i64), i64 ptrtoint (i8* getelementptr inbounds ([?? x i8], [?? x i8]* @command_line.1, i32 0, i32 0) to i64)) - ret void +source_filename = "!ROOT!/wybelibs/command_line.o" +target triple = ??? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c"Erroneous program argument vector\00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c"command_line:18:15\00", align 8 + +declare external fastcc {i64, i64, i1} @"wybe.array.[|]<0>"(i64) +declare external ccc void @error_exit(i64, i64) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) +@"resource#command_line.argc" = global i64 undef +@"resource#command_line.arguments" = global i64 undef +@"resource#command_line.argv" = global i64 undef +@"resource#command_line.command" = global i64 undef +@"resource#command_line.exit_code" = global i64 undef + +define external fastcc void @"command_line.<0>"() { + %"arguments##0" = load i64, ptr @"resource#command_line.arguments" + %"tmp#11##0" = tail call fastcc {i64, i64, i1} @"wybe.array.[|]<0>"(i64 %"arguments##0") + %"command##1" = extractvalue {i64, i64, i1}%"tmp#11##0", 0 + %"arguments##2" = extractvalue {i64, i64, i1}%"tmp#11##0", 1 + %"tmp#8##0" = extractvalue {i64, i64, i1}%"tmp#11##0", 2 + br i1 %"tmp#8##0", label %if.then.0, label %if.else.0 +if.then.0: + store i64 %"arguments##2", ptr @"resource#command_line.arguments" + store i64 %"command##1", ptr @"resource#command_line.command" + ret void +if.else.0: + call ccc void @error_exit(i64 ptrtoint( ptr @"cstring#1" to i64 ), i64 ptrtoint( ptr @"cstring#0" to i64 )) + ret void } - -define external fastcc void @"command_line.set_exit_code<0>"(i64 %"code##0") alwaysinline { -entry: - store i64 %"code##0", i64* @"resource#command_line.exit_code" - ret void +define external fastcc void @"command_line.set_exit_code<0>"(i64 %"code##0") { + store i64 %"code##0", ptr @"resource#command_line.exit_code" + ret void } + -------------------------------------------------- Module int_list representation : (not a type) @@ -1317,7 +1221,7 @@ extend(lst1##0:int_list.int_list, lst2##0:int_list.int_list, outByReference #res proc greater > (3 calls) -0: int_list.greater<0>[410bae77d3] +0: int_list.greater<0> greater(lst##0:int_list.int_list, v##0:wybe.int, outByReference #result##0:int_list.int_list)<{}; {}; {}>: AliasPairs: [] InterestingCallProperties: [InterestingUnaliased 0] @@ -1566,7 +1470,7 @@ range(start##0:wybe.int, stop##0:wybe.int, step##0:wybe.int, ?result##1:int_list proc range#cont#1 > (2 calls) -0: int_list.range#cont#1<0> +0: int_list.range#cont#1<0>[410bae77d3] range#cont#1(result##0:int_list.int_list, start##0:wybe.int, step##0:wybe.int, stop##0:wybe.int, ?result##1:int_list.int_list)<{}; {}; {}>: AliasPairs: [] InterestingCallProperties: [InterestingUnaliased 0] @@ -1739,659 +1643,584 @@ sort(lst##0:int_list.int_list, ?#result##0:int_list.int_list)<{}; {}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'int_list' - - - - -declare external ccc void @putchar(i8) - - -declare external ccc void @print_int(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i64 @"int_list.append<0>"(i64 %"lst##0", i64 %"v##0") { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"v##0", i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 0, i64* %5 - %6 = alloca i64 - call fastcc void @"int_list.extend<0>"(i64 %"lst##0", i64 %2, i64* %6) - %7 = load i64, i64* %6 - ret i64 %7 +source_filename = "/private!TMP!/int_list.wybe" +target triple = ??? + + +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc i64 @"int_list.append<0>"(i64 %"lst##0", i64 %"v##0") { + %"tmp#8##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#5##0" = ptrtoint ptr %"tmp#8##0" to i64 + %"tmp#9##0" = inttoptr i64 %"tmp#5##0" to ptr + store i64 %"v##0", ptr %"tmp#9##0" + %"tmp#10##0" = add i64 %"tmp#5##0", 8 + %"tmp#11##0" = inttoptr i64 %"tmp#10##0" to ptr + store i64 0, ptr %"tmp#11##0" + %"tmp#12##0" = alloca i8, i64 8, align 8 + call fastcc void @"int_list.extend<0>"(i64 %"lst##0", i64 %"tmp#5##0", ptr %"tmp#12##0") + %"tmp#13##0" = load i64, ptr %"tmp#12##0" + ret i64 %"tmp#13##0" } - -define external fastcc i64 @"int_list.append<0>[410bae77d3]"(i64 %"lst##0", i64 %"v##0") { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"v##0", i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 0, i64* %5 - %6 = alloca i64 - call fastcc void @"int_list.extend<0>[410bae77d3]"(i64 %"lst##0", i64 %2, i64* %6) - %7 = load i64, i64* %6 - ret i64 %7 +define external fastcc i64 @"int_list.append<0>[410bae77d3]"(i64 %"lst##0", i64 %"v##0") { + %"tmp#8##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#5##0" = ptrtoint ptr %"tmp#8##0" to i64 + %"tmp#9##0" = inttoptr i64 %"tmp#5##0" to ptr + store i64 %"v##0", ptr %"tmp#9##0" + %"tmp#10##0" = add i64 %"tmp#5##0", 8 + %"tmp#11##0" = inttoptr i64 %"tmp#10##0" to ptr + store i64 0, ptr %"tmp#11##0" + %"tmp#12##0" = alloca i8, i64 8, align 8 + call fastcc void @"int_list.extend<0>[410bae77d3]"(i64 %"lst##0", i64 %"tmp#5##0", ptr %"tmp#12##0") + %"tmp#13##0" = load i64, ptr %"tmp#12##0" + ret i64 %"tmp#13##0" } - -define external fastcc i64 @"int_list.count<0>"(i64 %"lst##0", i64 %"x##0") { -entry: - %0 = icmp ne i64 %"lst##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"lst##0" to i64* - %2 = load i64, i64* %1 - %3 = add i64 %"lst##0", 8 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = tail call fastcc i64 @"int_list.count<0>"(i64 %5, i64 %"x##0") - %7 = icmp eq i64 %2, %"x##0" - br i1 %7, label %if.then1, label %if.else1 -if.else: - ret i64 0 -if.then1: - %8 = add i64 %6, 1 - ret i64 %8 -if.else1: - ret i64 %6 +define external fastcc i64 @"int_list.count<0>"(i64 %"lst##0", i64 %"x##0") { + %"tmp#7##0" = icmp ne i64 %"lst##0", 0 + br i1 %"tmp#7##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#14##0" = inttoptr i64 %"lst##0" to ptr + %"h##0" = load i64, ptr %"tmp#14##0" + %"tmp#15##0" = add i64 %"lst##0", 8 + %"tmp#16##0" = inttoptr i64 %"tmp#15##0" to ptr + %"t##0" = load i64, ptr %"tmp#16##0" + %"tmp#2##0" = tail call fastcc i64 @"int_list.count<0>"(i64 %"t##0", i64 %"x##0") + %"tmp#4##0" = icmp eq i64 %"h##0", %"x##0" + br i1 %"tmp#4##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#17##0" = add i64 %"tmp#2##0", 1 + ret i64 %"tmp#17##0" +if.else.1: + ret i64 %"tmp#2##0" +if.else.0: + ret i64 0 } - -define external fastcc i64 @"int_list.count#cont#1<0>"(i64 %"tmp#2##0", i64 %"tmp#3##0") alwaysinline { -entry: - %0 = add i64 %"tmp#2##0", %"tmp#3##0" - ret i64 %0 +define external fastcc i64 @"int_list.count#cont#1<0>"(i64 %"tmp#2##0", i64 %"tmp#3##0") { + %"tmp#6##0" = add i64 %"tmp#2##0", %"tmp#3##0" + ret i64 %"tmp#6##0" } - -define external fastcc void @"int_list.extend<0>"(i64 %"lst1##0", i64 %"lst2##0", i64* %"#result##0") { -entry: - %0 = icmp ne i64 %"lst1##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"lst1##0" to i64* - %2 = load i64, i64* %1 - %3 = add i64 %"lst1##0", 8 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = trunc i64 16 to i32 - %7 = tail call ccc i8* @wybe_malloc(i32 %6) - %8 = ptrtoint i8* %7 to i64 - %9 = inttoptr i64 %8 to i64* - store i64 %2, i64* %9 - %10 = add i64 %8, 8 - %11 = inttoptr i64 %10 to i64* - store i64 %8, i64* %"#result##0" - musttail call fastcc void @"int_list.extend<0>"(i64 %5, i64 %"lst2##0", i64* %11) - ret void -if.else: - store i64 %"lst2##0", i64* %"#result##0" - ret void +define external fastcc void @"int_list.extend<0>"(i64 %"lst1##0", i64 %"lst2##0", ptr %"tmp#11##0") { + %"tmp#5##0" = icmp ne i64 %"lst1##0", 0 + br i1 %"tmp#5##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#12##0" = inttoptr i64 %"lst1##0" to ptr + %"h##0" = load i64, ptr %"tmp#12##0" + %"tmp#13##0" = add i64 %"lst1##0", 8 + %"tmp#14##0" = inttoptr i64 %"tmp#13##0" to ptr + %"t##0" = load i64, ptr %"tmp#14##0" + %"tmp#15##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#8##0" = ptrtoint ptr %"tmp#15##0" to i64 + %"tmp#16##0" = inttoptr i64 %"tmp#8##0" to ptr + store i64 %"h##0", ptr %"tmp#16##0" + store i64 %"tmp#8##0", ptr %"tmp#11##0" + %"tmp#17##0" = add i64 %"tmp#8##0", 8 + %"tmp#18##0" = inttoptr i64 %"tmp#17##0" to ptr + musttail call fastcc void @"int_list.extend<0>"(i64 %"t##0", i64 %"lst2##0", ptr %"tmp#18##0") + ret void +if.else.0: + store i64 %"lst2##0", ptr %"tmp#11##0" + ret void } - -define external fastcc void @"int_list.extend<0>[410bae77d3]"(i64 %"lst1##0", i64 %"lst2##0", i64* %"#result##0") { -entry: - %0 = icmp ne i64 %"lst1##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = add i64 %"lst1##0", 8 - %2 = inttoptr i64 %1 to i64* - %3 = load i64, i64* %2 - %4 = add i64 %"lst1##0", 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"lst1##0", i64* %"#result##0" - musttail call fastcc void @"int_list.extend<0>[410bae77d3]"(i64 %3, i64 %"lst2##0", i64* %5) - ret void -if.else: - store i64 %"lst2##0", i64* %"#result##0" - ret void +define external fastcc void @"int_list.extend<0>[410bae77d3]"(i64 %"lst1##0", i64 %"lst2##0", ptr %"tmp#11##0") { + %"tmp#5##0" = icmp ne i64 %"lst1##0", 0 + br i1 %"tmp#5##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#12##0" = add i64 %"lst1##0", 8 + %"tmp#13##0" = inttoptr i64 %"tmp#12##0" to ptr + %"t##0" = load i64, ptr %"tmp#13##0" + store i64 %"lst1##0", ptr %"tmp#11##0" + %"tmp#14##0" = add i64 %"lst1##0", 8 + %"tmp#15##0" = inttoptr i64 %"tmp#14##0" to ptr + musttail call fastcc void @"int_list.extend<0>[410bae77d3]"(i64 %"t##0", i64 %"lst2##0", ptr %"tmp#15##0") + ret void +if.else.0: + store i64 %"lst2##0", ptr %"tmp#11##0" + ret void } - -define external fastcc void @"int_list.greater<0>"(i64 %"lst##0", i64 %"v##0", i64* %"#result##0") { -entry: - %0 = icmp ne i64 %"lst##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"lst##0" to i64* - %2 = load i64, i64* %1 - %3 = add i64 %"lst##0", 8 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = icmp sge i64 %2, %"v##0" - br i1 %6, label %if.then1, label %if.else1 -if.else: - store i64 0, i64* %"#result##0" - ret void -if.then1: - %7 = trunc i64 16 to i32 - %8 = tail call ccc i8* @wybe_malloc(i32 %7) - %9 = ptrtoint i8* %8 to i64 - %10 = inttoptr i64 %9 to i64* - store i64 %2, i64* %10 - %11 = add i64 %9, 8 - %12 = inttoptr i64 %11 to i64* - store i64 %9, i64* %"#result##0" - musttail call fastcc void @"int_list.greater<0>"(i64 %5, i64 %"v##0", i64* %12) - ret void -if.else1: - musttail call fastcc void @"int_list.greater<0>"(i64 %5, i64 %"v##0", i64* %"#result##0") - ret void +define external fastcc void @"int_list.greater<0>"(i64 %"lst##0", i64 %"v##0", ptr %"tmp#17##0") { + %"tmp#9##0" = icmp ne i64 %"lst##0", 0 + br i1 %"tmp#9##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#18##0" = inttoptr i64 %"lst##0" to ptr + %"h##0" = load i64, ptr %"tmp#18##0" + %"tmp#19##0" = add i64 %"lst##0", 8 + %"tmp#20##0" = inttoptr i64 %"tmp#19##0" to ptr + %"t##0" = load i64, ptr %"tmp#20##0" + %"tmp#6##0" = icmp sge i64 %"h##0", %"v##0" + br i1 %"tmp#6##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#21##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#14##0" = ptrtoint ptr %"tmp#21##0" to i64 + %"tmp#22##0" = inttoptr i64 %"tmp#14##0" to ptr + store i64 %"h##0", ptr %"tmp#22##0" + store i64 %"tmp#14##0", ptr %"tmp#17##0" + %"tmp#23##0" = add i64 %"tmp#14##0", 8 + %"tmp#24##0" = inttoptr i64 %"tmp#23##0" to ptr + musttail call fastcc void @"int_list.greater<0>"(i64 %"t##0", i64 %"v##0", ptr %"tmp#24##0") + ret void +if.else.1: + musttail call fastcc void @"int_list.greater<0>"(i64 %"t##0", i64 %"v##0", ptr %"tmp#17##0") + ret void +if.else.0: + store i64 0, ptr %"tmp#17##0" + ret void } - -define external fastcc void @"int_list.greater<0>[410bae77d3]"(i64 %"lst##0", i64 %"v##0", i64* %"#result##0") { -entry: - %0 = icmp ne i64 %"lst##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"lst##0" to i64* - %2 = load i64, i64* %1 - %3 = add i64 %"lst##0", 8 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = icmp sge i64 %2, %"v##0" - br i1 %6, label %if.then1, label %if.else1 -if.else: - store i64 0, i64* %"#result##0" - ret void -if.then1: - %7 = add i64 %"lst##0", 8 - %8 = inttoptr i64 %7 to i64* - store i64 %"lst##0", i64* %"#result##0" - musttail call fastcc void @"int_list.greater<0>[410bae77d3]"(i64 %5, i64 %"v##0", i64* %8) - ret void -if.else1: - musttail call fastcc void @"int_list.greater<0>[410bae77d3]"(i64 %5, i64 %"v##0", i64* %"#result##0") - ret void +define external fastcc void @"int_list.greater<0>[410bae77d3]"(i64 %"lst##0", i64 %"v##0", ptr %"tmp#17##0") { + %"tmp#9##0" = icmp ne i64 %"lst##0", 0 + br i1 %"tmp#9##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#18##0" = inttoptr i64 %"lst##0" to ptr + %"h##0" = load i64, ptr %"tmp#18##0" + %"tmp#19##0" = add i64 %"lst##0", 8 + %"tmp#20##0" = inttoptr i64 %"tmp#19##0" to ptr + %"t##0" = load i64, ptr %"tmp#20##0" + %"tmp#6##0" = icmp sge i64 %"h##0", %"v##0" + br i1 %"tmp#6##0", label %if.then.1, label %if.else.1 +if.then.1: + store i64 %"lst##0", ptr %"tmp#17##0" + %"tmp#21##0" = add i64 %"lst##0", 8 + %"tmp#22##0" = inttoptr i64 %"tmp#21##0" to ptr + musttail call fastcc void @"int_list.greater<0>[410bae77d3]"(i64 %"t##0", i64 %"v##0", ptr %"tmp#22##0") + ret void +if.else.1: + musttail call fastcc void @"int_list.greater<0>[410bae77d3]"(i64 %"t##0", i64 %"v##0", ptr %"tmp#17##0") + ret void +if.else.0: + store i64 0, ptr %"tmp#17##0" + ret void } - -define external fastcc i64 @"int_list.index<0>"(i64 %"lst##0", i64 %"x##0") alwaysinline { -entry: - %0 = tail call fastcc i64 @"int_list.index_helper<0>"(i64 %"lst##0", i64 0, i64 %"x##0") - ret i64 %0 +define external fastcc i64 @"int_list.index<0>"(i64 %"lst##0", i64 %"x##0") { + %"tmp#1##0" = tail call fastcc i64 @"int_list.index_helper<0>"(i64 %"lst##0", i64 0, i64 %"x##0") + ret i64 %"tmp#1##0" } - -define external fastcc i64 @"int_list.index_helper<0>"(i64 %"lst##0", i64 %"idx##0", i64 %"x##0") { -entry: - %0 = icmp ne i64 %"lst##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"lst##0" to i64* - %2 = load i64, i64* %1 - %3 = add i64 %"lst##0", 8 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = icmp eq i64 %2, %"x##0" - br i1 %6, label %if.then1, label %if.else1 -if.else: - ret i64 -1 -if.then1: - ret i64 %"idx##0" -if.else1: - %7 = add i64 %"idx##0", 1 - %8 = musttail call fastcc i64 @"int_list.index_helper<0>"(i64 %5, i64 %7, i64 %"x##0") - ret i64 %8 +define external fastcc i64 @"int_list.index_helper<0>"(i64 %"lst##0", i64 %"idx##0", i64 %"x##0") { + %"tmp#7##0" = icmp ne i64 %"lst##0", 0 + br i1 %"tmp#7##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#12##0" = inttoptr i64 %"lst##0" to ptr + %"h##0" = load i64, ptr %"tmp#12##0" + %"tmp#13##0" = add i64 %"lst##0", 8 + %"tmp#14##0" = inttoptr i64 %"tmp#13##0" to ptr + %"t##0" = load i64, ptr %"tmp#14##0" + %"tmp#4##0" = icmp eq i64 %"h##0", %"x##0" + br i1 %"tmp#4##0", label %if.then.1, label %if.else.1 +if.then.1: + ret i64 %"idx##0" +if.else.1: + %"tmp#3##0" = add i64 %"idx##0", 1 + %"tmp#15##0" = tail call fastcc i64 @"int_list.index_helper<0>"(i64 %"t##0", i64 %"tmp#3##0", i64 %"x##0") + ret i64 %"tmp#15##0" +if.else.0: + ret i64 -1 } - -define external fastcc void @"int_list.insert<0>"(i64 %"lst##0", i64 %"idx##0", i64 %"v##0", i64* %"#result##0") { -entry: - %0 = icmp eq i64 %"idx##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = trunc i64 16 to i32 - %2 = tail call ccc i8* @wybe_malloc(i32 %1) - %3 = ptrtoint i8* %2 to i64 - %4 = inttoptr i64 %3 to i64* - store i64 %"v##0", i64* %4 - %5 = add i64 %3, 8 - %6 = inttoptr i64 %5 to i64* - store i64 %"lst##0", i64* %6 - store i64 %3, i64* %"#result##0" - ret void -if.else: - %7 = icmp ne i64 %"lst##0", 0 - br i1 %7, label %if.then1, label %if.else1 -if.then1: - %8 = inttoptr i64 %"lst##0" to i64* - %9 = load i64, i64* %8 - %10 = add i64 %"lst##0", 8 - %11 = inttoptr i64 %10 to i64* - %12 = load i64, i64* %11 - %13 = sub i64 %"idx##0", 1 - %14 = trunc i64 16 to i32 - %15 = tail call ccc i8* @wybe_malloc(i32 %14) - %16 = ptrtoint i8* %15 to i64 - %17 = inttoptr i64 %16 to i64* - store i64 %9, i64* %17 - %18 = add i64 %16, 8 - %19 = inttoptr i64 %18 to i64* - store i64 %16, i64* %"#result##0" - musttail call fastcc void @"int_list.insert<0>"(i64 %12, i64 %13, i64 %"v##0", i64* %19) - ret void -if.else1: - %20 = sub i64 %"idx##0", 1 - musttail call fastcc void @"int_list.insert<0>"(i64 0, i64 %20, i64 %"v##0", i64* %"#result##0") - ret void +define external fastcc void @"int_list.insert<0>"(i64 %"lst##0", i64 %"idx##0", i64 %"v##0", ptr %"tmp#28##0") { + %"tmp#9##0" = icmp eq i64 %"idx##0", 0 + br i1 %"tmp#9##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#29##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#25##0" = ptrtoint ptr %"tmp#29##0" to i64 + %"tmp#30##0" = inttoptr i64 %"tmp#25##0" to ptr + store i64 %"v##0", ptr %"tmp#30##0" + store i64 %"tmp#25##0", ptr %"tmp#28##0" + %"tmp#31##0" = add i64 %"tmp#25##0", 8 + %"tmp#32##0" = inttoptr i64 %"tmp#31##0" to ptr + store i64 %"lst##0", ptr %"tmp#32##0" + ret void +if.else.0: + %"tmp#13##0" = icmp ne i64 %"lst##0", 0 + br i1 %"tmp#13##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#33##0" = inttoptr i64 %"lst##0" to ptr + %"h##0" = load i64, ptr %"tmp#33##0" + %"tmp#34##0" = add i64 %"lst##0", 8 + %"tmp#35##0" = inttoptr i64 %"tmp#34##0" to ptr + %"t##0" = load i64, ptr %"tmp#35##0" + %"tmp#5##0" = sub i64 %"idx##0", 1 + %"tmp#36##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#20##0" = ptrtoint ptr %"tmp#36##0" to i64 + %"tmp#37##0" = inttoptr i64 %"tmp#20##0" to ptr + store i64 %"h##0", ptr %"tmp#37##0" + store i64 %"tmp#20##0", ptr %"tmp#28##0" + %"tmp#38##0" = add i64 %"tmp#20##0", 8 + %"tmp#39##0" = inttoptr i64 %"tmp#38##0" to ptr + musttail call fastcc void @"int_list.insert<0>"(i64 %"t##0", i64 %"tmp#5##0", i64 %"v##0", ptr %"tmp#39##0") + ret void +if.else.1: + %"tmp#7##0" = sub i64 %"idx##0", 1 + musttail call fastcc void @"int_list.insert<0>"(i64 0, i64 %"tmp#7##0", i64 %"v##0", ptr %"tmp#28##0") + ret void } - -define external fastcc void @"int_list.insert<0>[410bae77d3]"(i64 %"lst##0", i64 %"idx##0", i64 %"v##0", i64* %"#result##0") { -entry: - %0 = icmp eq i64 %"idx##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = trunc i64 16 to i32 - %2 = tail call ccc i8* @wybe_malloc(i32 %1) - %3 = ptrtoint i8* %2 to i64 - %4 = inttoptr i64 %3 to i64* - store i64 %"v##0", i64* %4 - %5 = add i64 %3, 8 - %6 = inttoptr i64 %5 to i64* - store i64 %"lst##0", i64* %6 - store i64 %3, i64* %"#result##0" - ret void -if.else: - %7 = icmp ne i64 %"lst##0", 0 - br i1 %7, label %if.then1, label %if.else1 -if.then1: - %8 = add i64 %"lst##0", 8 - %9 = inttoptr i64 %8 to i64* - %10 = load i64, i64* %9 - %11 = sub i64 %"idx##0", 1 - %12 = add i64 %"lst##0", 8 - %13 = inttoptr i64 %12 to i64* - store i64 %"lst##0", i64* %"#result##0" - musttail call fastcc void @"int_list.insert<0>[410bae77d3]"(i64 %10, i64 %11, i64 %"v##0", i64* %13) - ret void -if.else1: - %14 = sub i64 %"idx##0", 1 - musttail call fastcc void @"int_list.insert<0>[410bae77d3]"(i64 0, i64 %14, i64 %"v##0", i64* %"#result##0") - ret void +define external fastcc void @"int_list.insert<0>[410bae77d3]"(i64 %"lst##0", i64 %"idx##0", i64 %"v##0", ptr %"tmp#28##0") { + %"tmp#9##0" = icmp eq i64 %"idx##0", 0 + br i1 %"tmp#9##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#29##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#25##0" = ptrtoint ptr %"tmp#29##0" to i64 + %"tmp#30##0" = inttoptr i64 %"tmp#25##0" to ptr + store i64 %"v##0", ptr %"tmp#30##0" + store i64 %"tmp#25##0", ptr %"tmp#28##0" + %"tmp#31##0" = add i64 %"tmp#25##0", 8 + %"tmp#32##0" = inttoptr i64 %"tmp#31##0" to ptr + store i64 %"lst##0", ptr %"tmp#32##0" + ret void +if.else.0: + %"tmp#13##0" = icmp ne i64 %"lst##0", 0 + br i1 %"tmp#13##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#33##0" = add i64 %"lst##0", 8 + %"tmp#34##0" = inttoptr i64 %"tmp#33##0" to ptr + %"t##0" = load i64, ptr %"tmp#34##0" + %"tmp#5##0" = sub i64 %"idx##0", 1 + store i64 %"lst##0", ptr %"tmp#28##0" + %"tmp#35##0" = add i64 %"lst##0", 8 + %"tmp#36##0" = inttoptr i64 %"tmp#35##0" to ptr + musttail call fastcc void @"int_list.insert<0>[410bae77d3]"(i64 %"t##0", i64 %"tmp#5##0", i64 %"v##0", ptr %"tmp#36##0") + ret void +if.else.1: + %"tmp#7##0" = sub i64 %"idx##0", 1 + musttail call fastcc void @"int_list.insert<0>[410bae77d3]"(i64 0, i64 %"tmp#7##0", i64 %"v##0", ptr %"tmp#28##0") + ret void } - -define external fastcc void @"int_list.lesser<0>"(i64 %"lst##0", i64 %"v##0", i64* %"#result##0") { -entry: - %0 = icmp ne i64 %"lst##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"lst##0" to i64* - %2 = load i64, i64* %1 - %3 = add i64 %"lst##0", 8 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = icmp slt i64 %2, %"v##0" - br i1 %6, label %if.then1, label %if.else1 -if.else: - store i64 0, i64* %"#result##0" - ret void -if.then1: - %7 = trunc i64 16 to i32 - %8 = tail call ccc i8* @wybe_malloc(i32 %7) - %9 = ptrtoint i8* %8 to i64 - %10 = inttoptr i64 %9 to i64* - store i64 %2, i64* %10 - %11 = add i64 %9, 8 - %12 = inttoptr i64 %11 to i64* - store i64 %9, i64* %"#result##0" - musttail call fastcc void @"int_list.lesser<0>"(i64 %5, i64 %"v##0", i64* %12) - ret void -if.else1: - musttail call fastcc void @"int_list.lesser<0>"(i64 %5, i64 %"v##0", i64* %"#result##0") - ret void +define external fastcc void @"int_list.lesser<0>"(i64 %"lst##0", i64 %"v##0", ptr %"tmp#17##0") { + %"tmp#9##0" = icmp ne i64 %"lst##0", 0 + br i1 %"tmp#9##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#18##0" = inttoptr i64 %"lst##0" to ptr + %"h##0" = load i64, ptr %"tmp#18##0" + %"tmp#19##0" = add i64 %"lst##0", 8 + %"tmp#20##0" = inttoptr i64 %"tmp#19##0" to ptr + %"t##0" = load i64, ptr %"tmp#20##0" + %"tmp#6##0" = icmp slt i64 %"h##0", %"v##0" + br i1 %"tmp#6##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#21##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#14##0" = ptrtoint ptr %"tmp#21##0" to i64 + %"tmp#22##0" = inttoptr i64 %"tmp#14##0" to ptr + store i64 %"h##0", ptr %"tmp#22##0" + store i64 %"tmp#14##0", ptr %"tmp#17##0" + %"tmp#23##0" = add i64 %"tmp#14##0", 8 + %"tmp#24##0" = inttoptr i64 %"tmp#23##0" to ptr + musttail call fastcc void @"int_list.lesser<0>"(i64 %"t##0", i64 %"v##0", ptr %"tmp#24##0") + ret void +if.else.1: + musttail call fastcc void @"int_list.lesser<0>"(i64 %"t##0", i64 %"v##0", ptr %"tmp#17##0") + ret void +if.else.0: + store i64 0, ptr %"tmp#17##0" + ret void } - -define external fastcc void @"int_list.pop<0>"(i64 %"lst##0", i64 %"idx##0", i64* %"#result##0") { -entry: - %0 = icmp ne i64 %"lst##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"lst##0" to i64* - %2 = load i64, i64* %1 - %3 = add i64 %"lst##0", 8 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = icmp eq i64 %"idx##0", 0 - br i1 %6, label %if.then1, label %if.else1 -if.else: - store i64 0, i64* %"#result##0" - ret void -if.then1: - store i64 %5, i64* %"#result##0" - ret void -if.else1: - %7 = sub i64 %"idx##0", 1 - %8 = trunc i64 16 to i32 - %9 = tail call ccc i8* @wybe_malloc(i32 %8) - %10 = ptrtoint i8* %9 to i64 - %11 = inttoptr i64 %10 to i64* - store i64 %2, i64* %11 - %12 = add i64 %10, 8 - %13 = inttoptr i64 %12 to i64* - store i64 %10, i64* %"#result##0" - musttail call fastcc void @"int_list.pop<0>"(i64 %5, i64 %7, i64* %13) - ret void +define external fastcc void @"int_list.pop<0>"(i64 %"lst##0", i64 %"idx##0", ptr %"tmp#19##0") { + %"tmp#9##0" = icmp ne i64 %"lst##0", 0 + br i1 %"tmp#9##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#20##0" = inttoptr i64 %"lst##0" to ptr + %"h##0" = load i64, ptr %"tmp#20##0" + %"tmp#21##0" = add i64 %"lst##0", 8 + %"tmp#22##0" = inttoptr i64 %"tmp#21##0" to ptr + %"t##0" = load i64, ptr %"tmp#22##0" + %"tmp#6##0" = icmp eq i64 %"idx##0", 0 + br i1 %"tmp#6##0", label %if.then.1, label %if.else.1 +if.then.1: + store i64 %"t##0", ptr %"tmp#19##0" + ret void +if.else.1: + %"tmp#4##0" = sub i64 %"idx##0", 1 + %"tmp#23##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#16##0" = ptrtoint ptr %"tmp#23##0" to i64 + %"tmp#24##0" = inttoptr i64 %"tmp#16##0" to ptr + store i64 %"h##0", ptr %"tmp#24##0" + store i64 %"tmp#16##0", ptr %"tmp#19##0" + %"tmp#25##0" = add i64 %"tmp#16##0", 8 + %"tmp#26##0" = inttoptr i64 %"tmp#25##0" to ptr + musttail call fastcc void @"int_list.pop<0>"(i64 %"t##0", i64 %"tmp#4##0", ptr %"tmp#26##0") + ret void +if.else.0: + store i64 0, ptr %"tmp#19##0" + ret void } - -define external fastcc void @"int_list.pop<0>[410bae77d3]"(i64 %"lst##0", i64 %"idx##0", i64* %"#result##0") { -entry: - %0 = icmp ne i64 %"lst##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = add i64 %"lst##0", 8 - %2 = inttoptr i64 %1 to i64* - %3 = load i64, i64* %2 - %4 = icmp eq i64 %"idx##0", 0 - br i1 %4, label %if.then1, label %if.else1 -if.else: - store i64 0, i64* %"#result##0" - ret void -if.then1: - store i64 %3, i64* %"#result##0" - ret void -if.else1: - %5 = sub i64 %"idx##0", 1 - %6 = add i64 %"lst##0", 8 - %7 = inttoptr i64 %6 to i64* - store i64 %"lst##0", i64* %"#result##0" - musttail call fastcc void @"int_list.pop<0>[410bae77d3]"(i64 %3, i64 %5, i64* %7) - ret void +define external fastcc void @"int_list.pop<0>[410bae77d3]"(i64 %"lst##0", i64 %"idx##0", ptr %"tmp#19##0") { + %"tmp#9##0" = icmp ne i64 %"lst##0", 0 + br i1 %"tmp#9##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#20##0" = add i64 %"lst##0", 8 + %"tmp#21##0" = inttoptr i64 %"tmp#20##0" to ptr + %"t##0" = load i64, ptr %"tmp#21##0" + %"tmp#6##0" = icmp eq i64 %"idx##0", 0 + br i1 %"tmp#6##0", label %if.then.1, label %if.else.1 +if.then.1: + store i64 %"t##0", ptr %"tmp#19##0" + ret void +if.else.1: + %"tmp#4##0" = sub i64 %"idx##0", 1 + store i64 %"lst##0", ptr %"tmp#19##0" + %"tmp#22##0" = add i64 %"lst##0", 8 + %"tmp#23##0" = inttoptr i64 %"tmp#22##0" to ptr + musttail call fastcc void @"int_list.pop<0>[410bae77d3]"(i64 %"t##0", i64 %"tmp#4##0", ptr %"tmp#23##0") + ret void +if.else.0: + store i64 0, ptr %"tmp#19##0" + ret void } - -define external fastcc void @"int_list.print<0>"(i64 %"x##0") { -entry: - %0 = icmp ne i64 %"x##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"x##0" to i64* - %2 = load i64, i64* %1 - %3 = add i64 %"x##0", 8 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - tail call ccc void @print_int(i64 %2) - tail call ccc void @putchar(i8 32) - musttail call fastcc void @"int_list.print<0>"(i64 %5) - ret void -if.else: - ret void +define external fastcc void @"int_list.print<0>"(i64 %"x##0") { + %"tmp#2##0" = icmp ne i64 %"x##0", 0 + br i1 %"tmp#2##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#9##0" = inttoptr i64 %"x##0" to ptr + %"h##0" = load i64, ptr %"tmp#9##0" + %"tmp#10##0" = add i64 %"x##0", 8 + %"tmp#11##0" = inttoptr i64 %"tmp#10##0" to ptr + %"t##0" = load i64, ptr %"tmp#11##0" + call ccc void @print_int(i64 %"h##0") + call ccc void @putchar(i8 32) + tail call fastcc void @"int_list.print<0>"(i64 %"t##0") + ret void +if.else.0: + ret void } - -define external fastcc void @"int_list.println<0>"(i64 %"x##0") alwaysinline { -entry: - tail call fastcc void @"int_list.print<0>"(i64 %"x##0") - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"int_list.println<0>"(i64 %"x##0") { + tail call fastcc void @"int_list.print<0>"(i64 %"x##0") + call ccc void @putchar(i8 10) + ret void } - -define external fastcc i64 @"int_list.range<0>"(i64 %"start##0", i64 %"stop##0", i64 %"step##0") alwaysinline { -entry: - %0 = tail call fastcc i64 @"int_list.range#cont#1<0>"(i64 0, i64 %"start##0", i64 %"step##0", i64 %"stop##0") - ret i64 %0 +define external fastcc i64 @"int_list.range<0>"(i64 %"start##0", i64 %"stop##0", i64 %"step##0") { + %"tmp#4##0" = tail call fastcc i64 @"int_list.range#cont#1<0>"(i64 0, i64 %"start##0", i64 %"step##0", i64 %"stop##0") + ret i64 %"tmp#4##0" } - -define external fastcc i64 @"int_list.range#cont#1<0>"(i64 %"result##0", i64 %"start##0", i64 %"step##0", i64 %"stop##0") { -entry: - %0 = icmp slt i64 %"start##0", %"stop##0" - br i1 %0, label %if.then, label %if.else -if.then: - %1 = trunc i64 16 to i32 - %2 = tail call ccc i8* @wybe_malloc(i32 %1) - %3 = ptrtoint i8* %2 to i64 - %4 = inttoptr i64 %3 to i64* - store i64 %"start##0", i64* %4 - %5 = add i64 %3, 8 - %6 = inttoptr i64 %5 to i64* - store i64 %"result##0", i64* %6 - %7 = add i64 %"start##0", %"step##0" - %8 = musttail call fastcc i64 @"int_list.range#cont#1<0>"(i64 %3, i64 %7, i64 %"step##0", i64 %"stop##0") - ret i64 %8 -if.else: - %9 = tail call fastcc i64 @"int_list.reverse_helper<0>"(i64 %"result##0", i64 0) - ret i64 %9 +define external fastcc i64 @"int_list.range#cont#1<0>"(i64 %"result##0", i64 %"start##0", i64 %"step##0", i64 %"stop##0") { + %"tmp#3##0" = icmp slt i64 %"start##0", %"stop##0" + br i1 %"tmp#3##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#15##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#11##0" = ptrtoint ptr %"tmp#15##0" to i64 + %"tmp#16##0" = inttoptr i64 %"tmp#11##0" to ptr + store i64 %"start##0", ptr %"tmp#16##0" + %"tmp#17##0" = add i64 %"tmp#11##0", 8 + %"tmp#18##0" = inttoptr i64 %"tmp#17##0" to ptr + store i64 %"result##0", ptr %"tmp#18##0" + %"tmp#14##0" = add i64 %"start##0", %"step##0" + %"tmp#19##0" = tail call fastcc i64 @"int_list.range#cont#1<0>"(i64 %"tmp#11##0", i64 %"tmp#14##0", i64 %"step##0", i64 %"stop##0") + ret i64 %"tmp#19##0" +if.else.0: + %"tmp#20##0" = tail call fastcc i64 @"int_list.reverse_helper<0>"(i64 %"result##0", i64 0) + ret i64 %"tmp#20##0" } - -define external fastcc i64 @"int_list.range#cont#1<0>[410bae77d3]"(i64 %"result##0", i64 %"start##0", i64 %"step##0", i64 %"stop##0") { -entry: - %0 = icmp slt i64 %"start##0", %"stop##0" - br i1 %0, label %if.then, label %if.else -if.then: - %1 = trunc i64 16 to i32 - %2 = tail call ccc i8* @wybe_malloc(i32 %1) - %3 = ptrtoint i8* %2 to i64 - %4 = inttoptr i64 %3 to i64* - store i64 %"start##0", i64* %4 - %5 = add i64 %3, 8 - %6 = inttoptr i64 %5 to i64* - store i64 %"result##0", i64* %6 - %7 = add i64 %"start##0", %"step##0" - %8 = musttail call fastcc i64 @"int_list.range#cont#1<0>[410bae77d3]"(i64 %3, i64 %7, i64 %"step##0", i64 %"stop##0") - ret i64 %8 -if.else: - %9 = tail call fastcc i64 @"int_list.reverse_helper<0>[410bae77d3]"(i64 %"result##0", i64 0) - ret i64 %9 +define external fastcc i64 @"int_list.range#cont#1<0>[410bae77d3]"(i64 %"result##0", i64 %"start##0", i64 %"step##0", i64 %"stop##0") { + %"tmp#3##0" = icmp slt i64 %"start##0", %"stop##0" + br i1 %"tmp#3##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#15##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#11##0" = ptrtoint ptr %"tmp#15##0" to i64 + %"tmp#16##0" = inttoptr i64 %"tmp#11##0" to ptr + store i64 %"start##0", ptr %"tmp#16##0" + %"tmp#17##0" = add i64 %"tmp#11##0", 8 + %"tmp#18##0" = inttoptr i64 %"tmp#17##0" to ptr + store i64 %"result##0", ptr %"tmp#18##0" + %"tmp#14##0" = add i64 %"start##0", %"step##0" + %"tmp#19##0" = tail call fastcc i64 @"int_list.range#cont#1<0>[410bae77d3]"(i64 %"tmp#11##0", i64 %"tmp#14##0", i64 %"step##0", i64 %"stop##0") + ret i64 %"tmp#19##0" +if.else.0: + %"tmp#20##0" = tail call fastcc i64 @"int_list.reverse_helper<0>[410bae77d3]"(i64 %"result##0", i64 0) + ret i64 %"tmp#20##0" } - -define external fastcc i64 @"int_list.range#cont#2<0>"(i64 %"result##0", i64 %"start##0", i64 %"step##0", i64 %"stop##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"start##0", i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"result##0", i64* %5 - %6 = add i64 %"start##0", %"step##0" - %7 = musttail call fastcc i64 @"int_list.range#cont#1<0>"(i64 %2, i64 %6, i64 %"step##0", i64 %"stop##0") - ret i64 %7 +define external fastcc i64 @"int_list.range#cont#2<0>"(i64 %"result##0", i64 %"start##0", i64 %"step##0", i64 %"stop##0") { + %"tmp#10##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#5##0" = ptrtoint ptr %"tmp#10##0" to i64 + %"tmp#11##0" = inttoptr i64 %"tmp#5##0" to ptr + store i64 %"start##0", ptr %"tmp#11##0" + %"tmp#12##0" = add i64 %"tmp#5##0", 8 + %"tmp#13##0" = inttoptr i64 %"tmp#12##0" to ptr + store i64 %"result##0", ptr %"tmp#13##0" + %"tmp#2##0" = add i64 %"start##0", %"step##0" + %"tmp#14##0" = tail call fastcc i64 @"int_list.range#cont#1<0>"(i64 %"tmp#5##0", i64 %"tmp#2##0", i64 %"step##0", i64 %"stop##0") + ret i64 %"tmp#14##0" } - -define external fastcc void @"int_list.remove<0>"(i64 %"lst##0", i64 %"v##0", i64* %"#result##0") { -entry: - %0 = icmp ne i64 %"lst##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"lst##0" to i64* - %2 = load i64, i64* %1 - %3 = add i64 %"lst##0", 8 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = icmp eq i64 %2, %"v##0" - br i1 %6, label %if.then1, label %if.else1 -if.else: - store i64 0, i64* %"#result##0" - ret void -if.then1: - store i64 %5, i64* %"#result##0" - ret void -if.else1: - %7 = trunc i64 16 to i32 - %8 = tail call ccc i8* @wybe_malloc(i32 %7) - %9 = ptrtoint i8* %8 to i64 - %10 = inttoptr i64 %9 to i64* - store i64 %2, i64* %10 - %11 = add i64 %9, 8 - %12 = inttoptr i64 %11 to i64* - store i64 %9, i64* %"#result##0" - musttail call fastcc void @"int_list.remove<0>"(i64 %5, i64 %"v##0", i64* %12) - ret void +define external fastcc void @"int_list.remove<0>"(i64 %"lst##0", i64 %"v##0", ptr %"tmp#16##0") { + %"tmp#8##0" = icmp ne i64 %"lst##0", 0 + br i1 %"tmp#8##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#17##0" = inttoptr i64 %"lst##0" to ptr + %"h##0" = load i64, ptr %"tmp#17##0" + %"tmp#18##0" = add i64 %"lst##0", 8 + %"tmp#19##0" = inttoptr i64 %"tmp#18##0" to ptr + %"t##0" = load i64, ptr %"tmp#19##0" + %"tmp#5##0" = icmp eq i64 %"h##0", %"v##0" + br i1 %"tmp#5##0", label %if.then.1, label %if.else.1 +if.then.1: + store i64 %"t##0", ptr %"tmp#16##0" + ret void +if.else.1: + %"tmp#20##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#13##0" = ptrtoint ptr %"tmp#20##0" to i64 + %"tmp#21##0" = inttoptr i64 %"tmp#13##0" to ptr + store i64 %"h##0", ptr %"tmp#21##0" + store i64 %"tmp#13##0", ptr %"tmp#16##0" + %"tmp#22##0" = add i64 %"tmp#13##0", 8 + %"tmp#23##0" = inttoptr i64 %"tmp#22##0" to ptr + musttail call fastcc void @"int_list.remove<0>"(i64 %"t##0", i64 %"v##0", ptr %"tmp#23##0") + ret void +if.else.0: + store i64 0, ptr %"tmp#16##0" + ret void } - -define external fastcc void @"int_list.remove<0>[410bae77d3]"(i64 %"lst##0", i64 %"v##0", i64* %"#result##0") { -entry: - %0 = icmp ne i64 %"lst##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"lst##0" to i64* - %2 = load i64, i64* %1 - %3 = add i64 %"lst##0", 8 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = icmp eq i64 %2, %"v##0" - br i1 %6, label %if.then1, label %if.else1 -if.else: - store i64 0, i64* %"#result##0" - ret void -if.then1: - store i64 %5, i64* %"#result##0" - ret void -if.else1: - %7 = add i64 %"lst##0", 8 - %8 = inttoptr i64 %7 to i64* - store i64 %"lst##0", i64* %"#result##0" - musttail call fastcc void @"int_list.remove<0>[410bae77d3]"(i64 %5, i64 %"v##0", i64* %8) - ret void +define external fastcc void @"int_list.remove<0>[410bae77d3]"(i64 %"lst##0", i64 %"v##0", ptr %"tmp#16##0") { + %"tmp#8##0" = icmp ne i64 %"lst##0", 0 + br i1 %"tmp#8##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#17##0" = inttoptr i64 %"lst##0" to ptr + %"h##0" = load i64, ptr %"tmp#17##0" + %"tmp#18##0" = add i64 %"lst##0", 8 + %"tmp#19##0" = inttoptr i64 %"tmp#18##0" to ptr + %"t##0" = load i64, ptr %"tmp#19##0" + %"tmp#5##0" = icmp eq i64 %"h##0", %"v##0" + br i1 %"tmp#5##0", label %if.then.1, label %if.else.1 +if.then.1: + store i64 %"t##0", ptr %"tmp#16##0" + ret void +if.else.1: + store i64 %"lst##0", ptr %"tmp#16##0" + %"tmp#20##0" = add i64 %"lst##0", 8 + %"tmp#21##0" = inttoptr i64 %"tmp#20##0" to ptr + musttail call fastcc void @"int_list.remove<0>[410bae77d3]"(i64 %"t##0", i64 %"v##0", ptr %"tmp#21##0") + ret void +if.else.0: + store i64 0, ptr %"tmp#16##0" + ret void } - -define external fastcc i64 @"int_list.reverse<0>"(i64 %"lst##0") alwaysinline { -entry: - %0 = tail call fastcc i64 @"int_list.reverse_helper<0>"(i64 %"lst##0", i64 0) - ret i64 %0 +define external fastcc i64 @"int_list.reverse<0>"(i64 %"lst##0") { + %"tmp#2##0" = tail call fastcc i64 @"int_list.reverse_helper<0>"(i64 %"lst##0", i64 0) + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"int_list.reverse_helper<0>"(i64 %"lst##0", i64 %"acc##0") { -entry: - %0 = icmp ne i64 %"lst##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"lst##0" to i64* - %2 = load i64, i64* %1 - %3 = add i64 %"lst##0", 8 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = trunc i64 16 to i32 - %7 = tail call ccc i8* @wybe_malloc(i32 %6) - %8 = ptrtoint i8* %7 to i64 - %9 = inttoptr i64 %8 to i64* - store i64 %2, i64* %9 - %10 = add i64 %8, 8 - %11 = inttoptr i64 %10 to i64* - store i64 %"acc##0", i64* %11 - %12 = musttail call fastcc i64 @"int_list.reverse_helper<0>"(i64 %5, i64 %8) - ret i64 %12 -if.else: - ret i64 %"acc##0" +define external fastcc i64 @"int_list.reverse_helper<0>"(i64 %"lst##0", i64 %"acc##0") { + %"tmp#5##0" = icmp ne i64 %"lst##0", 0 + br i1 %"tmp#5##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#11##0" = inttoptr i64 %"lst##0" to ptr + %"h##0" = load i64, ptr %"tmp#11##0" + %"tmp#12##0" = add i64 %"lst##0", 8 + %"tmp#13##0" = inttoptr i64 %"tmp#12##0" to ptr + %"t##0" = load i64, ptr %"tmp#13##0" + %"tmp#14##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#8##0" = ptrtoint ptr %"tmp#14##0" to i64 + %"tmp#15##0" = inttoptr i64 %"tmp#8##0" to ptr + store i64 %"h##0", ptr %"tmp#15##0" + %"tmp#16##0" = add i64 %"tmp#8##0", 8 + %"tmp#17##0" = inttoptr i64 %"tmp#16##0" to ptr + store i64 %"acc##0", ptr %"tmp#17##0" + %"tmp#18##0" = tail call fastcc i64 @"int_list.reverse_helper<0>"(i64 %"t##0", i64 %"tmp#8##0") + ret i64 %"tmp#18##0" +if.else.0: + ret i64 %"acc##0" } - -define external fastcc i64 @"int_list.reverse_helper<0>[410bae77d3]"(i64 %"lst##0", i64 %"acc##0") { -entry: - %0 = icmp ne i64 %"lst##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = add i64 %"lst##0", 8 - %2 = inttoptr i64 %1 to i64* - %3 = load i64, i64* %2 - %4 = add i64 %"lst##0", 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"acc##0", i64* %5 - %6 = musttail call fastcc i64 @"int_list.reverse_helper<0>[410bae77d3]"(i64 %3, i64 %"lst##0") - ret i64 %6 -if.else: - ret i64 %"acc##0" +define external fastcc i64 @"int_list.reverse_helper<0>[410bae77d3]"(i64 %"lst##0", i64 %"acc##0") { + %"tmp#5##0" = icmp ne i64 %"lst##0", 0 + br i1 %"tmp#5##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#11##0" = add i64 %"lst##0", 8 + %"tmp#12##0" = inttoptr i64 %"tmp#11##0" to ptr + %"t##0" = load i64, ptr %"tmp#12##0" + %"tmp#13##0" = add i64 %"lst##0", 8 + %"tmp#14##0" = inttoptr i64 %"tmp#13##0" to ptr + store i64 %"acc##0", ptr %"tmp#14##0" + %"tmp#15##0" = tail call fastcc i64 @"int_list.reverse_helper<0>[410bae77d3]"(i64 %"t##0", i64 %"lst##0") + ret i64 %"tmp#15##0" +if.else.0: + ret i64 %"acc##0" } - -define external fastcc i64 @"int_list.sort<0>"(i64 %"lst##0") { -entry: - %0 = icmp ne i64 %"lst##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"lst##0" to i64* - %2 = load i64, i64* %1 - %3 = add i64 %"lst##0", 8 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = alloca i64 - call fastcc void @"int_list.lesser<0>"(i64 %5, i64 %2, i64* %6) - %7 = load i64, i64* %6 - %8 = tail call fastcc i64 @"int_list.sort<0>[410bae77d3]"(i64 %7) - %9 = alloca i64 - call fastcc void @"int_list.greater<0>"(i64 %5, i64 %2, i64* %9) - %10 = load i64, i64* %9 - %11 = tail call fastcc i64 @"int_list.sort<0>[410bae77d3]"(i64 %10) - %12 = trunc i64 16 to i32 - %13 = tail call ccc i8* @wybe_malloc(i32 %12) - %14 = ptrtoint i8* %13 to i64 - %15 = inttoptr i64 %14 to i64* - store i64 %2, i64* %15 - %16 = add i64 %14, 8 - %17 = inttoptr i64 %16 to i64* - store i64 %11, i64* %17 - %18 = alloca i64 - call fastcc void @"int_list.extend<0>[410bae77d3]"(i64 %8, i64 %14, i64* %18) - %19 = load i64, i64* %18 - ret i64 %19 -if.else: - ret i64 0 +define external fastcc i64 @"int_list.sort<0>"(i64 %"lst##0") { + %"tmp#10##0" = icmp ne i64 %"lst##0", 0 + br i1 %"tmp#10##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#16##0" = inttoptr i64 %"lst##0" to ptr + %"h##0" = load i64, ptr %"tmp#16##0" + %"tmp#17##0" = add i64 %"lst##0", 8 + %"tmp#18##0" = inttoptr i64 %"tmp#17##0" to ptr + %"t##0" = load i64, ptr %"tmp#18##0" + %"tmp#19##0" = alloca i8, i64 8, align 8 + call fastcc void @"int_list.lesser<0>"(i64 %"t##0", i64 %"h##0", ptr %"tmp#19##0") + %"tmp#3##0" = load i64, ptr %"tmp#19##0" + %"tmp#2##0" = call fastcc i64 @"int_list.sort<0>[410bae77d3]"(i64 %"tmp#3##0") + %"tmp#20##0" = alloca i8, i64 8, align 8 + call fastcc void @"int_list.greater<0>"(i64 %"t##0", i64 %"h##0", ptr %"tmp#20##0") + %"tmp#6##0" = load i64, ptr %"tmp#20##0" + %"tmp#5##0" = call fastcc i64 @"int_list.sort<0>[410bae77d3]"(i64 %"tmp#6##0") + %"tmp#21##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#13##0" = ptrtoint ptr %"tmp#21##0" to i64 + %"tmp#22##0" = inttoptr i64 %"tmp#13##0" to ptr + store i64 %"h##0", ptr %"tmp#22##0" + %"tmp#23##0" = add i64 %"tmp#13##0", 8 + %"tmp#24##0" = inttoptr i64 %"tmp#23##0" to ptr + store i64 %"tmp#5##0", ptr %"tmp#24##0" + %"tmp#25##0" = alloca i8, i64 8, align 8 + call fastcc void @"int_list.extend<0>[410bae77d3]"(i64 %"tmp#2##0", i64 %"tmp#13##0", ptr %"tmp#25##0") + %"tmp#26##0" = load i64, ptr %"tmp#25##0" + ret i64 %"tmp#26##0" +if.else.0: + ret i64 0 } - -define external fastcc i64 @"int_list.sort<0>[410bae77d3]"(i64 %"lst##0") { -entry: - %0 = icmp ne i64 %"lst##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"lst##0" to i64* - %2 = load i64, i64* %1 - %3 = add i64 %"lst##0", 8 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = alloca i64 - call fastcc void @"int_list.lesser<0>"(i64 %5, i64 %2, i64* %6) - %7 = load i64, i64* %6 - %8 = tail call fastcc i64 @"int_list.sort<0>[410bae77d3]"(i64 %7) - %9 = alloca i64 - call fastcc void @"int_list.greater<0>[410bae77d3]"(i64 %5, i64 %2, i64* %9) - %10 = load i64, i64* %9 - %11 = tail call fastcc i64 @"int_list.sort<0>[410bae77d3]"(i64 %10) - %12 = add i64 %"lst##0", 8 - %13 = inttoptr i64 %12 to i64* - store i64 %11, i64* %13 - %14 = alloca i64 - call fastcc void @"int_list.extend<0>[410bae77d3]"(i64 %8, i64 %"lst##0", i64* %14) - %15 = load i64, i64* %14 - ret i64 %15 -if.else: - ret i64 0 +define external fastcc i64 @"int_list.sort<0>[410bae77d3]"(i64 %"lst##0") { + %"tmp#10##0" = icmp ne i64 %"lst##0", 0 + br i1 %"tmp#10##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#16##0" = inttoptr i64 %"lst##0" to ptr + %"h##0" = load i64, ptr %"tmp#16##0" + %"tmp#17##0" = add i64 %"lst##0", 8 + %"tmp#18##0" = inttoptr i64 %"tmp#17##0" to ptr + %"t##0" = load i64, ptr %"tmp#18##0" + %"tmp#19##0" = alloca i8, i64 8, align 8 + call fastcc void @"int_list.lesser<0>"(i64 %"t##0", i64 %"h##0", ptr %"tmp#19##0") + %"tmp#3##0" = load i64, ptr %"tmp#19##0" + %"tmp#2##0" = call fastcc i64 @"int_list.sort<0>[410bae77d3]"(i64 %"tmp#3##0") + %"tmp#20##0" = alloca i8, i64 8, align 8 + call fastcc void @"int_list.greater<0>[410bae77d3]"(i64 %"t##0", i64 %"h##0", ptr %"tmp#20##0") + %"tmp#6##0" = load i64, ptr %"tmp#20##0" + %"tmp#5##0" = call fastcc i64 @"int_list.sort<0>[410bae77d3]"(i64 %"tmp#6##0") + %"tmp#21##0" = add i64 %"lst##0", 8 + %"tmp#22##0" = inttoptr i64 %"tmp#21##0" to ptr + store i64 %"tmp#5##0", ptr %"tmp#22##0" + %"tmp#23##0" = alloca i8, i64 8, align 8 + call fastcc void @"int_list.extend<0>[410bae77d3]"(i64 %"tmp#2##0", i64 %"lst##0", ptr %"tmp#23##0") + %"tmp#24##0" = load i64, ptr %"tmp#23##0" + ret i64 %"tmp#24##0" +if.else.0: + ret i64 0 } + -------------------------------------------------- Module int_list.int_list - representation : address + representation : pointer public submods : public resources: public procs : int_list.int_list.=<0> @@ -2550,183 +2379,158 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'int_list.int_list' - - - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i1 @"int_list.int_list.=<0>"(i64 %"#left##0", i64 %"#right##0") { -entry: - %0 = icmp ne i64 %"#left##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"#left##0" to i64* - %2 = load i64, i64* %1 - %3 = add i64 %"#left##0", 8 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = icmp ne i64 %"#right##0", 0 - br i1 %6, label %if.then1, label %if.else1 -if.else: - %14 = icmp eq i64 %"#right##0", 0 - ret i1 %14 -if.then1: - %7 = inttoptr i64 %"#right##0" to i64* - %8 = load i64, i64* %7 - %9 = add i64 %"#right##0", 8 - %10 = inttoptr i64 %9 to i64* - %11 = load i64, i64* %10 - %12 = icmp eq i64 %2, %8 - br i1 %12, label %if.then2, label %if.else2 -if.else1: - ret i1 0 -if.then2: - %13 = musttail call fastcc i1 @"int_list.int_list.=<0>"(i64 %5, i64 %11) - ret i1 %13 -if.else2: - ret i1 0 +source_filename = "/private!TMP!/int_list.wybe" +target triple = ??? + + +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc i1 @"int_list.int_list.=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#0##0" = icmp ne i64 %"#left##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#12##0" = inttoptr i64 %"#left##0" to ptr + %"#left#head##0" = load i64, ptr %"tmp#12##0" + %"tmp#13##0" = add i64 %"#left##0", 8 + %"tmp#14##0" = inttoptr i64 %"tmp#13##0" to ptr + %"#left#tail##0" = load i64, ptr %"tmp#14##0" + %"tmp#9##0" = icmp ne i64 %"#right##0", 0 + br i1 %"tmp#9##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#15##0" = inttoptr i64 %"#right##0" to ptr + %"#right#head##0" = load i64, ptr %"tmp#15##0" + %"tmp#16##0" = add i64 %"#right##0", 8 + %"tmp#17##0" = inttoptr i64 %"tmp#16##0" to ptr + %"#right#tail##0" = load i64, ptr %"tmp#17##0" + %"tmp#4##0" = icmp eq i64 %"#left#head##0", %"#right#head##0" + br i1 %"tmp#4##0", label %if.then.2, label %if.else.2 +if.then.2: + %"tmp#18##0" = tail call fastcc i1 @"int_list.int_list.=<0>"(i64 %"#left#tail##0", i64 %"#right#tail##0") + ret i1 %"tmp#18##0" +if.else.2: + ret i1 0 +if.else.1: + ret i1 0 +if.else.0: + %"tmp#19##0" = icmp eq i64 %"#right##0", 0 + ret i1 %"tmp#19##0" } - -define external fastcc i64 @"int_list.int_list.cons<0>"(i64 %"head##0", i64 %"tail##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"head##0", i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"tail##0", i64* %5 - ret i64 %2 +define external fastcc i64 @"int_list.int_list.cons<0>"(i64 %"head##0", i64 %"tail##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 16) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"head##0", ptr %"tmp#1##0" + %"tmp#2##0" = add i64 %"#rec##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"tail##0", ptr %"tmp#3##0" + ret i64 %"#rec##0" } - -define external fastcc {i64, i64, i1} @"int_list.int_list.cons<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#result##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"#result##0" to i64* - %2 = load i64, i64* %1 - %3 = add i64 %"#result##0", 8 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = insertvalue {i64, i64, i1} undef, i64 %2, 0 - %7 = insertvalue {i64, i64, i1} %6, i64 %5, 1 - %8 = insertvalue {i64, i64, i1} %7, i1 1, 2 - ret {i64, i64, i1} %8 -if.else: - %9 = insertvalue {i64, i64, i1} undef, i64 undef, 0 - %10 = insertvalue {i64, i64, i1} %9, i64 undef, 1 - %11 = insertvalue {i64, i64, i1} %10, i1 0, 2 - ret {i64, i64, i1} %11 +define external fastcc {i64, i64, i1} @"int_list.int_list.cons<1>"(i64 %"#result##0") { + %"tmp#0##0" = icmp ne i64 %"#result##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = inttoptr i64 %"#result##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + %"tmp#3##0" = add i64 %"#result##0", 8 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#4##0" + %"tmp#6##0" = insertvalue {i64, i64, i1} undef, i64 %"tmp#2##0", 0 + %"tmp#7##0" = insertvalue {i64, i64, i1} %"tmp#6##0", i64 %"tmp#5##0", 1 + %"tmp#8##0" = insertvalue {i64, i64, i1} %"tmp#7##0", i1 1, 2 + ret {i64, i64, i1} %"tmp#8##0" +if.else.0: + %"tmp#9##0" = insertvalue {i64, i64, i1} undef, i64 undef, 0 + %"tmp#10##0" = insertvalue {i64, i64, i1} %"tmp#9##0", i64 undef, 1 + %"tmp#11##0" = insertvalue {i64, i64, i1} %"tmp#10##0", i1 0, 2 + ret {i64, i64, i1} %"tmp#11##0" } - -define external fastcc {i64, i1} @"int_list.int_list.head<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"#rec##0" to i64* - %2 = load i64, i64* %1 - %3 = insertvalue {i64, i1} undef, i64 %2, 0 - %4 = insertvalue {i64, i1} %3, i1 1, 1 - ret {i64, i1} %4 -if.else: - %5 = insertvalue {i64, i1} undef, i64 undef, 0 - %6 = insertvalue {i64, i1} %5, i1 0, 1 - ret {i64, i1} %6 +define external fastcc {i64, i1} @"int_list.int_list.head<0>"(i64 %"#rec##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + %"tmp#3##0" = insertvalue {i64, i1} undef, i64 %"tmp#2##0", 0 + %"tmp#4##0" = insertvalue {i64, i1} %"tmp#3##0", i1 1, 1 + ret {i64, i1} %"tmp#4##0" +if.else.0: + %"tmp#5##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#6##0" = insertvalue {i64, i1} %"tmp#5##0", i1 0, 1 + ret {i64, i1} %"tmp#6##0" } - -define external fastcc {i64, i1} @"int_list.int_list.head<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = trunc i64 16 to i32 - %2 = tail call ccc i8* @wybe_malloc(i32 %1) - %3 = ptrtoint i8* %2 to i64 - %4 = inttoptr i64 %3 to i8* - %5 = inttoptr i64 %"#rec##0" to i8* - %6 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %4, i8* %5, i32 %6, i1 0) - %7 = inttoptr i64 %3 to i64* - store i64 %"#field##0", i64* %7 - %8 = insertvalue {i64, i1} undef, i64 %3, 0 - %9 = insertvalue {i64, i1} %8, i1 1, 1 - ret {i64, i1} %9 -if.else: - %10 = insertvalue {i64, i1} undef, i64 0, 0 - %11 = insertvalue {i64, i1} %10, i1 0, 1 - ret {i64, i1} %11 +define external fastcc {i64, i1} @"int_list.int_list.head<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#2##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#2##0", ptr %"tmp#1##0", i64 16, i1 0) + %"tmp#3##0" = ptrtoint ptr %"tmp#2##0" to i64 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 %"#field##0", ptr %"tmp#4##0" + %"tmp#5##0" = insertvalue {i64, i1} undef, i64 %"tmp#3##0", 0 + %"tmp#6##0" = insertvalue {i64, i1} %"tmp#5##0", i1 1, 1 + ret {i64, i1} %"tmp#6##0" +if.else.0: + %"tmp#7##0" = insertvalue {i64, i1} undef, i64 0, 0 + %"tmp#8##0" = insertvalue {i64, i1} %"tmp#7##0", i1 0, 1 + ret {i64, i1} %"tmp#8##0" } - -define external fastcc i64 @"int_list.int_list.nil<0>"() alwaysinline { -entry: - ret i64 0 +define external fastcc i64 @"int_list.int_list.nil<0>"() { + ret i64 0 } - -define external fastcc {i64, i1} @"int_list.int_list.tail<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = add i64 %"#rec##0", 8 - %2 = inttoptr i64 %1 to i64* - %3 = load i64, i64* %2 - %4 = insertvalue {i64, i1} undef, i64 %3, 0 - %5 = insertvalue {i64, i1} %4, i1 1, 1 - ret {i64, i1} %5 -if.else: - %6 = insertvalue {i64, i1} undef, i64 undef, 0 - %7 = insertvalue {i64, i1} %6, i1 0, 1 - ret {i64, i1} %7 +define external fastcc {i64, i1} @"int_list.int_list.tail<0>"(i64 %"#rec##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = add i64 %"#rec##0", 8 + %"tmp#2##0" = inttoptr i64 %"tmp#1##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#2##0" + %"tmp#4##0" = insertvalue {i64, i1} undef, i64 %"tmp#3##0", 0 + %"tmp#5##0" = insertvalue {i64, i1} %"tmp#4##0", i1 1, 1 + ret {i64, i1} %"tmp#5##0" +if.else.0: + %"tmp#6##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#7##0" = insertvalue {i64, i1} %"tmp#6##0", i1 0, 1 + ret {i64, i1} %"tmp#7##0" } - -define external fastcc {i64, i1} @"int_list.int_list.tail<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = trunc i64 16 to i32 - %2 = tail call ccc i8* @wybe_malloc(i32 %1) - %3 = ptrtoint i8* %2 to i64 - %4 = inttoptr i64 %3 to i8* - %5 = inttoptr i64 %"#rec##0" to i8* - %6 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %4, i8* %5, i32 %6, i1 0) - %7 = add i64 %3, 8 - %8 = inttoptr i64 %7 to i64* - store i64 %"#field##0", i64* %8 - %9 = insertvalue {i64, i1} undef, i64 %3, 0 - %10 = insertvalue {i64, i1} %9, i1 1, 1 - ret {i64, i1} %10 -if.else: - %11 = insertvalue {i64, i1} undef, i64 0, 0 - %12 = insertvalue {i64, i1} %11, i1 0, 1 - ret {i64, i1} %12 +define external fastcc {i64, i1} @"int_list.int_list.tail<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#2##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#2##0", ptr %"tmp#1##0", i64 16, i1 0) + %"tmp#3##0" = ptrtoint ptr %"tmp#2##0" to i64 + %"tmp#4##0" = add i64 %"tmp#3##0", 8 + %"tmp#5##0" = inttoptr i64 %"tmp#4##0" to ptr + store i64 %"#field##0", ptr %"tmp#5##0" + %"tmp#6##0" = insertvalue {i64, i1} undef, i64 %"tmp#3##0", 0 + %"tmp#7##0" = insertvalue {i64, i1} %"tmp#6##0", i1 1, 1 + ret {i64, i1} %"tmp#7##0" +if.else.0: + %"tmp#8##0" = insertvalue {i64, i1} undef, i64 0, 0 + %"tmp#9##0" = insertvalue {i64, i1} %"tmp#8##0", i1 0, 1 + ret {i64, i1} %"tmp#9##0" } - -define external fastcc i1 @"int_list.int_list.~=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = tail call fastcc i1 @"int_list.int_list.=<0>"(i64 %"#left##0", i64 %"#right##0") - %1 = xor i1 %0, 1 - ret i1 %1 +define external fastcc i1 @"int_list.int_list.~=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#0##0" = tail call fastcc i1 @"int_list.int_list.=<0>"(i64 %"#left##0", i64 %"#right##0") + %"tmp#1##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#1##0" } + -------------------------------------------------- Module int_list_test representation : (not a type) @@ -2833,7 +2637,7 @@ module top-level code > public {semipure} (0 calls) proc test_int_list > (2 calls) -0: int_list_test.test_int_list<0>[9e35cb823b] +0: int_list_test.test_int_list<0> test_int_list(x##0:int_list.int_list, y##0:int_list.int_list, z##0:int_list.int_list)<{<>}; {<>}; {}>: AliasPairs: [] InterestingCallProperties: [InterestingUnaliased 0,InterestingUnaliased 1,InterestingUnaliased 2] @@ -2940,261 +2744,187 @@ test_int_list(x##0:int_list.int_list, y##0:int_list.int_list, z##0:int_list.int_ LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'int_list_test' - - - - -@int_list_test.17 = constant {i64, i64} { i64 1, i64 ptrtoint ([?? x i8]* @int_list_test.16 to i64) } - - -@int_list_test.1 = constant {i64, i64} { i64 6, i64 ptrtoint ([?? x i8]* @int_list_test.0 to i64) } - - -@int_list_test.7 = constant {i64, i64} { i64 15, i64 ptrtoint ([?? x i8]* @int_list_test.6 to i64) } - - -@int_list_test.5 = constant {i64, i64} { i64 16, i64 ptrtoint ([?? x i8]* @int_list_test.4 to i64) } - - -@int_list_test.9 = constant {i64, i64} { i64 19, i64 ptrtoint ([?? x i8]* @int_list_test.8 to i64) } - - -@int_list_test.3 = constant {i64, i64} { i64 20, i64 ptrtoint ([?? x i8]* @int_list_test.2 to i64) } - - -@int_list_test.13 = constant {i64, i64} { i64 35, i64 ptrtoint ([?? x i8]* @int_list_test.12 to i64) } - - -@int_list_test.11 = constant {i64, i64} { i64 36, i64 ptrtoint ([?? x i8]* @int_list_test.10 to i64) } - - -@int_list_test.15 = constant {i64, i64} { i64 39, i64 ptrtoint ([?? x i8]* @int_list_test.14 to i64) } - - -@int_list_test.10 = constant [?? x i8] c" ** malloc count of building lists: \00" - - -@int_list_test.12 = constant [?? x i8] c" ** malloc count of test(aliased): \00" - - -@int_list_test.14 = constant [?? x i8] c" ** malloc count of test(non-aliased): \00" - - -@int_list_test.16 = constant [?? x i8] c"-\00" - - -@int_list_test.2 = constant [?? x i8] c"--------------------\00" - - -@int_list_test.6 = constant [?? x i8] c"original x y z:\00" - - -@int_list_test.4 = constant [?? x i8] c"tests with alias\00" - - -@int_list_test.8 = constant [?? x i8] c"tests without alias\00" - - -@int_list_test.0 = constant [?? x i8] c"x y z:\00" - - -declare external ccc void @putchar(i8) - - -declare external fastcc void @"int_list.print<0>"(i64) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external fastcc i64 @"int_list.sort<0>[410bae77d3]"(i64) - - -declare external fastcc void @"int_list.remove<0>[410bae77d3]"(i64, i64, i64*) - - -declare external fastcc void @"int_list.pop<0>[410bae77d3]"(i64, i64, i64*) - - -declare external fastcc void @"int_list.insert<0>[410bae77d3]"(i64, i64, i64, i64*) - - -declare external fastcc void @"int_list.extend<0>[410bae77d3]"(i64, i64, i64*) - - -declare external fastcc i64 @"int_list.append<0>[410bae77d3]"(i64, i64) - - -declare external fastcc i64 @"int_list.reverse_helper<0>[410bae77d3]"(i64, i64) - - -declare external fastcc i64 @"int_list.append<0>"(i64, i64) - - -declare external fastcc i64 @"int_list.reverse_helper<0>"(i64, i64) - - -declare external ccc void @print_int(i64) - - -declare external ccc i64 @malloc_count() - - -declare external fastcc i64 @"int_list.range#cont#1<0>[410bae77d3]"(i64, i64, i64, i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"int_list_test.<0>"() { -entry: - %0 = tail call ccc i64 @malloc_count() - %1 = tail call fastcc i64 @"int_list.range#cont#1<0>[410bae77d3]"(i64 0, i64 1, i64 1, i64 10) - %2 = tail call fastcc i64 @"int_list.range#cont#1<0>[410bae77d3]"(i64 0, i64 2, i64 2, i64 20) - %3 = tail call fastcc i64 @"int_list.range#cont#1<0>[410bae77d3]"(i64 0, i64 3, i64 3, i64 30) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @int_list_test.1, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"int_list.print<0>"(i64 %1) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"int_list.print<0>"(i64 %2) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"int_list.print<0>"(i64 %3) - tail call ccc void @putchar(i8 10) - %4 = tail call ccc i64 @malloc_count() - %5 = sub i64 %4, %0 - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @int_list_test.3, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @int_list_test.5, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - %6 = tail call ccc i64 @malloc_count() - tail call fastcc void @"int_list_test.test_int_list<0>"(i64 %1, i64 %2, i64 %3) - %7 = tail call ccc i64 @malloc_count() - %8 = sub i64 %7, %6 - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @int_list_test.7, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"int_list.print<0>"(i64 %1) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"int_list.print<0>"(i64 %2) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"int_list.print<0>"(i64 %3) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @int_list_test.3, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @int_list_test.3, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @int_list_test.9, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - %9 = tail call ccc i64 @malloc_count() - tail call fastcc void @"int_list_test.test_int_list<0>[9e35cb823b]"(i64 %1, i64 %2, i64 %3) - %10 = tail call ccc i64 @malloc_count() - %11 = sub i64 %10, %9 - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @int_list_test.3, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @int_list_test.11, i32 0, i32 0) to i64)) - tail call ccc void @print_int(i64 %5) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @int_list_test.13, i32 0, i32 0) to i64)) - tail call ccc void @print_int(i64 %8) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @int_list_test.15, i32 0, i32 0) to i64)) - tail call ccc void @print_int(i64 %11) - tail call ccc void @putchar(i8 10) - ret void +source_filename = "/private!TMP!/int_list_test.wybe" +target triple = ??? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c" ** malloc count of building lists: \00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c" ** malloc count of test(aliased): \00", align 8 +@"cstring#2" = private unnamed_addr constant [ ?? x i8 ] c" ** malloc count of test(non-aliased): \00", align 8 +@"cstring#3" = private unnamed_addr constant [ ?? x i8 ] c"-\00", align 8 +@"cstring#4" = private unnamed_addr constant [ ?? x i8 ] c"--------------------\00", align 8 +@"cstring#5" = private unnamed_addr constant [ ?? x i8 ] c"original x y z:\00", align 8 +@"cstring#6" = private unnamed_addr constant [ ?? x i8 ] c"tests with alias\00", align 8 +@"cstring#7" = private unnamed_addr constant [ ?? x i8 ] c"tests without alias\00", align 8 +@"cstring#8" = private unnamed_addr constant [ ?? x i8 ] c"x y z:\00", align 8 +@"string#9" = private unnamed_addr constant {i64, i64} { i64 36, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +@"string#10" = private unnamed_addr constant {i64, i64} { i64 35, i64 ptrtoint( ptr @"cstring#1" to i64 ) }, align 8 +@"string#11" = private unnamed_addr constant {i64, i64} { i64 39, i64 ptrtoint( ptr @"cstring#2" to i64 ) }, align 8 +@"string#12" = private unnamed_addr constant {i64, i64} { i64 1, i64 ptrtoint( ptr @"cstring#3" to i64 ) }, align 8 +@"string#13" = private unnamed_addr constant {i64, i64} { i64 20, i64 ptrtoint( ptr @"cstring#4" to i64 ) }, align 8 +@"string#14" = private unnamed_addr constant {i64, i64} { i64 15, i64 ptrtoint( ptr @"cstring#5" to i64 ) }, align 8 +@"string#15" = private unnamed_addr constant {i64, i64} { i64 16, i64 ptrtoint( ptr @"cstring#6" to i64 ) }, align 8 +@"string#16" = private unnamed_addr constant {i64, i64} { i64 19, i64 ptrtoint( ptr @"cstring#7" to i64 ) }, align 8 +@"string#17" = private unnamed_addr constant {i64, i64} { i64 6, i64 ptrtoint( ptr @"cstring#8" to i64 ) }, align 8 + +declare external fastcc i64 @"int_list.append<0>"(i64, i64) +declare external fastcc i64 @"int_list.append<0>[410bae77d3]"(i64, i64) +declare external fastcc void @"int_list.extend<0>[410bae77d3]"(i64, i64, ptr) +declare external fastcc void @"int_list.insert<0>[410bae77d3]"(i64, i64, i64, ptr) +declare external fastcc void @"int_list.pop<0>[410bae77d3]"(i64, i64, ptr) +declare external fastcc void @"int_list.print<0>"(i64) +declare external fastcc i64 @"int_list.range#cont#1<0>[410bae77d3]"(i64, i64, i64, i64) +declare external fastcc void @"int_list.remove<0>[410bae77d3]"(i64, i64, ptr) +declare external fastcc i64 @"int_list.reverse_helper<0>"(i64, i64) +declare external fastcc i64 @"int_list.reverse_helper<0>[410bae77d3]"(i64, i64) +declare external fastcc i64 @"int_list.sort<0>[410bae77d3]"(i64) +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc i64 @malloc_count() +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"int_list_test.<0>"() { + %"mc1##0" = call ccc i64 @malloc_count() + %"tmp#0##0" = tail call fastcc i64 @"int_list.range#cont#1<0>[410bae77d3]"(i64 0, i64 1, i64 1, i64 10) + %"tmp#1##0" = tail call fastcc i64 @"int_list.range#cont#1<0>[410bae77d3]"(i64 0, i64 2, i64 2, i64 20) + %"tmp#2##0" = tail call fastcc i64 @"int_list.range#cont#1<0>[410bae77d3]"(i64 0, i64 3, i64 3, i64 30) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#17" to i64 )) + call ccc void @putchar(i8 10) + tail call fastcc void @"int_list.print<0>"(i64 %"tmp#0##0") + call ccc void @putchar(i8 10) + tail call fastcc void @"int_list.print<0>"(i64 %"tmp#1##0") + call ccc void @putchar(i8 10) + tail call fastcc void @"int_list.print<0>"(i64 %"tmp#2##0") + call ccc void @putchar(i8 10) + %"mc2##0" = call ccc i64 @malloc_count() + %"tmp#3##0" = sub i64 %"mc2##0", %"mc1##0" + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#13" to i64 )) + call ccc void @putchar(i8 10) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#15" to i64 )) + call ccc void @putchar(i8 10) + %"mc1##1" = call ccc i64 @malloc_count() + tail call fastcc void @"int_list_test.test_int_list<0>"(i64 %"tmp#0##0", i64 %"tmp#1##0", i64 %"tmp#2##0") + %"mc2##1" = call ccc i64 @malloc_count() + %"tmp#4##0" = sub i64 %"mc2##1", %"mc1##1" + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#14" to i64 )) + call ccc void @putchar(i8 10) + tail call fastcc void @"int_list.print<0>"(i64 %"tmp#0##0") + call ccc void @putchar(i8 10) + tail call fastcc void @"int_list.print<0>"(i64 %"tmp#1##0") + call ccc void @putchar(i8 10) + tail call fastcc void @"int_list.print<0>"(i64 %"tmp#2##0") + call ccc void @putchar(i8 10) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#13" to i64 )) + call ccc void @putchar(i8 10) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#13" to i64 )) + call ccc void @putchar(i8 10) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#16" to i64 )) + call ccc void @putchar(i8 10) + %"mc1##2" = call ccc i64 @malloc_count() + tail call fastcc void @"int_list_test.test_int_list<0>[9e35cb823b]"(i64 %"tmp#0##0", i64 %"tmp#1##0", i64 %"tmp#2##0") + %"mc2##2" = call ccc i64 @malloc_count() + %"tmp#5##0" = sub i64 %"mc2##2", %"mc1##2" + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#13" to i64 )) + call ccc void @putchar(i8 10) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#9" to i64 )) + call ccc void @print_int(i64 %"tmp#3##0") + call ccc void @putchar(i8 10) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#10" to i64 )) + call ccc void @print_int(i64 %"tmp#4##0") + call ccc void @putchar(i8 10) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#11" to i64 )) + call ccc void @print_int(i64 %"tmp#5##0") + call ccc void @putchar(i8 10) + ret void } - -define external fastcc void @"int_list_test.test_int_list<0>"(i64 %"x##0", i64 %"y##0", i64 %"z##0") { -entry: - %0 = tail call fastcc i64 @"int_list.reverse_helper<0>"(i64 %"x##0", i64 0) - %1 = tail call fastcc i64 @"int_list.reverse_helper<0>"(i64 %"z##0", i64 0) - %2 = tail call fastcc i64 @"int_list.append<0>"(i64 %"y##0", i64 99) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @int_list_test.17, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"int_list.print<0>"(i64 %0) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"int_list.print<0>"(i64 %2) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"int_list.print<0>"(i64 %1) - tail call ccc void @putchar(i8 10) - %3 = alloca i64 - call fastcc void @"int_list.extend<0>[410bae77d3]"(i64 %0, i64 %2, i64* %3) - %4 = load i64, i64* %3 - %5 = alloca i64 - call fastcc void @"int_list.extend<0>[410bae77d3]"(i64 %4, i64 %1, i64* %5) - %6 = load i64, i64* %5 - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @int_list_test.17, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"int_list.print<0>"(i64 %6) - tail call ccc void @putchar(i8 10) - %7 = alloca i64 - call fastcc void @"int_list.insert<0>[410bae77d3]"(i64 %6, i64 4, i64 78, i64* %7) - %8 = load i64, i64* %7 - %9 = alloca i64 - call fastcc void @"int_list.pop<0>[410bae77d3]"(i64 %8, i64 20, i64* %9) - %10 = load i64, i64* %9 - %11 = alloca i64 - call fastcc void @"int_list.remove<0>[410bae77d3]"(i64 %10, i64 2, i64* %11) - %12 = load i64, i64* %11 - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @int_list_test.17, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"int_list.print<0>"(i64 %12) - tail call ccc void @putchar(i8 10) - %13 = tail call fastcc i64 @"int_list.sort<0>[410bae77d3]"(i64 %12) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @int_list_test.17, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"int_list.print<0>"(i64 %13) - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"int_list_test.test_int_list<0>"(i64 %"x##0", i64 %"y##0", i64 %"z##0") { + %"x##1" = tail call fastcc i64 @"int_list.reverse_helper<0>"(i64 %"x##0", i64 0) + %"z##1" = tail call fastcc i64 @"int_list.reverse_helper<0>"(i64 %"z##0", i64 0) + %"tmp#0##0" = tail call fastcc i64 @"int_list.append<0>"(i64 %"y##0", i64 99) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#12" to i64 )) + call ccc void @putchar(i8 10) + tail call fastcc void @"int_list.print<0>"(i64 %"x##1") + call ccc void @putchar(i8 10) + tail call fastcc void @"int_list.print<0>"(i64 %"tmp#0##0") + call ccc void @putchar(i8 10) + tail call fastcc void @"int_list.print<0>"(i64 %"z##1") + call ccc void @putchar(i8 10) + %"tmp#38##0" = alloca i8, i64 8, align 8 + call fastcc void @"int_list.extend<0>[410bae77d3]"(i64 %"x##1", i64 %"tmp#0##0", ptr %"tmp#38##0") + %"tmp#1##0" = load i64, ptr %"tmp#38##0" + %"tmp#39##0" = alloca i8, i64 8, align 8 + call fastcc void @"int_list.extend<0>[410bae77d3]"(i64 %"tmp#1##0", i64 %"z##1", ptr %"tmp#39##0") + %"tmp#2##0" = load i64, ptr %"tmp#39##0" + call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#12" to i64 )) + call ccc void @putchar(i8 10) + call fastcc void @"int_list.print<0>"(i64 %"tmp#2##0") + call ccc void @putchar(i8 10) + %"tmp#40##0" = alloca i8, i64 8, align 8 + call fastcc void @"int_list.insert<0>[410bae77d3]"(i64 %"tmp#2##0", i64 4, i64 78, ptr %"tmp#40##0") + %"tmp#3##0" = load i64, ptr %"tmp#40##0" + %"tmp#41##0" = alloca i8, i64 8, align 8 + call fastcc void @"int_list.pop<0>[410bae77d3]"(i64 %"tmp#3##0", i64 20, ptr %"tmp#41##0") + %"tmp#4##0" = load i64, ptr %"tmp#41##0" + %"tmp#42##0" = alloca i8, i64 8, align 8 + call fastcc void @"int_list.remove<0>[410bae77d3]"(i64 %"tmp#4##0", i64 2, ptr %"tmp#42##0") + %"tmp#5##0" = load i64, ptr %"tmp#42##0" + call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#12" to i64 )) + call ccc void @putchar(i8 10) + call fastcc void @"int_list.print<0>"(i64 %"tmp#5##0") + call ccc void @putchar(i8 10) + %"l##5" = call fastcc i64 @"int_list.sort<0>[410bae77d3]"(i64 %"tmp#5##0") + call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#12" to i64 )) + call ccc void @putchar(i8 10) + call fastcc void @"int_list.print<0>"(i64 %"l##5") + call ccc void @putchar(i8 10) + ret void } - -define external fastcc void @"int_list_test.test_int_list<0>[9e35cb823b]"(i64 %"x##0", i64 %"y##0", i64 %"z##0") { -entry: - %0 = tail call fastcc i64 @"int_list.reverse_helper<0>[410bae77d3]"(i64 %"x##0", i64 0) - %1 = tail call fastcc i64 @"int_list.reverse_helper<0>[410bae77d3]"(i64 %"z##0", i64 0) - %2 = tail call fastcc i64 @"int_list.append<0>[410bae77d3]"(i64 %"y##0", i64 99) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @int_list_test.17, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"int_list.print<0>"(i64 %0) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"int_list.print<0>"(i64 %2) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"int_list.print<0>"(i64 %1) - tail call ccc void @putchar(i8 10) - %3 = alloca i64 - call fastcc void @"int_list.extend<0>[410bae77d3]"(i64 %0, i64 %2, i64* %3) - %4 = load i64, i64* %3 - %5 = alloca i64 - call fastcc void @"int_list.extend<0>[410bae77d3]"(i64 %4, i64 %1, i64* %5) - %6 = load i64, i64* %5 - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @int_list_test.17, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"int_list.print<0>"(i64 %6) - tail call ccc void @putchar(i8 10) - %7 = alloca i64 - call fastcc void @"int_list.insert<0>[410bae77d3]"(i64 %6, i64 4, i64 78, i64* %7) - %8 = load i64, i64* %7 - %9 = alloca i64 - call fastcc void @"int_list.pop<0>[410bae77d3]"(i64 %8, i64 20, i64* %9) - %10 = load i64, i64* %9 - %11 = alloca i64 - call fastcc void @"int_list.remove<0>[410bae77d3]"(i64 %10, i64 2, i64* %11) - %12 = load i64, i64* %11 - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @int_list_test.17, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"int_list.print<0>"(i64 %12) - tail call ccc void @putchar(i8 10) - %13 = tail call fastcc i64 @"int_list.sort<0>[410bae77d3]"(i64 %12) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @int_list_test.17, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"int_list.print<0>"(i64 %13) - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"int_list_test.test_int_list<0>[9e35cb823b]"(i64 %"x##0", i64 %"y##0", i64 %"z##0") { + %"x##1" = tail call fastcc i64 @"int_list.reverse_helper<0>[410bae77d3]"(i64 %"x##0", i64 0) + %"z##1" = tail call fastcc i64 @"int_list.reverse_helper<0>[410bae77d3]"(i64 %"z##0", i64 0) + %"tmp#0##0" = tail call fastcc i64 @"int_list.append<0>[410bae77d3]"(i64 %"y##0", i64 99) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#12" to i64 )) + call ccc void @putchar(i8 10) + tail call fastcc void @"int_list.print<0>"(i64 %"x##1") + call ccc void @putchar(i8 10) + tail call fastcc void @"int_list.print<0>"(i64 %"tmp#0##0") + call ccc void @putchar(i8 10) + tail call fastcc void @"int_list.print<0>"(i64 %"z##1") + call ccc void @putchar(i8 10) + %"tmp#38##0" = alloca i8, i64 8, align 8 + call fastcc void @"int_list.extend<0>[410bae77d3]"(i64 %"x##1", i64 %"tmp#0##0", ptr %"tmp#38##0") + %"tmp#1##0" = load i64, ptr %"tmp#38##0" + %"tmp#39##0" = alloca i8, i64 8, align 8 + call fastcc void @"int_list.extend<0>[410bae77d3]"(i64 %"tmp#1##0", i64 %"z##1", ptr %"tmp#39##0") + %"tmp#2##0" = load i64, ptr %"tmp#39##0" + call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#12" to i64 )) + call ccc void @putchar(i8 10) + call fastcc void @"int_list.print<0>"(i64 %"tmp#2##0") + call ccc void @putchar(i8 10) + %"tmp#40##0" = alloca i8, i64 8, align 8 + call fastcc void @"int_list.insert<0>[410bae77d3]"(i64 %"tmp#2##0", i64 4, i64 78, ptr %"tmp#40##0") + %"tmp#3##0" = load i64, ptr %"tmp#40##0" + %"tmp#41##0" = alloca i8, i64 8, align 8 + call fastcc void @"int_list.pop<0>[410bae77d3]"(i64 %"tmp#3##0", i64 20, ptr %"tmp#41##0") + %"tmp#4##0" = load i64, ptr %"tmp#41##0" + %"tmp#42##0" = alloca i8, i64 8, align 8 + call fastcc void @"int_list.remove<0>[410bae77d3]"(i64 %"tmp#4##0", i64 2, ptr %"tmp#42##0") + %"tmp#5##0" = load i64, ptr %"tmp#42##0" + call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#12" to i64 )) + call ccc void @putchar(i8 10) + call fastcc void @"int_list.print<0>"(i64 %"tmp#5##0") + call ccc void @putchar(i8 10) + %"l##5" = call fastcc i64 @"int_list.sort<0>[410bae77d3]"(i64 %"tmp#5##0") + call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#12" to i64 )) + call ccc void @putchar(i8 10) + call fastcc void @"int_list.print<0>"(i64 %"l##5") + call ccc void @putchar(i8 10) + ret void } int_list.wybe:4:59: Explicit specification of current type int_list, it is recommended to specify type as _ diff --git a/test-cases/complex/utils.py b/test-cases/complex/utils.py index 121367478..f790777e7 100644 --- a/test-cases/complex/utils.py +++ b/test-cases/complex/utils.py @@ -16,15 +16,11 @@ def test_case(func) -> None: TEST_CASES.append((func.__name__, filename, func)) return func -def normalise(output: str) -> str: - output = re.sub(r"@([A-Za-z_]\w*):[0-9:]*", r"@\1:nn:nn", output) - output = re.sub(r"\[[0-9][0-9]* x i8\]", "[?? x i8]", output) - return output - class Context: - def __init__(self, tmp_dir: str, out_file: TextIOWrapper) -> None: + def __init__(self, tmp_dir: str, root_dir: str, out_file: TextIOWrapper) -> None: self.tmp_dir = tmp_dir + self.root_dir = root_dir self.out_file = out_file self.files_hash = defaultdict(str) @@ -105,7 +101,15 @@ def wybe_build_target(self, target: str, force_all: bool, final_dump: bool, self.write_section("ERROR OUTPUT", r.stdout.decode("utf-8")) r.check_returncode() - return (r.returncode, normalise(r.stdout.decode("utf-8"))) + return (r.returncode, self.normalise(r.stdout.decode("utf-8"))) + + def normalise(self, output: str) -> str: + output = re.sub(r"@([A-Za-z_]\w*):[0-9:]*", r"@\1:nn:nn", output) + output = re.sub(r"\[ [0-9][0-9]* x i8 \]", "[ ?? x i8 ]", output) + output = re.sub(r"(target triple *= *).*", r"\1???", output) + output = output.replace(self.tmp_dir, "!TMP!") + output = output.replace(self.root_dir, "!ROOT!") + return output def execute_program(self, exe: str, check: bool, input: Optional[str] = None, diff --git a/test-cases/execution/type_generics.exp b/test-cases/execution/type_generics.exp index e268769e0..d7f6880d9 100644 --- a/test-cases/execution/type_generics.exp +++ b/test-cases/execution/type_generics.exp @@ -2,8 +2,8 @@ 1 1 1 -1 -1 +42 +42 1.000000 1.000000 a diff --git a/test-cases/execution/type_generics.wybe b/test-cases/execution/type_generics.wybe index b151153d4..65cd7f96b 100644 --- a/test-cases/execution/type_generics.wybe +++ b/test-cases/execution/type_generics.wybe @@ -13,9 +13,10 @@ def {test} foo2(x:T0, ?y:T0) { [?y|_] = l } -if {foo2(1, ?y) :: !println(y)} -?i = 1; if {foo2(i, ?y) :: !println(y)} -?f = 1.0; if {foo2(f, ?fx) :: !println(fx)} +if {foo2(42, ?y) :: !println(y)} +?i = 42; if {foo2(i, ?y) :: !println(y)} +?f = 1.0; if {foo2(f, ?fx) :: !println(fx) + | else :: !println "foo2 fails!"} if {foo2(1.0, ?x) :: !println(x)} if {foo2('a', ?z) :: !println(z)} if {foo2(false, ?b) :: !println(b)} diff --git a/test-cases/final-dump-test.sh b/test-cases/final-dump-test.sh index 081a9f2c0..65891e2fb 100755 --- a/test-cases/final-dump-test.sh +++ b/test-cases/final-dump-test.sh @@ -22,20 +22,28 @@ do $TIMEOUT ../wybemk --log=FinalDump --force-all -L $LIBDIR $targ 2>&1 \ | sed -e 's/@\([A-Za-z0-9_]*\):[0-9:]*/@\1:nn:nn/g' \ -e "s|`pwd`|!ROOT!|g" \ - -e 's/\[[0-9][0-9]* x i8\]/[?? x i8]/g' \ + -e 's/\[ [0-9][0-9]* x i8 \]/[ ?? x i8 ]/g' \ + -e 's/^\(target triple *\)=.*/\1 ????/' \ > $out # Add a newline to the end of a file if there isn't to resolve platform differences. ed -s $out <<< w > /dev/null 2>&1 if [ ! -r $exp ] ; then printf "?" - NEW="$NEW\n $out" + NEW="$NEW\n test-cases/$out" elif diff -q $exp $out >/dev/null 2>&1 ; then printf "." else - printf "\n**************** difference building $targ ****************\n" >> ../ERRS - dwdiff -C1 -c -d '()<>~!@:?.%#' $exp $out >> ../ERRS 2>&1 printf "X" - FAILS="$FAILS\n $out" + FAILS="$FAILS\n test-cases/$out" + outlines=`wc -l < $out` + explines=`wc -l < $exp` + if [ "$outlines" -le 20 ] && [ "$explines" -gt 20 ] ; then + printf "\n************ unexpected output building $targ *************\n" >> ../ERRS + cat $out >> ../ERRS + else + printf "\n**************** difference building $targ ****************\n" >> ../ERRS + dwdiff -C1 -c -d '()<>~!@:?.%#' $exp $out >> ../ERRS 2>&1 + fi fi done echo -e diff --git a/test-cases/final-dump/aaa.exp b/test-cases/final-dump/aaa.exp index 739877b7e..790578069 100644 --- a/test-cases/final-dump/aaa.exp +++ b/test-cases/final-dump/aaa.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module aaa representation : (not a type) public submods : @@ -23,36 +26,25 @@ module top-level code > public {inline,semipure} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'aaa' +source_filename = "!ROOT!/final-dump/aaa.wybe" +target triple ???? - - - -@aaa.1 = constant {i64, i64} { i64 9, i64 ptrtoint ([?? x i8]* @aaa.0 to i64) } - - -@aaa.0 = constant [?? x i8] c"AAA: Init\00" - - -declare external ccc void @putchar(i8) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc i8* @wybe_malloc(i32) - +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c"AAA: Init\00", align 8 +@"string#1" = private unnamed_addr constant {i64, i64} { i64 9, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) - -define external fastcc void @"aaa.<0>"() alwaysinline { -entry: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @aaa.1, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"aaa.<0>"() { + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#1" to i64 )) + call ccc void @putchar(i8 10) + ret void } + -------------------------------------------------- Module bbb representation : (not a type) @@ -76,36 +68,25 @@ module top-level code > public {inline,semipure} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'bbb' +source_filename = "!ROOT!/final-dump/bbb.wybe" +target triple ???? - - - -@bbb.1 = constant {i64, i64} { i64 9, i64 ptrtoint ([?? x i8]* @bbb.0 to i64) } - - -@bbb.0 = constant [?? x i8] c"BBB: Init\00" - - -declare external ccc void @putchar(i8) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc i8* @wybe_malloc(i32) - +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c"BBB: Init\00", align 8 +@"string#1" = private unnamed_addr constant {i64, i64} { i64 9, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) - -define external fastcc void @"bbb.<0>"() alwaysinline { -entry: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @bbb.1, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"bbb.<0>"() { + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#1" to i64 )) + call ccc void @putchar(i8 10) + ret void } + -------------------------------------------------- Module ccc representation : (not a type) @@ -129,36 +110,25 @@ module top-level code > public {inline,semipure} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'ccc' +source_filename = "!ROOT!/final-dump/ccc.wybe" +target triple ???? - - - -@ccc.1 = constant {i64, i64} { i64 9, i64 ptrtoint ([?? x i8]* @ccc.0 to i64) } - - -@ccc.0 = constant [?? x i8] c"CCC: Init\00" - - -declare external ccc void @putchar(i8) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c"CCC: Init\00", align 8 +@"string#1" = private unnamed_addr constant {i64, i64} { i64 9, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -define external fastcc void @"ccc.<0>"() alwaysinline { -entry: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @ccc.1, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"ccc.<0>"() { + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#1" to i64 )) + call ccc void @putchar(i8 10) + ret void } + -------------------------------------------------- Module ddd representation : (not a type) @@ -181,33 +151,21 @@ module top-level code > public {inline,semipure} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'ddd' +source_filename = "!ROOT!/final-dump/ddd.wybe" +target triple ???? - - - -@ddd.1 = constant {i64, i64} { i64 9, i64 ptrtoint ([?? x i8]* @ddd.0 to i64) } - - -@ddd.0 = constant [?? x i8] c"DDD: Init\00" - - -declare external ccc void @putchar(i8) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c"DDD: Init\00", align 8 +@"string#1" = private unnamed_addr constant {i64, i64} { i64 9, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -define external fastcc void @"ddd.<0>"() alwaysinline { -entry: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @ddd.1, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"ddd.<0>"() { + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#1" to i64 )) + call ccc void @putchar(i8 10) + ret void } diff --git a/test-cases/final-dump/afterbreak.exp b/test-cases/final-dump/afterbreak.exp index e4e6a772e..77d8ae8df 100644 --- a/test-cases/final-dump/afterbreak.exp +++ b/test-cases/final-dump/afterbreak.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module afterbreak representation : (not a type) public submods : @@ -49,50 +52,38 @@ proc #cont#2 > {inline,semipure} (1 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'afterbreak' +source_filename = "!ROOT!/final-dump/afterbreak.wybe" +target triple ???? - - - -declare external ccc void @putchar(i8) - - -declare external ccc void @print_int(i64) +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"afterbreak.<0>"() alwaysinline { -entry: - tail call fastcc void @"afterbreak.#cont#1<0>"(i64 1) - ret void +define external fastcc void @"afterbreak.<0>"() { + tail call fastcc void @"afterbreak.#cont#1<0>"(i64 1) + ret void } - -define external fastcc void @"afterbreak.#cont#1<0>"(i64 %"x##0") { -entry: - %0 = icmp sgt i64 %"x##0", 10 - br i1 %0, label %if.then, label %if.else -if.then: - ret void -if.else: - %1 = add i64 %"x##0", 1 - tail call ccc void @print_int(i64 %1) - tail call ccc void @putchar(i8 10) - musttail call fastcc void @"afterbreak.#cont#1<0>"(i64 %1) - ret void +define external fastcc void @"afterbreak.#cont#1<0>"(i64 %"x##0") { + %"tmp#1##0" = icmp sgt i64 %"x##0", 10 + br i1 %"tmp#1##0", label %if.then.0, label %if.else.0 +if.then.0: + ret void +if.else.0: + %"tmp#0##0" = add i64 %"x##0", 1 + call ccc void @print_int(i64 %"tmp#0##0") + call ccc void @putchar(i8 10) + tail call fastcc void @"afterbreak.#cont#1<0>"(i64 %"tmp#0##0") + ret void } - -define external fastcc void @"afterbreak.#cont#2<0>"(i64 %"y##0") alwaysinline { -entry: - tail call ccc void @print_int(i64 %"y##0") - tail call ccc void @putchar(i8 10) - musttail call fastcc void @"afterbreak.#cont#1<0>"(i64 %"y##0") - ret void +define external fastcc void @"afterbreak.#cont#2<0>"(i64 %"y##0") { + call ccc void @print_int(i64 %"y##0") + call ccc void @putchar(i8 10) + tail call fastcc void @"afterbreak.#cont#1<0>"(i64 %"y##0") + ret void } diff --git a/test-cases/final-dump/alias1.exp b/test-cases/final-dump/alias1.exp index 752f34f66..715b24823 100644 --- a/test-cases/final-dump/alias1.exp +++ b/test-cases/final-dump/alias1.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module alias1 representation : (not a type) public submods : @@ -146,275 +149,183 @@ replicate(p1##0:position.position, ?p2##0:position.position)<{<>}; { LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'alias1' - - - - -@alias1.29 = constant {i64, i64} { i64 12, i64 ptrtoint ([?? x i8]* @alias1.28 to i64) } - - -@alias1.17 = constant {i64, i64} { i64 16, i64 ptrtoint ([?? x i8]* @alias1.16 to i64) } - - -@alias1.25 = constant {i64, i64} { i64 16, i64 ptrtoint ([?? x i8]* @alias1.24 to i64) } - - -@alias1.7 = constant {i64, i64} { i64 16, i64 ptrtoint ([?? x i8]* @alias1.6 to i64) } - - -@alias1.11 = constant {i64, i64} { i64 19, i64 ptrtoint ([?? x i8]* @alias1.10 to i64) } - - -@alias1.15 = constant {i64, i64} { i64 19, i64 ptrtoint ([?? x i8]* @alias1.14 to i64) } - - -@alias1.23 = constant {i64, i64} { i64 19, i64 ptrtoint ([?? x i8]* @alias1.22 to i64) } - - -@alias1.9 = constant {i64, i64} { i64 19, i64 ptrtoint ([?? x i8]* @alias1.8 to i64) } - - -@alias1.19 = constant {i64, i64} { i64 24, i64 ptrtoint ([?? x i8]* @alias1.18 to i64) } - - -@alias1.1 = constant {i64, i64} { i64 28, i64 ptrtoint ([?? x i8]* @alias1.0 to i64) } - - -@alias1.3 = constant {i64, i64} { i64 28, i64 ptrtoint ([?? x i8]* @alias1.2 to i64) } - - -@alias1.5 = constant {i64, i64} { i64 28, i64 ptrtoint ([?? x i8]* @alias1.4 to i64) } - - -@alias1.13 = constant {i64, i64} { i64 43, i64 ptrtoint ([?? x i8]* @alias1.12 to i64) } - - -@alias1.21 = constant {i64, i64} { i64 43, i64 ptrtoint ([?? x i8]* @alias1.20 to i64) } - - -@alias1.27 = constant {i64, i64} { i64 43, i64 ptrtoint ([?? x i8]* @alias1.26 to i64) } - - -@alias1.12 = constant [?? x i8] c"--- Inside bar, after calling x(!p2, 555): \00" - - -@alias1.6 = constant [?? x i8] c"--- Inside bar: \00" - - -@alias1.20 = constant [?? x i8] c"--- Inside baz, after calling x(!p1, 555): \00" - - -@alias1.16 = constant [?? x i8] c"--- Inside baz: \00" - - -@alias1.26 = constant [?? x i8] c"--- Inside foo, after calling x(!p1, 555): \00" - - -@alias1.24 = constant [?? x i8] c"--- Inside foo: \00" - - -@alias1.2 = constant [?? x i8] c"-------------- Calling bar: \00" - - -@alias1.4 = constant [?? x i8] c"-------------- Calling baz: \00" - - -@alias1.0 = constant [?? x i8] c"-------------- Calling foo: \00" - - -@alias1.8 = constant [?? x i8] c"expect p1(101,102):\00" - - -@alias1.22 = constant [?? x i8] c"expect p1(555,102):\00" - - -@alias1.10 = constant [?? x i8] c"expect p2(101,102):\00" - - -@alias1.14 = constant [?? x i8] c"expect p2(555,102):\00" - - -@alias1.18 = constant [?? x i8] c"expect p3(33333333,102):\00" - - -@alias1.28 = constant [?? x i8] c"random print\00" - - -declare external ccc void @putchar(i8) - - -declare external ccc void @print_int(i64) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external fastcc void @"position.printPosition<0>"(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"alias1.<0>"() { -entry: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias1.1, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"alias1.foo<0>"() - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias1.3, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"alias1.bar<0>"() - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias1.5, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - musttail call fastcc void @"alias1.baz<0>"() - ret void +source_filename = "!ROOT!/final-dump/alias1.wybe" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c"--- Inside bar, after calling x(!p2, 555): \00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c"--- Inside bar: \00", align 8 +@"cstring#2" = private unnamed_addr constant [ ?? x i8 ] c"--- Inside baz, after calling x(!p1, 555): \00", align 8 +@"cstring#3" = private unnamed_addr constant [ ?? x i8 ] c"--- Inside baz: \00", align 8 +@"cstring#4" = private unnamed_addr constant [ ?? x i8 ] c"--- Inside foo, after calling x(!p1, 555): \00", align 8 +@"cstring#5" = private unnamed_addr constant [ ?? x i8 ] c"--- Inside foo: \00", align 8 +@"cstring#6" = private unnamed_addr constant [ ?? x i8 ] c"-------------- Calling bar: \00", align 8 +@"cstring#7" = private unnamed_addr constant [ ?? x i8 ] c"-------------- Calling baz: \00", align 8 +@"cstring#8" = private unnamed_addr constant [ ?? x i8 ] c"-------------- Calling foo: \00", align 8 +@"cstring#9" = private unnamed_addr constant [ ?? x i8 ] c"expect p1(101,102):\00", align 8 +@"cstring#10" = private unnamed_addr constant [ ?? x i8 ] c"expect p1(555,102):\00", align 8 +@"cstring#11" = private unnamed_addr constant [ ?? x i8 ] c"expect p2(101,102):\00", align 8 +@"cstring#12" = private unnamed_addr constant [ ?? x i8 ] c"expect p2(555,102):\00", align 8 +@"cstring#13" = private unnamed_addr constant [ ?? x i8 ] c"expect p3(33333333,102):\00", align 8 +@"cstring#14" = private unnamed_addr constant [ ?? x i8 ] c"random print\00", align 8 +@"string#15" = private unnamed_addr constant {i64, i64} { i64 43, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +@"string#16" = private unnamed_addr constant {i64, i64} { i64 16, i64 ptrtoint( ptr @"cstring#1" to i64 ) }, align 8 +@"string#17" = private unnamed_addr constant {i64, i64} { i64 43, i64 ptrtoint( ptr @"cstring#2" to i64 ) }, align 8 +@"string#18" = private unnamed_addr constant {i64, i64} { i64 16, i64 ptrtoint( ptr @"cstring#3" to i64 ) }, align 8 +@"string#19" = private unnamed_addr constant {i64, i64} { i64 43, i64 ptrtoint( ptr @"cstring#4" to i64 ) }, align 8 +@"string#20" = private unnamed_addr constant {i64, i64} { i64 16, i64 ptrtoint( ptr @"cstring#5" to i64 ) }, align 8 +@"string#21" = private unnamed_addr constant {i64, i64} { i64 28, i64 ptrtoint( ptr @"cstring#6" to i64 ) }, align 8 +@"string#22" = private unnamed_addr constant {i64, i64} { i64 28, i64 ptrtoint( ptr @"cstring#7" to i64 ) }, align 8 +@"string#23" = private unnamed_addr constant {i64, i64} { i64 28, i64 ptrtoint( ptr @"cstring#8" to i64 ) }, align 8 +@"string#24" = private unnamed_addr constant {i64, i64} { i64 19, i64 ptrtoint( ptr @"cstring#9" to i64 ) }, align 8 +@"string#25" = private unnamed_addr constant {i64, i64} { i64 19, i64 ptrtoint( ptr @"cstring#10" to i64 ) }, align 8 +@"string#26" = private unnamed_addr constant {i64, i64} { i64 19, i64 ptrtoint( ptr @"cstring#11" to i64 ) }, align 8 +@"string#27" = private unnamed_addr constant {i64, i64} { i64 19, i64 ptrtoint( ptr @"cstring#12" to i64 ) }, align 8 +@"string#28" = private unnamed_addr constant {i64, i64} { i64 24, i64 ptrtoint( ptr @"cstring#13" to i64 ) }, align 8 +@"string#29" = private unnamed_addr constant {i64, i64} { i64 12, i64 ptrtoint( ptr @"cstring#14" to i64 ) }, align 8 + +declare external fastcc void @"position.printPosition<0>"(i64) +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"alias1.<0>"() { + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#23" to i64 )) + call ccc void @putchar(i8 10) + tail call fastcc void @"alias1.foo<0>"() + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#21" to i64 )) + call ccc void @putchar(i8 10) + tail call fastcc void @"alias1.bar<0>"() + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#22" to i64 )) + call ccc void @putchar(i8 10) + tail call fastcc void @"alias1.baz<0>"() + ret void } - -define external fastcc void @"alias1.bar<0>"() { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 101, i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 102, i64* %5 - %6 = tail call fastcc i64 @"alias1.replicate<0>"(i64 %2) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias1.7, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias1.9, i32 0, i32 0) to i64)) - tail call fastcc void @"position.printPosition<0>"(i64 %2) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias1.11, i32 0, i32 0) to i64)) - tail call fastcc void @"position.printPosition<0>"(i64 %6) - %7 = trunc i64 16 to i32 - %8 = tail call ccc i8* @wybe_malloc(i32 %7) - %9 = ptrtoint i8* %8 to i64 - %10 = inttoptr i64 %9 to i8* - %11 = inttoptr i64 %6 to i8* - %12 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %10, i8* %11, i32 %12, i1 0) - %13 = inttoptr i64 %9 to i64* - store i64 555, i64* %13 - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias1.13, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias1.9, i32 0, i32 0) to i64)) - tail call fastcc void @"position.printPosition<0>"(i64 %2) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias1.15, i32 0, i32 0) to i64)) - tail call fastcc void @"position.printPosition<0>"(i64 %9) - ret void +define external fastcc void @"alias1.bar<0>"() { + %"tmp#13##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#3##0" = ptrtoint ptr %"tmp#13##0" to i64 + %"tmp#14##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 101, ptr %"tmp#14##0" + %"tmp#15##0" = add i64 %"tmp#3##0", 8 + %"tmp#16##0" = inttoptr i64 %"tmp#15##0" to ptr + store i64 102, ptr %"tmp#16##0" + %"p2##0" = tail call fastcc i64 @"alias1.replicate<0>"(i64 %"tmp#3##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#16" to i64 )) + call ccc void @putchar(i8 10) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#24" to i64 )) + tail call fastcc void @"position.printPosition<0>"(i64 %"tmp#3##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#26" to i64 )) + tail call fastcc void @"position.printPosition<0>"(i64 %"p2##0") + %"tmp#17##0" = inttoptr i64 %"p2##0" to ptr + %"tmp#18##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#18##0", ptr %"tmp#17##0", i64 16, i1 0) + %"tmp#19##0" = ptrtoint ptr %"tmp#18##0" to i64 + %"tmp#20##0" = inttoptr i64 %"tmp#19##0" to ptr + store i64 555, ptr %"tmp#20##0" + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#15" to i64 )) + call ccc void @putchar(i8 10) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#24" to i64 )) + tail call fastcc void @"position.printPosition<0>"(i64 %"tmp#3##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#27" to i64 )) + tail call fastcc void @"position.printPosition<0>"(i64 %"tmp#19##0") + ret void } - -define external fastcc void @"alias1.baz<0>"() { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 101, i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 102, i64* %5 - %6 = tail call fastcc i64 @"alias1.replicate<0>"(i64 %2) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias1.17, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias1.9, i32 0, i32 0) to i64)) - tail call fastcc void @"position.printPosition<0>"(i64 %2) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias1.11, i32 0, i32 0) to i64)) - tail call fastcc void @"position.printPosition<0>"(i64 %6) - %7 = add i64 %6, 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = trunc i64 16 to i32 - %11 = tail call ccc i8* @wybe_malloc(i32 %10) - %12 = ptrtoint i8* %11 to i64 - %13 = inttoptr i64 %12 to i64* - store i64 33333333, i64* %13 - %14 = add i64 %12, 8 - %15 = inttoptr i64 %14 to i64* - store i64 %9, i64* %15 - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias1.19, i32 0, i32 0) to i64)) - tail call fastcc void @"position.printPosition<0>"(i64 %12) - %16 = trunc i64 16 to i32 - %17 = tail call ccc i8* @wybe_malloc(i32 %16) - %18 = ptrtoint i8* %17 to i64 - %19 = inttoptr i64 %18 to i8* - %20 = inttoptr i64 %2 to i8* - %21 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %19, i8* %20, i32 %21, i1 0) - %22 = inttoptr i64 %18 to i64* - store i64 555, i64* %22 - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias1.21, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias1.23, i32 0, i32 0) to i64)) - tail call fastcc void @"position.printPosition<0>"(i64 %18) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias1.11, i32 0, i32 0) to i64)) - tail call fastcc void @"position.printPosition<0>"(i64 %6) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias1.19, i32 0, i32 0) to i64)) - tail call fastcc void @"position.printPosition<0>"(i64 %12) - ret void +define external fastcc void @"alias1.baz<0>"() { + %"tmp#20##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#5##0" = ptrtoint ptr %"tmp#20##0" to i64 + %"tmp#21##0" = inttoptr i64 %"tmp#5##0" to ptr + store i64 101, ptr %"tmp#21##0" + %"tmp#22##0" = add i64 %"tmp#5##0", 8 + %"tmp#23##0" = inttoptr i64 %"tmp#22##0" to ptr + store i64 102, ptr %"tmp#23##0" + %"p2##0" = tail call fastcc i64 @"alias1.replicate<0>"(i64 %"tmp#5##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#18" to i64 )) + call ccc void @putchar(i8 10) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#24" to i64 )) + tail call fastcc void @"position.printPosition<0>"(i64 %"tmp#5##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#26" to i64 )) + tail call fastcc void @"position.printPosition<0>"(i64 %"p2##0") + %"tmp#24##0" = add i64 %"p2##0", 8 + %"tmp#25##0" = inttoptr i64 %"tmp#24##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#25##0" + %"tmp#26##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#13##0" = ptrtoint ptr %"tmp#26##0" to i64 + %"tmp#27##0" = inttoptr i64 %"tmp#13##0" to ptr + store i64 33333333, ptr %"tmp#27##0" + %"tmp#28##0" = add i64 %"tmp#13##0", 8 + %"tmp#29##0" = inttoptr i64 %"tmp#28##0" to ptr + store i64 %"tmp#2##0", ptr %"tmp#29##0" + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#28" to i64 )) + tail call fastcc void @"position.printPosition<0>"(i64 %"tmp#13##0") + %"tmp#30##0" = inttoptr i64 %"tmp#5##0" to ptr + %"tmp#31##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#31##0", ptr %"tmp#30##0", i64 16, i1 0) + %"tmp#32##0" = ptrtoint ptr %"tmp#31##0" to i64 + %"tmp#33##0" = inttoptr i64 %"tmp#32##0" to ptr + store i64 555, ptr %"tmp#33##0" + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#17" to i64 )) + call ccc void @putchar(i8 10) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#25" to i64 )) + tail call fastcc void @"position.printPosition<0>"(i64 %"tmp#32##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#26" to i64 )) + tail call fastcc void @"position.printPosition<0>"(i64 %"p2##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#28" to i64 )) + tail call fastcc void @"position.printPosition<0>"(i64 %"tmp#13##0") + ret void } - -define external fastcc void @"alias1.foo<0>"() { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 101, i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 102, i64* %5 - %6 = tail call fastcc i64 @"alias1.replicate<0>"(i64 %2) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias1.25, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias1.9, i32 0, i32 0) to i64)) - tail call fastcc void @"position.printPosition<0>"(i64 %2) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias1.11, i32 0, i32 0) to i64)) - tail call fastcc void @"position.printPosition<0>"(i64 %6) - %7 = trunc i64 16 to i32 - %8 = tail call ccc i8* @wybe_malloc(i32 %7) - %9 = ptrtoint i8* %8 to i64 - %10 = inttoptr i64 %9 to i8* - %11 = inttoptr i64 %2 to i8* - %12 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %10, i8* %11, i32 %12, i1 0) - %13 = inttoptr i64 %9 to i64* - store i64 555, i64* %13 - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias1.27, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias1.23, i32 0, i32 0) to i64)) - tail call fastcc void @"position.printPosition<0>"(i64 %9) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias1.11, i32 0, i32 0) to i64)) - tail call fastcc void @"position.printPosition<0>"(i64 %6) - ret void +define external fastcc void @"alias1.foo<0>"() { + %"tmp#13##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#3##0" = ptrtoint ptr %"tmp#13##0" to i64 + %"tmp#14##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 101, ptr %"tmp#14##0" + %"tmp#15##0" = add i64 %"tmp#3##0", 8 + %"tmp#16##0" = inttoptr i64 %"tmp#15##0" to ptr + store i64 102, ptr %"tmp#16##0" + %"p2##0" = tail call fastcc i64 @"alias1.replicate<0>"(i64 %"tmp#3##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#20" to i64 )) + call ccc void @putchar(i8 10) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#24" to i64 )) + tail call fastcc void @"position.printPosition<0>"(i64 %"tmp#3##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#26" to i64 )) + tail call fastcc void @"position.printPosition<0>"(i64 %"p2##0") + %"tmp#17##0" = inttoptr i64 %"tmp#3##0" to ptr + %"tmp#18##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#18##0", ptr %"tmp#17##0", i64 16, i1 0) + %"tmp#19##0" = ptrtoint ptr %"tmp#18##0" to i64 + %"tmp#20##0" = inttoptr i64 %"tmp#19##0" to ptr + store i64 555, ptr %"tmp#20##0" + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#19" to i64 )) + call ccc void @putchar(i8 10) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#25" to i64 )) + tail call fastcc void @"position.printPosition<0>"(i64 %"tmp#19##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#26" to i64 )) + tail call fastcc void @"position.printPosition<0>"(i64 %"p2##0") + ret void } - -define external fastcc i64 @"alias1.replicate<0>"(i64 %"p1##0") { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 0, i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 0, i64* %5 - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias1.29, i32 0, i32 0) to i64)) - %6 = inttoptr i64 %2 to i64* - %7 = load i64, i64* %6 - tail call ccc void @print_int(i64 %7) - tail call ccc void @putchar(i8 10) - ret i64 %"p1##0" +define external fastcc i64 @"alias1.replicate<0>"(i64 %"p1##0") { + %"tmp#11##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#4##0" = ptrtoint ptr %"tmp#11##0" to i64 + %"tmp#12##0" = inttoptr i64 %"tmp#4##0" to ptr + store i64 0, ptr %"tmp#12##0" + %"tmp#13##0" = add i64 %"tmp#4##0", 8 + %"tmp#14##0" = inttoptr i64 %"tmp#13##0" to ptr + store i64 0, ptr %"tmp#14##0" + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#29" to i64 )) + %"tmp#15##0" = inttoptr i64 %"tmp#4##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#15##0" + call ccc void @print_int(i64 %"tmp#1##0") + call ccc void @putchar(i8 10) + ret i64 %"p1##0" } + -------------------------------------------------- Module position representation : (not a type) @@ -457,63 +368,42 @@ printPosition(pos##0:position.position)<{<>}; {<>}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'position' - - - - -@position.3 = constant {i64, i64} { i64 1, i64 ptrtoint ([?? x i8]* @position.2 to i64) } - - -@position.5 = constant {i64, i64} { i64 1, i64 ptrtoint ([?? x i8]* @position.4 to i64) } - - -@position.1 = constant {i64, i64} { i64 2, i64 ptrtoint ([?? x i8]* @position.0 to i64) } - - -@position.0 = constant [?? x i8] c" (\00" - - -@position.4 = constant [?? x i8] c")\00" - - -@position.2 = constant [?? x i8] c",\00" - - -declare external ccc void @putchar(i8) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc void @print_int(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"position.printPosition<0>"(i64 %"pos##0") { -entry: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @position.1, i32 0, i32 0) to i64)) - %0 = inttoptr i64 %"pos##0" to i64* - %1 = load i64, i64* %0 - tail call ccc void @print_int(i64 %1) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @position.3, i32 0, i32 0) to i64)) - %2 = add i64 %"pos##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - tail call ccc void @print_int(i64 %4) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @position.5, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - ret void +source_filename = "!ROOT!/final-dump/position.wybe" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c" (\00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c")\00", align 8 +@"cstring#2" = private unnamed_addr constant [ ?? x i8 ] c",\00", align 8 +@"string#3" = private unnamed_addr constant {i64, i64} { i64 2, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +@"string#4" = private unnamed_addr constant {i64, i64} { i64 1, i64 ptrtoint( ptr @"cstring#1" to i64 ) }, align 8 +@"string#5" = private unnamed_addr constant {i64, i64} { i64 1, i64 ptrtoint( ptr @"cstring#2" to i64 ) }, align 8 + +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"position.printPosition<0>"(i64 %"pos##0") { + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#3" to i64 )) + %"tmp#13##0" = inttoptr i64 %"pos##0" to ptr + %"tmp#0##0" = load i64, ptr %"tmp#13##0" + call ccc void @print_int(i64 %"tmp#0##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#5" to i64 )) + %"tmp#14##0" = add i64 %"pos##0", 8 + %"tmp#15##0" = inttoptr i64 %"tmp#14##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#15##0" + call ccc void @print_int(i64 %"tmp#1##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#4" to i64 )) + call ccc void @putchar(i8 10) + ret void } + -------------------------------------------------- Module position.position - representation : address + representation : pointer public submods : public resources: public procs : position.position.=<0> @@ -615,134 +505,110 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'position.position' - - - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i1 @"position.position.=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %"#right##0" to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = icmp eq i64 %1, %6 - br i1 %10, label %if.then, label %if.else -if.then: - %11 = icmp eq i64 %4, %9 - ret i1 %11 -if.else: - ret i1 0 +source_filename = "!ROOT!/final-dump/position.wybe" +target triple ???? + + +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc i1 @"position.position.=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#9##0" = inttoptr i64 %"#left##0" to ptr + %"#left#x##0" = load i64, ptr %"tmp#9##0" + %"tmp#10##0" = add i64 %"#left##0", 8 + %"tmp#11##0" = inttoptr i64 %"tmp#10##0" to ptr + %"#left#y##0" = load i64, ptr %"tmp#11##0" + %"tmp#12##0" = inttoptr i64 %"#right##0" to ptr + %"#right#x##0" = load i64, ptr %"tmp#12##0" + %"tmp#13##0" = add i64 %"#right##0", 8 + %"tmp#14##0" = inttoptr i64 %"tmp#13##0" to ptr + %"#right#y##0" = load i64, ptr %"tmp#14##0" + %"tmp#1##0" = icmp eq i64 %"#left#x##0", %"#right#x##0" + br i1 %"tmp#1##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#15##0" = icmp eq i64 %"#left#y##0", %"#right#y##0" + ret i1 %"tmp#15##0" +if.else.0: + ret i1 0 } - -define external fastcc i64 @"position.position.position<0>"(i64 %"x##0", i64 %"y##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"x##0", i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"y##0", i64* %5 - ret i64 %2 +define external fastcc i64 @"position.position.position<0>"(i64 %"x##0", i64 %"y##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 16) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"x##0", ptr %"tmp#1##0" + %"tmp#2##0" = add i64 %"#rec##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"y##0", ptr %"tmp#3##0" + ret i64 %"#rec##0" } - -define external fastcc {i64, i64} @"position.position.position<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#result##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#result##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = insertvalue {i64, i64} undef, i64 %1, 0 - %6 = insertvalue {i64, i64} %5, i64 %4, 1 - ret {i64, i64} %6 +define external fastcc {i64, i64} @"position.position.position<1>"(i64 %"#result##0") { + %"tmp#0##0" = inttoptr i64 %"#result##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + %"tmp#2##0" = add i64 %"#result##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#3##0" + %"tmp#5##0" = insertvalue {i64, i64} undef, i64 %"tmp#1##0", 0 + %"tmp#6##0" = insertvalue {i64, i64} %"tmp#5##0", i64 %"tmp#4##0", 1 + ret {i64, i64} %"tmp#6##0" } - -define external fastcc i64 @"position.position.x<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#rec##0" to i64* - %1 = load i64, i64* %0 - ret i64 %1 +define external fastcc i64 @"position.position.x<0>"(i64 %"#rec##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + ret i64 %"tmp#1##0" } - -define external fastcc i64 @"position.position.x<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = inttoptr i64 %2 to i64* - store i64 %"#field##0", i64* %6 - ret i64 %2 +define external fastcc i64 @"position.position.x<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"#field##0", ptr %"tmp#3##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"position.position.y<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = add i64 %"#rec##0", 8 - %1 = inttoptr i64 %0 to i64* - %2 = load i64, i64* %1 - ret i64 %2 +define external fastcc i64 @"position.position.y<0>"(i64 %"#rec##0") { + %"tmp#0##0" = add i64 %"#rec##0", 8 + %"tmp#1##0" = inttoptr i64 %"tmp#0##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"position.position.y<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = add i64 %2, 8 - %7 = inttoptr i64 %6 to i64* - store i64 %"#field##0", i64* %7 - ret i64 %2 +define external fastcc i64 @"position.position.y<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = add i64 %"tmp#2##0", 8 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 %"#field##0", ptr %"tmp#4##0" + ret i64 %"tmp#2##0" } - -define external fastcc i1 @"position.position.~=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %"#right##0" to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = icmp eq i64 %1, %6 - br i1 %10, label %if.then, label %if.else -if.then: - %11 = icmp eq i64 %4, %9 - %12 = xor i1 %11, 1 - ret i1 %12 -if.else: - %13 = xor i1 0, 1 - ret i1 %13 +define external fastcc i1 @"position.position.~=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#8##0" = inttoptr i64 %"#left##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#8##0" + %"tmp#9##0" = add i64 %"#left##0", 8 + %"tmp#10##0" = inttoptr i64 %"tmp#9##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#10##0" + %"tmp#11##0" = inttoptr i64 %"#right##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#11##0" + %"tmp#12##0" = add i64 %"#right##0", 8 + %"tmp#13##0" = inttoptr i64 %"tmp#12##0" to ptr + %"tmp#6##0" = load i64, ptr %"tmp#13##0" + %"tmp#7##0" = icmp eq i64 %"tmp#3##0", %"tmp#5##0" + br i1 %"tmp#7##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#0##0" = icmp eq i64 %"tmp#4##0", %"tmp#6##0" + %"tmp#14##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#14##0" +if.else.0: + %"tmp#15##0" = xor i1 0, 1 + ret i1 %"tmp#15##0" } diff --git a/test-cases/final-dump/alias2.exp b/test-cases/final-dump/alias2.exp index 3c0b6e7f5..24394692a 100644 --- a/test-cases/final-dump/alias2.exp +++ b/test-cases/final-dump/alias2.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module alias2 representation : (not a type) public submods : @@ -68,128 +71,93 @@ pcopy(p1##0:position.position, ?p2##2:position.position)<{<>}; {<"(i64) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc void @putchar(i8) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"alias2.<0>"() { -entry: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias2.1, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 0, i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 20, i64* %5 - %6 = tail call fastcc i64 @"alias2.pcopy<0>"(i64 %2) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias2.3, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias2.5, i32 0, i32 0) to i64)) - tail call fastcc void @"position.printPosition<0>"(i64 %6) - ret void +source_filename = "!ROOT!/final-dump/alias2.wybe" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c"--- After calling pcopy: \00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c"--- Inside pcopy: \00", align 8 +@"cstring#2" = private unnamed_addr constant [ ?? x i8 ] c"copy a position\00", align 8 +@"cstring#3" = private unnamed_addr constant [ ?? x i8 ] c"expect p2(0,20):\00", align 8 +@"cstring#4" = private unnamed_addr constant [ ?? x i8 ] c"expect r(0,20):\00", align 8 +@"string#5" = private unnamed_addr constant {i64, i64} { i64 25, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +@"string#6" = private unnamed_addr constant {i64, i64} { i64 18, i64 ptrtoint( ptr @"cstring#1" to i64 ) }, align 8 +@"string#7" = private unnamed_addr constant {i64, i64} { i64 15, i64 ptrtoint( ptr @"cstring#2" to i64 ) }, align 8 +@"string#8" = private unnamed_addr constant {i64, i64} { i64 16, i64 ptrtoint( ptr @"cstring#3" to i64 ) }, align 8 +@"string#9" = private unnamed_addr constant {i64, i64} { i64 15, i64 ptrtoint( ptr @"cstring#4" to i64 ) }, align 8 + +declare external fastcc void @"position.printPosition<0>"(i64) +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @putchar(i8) +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"alias2.<0>"() { + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#7" to i64 )) + call ccc void @putchar(i8 10) + %"tmp#11##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#6##0" = ptrtoint ptr %"tmp#11##0" to i64 + %"tmp#12##0" = inttoptr i64 %"tmp#6##0" to ptr + store i64 0, ptr %"tmp#12##0" + %"tmp#13##0" = add i64 %"tmp#6##0", 8 + %"tmp#14##0" = inttoptr i64 %"tmp#13##0" to ptr + store i64 20, ptr %"tmp#14##0" + %"r##0" = tail call fastcc i64 @"alias2.pcopy<0>"(i64 %"tmp#6##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#5" to i64 )) + call ccc void @putchar(i8 10) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#9" to i64 )) + tail call fastcc void @"position.printPosition<0>"(i64 %"r##0") + ret void } - -define external fastcc i64 @"alias2.fcopy<0>"(i64 %"p1##0") { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 0, i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 0, i64* %5 - %6 = inttoptr i64 %"p1##0" to i64* - %7 = load i64, i64* %6 - %8 = inttoptr i64 %2 to i64* - store i64 %7, i64* %8 - %9 = add i64 %"p1##0", 8 - %10 = inttoptr i64 %9 to i64* - %11 = load i64, i64* %10 - %12 = add i64 %2, 8 - %13 = inttoptr i64 %12 to i64* - store i64 %11, i64* %13 - ret i64 %2 +define external fastcc i64 @"alias2.fcopy<0>"(i64 %"p1##0") { + %"tmp#13##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#5##0" = ptrtoint ptr %"tmp#13##0" to i64 + %"tmp#14##0" = inttoptr i64 %"tmp#5##0" to ptr + store i64 0, ptr %"tmp#14##0" + %"tmp#15##0" = add i64 %"tmp#5##0", 8 + %"tmp#16##0" = inttoptr i64 %"tmp#15##0" to ptr + store i64 0, ptr %"tmp#16##0" + %"tmp#17##0" = inttoptr i64 %"p1##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#17##0" + %"tmp#18##0" = inttoptr i64 %"tmp#5##0" to ptr + store i64 %"tmp#1##0", ptr %"tmp#18##0" + %"tmp#19##0" = add i64 %"p1##0", 8 + %"tmp#20##0" = inttoptr i64 %"tmp#19##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#20##0" + %"tmp#21##0" = add i64 %"tmp#5##0", 8 + %"tmp#22##0" = inttoptr i64 %"tmp#21##0" to ptr + store i64 %"tmp#2##0", ptr %"tmp#22##0" + ret i64 %"tmp#5##0" } - -define external fastcc i64 @"alias2.pcopy<0>"(i64 %"p1##0") { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 0, i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 0, i64* %5 - %6 = inttoptr i64 %"p1##0" to i64* - %7 = load i64, i64* %6 - %8 = inttoptr i64 %2 to i64* - store i64 %7, i64* %8 - %9 = add i64 %"p1##0", 8 - %10 = inttoptr i64 %9 to i64* - %11 = load i64, i64* %10 - %12 = add i64 %2, 8 - %13 = inttoptr i64 %12 to i64* - store i64 %11, i64* %13 - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias2.7, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias2.9, i32 0, i32 0) to i64)) - tail call fastcc void @"position.printPosition<0>"(i64 %2) - ret i64 %2 +define external fastcc i64 @"alias2.pcopy<0>"(i64 %"p1##0") { + %"tmp#16##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#5##0" = ptrtoint ptr %"tmp#16##0" to i64 + %"tmp#17##0" = inttoptr i64 %"tmp#5##0" to ptr + store i64 0, ptr %"tmp#17##0" + %"tmp#18##0" = add i64 %"tmp#5##0", 8 + %"tmp#19##0" = inttoptr i64 %"tmp#18##0" to ptr + store i64 0, ptr %"tmp#19##0" + %"tmp#20##0" = inttoptr i64 %"p1##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#20##0" + %"tmp#21##0" = inttoptr i64 %"tmp#5##0" to ptr + store i64 %"tmp#1##0", ptr %"tmp#21##0" + %"tmp#22##0" = add i64 %"p1##0", 8 + %"tmp#23##0" = inttoptr i64 %"tmp#22##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#23##0" + %"tmp#24##0" = add i64 %"tmp#5##0", 8 + %"tmp#25##0" = inttoptr i64 %"tmp#24##0" to ptr + store i64 %"tmp#2##0", ptr %"tmp#25##0" + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#6" to i64 )) + call ccc void @putchar(i8 10) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#8" to i64 )) + tail call fastcc void @"position.printPosition<0>"(i64 %"tmp#5##0") + ret i64 %"tmp#5##0" } + -------------------------------------------------- Module position representation : (not a type) @@ -232,63 +200,42 @@ printPosition(pos##0:position.position)<{<>}; {<>}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'position' - - - - -@position.3 = constant {i64, i64} { i64 1, i64 ptrtoint ([?? x i8]* @position.2 to i64) } - - -@position.5 = constant {i64, i64} { i64 1, i64 ptrtoint ([?? x i8]* @position.4 to i64) } - - -@position.1 = constant {i64, i64} { i64 2, i64 ptrtoint ([?? x i8]* @position.0 to i64) } - - -@position.0 = constant [?? x i8] c" (\00" - - -@position.4 = constant [?? x i8] c")\00" - - -@position.2 = constant [?? x i8] c",\00" - - -declare external ccc void @putchar(i8) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc void @print_int(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"position.printPosition<0>"(i64 %"pos##0") { -entry: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @position.1, i32 0, i32 0) to i64)) - %0 = inttoptr i64 %"pos##0" to i64* - %1 = load i64, i64* %0 - tail call ccc void @print_int(i64 %1) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @position.3, i32 0, i32 0) to i64)) - %2 = add i64 %"pos##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - tail call ccc void @print_int(i64 %4) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @position.5, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - ret void +source_filename = "!ROOT!/final-dump/position.wybe" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c" (\00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c")\00", align 8 +@"cstring#2" = private unnamed_addr constant [ ?? x i8 ] c",\00", align 8 +@"string#3" = private unnamed_addr constant {i64, i64} { i64 2, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +@"string#4" = private unnamed_addr constant {i64, i64} { i64 1, i64 ptrtoint( ptr @"cstring#1" to i64 ) }, align 8 +@"string#5" = private unnamed_addr constant {i64, i64} { i64 1, i64 ptrtoint( ptr @"cstring#2" to i64 ) }, align 8 + +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"position.printPosition<0>"(i64 %"pos##0") { + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#3" to i64 )) + %"tmp#13##0" = inttoptr i64 %"pos##0" to ptr + %"tmp#0##0" = load i64, ptr %"tmp#13##0" + call ccc void @print_int(i64 %"tmp#0##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#5" to i64 )) + %"tmp#14##0" = add i64 %"pos##0", 8 + %"tmp#15##0" = inttoptr i64 %"tmp#14##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#15##0" + call ccc void @print_int(i64 %"tmp#1##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#4" to i64 )) + call ccc void @putchar(i8 10) + ret void } + -------------------------------------------------- Module position.position - representation : address + representation : pointer public submods : public resources: public procs : position.position.=<0> @@ -390,134 +337,110 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'position.position' - - - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i1 @"position.position.=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %"#right##0" to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = icmp eq i64 %1, %6 - br i1 %10, label %if.then, label %if.else -if.then: - %11 = icmp eq i64 %4, %9 - ret i1 %11 -if.else: - ret i1 0 +source_filename = "!ROOT!/final-dump/position.wybe" +target triple ???? + + +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc i1 @"position.position.=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#9##0" = inttoptr i64 %"#left##0" to ptr + %"#left#x##0" = load i64, ptr %"tmp#9##0" + %"tmp#10##0" = add i64 %"#left##0", 8 + %"tmp#11##0" = inttoptr i64 %"tmp#10##0" to ptr + %"#left#y##0" = load i64, ptr %"tmp#11##0" + %"tmp#12##0" = inttoptr i64 %"#right##0" to ptr + %"#right#x##0" = load i64, ptr %"tmp#12##0" + %"tmp#13##0" = add i64 %"#right##0", 8 + %"tmp#14##0" = inttoptr i64 %"tmp#13##0" to ptr + %"#right#y##0" = load i64, ptr %"tmp#14##0" + %"tmp#1##0" = icmp eq i64 %"#left#x##0", %"#right#x##0" + br i1 %"tmp#1##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#15##0" = icmp eq i64 %"#left#y##0", %"#right#y##0" + ret i1 %"tmp#15##0" +if.else.0: + ret i1 0 } - -define external fastcc i64 @"position.position.position<0>"(i64 %"x##0", i64 %"y##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"x##0", i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"y##0", i64* %5 - ret i64 %2 +define external fastcc i64 @"position.position.position<0>"(i64 %"x##0", i64 %"y##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 16) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"x##0", ptr %"tmp#1##0" + %"tmp#2##0" = add i64 %"#rec##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"y##0", ptr %"tmp#3##0" + ret i64 %"#rec##0" } - -define external fastcc {i64, i64} @"position.position.position<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#result##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#result##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = insertvalue {i64, i64} undef, i64 %1, 0 - %6 = insertvalue {i64, i64} %5, i64 %4, 1 - ret {i64, i64} %6 +define external fastcc {i64, i64} @"position.position.position<1>"(i64 %"#result##0") { + %"tmp#0##0" = inttoptr i64 %"#result##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + %"tmp#2##0" = add i64 %"#result##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#3##0" + %"tmp#5##0" = insertvalue {i64, i64} undef, i64 %"tmp#1##0", 0 + %"tmp#6##0" = insertvalue {i64, i64} %"tmp#5##0", i64 %"tmp#4##0", 1 + ret {i64, i64} %"tmp#6##0" } - -define external fastcc i64 @"position.position.x<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#rec##0" to i64* - %1 = load i64, i64* %0 - ret i64 %1 +define external fastcc i64 @"position.position.x<0>"(i64 %"#rec##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + ret i64 %"tmp#1##0" } - -define external fastcc i64 @"position.position.x<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = inttoptr i64 %2 to i64* - store i64 %"#field##0", i64* %6 - ret i64 %2 +define external fastcc i64 @"position.position.x<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"#field##0", ptr %"tmp#3##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"position.position.y<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = add i64 %"#rec##0", 8 - %1 = inttoptr i64 %0 to i64* - %2 = load i64, i64* %1 - ret i64 %2 +define external fastcc i64 @"position.position.y<0>"(i64 %"#rec##0") { + %"tmp#0##0" = add i64 %"#rec##0", 8 + %"tmp#1##0" = inttoptr i64 %"tmp#0##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"position.position.y<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = add i64 %2, 8 - %7 = inttoptr i64 %6 to i64* - store i64 %"#field##0", i64* %7 - ret i64 %2 +define external fastcc i64 @"position.position.y<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = add i64 %"tmp#2##0", 8 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 %"#field##0", ptr %"tmp#4##0" + ret i64 %"tmp#2##0" } - -define external fastcc i1 @"position.position.~=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %"#right##0" to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = icmp eq i64 %1, %6 - br i1 %10, label %if.then, label %if.else -if.then: - %11 = icmp eq i64 %4, %9 - %12 = xor i1 %11, 1 - ret i1 %12 -if.else: - %13 = xor i1 0, 1 - ret i1 %13 +define external fastcc i1 @"position.position.~=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#8##0" = inttoptr i64 %"#left##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#8##0" + %"tmp#9##0" = add i64 %"#left##0", 8 + %"tmp#10##0" = inttoptr i64 %"tmp#9##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#10##0" + %"tmp#11##0" = inttoptr i64 %"#right##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#11##0" + %"tmp#12##0" = add i64 %"#right##0", 8 + %"tmp#13##0" = inttoptr i64 %"tmp#12##0" to ptr + %"tmp#6##0" = load i64, ptr %"tmp#13##0" + %"tmp#7##0" = icmp eq i64 %"tmp#3##0", %"tmp#5##0" + br i1 %"tmp#7##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#0##0" = icmp eq i64 %"tmp#4##0", %"tmp#6##0" + %"tmp#14##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#14##0" +if.else.0: + %"tmp#15##0" = xor i1 0, 1 + ret i1 %"tmp#15##0" } diff --git a/test-cases/final-dump/alias3.exp b/test-cases/final-dump/alias3.exp index 46194d21b..0e1aae54c 100644 --- a/test-cases/final-dump/alias3.exp +++ b/test-cases/final-dump/alias3.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module alias3 representation : (not a type) public submods : @@ -68,123 +71,83 @@ replicate1(p1##0:position.position, ?p2##2:position.position)<{<>}; LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'alias3' - - - - -@alias3.3 = constant {i64, i64} { i64 15, i64 ptrtoint ([?? x i8]* @alias3.2 to i64) } - - -@alias3.5 = constant {i64, i64} { i64 15, i64 ptrtoint ([?? x i8]* @alias3.4 to i64) } - - -@alias3.9 = constant {i64, i64} { i64 17, i64 ptrtoint ([?? x i8]* @alias3.8 to i64) } - - -@alias3.11 = constant {i64, i64} { i64 23, i64 ptrtoint ([?? x i8]* @alias3.10 to i64) } - - -@alias3.1 = constant {i64, i64} { i64 30, i64 ptrtoint ([?? x i8]* @alias3.0 to i64) } - - -@alias3.7 = constant {i64, i64} { i64 31, i64 ptrtoint ([?? x i8]* @alias3.6 to i64) } - - -@alias3.0 = constant [?? x i8] c"--- After calling replicate1: \00" - - -@alias3.6 = constant [?? x i8] c"--- After calling x(!p1, 555): \00" - - -@alias3.10 = constant [?? x i8] c"--- Inside replicate1: \00" - - -@alias3.2 = constant [?? x i8] c"expect p1(1,1):\00" - - -@alias3.8 = constant [?? x i8] c"expect p1(555,1):\00" - - -@alias3.4 = constant [?? x i8] c"expect p2(2,2):\00" - - -declare external fastcc void @"position.printPosition<0>"(i64) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc void @putchar(i8) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"alias3.<0>"() alwaysinline { -entry: - musttail call fastcc void @"alias3.bar<0>"() - ret void +source_filename = "!ROOT!/final-dump/alias3.wybe" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c"--- After calling replicate1: \00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c"--- After calling x(!p1, 555): \00", align 8 +@"cstring#2" = private unnamed_addr constant [ ?? x i8 ] c"--- Inside replicate1: \00", align 8 +@"cstring#3" = private unnamed_addr constant [ ?? x i8 ] c"expect p1(1,1):\00", align 8 +@"cstring#4" = private unnamed_addr constant [ ?? x i8 ] c"expect p1(555,1):\00", align 8 +@"cstring#5" = private unnamed_addr constant [ ?? x i8 ] c"expect p2(2,2):\00", align 8 +@"string#6" = private unnamed_addr constant {i64, i64} { i64 30, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +@"string#7" = private unnamed_addr constant {i64, i64} { i64 31, i64 ptrtoint( ptr @"cstring#1" to i64 ) }, align 8 +@"string#8" = private unnamed_addr constant {i64, i64} { i64 23, i64 ptrtoint( ptr @"cstring#2" to i64 ) }, align 8 +@"string#9" = private unnamed_addr constant {i64, i64} { i64 15, i64 ptrtoint( ptr @"cstring#3" to i64 ) }, align 8 +@"string#10" = private unnamed_addr constant {i64, i64} { i64 17, i64 ptrtoint( ptr @"cstring#4" to i64 ) }, align 8 +@"string#11" = private unnamed_addr constant {i64, i64} { i64 15, i64 ptrtoint( ptr @"cstring#5" to i64 ) }, align 8 + +declare external fastcc void @"position.printPosition<0>"(i64) +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @putchar(i8) +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"alias3.<0>"() { + tail call fastcc void @"alias3.bar<0>"() + ret void } - -define external fastcc void @"alias3.bar<0>"() { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 1, i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 1, i64* %5 - %6 = tail call fastcc i64 @"alias3.replicate1<0>"(i64 %2) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias3.1, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias3.3, i32 0, i32 0) to i64)) - tail call fastcc void @"position.printPosition<0>"(i64 %2) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias3.5, i32 0, i32 0) to i64)) - tail call fastcc void @"position.printPosition<0>"(i64 %6) - %7 = inttoptr i64 %2 to i64* - store i64 555, i64* %7 - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias3.7, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias3.9, i32 0, i32 0) to i64)) - tail call fastcc void @"position.printPosition<0>"(i64 %2) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias3.5, i32 0, i32 0) to i64)) - tail call fastcc void @"position.printPosition<0>"(i64 %6) - ret void +define external fastcc void @"alias3.bar<0>"() { + %"tmp#13##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#3##0" = ptrtoint ptr %"tmp#13##0" to i64 + %"tmp#14##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 1, ptr %"tmp#14##0" + %"tmp#15##0" = add i64 %"tmp#3##0", 8 + %"tmp#16##0" = inttoptr i64 %"tmp#15##0" to ptr + store i64 1, ptr %"tmp#16##0" + %"p2##0" = tail call fastcc i64 @"alias3.replicate1<0>"(i64 %"tmp#3##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#6" to i64 )) + call ccc void @putchar(i8 10) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#9" to i64 )) + tail call fastcc void @"position.printPosition<0>"(i64 %"tmp#3##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#11" to i64 )) + tail call fastcc void @"position.printPosition<0>"(i64 %"p2##0") + %"tmp#17##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 555, ptr %"tmp#17##0" + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#7" to i64 )) + call ccc void @putchar(i8 10) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#10" to i64 )) + tail call fastcc void @"position.printPosition<0>"(i64 %"tmp#3##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#11" to i64 )) + tail call fastcc void @"position.printPosition<0>"(i64 %"p2##0") + ret void } - -define external fastcc i64 @"alias3.replicate1<0>"(i64 %"p1##0") { -entry: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias3.11, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias3.3, i32 0, i32 0) to i64)) - tail call fastcc void @"position.printPosition<0>"(i64 %"p1##0") - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"p1##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = inttoptr i64 %2 to i64* - store i64 2, i64* %6 - %7 = add i64 %2, 8 - %8 = inttoptr i64 %7 to i64* - store i64 2, i64* %8 - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias3.3, i32 0, i32 0) to i64)) - tail call fastcc void @"position.printPosition<0>"(i64 %"p1##0") - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias3.5, i32 0, i32 0) to i64)) - tail call fastcc void @"position.printPosition<0>"(i64 %2) - ret i64 %2 +define external fastcc i64 @"alias3.replicate1<0>"(i64 %"p1##0") { + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#8" to i64 )) + call ccc void @putchar(i8 10) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#9" to i64 )) + tail call fastcc void @"position.printPosition<0>"(i64 %"p1##0") + %"tmp#7##0" = inttoptr i64 %"p1##0" to ptr + %"tmp#8##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#8##0", ptr %"tmp#7##0", i64 16, i1 0) + %"tmp#9##0" = ptrtoint ptr %"tmp#8##0" to i64 + %"tmp#10##0" = inttoptr i64 %"tmp#9##0" to ptr + store i64 2, ptr %"tmp#10##0" + %"tmp#11##0" = add i64 %"tmp#9##0", 8 + %"tmp#12##0" = inttoptr i64 %"tmp#11##0" to ptr + store i64 2, ptr %"tmp#12##0" + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#9" to i64 )) + tail call fastcc void @"position.printPosition<0>"(i64 %"p1##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#11" to i64 )) + tail call fastcc void @"position.printPosition<0>"(i64 %"tmp#9##0") + ret i64 %"tmp#9##0" } + -------------------------------------------------- Module position representation : (not a type) @@ -227,63 +190,42 @@ printPosition(pos##0:position.position)<{<>}; {<>}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'position' - - - - -@position.3 = constant {i64, i64} { i64 1, i64 ptrtoint ([?? x i8]* @position.2 to i64) } - - -@position.5 = constant {i64, i64} { i64 1, i64 ptrtoint ([?? x i8]* @position.4 to i64) } - - -@position.1 = constant {i64, i64} { i64 2, i64 ptrtoint ([?? x i8]* @position.0 to i64) } - - -@position.0 = constant [?? x i8] c" (\00" - - -@position.4 = constant [?? x i8] c")\00" - - -@position.2 = constant [?? x i8] c",\00" - - -declare external ccc void @putchar(i8) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc void @print_int(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"position.printPosition<0>"(i64 %"pos##0") { -entry: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @position.1, i32 0, i32 0) to i64)) - %0 = inttoptr i64 %"pos##0" to i64* - %1 = load i64, i64* %0 - tail call ccc void @print_int(i64 %1) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @position.3, i32 0, i32 0) to i64)) - %2 = add i64 %"pos##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - tail call ccc void @print_int(i64 %4) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @position.5, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - ret void +source_filename = "!ROOT!/final-dump/position.wybe" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c" (\00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c")\00", align 8 +@"cstring#2" = private unnamed_addr constant [ ?? x i8 ] c",\00", align 8 +@"string#3" = private unnamed_addr constant {i64, i64} { i64 2, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +@"string#4" = private unnamed_addr constant {i64, i64} { i64 1, i64 ptrtoint( ptr @"cstring#1" to i64 ) }, align 8 +@"string#5" = private unnamed_addr constant {i64, i64} { i64 1, i64 ptrtoint( ptr @"cstring#2" to i64 ) }, align 8 + +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"position.printPosition<0>"(i64 %"pos##0") { + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#3" to i64 )) + %"tmp#13##0" = inttoptr i64 %"pos##0" to ptr + %"tmp#0##0" = load i64, ptr %"tmp#13##0" + call ccc void @print_int(i64 %"tmp#0##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#5" to i64 )) + %"tmp#14##0" = add i64 %"pos##0", 8 + %"tmp#15##0" = inttoptr i64 %"tmp#14##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#15##0" + call ccc void @print_int(i64 %"tmp#1##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#4" to i64 )) + call ccc void @putchar(i8 10) + ret void } + -------------------------------------------------- Module position.position - representation : address + representation : pointer public submods : public resources: public procs : position.position.=<0> @@ -385,134 +327,110 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'position.position' - - - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i1 @"position.position.=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %"#right##0" to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = icmp eq i64 %1, %6 - br i1 %10, label %if.then, label %if.else -if.then: - %11 = icmp eq i64 %4, %9 - ret i1 %11 -if.else: - ret i1 0 +source_filename = "!ROOT!/final-dump/position.wybe" +target triple ???? + + +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc i1 @"position.position.=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#9##0" = inttoptr i64 %"#left##0" to ptr + %"#left#x##0" = load i64, ptr %"tmp#9##0" + %"tmp#10##0" = add i64 %"#left##0", 8 + %"tmp#11##0" = inttoptr i64 %"tmp#10##0" to ptr + %"#left#y##0" = load i64, ptr %"tmp#11##0" + %"tmp#12##0" = inttoptr i64 %"#right##0" to ptr + %"#right#x##0" = load i64, ptr %"tmp#12##0" + %"tmp#13##0" = add i64 %"#right##0", 8 + %"tmp#14##0" = inttoptr i64 %"tmp#13##0" to ptr + %"#right#y##0" = load i64, ptr %"tmp#14##0" + %"tmp#1##0" = icmp eq i64 %"#left#x##0", %"#right#x##0" + br i1 %"tmp#1##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#15##0" = icmp eq i64 %"#left#y##0", %"#right#y##0" + ret i1 %"tmp#15##0" +if.else.0: + ret i1 0 } - -define external fastcc i64 @"position.position.position<0>"(i64 %"x##0", i64 %"y##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"x##0", i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"y##0", i64* %5 - ret i64 %2 +define external fastcc i64 @"position.position.position<0>"(i64 %"x##0", i64 %"y##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 16) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"x##0", ptr %"tmp#1##0" + %"tmp#2##0" = add i64 %"#rec##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"y##0", ptr %"tmp#3##0" + ret i64 %"#rec##0" } - -define external fastcc {i64, i64} @"position.position.position<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#result##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#result##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = insertvalue {i64, i64} undef, i64 %1, 0 - %6 = insertvalue {i64, i64} %5, i64 %4, 1 - ret {i64, i64} %6 +define external fastcc {i64, i64} @"position.position.position<1>"(i64 %"#result##0") { + %"tmp#0##0" = inttoptr i64 %"#result##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + %"tmp#2##0" = add i64 %"#result##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#3##0" + %"tmp#5##0" = insertvalue {i64, i64} undef, i64 %"tmp#1##0", 0 + %"tmp#6##0" = insertvalue {i64, i64} %"tmp#5##0", i64 %"tmp#4##0", 1 + ret {i64, i64} %"tmp#6##0" } - -define external fastcc i64 @"position.position.x<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#rec##0" to i64* - %1 = load i64, i64* %0 - ret i64 %1 +define external fastcc i64 @"position.position.x<0>"(i64 %"#rec##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + ret i64 %"tmp#1##0" } - -define external fastcc i64 @"position.position.x<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = inttoptr i64 %2 to i64* - store i64 %"#field##0", i64* %6 - ret i64 %2 +define external fastcc i64 @"position.position.x<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"#field##0", ptr %"tmp#3##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"position.position.y<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = add i64 %"#rec##0", 8 - %1 = inttoptr i64 %0 to i64* - %2 = load i64, i64* %1 - ret i64 %2 +define external fastcc i64 @"position.position.y<0>"(i64 %"#rec##0") { + %"tmp#0##0" = add i64 %"#rec##0", 8 + %"tmp#1##0" = inttoptr i64 %"tmp#0##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"position.position.y<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = add i64 %2, 8 - %7 = inttoptr i64 %6 to i64* - store i64 %"#field##0", i64* %7 - ret i64 %2 +define external fastcc i64 @"position.position.y<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = add i64 %"tmp#2##0", 8 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 %"#field##0", ptr %"tmp#4##0" + ret i64 %"tmp#2##0" } - -define external fastcc i1 @"position.position.~=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %"#right##0" to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = icmp eq i64 %1, %6 - br i1 %10, label %if.then, label %if.else -if.then: - %11 = icmp eq i64 %4, %9 - %12 = xor i1 %11, 1 - ret i1 %12 -if.else: - %13 = xor i1 0, 1 - ret i1 %13 +define external fastcc i1 @"position.position.~=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#8##0" = inttoptr i64 %"#left##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#8##0" + %"tmp#9##0" = add i64 %"#left##0", 8 + %"tmp#10##0" = inttoptr i64 %"tmp#9##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#10##0" + %"tmp#11##0" = inttoptr i64 %"#right##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#11##0" + %"tmp#12##0" = add i64 %"#right##0", 8 + %"tmp#13##0" = inttoptr i64 %"tmp#12##0" to ptr + %"tmp#6##0" = load i64, ptr %"tmp#13##0" + %"tmp#7##0" = icmp eq i64 %"tmp#3##0", %"tmp#5##0" + br i1 %"tmp#7##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#0##0" = icmp eq i64 %"tmp#4##0", %"tmp#6##0" + %"tmp#14##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#14##0" +if.else.0: + %"tmp#15##0" = xor i1 0, 1 + ret i1 %"tmp#15##0" } diff --git a/test-cases/final-dump/alias4.exp b/test-cases/final-dump/alias4.exp index 39ae79373..13a01f1e2 100644 --- a/test-cases/final-dump/alias4.exp +++ b/test-cases/final-dump/alias4.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module alias4 representation : (not a type) public submods : @@ -69,127 +72,87 @@ replicate1(p1##0:position.position, ?p2##0:position.position)<{<>}; LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'alias4' - - - - -@alias4.11 = constant {i64, i64} { i64 17, i64 ptrtoint ([?? x i8]* @alias4.10 to i64) } - - -@alias4.3 = constant {i64, i64} { i64 19, i64 ptrtoint ([?? x i8]* @alias4.2 to i64) } - - -@alias4.5 = constant {i64, i64} { i64 19, i64 ptrtoint ([?? x i8]* @alias4.4 to i64) } - - -@alias4.9 = constant {i64, i64} { i64 19, i64 ptrtoint ([?? x i8]* @alias4.8 to i64) } - - -@alias4.1 = constant {i64, i64} { i64 30, i64 ptrtoint ([?? x i8]* @alias4.0 to i64) } - - -@alias4.7 = constant {i64, i64} { i64 31, i64 ptrtoint ([?? x i8]* @alias4.6 to i64) } - - -@alias4.0 = constant [?? x i8] c"--- After calling replicate1: \00" - - -@alias4.6 = constant [?? x i8] c"--- After calling x(!p1, 555): \00" - - -@alias4.2 = constant [?? x i8] c"expect p1(100,100):\00" - - -@alias4.8 = constant [?? x i8] c"expect p1(555,100):\00" - - -@alias4.4 = constant [?? x i8] c"expect p2(100,200):\00" - - -@alias4.10 = constant [?? x i8] c"random replicate1\00" - - -declare external ccc void @putchar(i8) - - -declare external ccc void @print_int(i64) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external fastcc void @"position.printPosition<0>"(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"alias4.<0>"() alwaysinline { -entry: - musttail call fastcc void @"alias4.bar<0>"() - ret void +source_filename = "!ROOT!/final-dump/alias4.wybe" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c"--- After calling replicate1: \00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c"--- After calling x(!p1, 555): \00", align 8 +@"cstring#2" = private unnamed_addr constant [ ?? x i8 ] c"expect p1(100,100):\00", align 8 +@"cstring#3" = private unnamed_addr constant [ ?? x i8 ] c"expect p1(555,100):\00", align 8 +@"cstring#4" = private unnamed_addr constant [ ?? x i8 ] c"expect p2(100,200):\00", align 8 +@"cstring#5" = private unnamed_addr constant [ ?? x i8 ] c"random replicate1\00", align 8 +@"string#6" = private unnamed_addr constant {i64, i64} { i64 30, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +@"string#7" = private unnamed_addr constant {i64, i64} { i64 31, i64 ptrtoint( ptr @"cstring#1" to i64 ) }, align 8 +@"string#8" = private unnamed_addr constant {i64, i64} { i64 19, i64 ptrtoint( ptr @"cstring#2" to i64 ) }, align 8 +@"string#9" = private unnamed_addr constant {i64, i64} { i64 19, i64 ptrtoint( ptr @"cstring#3" to i64 ) }, align 8 +@"string#10" = private unnamed_addr constant {i64, i64} { i64 19, i64 ptrtoint( ptr @"cstring#4" to i64 ) }, align 8 +@"string#11" = private unnamed_addr constant {i64, i64} { i64 17, i64 ptrtoint( ptr @"cstring#5" to i64 ) }, align 8 + +declare external fastcc void @"position.printPosition<0>"(i64) +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"alias4.<0>"() { + tail call fastcc void @"alias4.bar<0>"() + ret void } - -define external fastcc void @"alias4.bar<0>"() { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 100, i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 100, i64* %5 - %6 = tail call fastcc i64 @"alias4.replicate1<0>"(i64 %2) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias4.1, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias4.3, i32 0, i32 0) to i64)) - tail call fastcc void @"position.printPosition<0>"(i64 %2) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias4.5, i32 0, i32 0) to i64)) - tail call fastcc void @"position.printPosition<0>"(i64 %6) - %7 = inttoptr i64 %2 to i64* - store i64 555, i64* %7 - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias4.7, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias4.9, i32 0, i32 0) to i64)) - tail call fastcc void @"position.printPosition<0>"(i64 %2) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias4.5, i32 0, i32 0) to i64)) - tail call fastcc void @"position.printPosition<0>"(i64 %6) - ret void +define external fastcc void @"alias4.bar<0>"() { + %"tmp#13##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#3##0" = ptrtoint ptr %"tmp#13##0" to i64 + %"tmp#14##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 100, ptr %"tmp#14##0" + %"tmp#15##0" = add i64 %"tmp#3##0", 8 + %"tmp#16##0" = inttoptr i64 %"tmp#15##0" to ptr + store i64 100, ptr %"tmp#16##0" + %"p2##0" = tail call fastcc i64 @"alias4.replicate1<0>"(i64 %"tmp#3##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#6" to i64 )) + call ccc void @putchar(i8 10) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#8" to i64 )) + tail call fastcc void @"position.printPosition<0>"(i64 %"tmp#3##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#10" to i64 )) + tail call fastcc void @"position.printPosition<0>"(i64 %"p2##0") + %"tmp#17##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 555, ptr %"tmp#17##0" + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#7" to i64 )) + call ccc void @putchar(i8 10) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#9" to i64 )) + tail call fastcc void @"position.printPosition<0>"(i64 %"tmp#3##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#10" to i64 )) + tail call fastcc void @"position.printPosition<0>"(i64 %"p2##0") + ret void } - -define external fastcc i64 @"alias4.replicate1<0>"(i64 %"p1##0") { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 0, i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 0, i64* %5 - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias4.11, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - %6 = inttoptr i64 %2 to i64* - %7 = load i64, i64* %6 - tail call ccc void @print_int(i64 %7) - tail call ccc void @putchar(i8 10) - %8 = inttoptr i64 %"p1##0" to i64* - %9 = load i64, i64* %8 - %10 = inttoptr i64 %2 to i64* - store i64 %9, i64* %10 - %11 = add i64 %2, 8 - %12 = inttoptr i64 %11 to i64* - store i64 200, i64* %12 - ret i64 %2 +define external fastcc i64 @"alias4.replicate1<0>"(i64 %"p1##0") { + %"tmp#21##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#6##0" = ptrtoint ptr %"tmp#21##0" to i64 + %"tmp#22##0" = inttoptr i64 %"tmp#6##0" to ptr + store i64 0, ptr %"tmp#22##0" + %"tmp#23##0" = add i64 %"tmp#6##0", 8 + %"tmp#24##0" = inttoptr i64 %"tmp#23##0" to ptr + store i64 0, ptr %"tmp#24##0" + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#11" to i64 )) + call ccc void @putchar(i8 10) + %"tmp#25##0" = inttoptr i64 %"tmp#6##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#25##0" + call ccc void @print_int(i64 %"tmp#1##0") + call ccc void @putchar(i8 10) + %"tmp#26##0" = inttoptr i64 %"p1##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#26##0" + %"tmp#27##0" = inttoptr i64 %"tmp#6##0" to ptr + store i64 %"tmp#3##0", ptr %"tmp#27##0" + %"tmp#28##0" = add i64 %"tmp#6##0", 8 + %"tmp#29##0" = inttoptr i64 %"tmp#28##0" to ptr + store i64 200, ptr %"tmp#29##0" + ret i64 %"tmp#6##0" } + -------------------------------------------------- Module position representation : (not a type) @@ -232,63 +195,42 @@ printPosition(pos##0:position.position)<{<>}; {<>}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'position' - - - - -@position.3 = constant {i64, i64} { i64 1, i64 ptrtoint ([?? x i8]* @position.2 to i64) } - - -@position.5 = constant {i64, i64} { i64 1, i64 ptrtoint ([?? x i8]* @position.4 to i64) } - - -@position.1 = constant {i64, i64} { i64 2, i64 ptrtoint ([?? x i8]* @position.0 to i64) } - - -@position.0 = constant [?? x i8] c" (\00" - - -@position.4 = constant [?? x i8] c")\00" - - -@position.2 = constant [?? x i8] c",\00" - - -declare external ccc void @putchar(i8) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc void @print_int(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"position.printPosition<0>"(i64 %"pos##0") { -entry: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @position.1, i32 0, i32 0) to i64)) - %0 = inttoptr i64 %"pos##0" to i64* - %1 = load i64, i64* %0 - tail call ccc void @print_int(i64 %1) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @position.3, i32 0, i32 0) to i64)) - %2 = add i64 %"pos##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - tail call ccc void @print_int(i64 %4) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @position.5, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - ret void +source_filename = "!ROOT!/final-dump/position.wybe" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c" (\00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c")\00", align 8 +@"cstring#2" = private unnamed_addr constant [ ?? x i8 ] c",\00", align 8 +@"string#3" = private unnamed_addr constant {i64, i64} { i64 2, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +@"string#4" = private unnamed_addr constant {i64, i64} { i64 1, i64 ptrtoint( ptr @"cstring#1" to i64 ) }, align 8 +@"string#5" = private unnamed_addr constant {i64, i64} { i64 1, i64 ptrtoint( ptr @"cstring#2" to i64 ) }, align 8 + +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"position.printPosition<0>"(i64 %"pos##0") { + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#3" to i64 )) + %"tmp#13##0" = inttoptr i64 %"pos##0" to ptr + %"tmp#0##0" = load i64, ptr %"tmp#13##0" + call ccc void @print_int(i64 %"tmp#0##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#5" to i64 )) + %"tmp#14##0" = add i64 %"pos##0", 8 + %"tmp#15##0" = inttoptr i64 %"tmp#14##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#15##0" + call ccc void @print_int(i64 %"tmp#1##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#4" to i64 )) + call ccc void @putchar(i8 10) + ret void } + -------------------------------------------------- Module position.position - representation : address + representation : pointer public submods : public resources: public procs : position.position.=<0> @@ -390,134 +332,110 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'position.position' - - - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i1 @"position.position.=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %"#right##0" to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = icmp eq i64 %1, %6 - br i1 %10, label %if.then, label %if.else -if.then: - %11 = icmp eq i64 %4, %9 - ret i1 %11 -if.else: - ret i1 0 +source_filename = "!ROOT!/final-dump/position.wybe" +target triple ???? + + +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc i1 @"position.position.=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#9##0" = inttoptr i64 %"#left##0" to ptr + %"#left#x##0" = load i64, ptr %"tmp#9##0" + %"tmp#10##0" = add i64 %"#left##0", 8 + %"tmp#11##0" = inttoptr i64 %"tmp#10##0" to ptr + %"#left#y##0" = load i64, ptr %"tmp#11##0" + %"tmp#12##0" = inttoptr i64 %"#right##0" to ptr + %"#right#x##0" = load i64, ptr %"tmp#12##0" + %"tmp#13##0" = add i64 %"#right##0", 8 + %"tmp#14##0" = inttoptr i64 %"tmp#13##0" to ptr + %"#right#y##0" = load i64, ptr %"tmp#14##0" + %"tmp#1##0" = icmp eq i64 %"#left#x##0", %"#right#x##0" + br i1 %"tmp#1##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#15##0" = icmp eq i64 %"#left#y##0", %"#right#y##0" + ret i1 %"tmp#15##0" +if.else.0: + ret i1 0 } - -define external fastcc i64 @"position.position.position<0>"(i64 %"x##0", i64 %"y##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"x##0", i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"y##0", i64* %5 - ret i64 %2 +define external fastcc i64 @"position.position.position<0>"(i64 %"x##0", i64 %"y##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 16) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"x##0", ptr %"tmp#1##0" + %"tmp#2##0" = add i64 %"#rec##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"y##0", ptr %"tmp#3##0" + ret i64 %"#rec##0" } - -define external fastcc {i64, i64} @"position.position.position<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#result##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#result##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = insertvalue {i64, i64} undef, i64 %1, 0 - %6 = insertvalue {i64, i64} %5, i64 %4, 1 - ret {i64, i64} %6 +define external fastcc {i64, i64} @"position.position.position<1>"(i64 %"#result##0") { + %"tmp#0##0" = inttoptr i64 %"#result##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + %"tmp#2##0" = add i64 %"#result##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#3##0" + %"tmp#5##0" = insertvalue {i64, i64} undef, i64 %"tmp#1##0", 0 + %"tmp#6##0" = insertvalue {i64, i64} %"tmp#5##0", i64 %"tmp#4##0", 1 + ret {i64, i64} %"tmp#6##0" } - -define external fastcc i64 @"position.position.x<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#rec##0" to i64* - %1 = load i64, i64* %0 - ret i64 %1 +define external fastcc i64 @"position.position.x<0>"(i64 %"#rec##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + ret i64 %"tmp#1##0" } - -define external fastcc i64 @"position.position.x<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = inttoptr i64 %2 to i64* - store i64 %"#field##0", i64* %6 - ret i64 %2 +define external fastcc i64 @"position.position.x<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"#field##0", ptr %"tmp#3##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"position.position.y<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = add i64 %"#rec##0", 8 - %1 = inttoptr i64 %0 to i64* - %2 = load i64, i64* %1 - ret i64 %2 +define external fastcc i64 @"position.position.y<0>"(i64 %"#rec##0") { + %"tmp#0##0" = add i64 %"#rec##0", 8 + %"tmp#1##0" = inttoptr i64 %"tmp#0##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"position.position.y<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = add i64 %2, 8 - %7 = inttoptr i64 %6 to i64* - store i64 %"#field##0", i64* %7 - ret i64 %2 +define external fastcc i64 @"position.position.y<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = add i64 %"tmp#2##0", 8 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 %"#field##0", ptr %"tmp#4##0" + ret i64 %"tmp#2##0" } - -define external fastcc i1 @"position.position.~=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %"#right##0" to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = icmp eq i64 %1, %6 - br i1 %10, label %if.then, label %if.else -if.then: - %11 = icmp eq i64 %4, %9 - %12 = xor i1 %11, 1 - ret i1 %12 -if.else: - %13 = xor i1 0, 1 - ret i1 %13 +define external fastcc i1 @"position.position.~=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#8##0" = inttoptr i64 %"#left##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#8##0" + %"tmp#9##0" = add i64 %"#left##0", 8 + %"tmp#10##0" = inttoptr i64 %"tmp#9##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#10##0" + %"tmp#11##0" = inttoptr i64 %"#right##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#11##0" + %"tmp#12##0" = add i64 %"#right##0", 8 + %"tmp#13##0" = inttoptr i64 %"tmp#12##0" to ptr + %"tmp#6##0" = load i64, ptr %"tmp#13##0" + %"tmp#7##0" = icmp eq i64 %"tmp#3##0", %"tmp#5##0" + br i1 %"tmp#7##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#0##0" = icmp eq i64 %"tmp#4##0", %"tmp#6##0" + %"tmp#14##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#14##0" +if.else.0: + %"tmp#15##0" = xor i1 0, 1 + ret i1 %"tmp#15##0" } diff --git a/test-cases/final-dump/alias5.exp b/test-cases/final-dump/alias5.exp index 84b05a515..a530823ed 100644 --- a/test-cases/final-dump/alias5.exp +++ b/test-cases/final-dump/alias5.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module alias5 representation : (not a type) public submods : @@ -65,97 +68,63 @@ replicate1(v1##0:wybe.int, ?v2##0:wybe.int, v3##0:wybe.int, ?v4##1:wybe.int)<{<< LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'alias5' - - - - -@alias5.1 = constant {i64, i64} { i64 15, i64 ptrtoint ([?? x i8]* @alias5.0 to i64) } - - -@alias5.3 = constant {i64, i64} { i64 15, i64 ptrtoint ([?? x i8]* @alias5.2 to i64) } - - -@alias5.5 = constant {i64, i64} { i64 15, i64 ptrtoint ([?? x i8]* @alias5.4 to i64) } - - -@alias5.7 = constant {i64, i64} { i64 17, i64 ptrtoint ([?? x i8]* @alias5.6 to i64) } - - -@alias5.9 = constant {i64, i64} { i64 17, i64 ptrtoint ([?? x i8]* @alias5.8 to i64) } - - -@alias5.0 = constant [?? x i8] c"expect p1=111: \00" - - -@alias5.2 = constant [?? x i8] c"expect p2=100: \00" - - -@alias5.4 = constant [?? x i8] c"expect p3=100: \00" - - -@alias5.6 = constant [?? x i8] c"expect p4=45000: \00" - - -@alias5.8 = constant [?? x i8] c"random replicate1\00" - - -declare external ccc void @putchar(i8) - - -declare external ccc void @print_int(i64) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"alias5.<0>"() alwaysinline { -entry: - musttail call fastcc void @"alias5.bar<0>"() - ret void +source_filename = "!ROOT!/final-dump/alias5.wybe" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c"expect p1=111: \00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c"expect p2=100: \00", align 8 +@"cstring#2" = private unnamed_addr constant [ ?? x i8 ] c"expect p3=100: \00", align 8 +@"cstring#3" = private unnamed_addr constant [ ?? x i8 ] c"expect p4=45000: \00", align 8 +@"cstring#4" = private unnamed_addr constant [ ?? x i8 ] c"random replicate1\00", align 8 +@"string#5" = private unnamed_addr constant {i64, i64} { i64 15, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +@"string#6" = private unnamed_addr constant {i64, i64} { i64 15, i64 ptrtoint( ptr @"cstring#1" to i64 ) }, align 8 +@"string#7" = private unnamed_addr constant {i64, i64} { i64 15, i64 ptrtoint( ptr @"cstring#2" to i64 ) }, align 8 +@"string#8" = private unnamed_addr constant {i64, i64} { i64 17, i64 ptrtoint( ptr @"cstring#3" to i64 ) }, align 8 +@"string#9" = private unnamed_addr constant {i64, i64} { i64 17, i64 ptrtoint( ptr @"cstring#4" to i64 ) }, align 8 + +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"alias5.<0>"() { + tail call fastcc void @"alias5.bar<0>"() + ret void } - -define external fastcc void @"alias5.bar<0>"() { -entry: - %0 = tail call fastcc {i64, i64} @"alias5.replicate1<0>"(i64 100, i64 800) - %1 = extractvalue {i64, i64} %0, 0 - %2 = extractvalue {i64, i64} %0, 1 - %3 = tail call fastcc {i64, i64} @"alias5.replicate1<0>"(i64 100, i64 800) - %4 = extractvalue {i64, i64} %3, 0 - %5 = extractvalue {i64, i64} %3, 1 - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias5.1, i32 0, i32 0) to i64)) - tail call ccc void @print_int(i64 111) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias5.3, i32 0, i32 0) to i64)) - tail call ccc void @print_int(i64 %1) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias5.5, i32 0, i32 0) to i64)) - tail call ccc void @print_int(i64 %4) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias5.7, i32 0, i32 0) to i64)) - tail call ccc void @print_int(i64 %5) - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"alias5.bar<0>"() { + %"tmp#16##0" = tail call fastcc {i64, i64} @"alias5.replicate1<0>"(i64 100, i64 800) + %"p2##0" = extractvalue {i64, i64}%"tmp#16##0", 0 + %"p4##0" = extractvalue {i64, i64}%"tmp#16##0", 1 + %"tmp#17##0" = tail call fastcc {i64, i64} @"alias5.replicate1<0>"(i64 100, i64 800) + %"p3##0" = extractvalue {i64, i64}%"tmp#17##0", 0 + %"p4##1" = extractvalue {i64, i64}%"tmp#17##0", 1 + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#5" to i64 )) + call ccc void @print_int(i64 111) + call ccc void @putchar(i8 10) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#6" to i64 )) + call ccc void @print_int(i64 %"p2##0") + call ccc void @putchar(i8 10) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#7" to i64 )) + call ccc void @print_int(i64 %"p3##0") + call ccc void @putchar(i8 10) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#8" to i64 )) + call ccc void @print_int(i64 %"p4##1") + call ccc void @putchar(i8 10) + ret void } - -define external fastcc {i64, i64} @"alias5.replicate1<0>"(i64 %"v1##0", i64 %"v3##0") { -entry: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias5.9, i32 0, i32 0) to i64)) - tail call ccc void @print_int(i64 2) - tail call ccc void @putchar(i8 10) - %0 = add i64 %"v3##0", 100 - %1 = mul i64 %0, 200 - %2 = sdiv exact i64 %1, 4 - %3 = insertvalue {i64, i64} undef, i64 %"v1##0", 0 - %4 = insertvalue {i64, i64} %3, i64 %2, 1 - ret {i64, i64} %4 +define external fastcc {i64, i64} @"alias5.replicate1<0>"(i64 %"v1##0", i64 %"v3##0") { + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#9" to i64 )) + call ccc void @print_int(i64 2) + call ccc void @putchar(i8 10) + %"tmp#0##0" = add i64 %"v3##0", 100 + %"tmp#2##0" = mul i64 %"tmp#0##0", 200 + %"tmp#13##0" = sdiv i64 %"tmp#2##0", 4 + %"tmp#14##0" = insertvalue {i64, i64} undef, i64 %"v1##0", 0 + %"tmp#15##0" = insertvalue {i64, i64} %"tmp#14##0", i64 %"tmp#13##0", 1 + ret {i64, i64} %"tmp#15##0" } diff --git a/test-cases/final-dump/alias_cyclic.exp b/test-cases/final-dump/alias_cyclic.exp index e5623092c..63b1b6c53 100644 --- a/test-cases/final-dump/alias_cyclic.exp +++ b/test-cases/final-dump/alias_cyclic.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module alias_cyclic representation : (not a type) public submods : @@ -37,7 +40,7 @@ bar()<{<>}; {<>}; {}>: proc updateX > public (2 calls) -0: alias_cyclic.updateX<0>[410bae77d3] +0: alias_cyclic.updateX<0> updateX(p1##0:position.position, ?p2##0:position.position)<{<>}; {<>}; {}>: AliasPairs: [(p1##0,p2##0)] InterestingCallProperties: [InterestingUnaliased 0] @@ -68,7 +71,7 @@ updateX(p1##0:position.position, ?p2##0:position.position)<{<>}; {<< proc updateY > public (1 calls) -0: alias_cyclic.updateY<0>[410bae77d3] +0: alias_cyclic.updateY<0> updateY(p1##0:position.position, ?p2##0:position.position)<{<>}; {<>}; {}>: AliasPairs: [(p1##0,p2##0)] InterestingCallProperties: [InterestingUnaliased 0] @@ -99,146 +102,115 @@ updateY(p1##0:position.position, ?p2##0:position.position)<{<>}; {<< LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'alias_cyclic' +source_filename = "!ROOT!/final-dump/alias_cyclic.wybe" +target triple ???? - - - -@alias_cyclic.1 = constant {i64, i64} { i64 12, i64 ptrtoint ([?? x i8]* @alias_cyclic.0 to i64) } - - -@alias_cyclic.3 = constant {i64, i64} { i64 12, i64 ptrtoint ([?? x i8]* @alias_cyclic.2 to i64) } - - -@alias_cyclic.0 = constant [?? x i8] c"p1(100,900):\00" - - -@alias_cyclic.2 = constant [?? x i8] c"p2(102,900):\00" - - -declare external fastcc void @"position.printPosition<0>"(i64) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc i8* @wybe_malloc(i32) +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c"p1(100,900):\00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c"p2(102,900):\00", align 8 +@"string#2" = private unnamed_addr constant {i64, i64} { i64 12, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +@"string#3" = private unnamed_addr constant {i64, i64} { i64 12, i64 ptrtoint( ptr @"cstring#1" to i64 ) }, align 8 +declare external fastcc void @"position.printPosition<0>"(i64) +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"alias_cyclic.<0>"() alwaysinline { -entry: - musttail call fastcc void @"alias_cyclic.bar<0>"() - ret void +define external fastcc void @"alias_cyclic.<0>"() { + tail call fastcc void @"alias_cyclic.bar<0>"() + ret void } - -define external fastcc void @"alias_cyclic.bar<0>"() { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 100, i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 900, i64* %5 - %6 = tail call fastcc i64 @"alias_cyclic.updateX<0>"(i64 %2) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_cyclic.1, i32 0, i32 0) to i64)) - tail call fastcc void @"position.printPosition<0>"(i64 %2) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_cyclic.3, i32 0, i32 0) to i64)) - tail call fastcc void @"position.printPosition<0>"(i64 %6) - ret void +define external fastcc void @"alias_cyclic.bar<0>"() { + %"tmp#5##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#3##0" = ptrtoint ptr %"tmp#5##0" to i64 + %"tmp#6##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 100, ptr %"tmp#6##0" + %"tmp#7##0" = add i64 %"tmp#3##0", 8 + %"tmp#8##0" = inttoptr i64 %"tmp#7##0" to ptr + store i64 900, ptr %"tmp#8##0" + %"p2##0" = tail call fastcc i64 @"alias_cyclic.updateX<0>"(i64 %"tmp#3##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#2" to i64 )) + tail call fastcc void @"position.printPosition<0>"(i64 %"tmp#3##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#3" to i64 )) + tail call fastcc void @"position.printPosition<0>"(i64 %"p2##0") + ret void } - -define external fastcc i64 @"alias_cyclic.updateX<0>"(i64 %"p1##0") { -entry: - %0 = inttoptr i64 %"p1##0" to i64* - %1 = load i64, i64* %0 - %2 = icmp sgt i64 %1, 101 - br i1 %2, label %if.then, label %if.else -if.then: - ret i64 %"p1##0" -if.else: - %3 = add i64 %1, 1 - %4 = trunc i64 16 to i32 - %5 = tail call ccc i8* @wybe_malloc(i32 %4) - %6 = ptrtoint i8* %5 to i64 - %7 = inttoptr i64 %6 to i8* - %8 = inttoptr i64 %"p1##0" to i8* - %9 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %7, i8* %8, i32 %9, i1 0) - %10 = inttoptr i64 %6 to i64* - store i64 %3, i64* %10 - %11 = musttail call fastcc i64 @"alias_cyclic.updateY<0>[410bae77d3]"(i64 %6) - ret i64 %11 +define external fastcc i64 @"alias_cyclic.updateX<0>"(i64 %"p1##0") { + %"tmp#12##0" = inttoptr i64 %"p1##0" to ptr + %"tmp#0##0" = load i64, ptr %"tmp#12##0" + %"tmp#3##0" = icmp sgt i64 %"tmp#0##0", 101 + br i1 %"tmp#3##0", label %if.then.0, label %if.else.0 +if.then.0: + ret i64 %"p1##0" +if.else.0: + %"tmp#2##0" = add i64 %"tmp#0##0", 1 + %"tmp#13##0" = inttoptr i64 %"p1##0" to ptr + %"tmp#14##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#14##0", ptr %"tmp#13##0", i64 16, i1 0) + %"tmp#15##0" = ptrtoint ptr %"tmp#14##0" to i64 + %"tmp#16##0" = inttoptr i64 %"tmp#15##0" to ptr + store i64 %"tmp#2##0", ptr %"tmp#16##0" + %"tmp#17##0" = tail call fastcc i64 @"alias_cyclic.updateY<0>[410bae77d3]"(i64 %"tmp#15##0") + ret i64 %"tmp#17##0" } - -define external fastcc i64 @"alias_cyclic.updateX<0>[410bae77d3]"(i64 %"p1##0") { -entry: - %0 = inttoptr i64 %"p1##0" to i64* - %1 = load i64, i64* %0 - %2 = icmp sgt i64 %1, 101 - br i1 %2, label %if.then, label %if.else -if.then: - ret i64 %"p1##0" -if.else: - %3 = add i64 %1, 1 - %4 = inttoptr i64 %"p1##0" to i64* - store i64 %3, i64* %4 - %5 = musttail call fastcc i64 @"alias_cyclic.updateY<0>[410bae77d3]"(i64 %"p1##0") - ret i64 %5 +define external fastcc i64 @"alias_cyclic.updateX<0>[410bae77d3]"(i64 %"p1##0") { + %"tmp#12##0" = inttoptr i64 %"p1##0" to ptr + %"tmp#0##0" = load i64, ptr %"tmp#12##0" + %"tmp#3##0" = icmp sgt i64 %"tmp#0##0", 101 + br i1 %"tmp#3##0", label %if.then.0, label %if.else.0 +if.then.0: + ret i64 %"p1##0" +if.else.0: + %"tmp#2##0" = add i64 %"tmp#0##0", 1 + %"tmp#13##0" = inttoptr i64 %"p1##0" to ptr + store i64 %"tmp#2##0", ptr %"tmp#13##0" + %"tmp#14##0" = tail call fastcc i64 @"alias_cyclic.updateY<0>[410bae77d3]"(i64 %"p1##0") + ret i64 %"tmp#14##0" } - -define external fastcc i64 @"alias_cyclic.updateY<0>"(i64 %"p1##0") { -entry: - %0 = add i64 %"p1##0", 8 - %1 = inttoptr i64 %0 to i64* - %2 = load i64, i64* %1 - %3 = icmp sgt i64 %2, 901 - br i1 %3, label %if.then, label %if.else -if.then: - ret i64 %"p1##0" -if.else: - %4 = add i64 %2, 1 - %5 = trunc i64 16 to i32 - %6 = tail call ccc i8* @wybe_malloc(i32 %5) - %7 = ptrtoint i8* %6 to i64 - %8 = inttoptr i64 %7 to i8* - %9 = inttoptr i64 %"p1##0" to i8* - %10 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %8, i8* %9, i32 %10, i1 0) - %11 = add i64 %7, 8 - %12 = inttoptr i64 %11 to i64* - store i64 %4, i64* %12 - %13 = musttail call fastcc i64 @"alias_cyclic.updateX<0>[410bae77d3]"(i64 %7) - ret i64 %13 +define external fastcc i64 @"alias_cyclic.updateY<0>"(i64 %"p1##0") { + %"tmp#12##0" = add i64 %"p1##0", 8 + %"tmp#13##0" = inttoptr i64 %"tmp#12##0" to ptr + %"tmp#0##0" = load i64, ptr %"tmp#13##0" + %"tmp#3##0" = icmp sgt i64 %"tmp#0##0", 901 + br i1 %"tmp#3##0", label %if.then.0, label %if.else.0 +if.then.0: + ret i64 %"p1##0" +if.else.0: + %"tmp#2##0" = add i64 %"tmp#0##0", 1 + %"tmp#14##0" = inttoptr i64 %"p1##0" to ptr + %"tmp#15##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#15##0", ptr %"tmp#14##0", i64 16, i1 0) + %"tmp#16##0" = ptrtoint ptr %"tmp#15##0" to i64 + %"tmp#17##0" = add i64 %"tmp#16##0", 8 + %"tmp#18##0" = inttoptr i64 %"tmp#17##0" to ptr + store i64 %"tmp#2##0", ptr %"tmp#18##0" + %"tmp#19##0" = tail call fastcc i64 @"alias_cyclic.updateX<0>[410bae77d3]"(i64 %"tmp#16##0") + ret i64 %"tmp#19##0" } - -define external fastcc i64 @"alias_cyclic.updateY<0>[410bae77d3]"(i64 %"p1##0") { -entry: - %0 = add i64 %"p1##0", 8 - %1 = inttoptr i64 %0 to i64* - %2 = load i64, i64* %1 - %3 = icmp sgt i64 %2, 901 - br i1 %3, label %if.then, label %if.else -if.then: - ret i64 %"p1##0" -if.else: - %4 = add i64 %2, 1 - %5 = add i64 %"p1##0", 8 - %6 = inttoptr i64 %5 to i64* - store i64 %4, i64* %6 - %7 = musttail call fastcc i64 @"alias_cyclic.updateX<0>[410bae77d3]"(i64 %"p1##0") - ret i64 %7 +define external fastcc i64 @"alias_cyclic.updateY<0>[410bae77d3]"(i64 %"p1##0") { + %"tmp#12##0" = add i64 %"p1##0", 8 + %"tmp#13##0" = inttoptr i64 %"tmp#12##0" to ptr + %"tmp#0##0" = load i64, ptr %"tmp#13##0" + %"tmp#3##0" = icmp sgt i64 %"tmp#0##0", 901 + br i1 %"tmp#3##0", label %if.then.0, label %if.else.0 +if.then.0: + ret i64 %"p1##0" +if.else.0: + %"tmp#2##0" = add i64 %"tmp#0##0", 1 + %"tmp#14##0" = add i64 %"p1##0", 8 + %"tmp#15##0" = inttoptr i64 %"tmp#14##0" to ptr + store i64 %"tmp#2##0", ptr %"tmp#15##0" + %"tmp#16##0" = tail call fastcc i64 @"alias_cyclic.updateX<0>[410bae77d3]"(i64 %"p1##0") + ret i64 %"tmp#16##0" } + -------------------------------------------------- Module position representation : (not a type) @@ -281,63 +253,42 @@ printPosition(pos##0:position.position)<{<>}; {<>}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'position' - - - - -@position.3 = constant {i64, i64} { i64 1, i64 ptrtoint ([?? x i8]* @position.2 to i64) } - - -@position.5 = constant {i64, i64} { i64 1, i64 ptrtoint ([?? x i8]* @position.4 to i64) } - - -@position.1 = constant {i64, i64} { i64 2, i64 ptrtoint ([?? x i8]* @position.0 to i64) } - - -@position.0 = constant [?? x i8] c" (\00" - - -@position.4 = constant [?? x i8] c")\00" - - -@position.2 = constant [?? x i8] c",\00" - - -declare external ccc void @putchar(i8) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc void @print_int(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"position.printPosition<0>"(i64 %"pos##0") { -entry: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @position.1, i32 0, i32 0) to i64)) - %0 = inttoptr i64 %"pos##0" to i64* - %1 = load i64, i64* %0 - tail call ccc void @print_int(i64 %1) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @position.3, i32 0, i32 0) to i64)) - %2 = add i64 %"pos##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - tail call ccc void @print_int(i64 %4) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @position.5, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - ret void +source_filename = "!ROOT!/final-dump/position.wybe" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c" (\00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c")\00", align 8 +@"cstring#2" = private unnamed_addr constant [ ?? x i8 ] c",\00", align 8 +@"string#3" = private unnamed_addr constant {i64, i64} { i64 2, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +@"string#4" = private unnamed_addr constant {i64, i64} { i64 1, i64 ptrtoint( ptr @"cstring#1" to i64 ) }, align 8 +@"string#5" = private unnamed_addr constant {i64, i64} { i64 1, i64 ptrtoint( ptr @"cstring#2" to i64 ) }, align 8 + +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"position.printPosition<0>"(i64 %"pos##0") { + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#3" to i64 )) + %"tmp#13##0" = inttoptr i64 %"pos##0" to ptr + %"tmp#0##0" = load i64, ptr %"tmp#13##0" + call ccc void @print_int(i64 %"tmp#0##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#5" to i64 )) + %"tmp#14##0" = add i64 %"pos##0", 8 + %"tmp#15##0" = inttoptr i64 %"tmp#14##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#15##0" + call ccc void @print_int(i64 %"tmp#1##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#4" to i64 )) + call ccc void @putchar(i8 10) + ret void } + -------------------------------------------------- Module position.position - representation : address + representation : pointer public submods : public resources: public procs : position.position.=<0> @@ -439,134 +390,110 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'position.position' - - - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i1 @"position.position.=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %"#right##0" to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = icmp eq i64 %1, %6 - br i1 %10, label %if.then, label %if.else -if.then: - %11 = icmp eq i64 %4, %9 - ret i1 %11 -if.else: - ret i1 0 +source_filename = "!ROOT!/final-dump/position.wybe" +target triple ???? + + +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc i1 @"position.position.=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#9##0" = inttoptr i64 %"#left##0" to ptr + %"#left#x##0" = load i64, ptr %"tmp#9##0" + %"tmp#10##0" = add i64 %"#left##0", 8 + %"tmp#11##0" = inttoptr i64 %"tmp#10##0" to ptr + %"#left#y##0" = load i64, ptr %"tmp#11##0" + %"tmp#12##0" = inttoptr i64 %"#right##0" to ptr + %"#right#x##0" = load i64, ptr %"tmp#12##0" + %"tmp#13##0" = add i64 %"#right##0", 8 + %"tmp#14##0" = inttoptr i64 %"tmp#13##0" to ptr + %"#right#y##0" = load i64, ptr %"tmp#14##0" + %"tmp#1##0" = icmp eq i64 %"#left#x##0", %"#right#x##0" + br i1 %"tmp#1##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#15##0" = icmp eq i64 %"#left#y##0", %"#right#y##0" + ret i1 %"tmp#15##0" +if.else.0: + ret i1 0 } - -define external fastcc i64 @"position.position.position<0>"(i64 %"x##0", i64 %"y##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"x##0", i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"y##0", i64* %5 - ret i64 %2 +define external fastcc i64 @"position.position.position<0>"(i64 %"x##0", i64 %"y##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 16) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"x##0", ptr %"tmp#1##0" + %"tmp#2##0" = add i64 %"#rec##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"y##0", ptr %"tmp#3##0" + ret i64 %"#rec##0" } - -define external fastcc {i64, i64} @"position.position.position<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#result##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#result##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = insertvalue {i64, i64} undef, i64 %1, 0 - %6 = insertvalue {i64, i64} %5, i64 %4, 1 - ret {i64, i64} %6 +define external fastcc {i64, i64} @"position.position.position<1>"(i64 %"#result##0") { + %"tmp#0##0" = inttoptr i64 %"#result##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + %"tmp#2##0" = add i64 %"#result##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#3##0" + %"tmp#5##0" = insertvalue {i64, i64} undef, i64 %"tmp#1##0", 0 + %"tmp#6##0" = insertvalue {i64, i64} %"tmp#5##0", i64 %"tmp#4##0", 1 + ret {i64, i64} %"tmp#6##0" } - -define external fastcc i64 @"position.position.x<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#rec##0" to i64* - %1 = load i64, i64* %0 - ret i64 %1 +define external fastcc i64 @"position.position.x<0>"(i64 %"#rec##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + ret i64 %"tmp#1##0" } - -define external fastcc i64 @"position.position.x<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = inttoptr i64 %2 to i64* - store i64 %"#field##0", i64* %6 - ret i64 %2 +define external fastcc i64 @"position.position.x<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"#field##0", ptr %"tmp#3##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"position.position.y<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = add i64 %"#rec##0", 8 - %1 = inttoptr i64 %0 to i64* - %2 = load i64, i64* %1 - ret i64 %2 +define external fastcc i64 @"position.position.y<0>"(i64 %"#rec##0") { + %"tmp#0##0" = add i64 %"#rec##0", 8 + %"tmp#1##0" = inttoptr i64 %"tmp#0##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"position.position.y<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = add i64 %2, 8 - %7 = inttoptr i64 %6 to i64* - store i64 %"#field##0", i64* %7 - ret i64 %2 +define external fastcc i64 @"position.position.y<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = add i64 %"tmp#2##0", 8 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 %"#field##0", ptr %"tmp#4##0" + ret i64 %"tmp#2##0" } - -define external fastcc i1 @"position.position.~=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %"#right##0" to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = icmp eq i64 %1, %6 - br i1 %10, label %if.then, label %if.else -if.then: - %11 = icmp eq i64 %4, %9 - %12 = xor i1 %11, 1 - ret i1 %12 -if.else: - %13 = xor i1 0, 1 - ret i1 %13 +define external fastcc i1 @"position.position.~=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#8##0" = inttoptr i64 %"#left##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#8##0" + %"tmp#9##0" = add i64 %"#left##0", 8 + %"tmp#10##0" = inttoptr i64 %"tmp#9##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#10##0" + %"tmp#11##0" = inttoptr i64 %"#right##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#11##0" + %"tmp#12##0" = add i64 %"#right##0", 8 + %"tmp#13##0" = inttoptr i64 %"tmp#12##0" to ptr + %"tmp#6##0" = load i64, ptr %"tmp#13##0" + %"tmp#7##0" = icmp eq i64 %"tmp#3##0", %"tmp#5##0" + br i1 %"tmp#7##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#0##0" = icmp eq i64 %"tmp#4##0", %"tmp#6##0" + %"tmp#14##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#14##0" +if.else.0: + %"tmp#15##0" = xor i1 0, 1 + ret i1 %"tmp#15##0" } diff --git a/test-cases/final-dump/alias_data.exp b/test-cases/final-dump/alias_data.exp index e06e53315..3682ddcff 100644 --- a/test-cases/final-dump/alias_data.exp +++ b/test-cases/final-dump/alias_data.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module alias_data representation : (not a type) public submods : @@ -53,87 +56,59 @@ bar()<{<>}; {<>}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'alias_data' - - - - -@alias_data.3 = constant {i64, i64} { i64 8, i64 ptrtoint ([?? x i8]* @alias_data.2 to i64) } - - -@alias_data.5 = constant {i64, i64} { i64 8, i64 ptrtoint ([?? x i8]* @alias_data.4 to i64) } - - -@alias_data.1 = constant {i64, i64} { i64 11, i64 ptrtoint ([?? x i8]* @alias_data.0 to i64) } - - -@alias_data.0 = constant [?? x i8] c"intro to cs\00" - - -@alias_data.2 = constant [?? x i8] c"student1\00" - - -@alias_data.4 = constant [?? x i8] c"student2\00" - - -declare external fastcc void @"student.printStudent<0>[410bae77d3]"(i64) - - -declare external ccc void @putchar(i8) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external fastcc void @"student.printStudent<0>"(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"alias_data.<0>"() alwaysinline { -entry: - musttail call fastcc void @"alias_data.bar<0>"() - ret void +source_filename = "!ROOT!/final-dump/alias_data.wybe" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c"intro to cs\00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c"student1\00", align 8 +@"cstring#2" = private unnamed_addr constant [ ?? x i8 ] c"student2\00", align 8 +@"string#3" = private unnamed_addr constant {i64, i64} { i64 11, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +@"string#4" = private unnamed_addr constant {i64, i64} { i64 8, i64 ptrtoint( ptr @"cstring#1" to i64 ) }, align 8 +@"string#5" = private unnamed_addr constant {i64, i64} { i64 8, i64 ptrtoint( ptr @"cstring#2" to i64 ) }, align 8 + +declare external fastcc void @"student.printStudent<0>"(i64) +declare external fastcc void @"student.printStudent<0>[410bae77d3]"(i64) +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @putchar(i8) +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"alias_data.<0>"() { + tail call fastcc void @"alias_data.bar<0>"() + ret void } - -define external fastcc i64 @"alias_data.backup<0>"(i64 %"student1##0") alwaysinline { -entry: - ret i64 %"student1##0" +define external fastcc i64 @"alias_data.backup<0>"(i64 %"student1##0") { + ret i64 %"student1##0" } - -define external fastcc void @"alias_data.bar<0>"() { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 101, i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_data.1, i32 0, i32 0) to i64), i64* %5 - %6 = trunc i64 16 to i32 - %7 = tail call ccc i8* @wybe_malloc(i32 %6) - %8 = ptrtoint i8* %7 to i64 - %9 = inttoptr i64 %8 to i64* - store i64 9401, i64* %9 - %10 = add i64 %8, 8 - %11 = inttoptr i64 %10 to i64* - store i64 %2, i64* %11 - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_data.3, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"student.printStudent<0>"(i64 %8) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_data.5, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"student.printStudent<0>[410bae77d3]"(i64 %8) - ret void +define external fastcc void @"alias_data.bar<0>"() { + %"tmp#17##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#4##0" = ptrtoint ptr %"tmp#17##0" to i64 + %"tmp#18##0" = inttoptr i64 %"tmp#4##0" to ptr + store i64 101, ptr %"tmp#18##0" + %"tmp#19##0" = add i64 %"tmp#4##0", 8 + %"tmp#20##0" = inttoptr i64 %"tmp#19##0" to ptr + store i64 ptrtoint( ptr @"string#3" to i64 ), ptr %"tmp#20##0" + %"tmp#21##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#8##0" = ptrtoint ptr %"tmp#21##0" to i64 + %"tmp#22##0" = inttoptr i64 %"tmp#8##0" to ptr + store i64 9401, ptr %"tmp#22##0" + %"tmp#23##0" = add i64 %"tmp#8##0", 8 + %"tmp#24##0" = inttoptr i64 %"tmp#23##0" to ptr + store i64 %"tmp#4##0", ptr %"tmp#24##0" + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#4" to i64 )) + call ccc void @putchar(i8 10) + tail call fastcc void @"student.printStudent<0>"(i64 %"tmp#8##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#5" to i64 )) + call ccc void @putchar(i8 10) + tail call fastcc void @"student.printStudent<0>[410bae77d3]"(i64 %"tmp#8##0") + ret void } + -------------------------------------------------- Module student representation : (not a type) @@ -228,128 +203,96 @@ printStudent(stu##0:student.student)<{<>}; {<>}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'student' - - - - -@student.3 = constant {i64, i64} { i64 12, i64 ptrtoint ([?? x i8]* @student.2 to i64) } - - -@student.5 = constant {i64, i64} { i64 13, i64 ptrtoint ([?? x i8]* @student.4 to i64) } - - -@student.7 = constant {i64, i64} { i64 13, i64 ptrtoint ([?? x i8]* @student.6 to i64) } - - -@student.1 = constant {i64, i64} { i64 23, i64 ptrtoint ([?? x i8]* @student.0 to i64) } - - -@student.0 = constant [?? x i8] c"Declarative Programming\00" - - -@student.4 = constant [?? x i8] c"course code: \00" - - -@student.6 = constant [?? x i8] c"course name: \00" - - -@student.2 = constant [?? x i8] c"student id: \00" - - -declare external ccc void @putchar(i8) - - -declare external fastcc void @"wybe.string.print<0>[410bae77d3]"(i64) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc void @print_int(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"student.<0>"() { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 90048, i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @student.1, i32 0, i32 0) to i64), i64* %5 - %6 = trunc i64 16 to i32 - %7 = tail call ccc i8* @wybe_malloc(i32 %6) - %8 = ptrtoint i8* %7 to i64 - %9 = inttoptr i64 %8 to i64* - store i64 12345, i64* %9 - %10 = add i64 %8, 8 - %11 = inttoptr i64 %10 to i64* - store i64 %2, i64* %11 - tail call fastcc void @"student.printStudent<0>[410bae77d3]"(i64 %8) - ret void +source_filename = "!ROOT!/final-dump/student.wybe" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c"Declarative Programming\00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c"course code: \00", align 8 +@"cstring#2" = private unnamed_addr constant [ ?? x i8 ] c"course name: \00", align 8 +@"cstring#3" = private unnamed_addr constant [ ?? x i8 ] c"student id: \00", align 8 +@"string#4" = private unnamed_addr constant {i64, i64} { i64 23, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +@"string#5" = private unnamed_addr constant {i64, i64} { i64 13, i64 ptrtoint( ptr @"cstring#1" to i64 ) }, align 8 +@"string#6" = private unnamed_addr constant {i64, i64} { i64 13, i64 ptrtoint( ptr @"cstring#2" to i64 ) }, align 8 +@"string#7" = private unnamed_addr constant {i64, i64} { i64 12, i64 ptrtoint( ptr @"cstring#3" to i64 ) }, align 8 + +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external fastcc void @"wybe.string.print<0>[410bae77d3]"(i64) +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"student.<0>"() { + %"tmp#12##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#4##0" = ptrtoint ptr %"tmp#12##0" to i64 + %"tmp#13##0" = inttoptr i64 %"tmp#4##0" to ptr + store i64 90048, ptr %"tmp#13##0" + %"tmp#14##0" = add i64 %"tmp#4##0", 8 + %"tmp#15##0" = inttoptr i64 %"tmp#14##0" to ptr + store i64 ptrtoint( ptr @"string#4" to i64 ), ptr %"tmp#15##0" + %"tmp#16##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#9##0" = ptrtoint ptr %"tmp#16##0" to i64 + %"tmp#17##0" = inttoptr i64 %"tmp#9##0" to ptr + store i64 12345, ptr %"tmp#17##0" + %"tmp#18##0" = add i64 %"tmp#9##0", 8 + %"tmp#19##0" = inttoptr i64 %"tmp#18##0" to ptr + store i64 %"tmp#4##0", ptr %"tmp#19##0" + tail call fastcc void @"student.printStudent<0>[410bae77d3]"(i64 %"tmp#9##0") + ret void } - -define external fastcc void @"student.printStudent<0>"(i64 %"stu##0") { -entry: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @student.3, i32 0, i32 0) to i64)) - %0 = inttoptr i64 %"stu##0" to i64* - %1 = load i64, i64* %0 - tail call ccc void @print_int(i64 %1) - tail call ccc void @putchar(i8 10) - %2 = add i64 %"stu##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @student.5, i32 0, i32 0) to i64)) - %5 = inttoptr i64 %4 to i64* - %6 = load i64, i64* %5 - tail call ccc void @print_int(i64 %6) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @student.7, i32 0, i32 0) to i64)) - %7 = add i64 %4, 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - tail call fastcc void @"wybe.string.print<0>"(i64 %9) - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"student.printStudent<0>"(i64 %"stu##0") { + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#7" to i64 )) + %"tmp#19##0" = inttoptr i64 %"stu##0" to ptr + %"tmp#0##0" = load i64, ptr %"tmp#19##0" + call ccc void @print_int(i64 %"tmp#0##0") + call ccc void @putchar(i8 10) + %"tmp#20##0" = add i64 %"stu##0", 8 + %"tmp#21##0" = inttoptr i64 %"tmp#20##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#21##0" + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#5" to i64 )) + %"tmp#22##0" = inttoptr i64 %"tmp#1##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#22##0" + call ccc void @print_int(i64 %"tmp#2##0") + call ccc void @putchar(i8 10) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#6" to i64 )) + %"tmp#23##0" = add i64 %"tmp#1##0", 8 + %"tmp#24##0" = inttoptr i64 %"tmp#23##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#24##0" + tail call fastcc void @"wybe.string.print<0>"(i64 %"tmp#3##0") + call ccc void @putchar(i8 10) + ret void } - -define external fastcc void @"student.printStudent<0>[410bae77d3]"(i64 %"stu##0") { -entry: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @student.3, i32 0, i32 0) to i64)) - %0 = inttoptr i64 %"stu##0" to i64* - %1 = load i64, i64* %0 - tail call ccc void @print_int(i64 %1) - tail call ccc void @putchar(i8 10) - %2 = add i64 %"stu##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @student.5, i32 0, i32 0) to i64)) - %5 = inttoptr i64 %4 to i64* - %6 = load i64, i64* %5 - tail call ccc void @print_int(i64 %6) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @student.7, i32 0, i32 0) to i64)) - %7 = add i64 %4, 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - tail call fastcc void @"wybe.string.print<0>[410bae77d3]"(i64 %9) - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"student.printStudent<0>[410bae77d3]"(i64 %"stu##0") { + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#7" to i64 )) + %"tmp#19##0" = inttoptr i64 %"stu##0" to ptr + %"tmp#0##0" = load i64, ptr %"tmp#19##0" + call ccc void @print_int(i64 %"tmp#0##0") + call ccc void @putchar(i8 10) + %"tmp#20##0" = add i64 %"stu##0", 8 + %"tmp#21##0" = inttoptr i64 %"tmp#20##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#21##0" + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#5" to i64 )) + %"tmp#22##0" = inttoptr i64 %"tmp#1##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#22##0" + call ccc void @print_int(i64 %"tmp#2##0") + call ccc void @putchar(i8 10) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#6" to i64 )) + %"tmp#23##0" = add i64 %"tmp#1##0", 8 + %"tmp#24##0" = inttoptr i64 %"tmp#23##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#24##0" + tail call fastcc void @"wybe.string.print<0>[410bae77d3]"(i64 %"tmp#3##0") + call ccc void @putchar(i8 10) + ret void } + -------------------------------------------------- Module student.course - representation : address + representation : pointer public submods : public resources: public procs : student.course.=<0> @@ -453,145 +396,120 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'student.course' - - - - -declare external fastcc i2 @"wybe.string.<=>#cont#2<0>"(i2, i64, i64, i64, i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i1 @"student.course.=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %"#right##0" to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = icmp eq i64 %1, %6 - br i1 %10, label %if.then, label %if.else -if.then: - %11 = tail call fastcc i2 @"wybe.string.<=>#cont#2<0>"(i2 1, i64 %4, i64 %9, i64 %4, i64 %9) - %12 = icmp eq i2 %11, 1 - ret i1 %12 -if.else: - ret i1 0 +source_filename = "!ROOT!/final-dump/student.wybe" +target triple ???? + + +declare external fastcc i2 @"wybe.string.<=>#cont#2<0>"(i2, i64, i64, i64, i64) +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc i1 @"student.course.=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#10##0" = inttoptr i64 %"#left##0" to ptr + %"#left#code##0" = load i64, ptr %"tmp#10##0" + %"tmp#11##0" = add i64 %"#left##0", 8 + %"tmp#12##0" = inttoptr i64 %"tmp#11##0" to ptr + %"#left#name##0" = load i64, ptr %"tmp#12##0" + %"tmp#13##0" = inttoptr i64 %"#right##0" to ptr + %"#right#code##0" = load i64, ptr %"tmp#13##0" + %"tmp#14##0" = add i64 %"#right##0", 8 + %"tmp#15##0" = inttoptr i64 %"tmp#14##0" to ptr + %"#right#name##0" = load i64, ptr %"tmp#15##0" + %"tmp#1##0" = icmp eq i64 %"#left#code##0", %"#right#code##0" + br i1 %"tmp#1##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#9##0" = tail call fastcc i2 @"wybe.string.<=>#cont#2<0>"(i2 1, i64 %"#left#name##0", i64 %"#right#name##0", i64 %"#left#name##0", i64 %"#right#name##0") + %"tmp#16##0" = icmp eq i2 %"tmp#9##0", 1 + ret i1 %"tmp#16##0" +if.else.0: + ret i1 0 } - -define external fastcc i64 @"student.course.code<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#rec##0" to i64* - %1 = load i64, i64* %0 - ret i64 %1 +define external fastcc i64 @"student.course.code<0>"(i64 %"#rec##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + ret i64 %"tmp#1##0" } - -define external fastcc i64 @"student.course.code<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = inttoptr i64 %2 to i64* - store i64 %"#field##0", i64* %6 - ret i64 %2 +define external fastcc i64 @"student.course.code<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"#field##0", ptr %"tmp#3##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"student.course.course<0>"(i64 %"code##0", i64 %"name##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"code##0", i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"name##0", i64* %5 - ret i64 %2 +define external fastcc i64 @"student.course.course<0>"(i64 %"code##0", i64 %"name##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 16) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"code##0", ptr %"tmp#1##0" + %"tmp#2##0" = add i64 %"#rec##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"name##0", ptr %"tmp#3##0" + ret i64 %"#rec##0" } - -define external fastcc {i64, i64} @"student.course.course<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#result##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#result##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = insertvalue {i64, i64} undef, i64 %1, 0 - %6 = insertvalue {i64, i64} %5, i64 %4, 1 - ret {i64, i64} %6 +define external fastcc {i64, i64} @"student.course.course<1>"(i64 %"#result##0") { + %"tmp#0##0" = inttoptr i64 %"#result##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + %"tmp#2##0" = add i64 %"#result##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#3##0" + %"tmp#5##0" = insertvalue {i64, i64} undef, i64 %"tmp#1##0", 0 + %"tmp#6##0" = insertvalue {i64, i64} %"tmp#5##0", i64 %"tmp#4##0", 1 + ret {i64, i64} %"tmp#6##0" } - -define external fastcc i64 @"student.course.name<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = add i64 %"#rec##0", 8 - %1 = inttoptr i64 %0 to i64* - %2 = load i64, i64* %1 - ret i64 %2 +define external fastcc i64 @"student.course.name<0>"(i64 %"#rec##0") { + %"tmp#0##0" = add i64 %"#rec##0", 8 + %"tmp#1##0" = inttoptr i64 %"tmp#0##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"student.course.name<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = add i64 %2, 8 - %7 = inttoptr i64 %6 to i64* - store i64 %"#field##0", i64* %7 - ret i64 %2 +define external fastcc i64 @"student.course.name<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = add i64 %"tmp#2##0", 8 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 %"#field##0", ptr %"tmp#4##0" + ret i64 %"tmp#2##0" } - -define external fastcc i1 @"student.course.~=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %"#right##0" to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = icmp eq i64 %1, %6 - br i1 %10, label %if.then, label %if.else -if.then: - %11 = tail call fastcc i2 @"wybe.string.<=>#cont#2<0>"(i2 1, i64 %4, i64 %9, i64 %4, i64 %9) - %12 = icmp eq i2 %11, 1 - %13 = xor i1 %12, 1 - ret i1 %13 -if.else: - %14 = xor i1 0, 1 - ret i1 %14 +define external fastcc i1 @"student.course.~=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#9##0" = inttoptr i64 %"#left##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#9##0" + %"tmp#10##0" = add i64 %"#left##0", 8 + %"tmp#11##0" = inttoptr i64 %"tmp#10##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#11##0" + %"tmp#12##0" = inttoptr i64 %"#right##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#12##0" + %"tmp#13##0" = add i64 %"#right##0", 8 + %"tmp#14##0" = inttoptr i64 %"tmp#13##0" to ptr + %"tmp#6##0" = load i64, ptr %"tmp#14##0" + %"tmp#7##0" = icmp eq i64 %"tmp#3##0", %"tmp#5##0" + br i1 %"tmp#7##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#8##0" = tail call fastcc i2 @"wybe.string.<=>#cont#2<0>"(i2 1, i64 %"tmp#4##0", i64 %"tmp#6##0", i64 %"tmp#4##0", i64 %"tmp#6##0") + %"tmp#0##0" = icmp eq i2 %"tmp#8##0", 1 + %"tmp#15##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#15##0" +if.else.0: + %"tmp#16##0" = xor i1 0, 1 + ret i1 %"tmp#16##0" } + -------------------------------------------------- Module student.student - representation : address + representation : pointer public submods : public resources: public procs : student.student.=<0> @@ -718,170 +636,144 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'student.student' - - - - -declare external fastcc i2 @"wybe.string.<=>#cont#2<0>"(i2, i64, i64, i64, i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i1 @"student.student.=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %"#right##0" to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = icmp eq i64 %1, %6 - br i1 %10, label %if.then, label %if.else -if.then: - %11 = inttoptr i64 %4 to i64* - %12 = load i64, i64* %11 - %13 = add i64 %4, 8 - %14 = inttoptr i64 %13 to i64* - %15 = load i64, i64* %14 - %16 = inttoptr i64 %9 to i64* - %17 = load i64, i64* %16 - %18 = add i64 %9, 8 - %19 = inttoptr i64 %18 to i64* - %20 = load i64, i64* %19 - %21 = icmp eq i64 %17, %12 - br i1 %21, label %if.then1, label %if.else1 -if.else: - ret i1 0 -if.then1: - %22 = tail call fastcc i2 @"wybe.string.<=>#cont#2<0>"(i2 1, i64 %15, i64 %20, i64 %15, i64 %20) - %23 = icmp eq i2 %22, 1 - ret i1 %23 -if.else1: - ret i1 0 +source_filename = "!ROOT!/final-dump/student.wybe" +target triple ???? + + +declare external fastcc i2 @"wybe.string.<=>#cont#2<0>"(i2, i64, i64, i64, i64) +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc i1 @"student.student.=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#15##0" = inttoptr i64 %"#left##0" to ptr + %"#left#id##0" = load i64, ptr %"tmp#15##0" + %"tmp#16##0" = add i64 %"#left##0", 8 + %"tmp#17##0" = inttoptr i64 %"tmp#16##0" to ptr + %"#left#major##0" = load i64, ptr %"tmp#17##0" + %"tmp#18##0" = inttoptr i64 %"#right##0" to ptr + %"#right#id##0" = load i64, ptr %"tmp#18##0" + %"tmp#19##0" = add i64 %"#right##0", 8 + %"tmp#20##0" = inttoptr i64 %"tmp#19##0" to ptr + %"#right#major##0" = load i64, ptr %"tmp#20##0" + %"tmp#1##0" = icmp eq i64 %"#left#id##0", %"#right#id##0" + br i1 %"tmp#1##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#21##0" = inttoptr i64 %"#left#major##0" to ptr + %"tmp#9##0" = load i64, ptr %"tmp#21##0" + %"tmp#22##0" = add i64 %"#left#major##0", 8 + %"tmp#23##0" = inttoptr i64 %"tmp#22##0" to ptr + %"tmp#10##0" = load i64, ptr %"tmp#23##0" + %"tmp#24##0" = inttoptr i64 %"#right#major##0" to ptr + %"tmp#11##0" = load i64, ptr %"tmp#24##0" + %"tmp#25##0" = add i64 %"#right#major##0", 8 + %"tmp#26##0" = inttoptr i64 %"tmp#25##0" to ptr + %"tmp#12##0" = load i64, ptr %"tmp#26##0" + %"tmp#13##0" = icmp eq i64 %"tmp#11##0", %"tmp#9##0" + br i1 %"tmp#13##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#14##0" = tail call fastcc i2 @"wybe.string.<=>#cont#2<0>"(i2 1, i64 %"tmp#10##0", i64 %"tmp#12##0", i64 %"tmp#10##0", i64 %"tmp#12##0") + %"tmp#27##0" = icmp eq i2 %"tmp#14##0", 1 + ret i1 %"tmp#27##0" +if.else.1: + ret i1 0 +if.else.0: + ret i1 0 } - -define external fastcc i64 @"student.student.id<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#rec##0" to i64* - %1 = load i64, i64* %0 - ret i64 %1 +define external fastcc i64 @"student.student.id<0>"(i64 %"#rec##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + ret i64 %"tmp#1##0" } - -define external fastcc i64 @"student.student.id<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = inttoptr i64 %2 to i64* - store i64 %"#field##0", i64* %6 - ret i64 %2 +define external fastcc i64 @"student.student.id<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"#field##0", ptr %"tmp#3##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"student.student.major<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = add i64 %"#rec##0", 8 - %1 = inttoptr i64 %0 to i64* - %2 = load i64, i64* %1 - ret i64 %2 +define external fastcc i64 @"student.student.major<0>"(i64 %"#rec##0") { + %"tmp#0##0" = add i64 %"#rec##0", 8 + %"tmp#1##0" = inttoptr i64 %"tmp#0##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"student.student.major<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = add i64 %2, 8 - %7 = inttoptr i64 %6 to i64* - store i64 %"#field##0", i64* %7 - ret i64 %2 +define external fastcc i64 @"student.student.major<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = add i64 %"tmp#2##0", 8 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 %"#field##0", ptr %"tmp#4##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"student.student.student<0>"(i64 %"id##0", i64 %"major##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"id##0", i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"major##0", i64* %5 - ret i64 %2 +define external fastcc i64 @"student.student.student<0>"(i64 %"id##0", i64 %"major##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 16) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"id##0", ptr %"tmp#1##0" + %"tmp#2##0" = add i64 %"#rec##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"major##0", ptr %"tmp#3##0" + ret i64 %"#rec##0" } - -define external fastcc {i64, i64} @"student.student.student<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#result##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#result##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = insertvalue {i64, i64} undef, i64 %1, 0 - %6 = insertvalue {i64, i64} %5, i64 %4, 1 - ret {i64, i64} %6 +define external fastcc {i64, i64} @"student.student.student<1>"(i64 %"#result##0") { + %"tmp#0##0" = inttoptr i64 %"#result##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + %"tmp#2##0" = add i64 %"#result##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#3##0" + %"tmp#5##0" = insertvalue {i64, i64} undef, i64 %"tmp#1##0", 0 + %"tmp#6##0" = insertvalue {i64, i64} %"tmp#5##0", i64 %"tmp#4##0", 1 + ret {i64, i64} %"tmp#6##0" } - -define external fastcc i1 @"student.student.~=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %"#right##0" to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = icmp eq i64 %1, %6 - br i1 %10, label %if.then, label %if.else -if.then: - %11 = inttoptr i64 %4 to i64* - %12 = load i64, i64* %11 - %13 = add i64 %4, 8 - %14 = inttoptr i64 %13 to i64* - %15 = load i64, i64* %14 - %16 = inttoptr i64 %9 to i64* - %17 = load i64, i64* %16 - %18 = add i64 %9, 8 - %19 = inttoptr i64 %18 to i64* - %20 = load i64, i64* %19 - %21 = icmp eq i64 %17, %12 - br i1 %21, label %if.then1, label %if.else1 -if.else: - %26 = xor i1 0, 1 - ret i1 %26 -if.then1: - %22 = tail call fastcc i2 @"wybe.string.<=>#cont#2<0>"(i2 1, i64 %15, i64 %20, i64 %15, i64 %20) - %23 = icmp eq i2 %22, 1 - %24 = xor i1 %23, 1 - ret i1 %24 -if.else1: - %25 = xor i1 0, 1 - ret i1 %25 +define external fastcc i1 @"student.student.~=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#14##0" = inttoptr i64 %"#left##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#14##0" + %"tmp#15##0" = add i64 %"#left##0", 8 + %"tmp#16##0" = inttoptr i64 %"tmp#15##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#16##0" + %"tmp#17##0" = inttoptr i64 %"#right##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#17##0" + %"tmp#18##0" = add i64 %"#right##0", 8 + %"tmp#19##0" = inttoptr i64 %"tmp#18##0" to ptr + %"tmp#6##0" = load i64, ptr %"tmp#19##0" + %"tmp#7##0" = icmp eq i64 %"tmp#3##0", %"tmp#5##0" + br i1 %"tmp#7##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#20##0" = inttoptr i64 %"tmp#4##0" to ptr + %"tmp#8##0" = load i64, ptr %"tmp#20##0" + %"tmp#21##0" = add i64 %"tmp#4##0", 8 + %"tmp#22##0" = inttoptr i64 %"tmp#21##0" to ptr + %"tmp#9##0" = load i64, ptr %"tmp#22##0" + %"tmp#23##0" = inttoptr i64 %"tmp#6##0" to ptr + %"tmp#10##0" = load i64, ptr %"tmp#23##0" + %"tmp#24##0" = add i64 %"tmp#6##0", 8 + %"tmp#25##0" = inttoptr i64 %"tmp#24##0" to ptr + %"tmp#11##0" = load i64, ptr %"tmp#25##0" + %"tmp#12##0" = icmp eq i64 %"tmp#10##0", %"tmp#8##0" + br i1 %"tmp#12##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#13##0" = tail call fastcc i2 @"wybe.string.<=>#cont#2<0>"(i2 1, i64 %"tmp#9##0", i64 %"tmp#11##0", i64 %"tmp#9##0", i64 %"tmp#11##0") + %"tmp#0##0" = icmp eq i2 %"tmp#13##0", 1 + %"tmp#26##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#26##0" +if.else.1: + %"tmp#27##0" = xor i1 0, 1 + ret i1 %"tmp#27##0" +if.else.0: + %"tmp#28##0" = xor i1 0, 1 + ret i1 %"tmp#28##0" } diff --git a/test-cases/final-dump/alias_des.exp b/test-cases/final-dump/alias_des.exp index 2963acbef..7ed65f416 100644 --- a/test-cases/final-dump/alias_des.exp +++ b/test-cases/final-dump/alias_des.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module alias_des representation : (not a type) public submods : @@ -54,95 +57,71 @@ replicate(?p2##1:position.position)<{<>}; {<>}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'alias_des' +source_filename = "!ROOT!/final-dump/alias_des.wybe" +target triple ???? - - - -@alias_des.5 = constant {i64, i64} { i64 19, i64 ptrtoint ([?? x i8]* @alias_des.4 to i64) } - - -@alias_des.3 = constant {i64, i64} { i64 21, i64 ptrtoint ([?? x i8]* @alias_des.2 to i64) } - - -@alias_des.1 = constant {i64, i64} { i64 47, i64 ptrtoint ([?? x i8]* @alias_des.0 to i64) } - - -@alias_des.0 = constant [?? x i8] c"--- after x(!p2, 20000) - expect p2(20000,103):\00" - - -@alias_des.2 = constant [?? x i8] c"expect p1(10000,102):\00" - - -@alias_des.4 = constant [?? x i8] c"expect p2(101,103):\00" - - -declare external fastcc void @"position.printPosition<0>"(i64) +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c"--- after x(!p2, 20000) - expect p2(20000,103):\00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c"expect p1(10000,102):\00", align 8 +@"cstring#2" = private unnamed_addr constant [ ?? x i8 ] c"expect p2(101,103):\00", align 8 +@"string#3" = private unnamed_addr constant {i64, i64} { i64 47, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +@"string#4" = private unnamed_addr constant {i64, i64} { i64 21, i64 ptrtoint( ptr @"cstring#1" to i64 ) }, align 8 +@"string#5" = private unnamed_addr constant {i64, i64} { i64 19, i64 ptrtoint( ptr @"cstring#2" to i64 ) }, align 8 +declare external fastcc void @"position.printPosition<0>"(i64) +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"alias_des.<0>"() alwaysinline { -entry: - musttail call fastcc void @"alias_des.foo<0>"() - ret void +define external fastcc void @"alias_des.<0>"() { + tail call fastcc void @"alias_des.foo<0>"() + ret void } - -define external fastcc void @"alias_des.foo<0>"() { -entry: - %0 = tail call fastcc i64 @"alias_des.replicate<0>"() - %1 = inttoptr i64 %0 to i64* - store i64 20000, i64* %1 - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_des.1, i32 0, i32 0) to i64)) - tail call fastcc void @"position.printPosition<0>"(i64 %0) - ret void +define external fastcc void @"alias_des.foo<0>"() { + %"p2##0" = tail call fastcc i64 @"alias_des.replicate<0>"() + %"tmp#2##0" = inttoptr i64 %"p2##0" to ptr + store i64 20000, ptr %"tmp#2##0" + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#3" to i64 )) + tail call fastcc void @"position.printPosition<0>"(i64 %"p2##0") + ret void } - -define external fastcc i64 @"alias_des.replicate<0>"() { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 101, i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 102, i64* %5 - %6 = inttoptr i64 %2 to i64* - %7 = load i64, i64* %6 - %8 = trunc i64 16 to i32 - %9 = tail call ccc i8* @wybe_malloc(i32 %8) - %10 = ptrtoint i8* %9 to i64 - %11 = inttoptr i64 %10 to i64* - store i64 %7, i64* %11 - %12 = add i64 %10, 8 - %13 = inttoptr i64 %12 to i64* - store i64 102, i64* %13 - %14 = inttoptr i64 %2 to i64* - store i64 10000, i64* %14 - %15 = add i64 %2, 8 - %16 = inttoptr i64 %15 to i64* - %17 = load i64, i64* %16 - %18 = add i64 %17, 1 - %19 = add i64 %10, 8 - %20 = inttoptr i64 %19 to i64* - store i64 %18, i64* %20 - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_des.3, i32 0, i32 0) to i64)) - tail call fastcc void @"position.printPosition<0>"(i64 %2) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_des.5, i32 0, i32 0) to i64)) - tail call fastcc void @"position.printPosition<0>"(i64 %10) - ret i64 %10 +define external fastcc i64 @"alias_des.replicate<0>"() { + %"tmp#23##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#8##0" = ptrtoint ptr %"tmp#23##0" to i64 + %"tmp#24##0" = inttoptr i64 %"tmp#8##0" to ptr + store i64 101, ptr %"tmp#24##0" + %"tmp#25##0" = add i64 %"tmp#8##0", 8 + %"tmp#26##0" = inttoptr i64 %"tmp#25##0" to ptr + store i64 102, ptr %"tmp#26##0" + %"tmp#27##0" = inttoptr i64 %"tmp#8##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#27##0" + %"tmp#28##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#14##0" = ptrtoint ptr %"tmp#28##0" to i64 + %"tmp#29##0" = inttoptr i64 %"tmp#14##0" to ptr + store i64 %"tmp#2##0", ptr %"tmp#29##0" + %"tmp#30##0" = add i64 %"tmp#14##0", 8 + %"tmp#31##0" = inttoptr i64 %"tmp#30##0" to ptr + store i64 102, ptr %"tmp#31##0" + %"tmp#32##0" = inttoptr i64 %"tmp#8##0" to ptr + store i64 10000, ptr %"tmp#32##0" + %"tmp#33##0" = add i64 %"tmp#8##0", 8 + %"tmp#34##0" = inttoptr i64 %"tmp#33##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#34##0" + %"tmp#4##0" = add i64 %"tmp#5##0", 1 + %"tmp#35##0" = add i64 %"tmp#14##0", 8 + %"tmp#36##0" = inttoptr i64 %"tmp#35##0" to ptr + store i64 %"tmp#4##0", ptr %"tmp#36##0" + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#4" to i64 )) + tail call fastcc void @"position.printPosition<0>"(i64 %"tmp#8##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#5" to i64 )) + tail call fastcc void @"position.printPosition<0>"(i64 %"tmp#14##0") + ret i64 %"tmp#14##0" } + -------------------------------------------------- Module position representation : (not a type) @@ -185,63 +164,42 @@ printPosition(pos##0:position.position)<{<>}; {<>}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'position' - - - - -@position.3 = constant {i64, i64} { i64 1, i64 ptrtoint ([?? x i8]* @position.2 to i64) } - - -@position.5 = constant {i64, i64} { i64 1, i64 ptrtoint ([?? x i8]* @position.4 to i64) } - - -@position.1 = constant {i64, i64} { i64 2, i64 ptrtoint ([?? x i8]* @position.0 to i64) } - - -@position.0 = constant [?? x i8] c" (\00" - - -@position.4 = constant [?? x i8] c")\00" - - -@position.2 = constant [?? x i8] c",\00" - - -declare external ccc void @putchar(i8) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc void @print_int(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"position.printPosition<0>"(i64 %"pos##0") { -entry: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @position.1, i32 0, i32 0) to i64)) - %0 = inttoptr i64 %"pos##0" to i64* - %1 = load i64, i64* %0 - tail call ccc void @print_int(i64 %1) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @position.3, i32 0, i32 0) to i64)) - %2 = add i64 %"pos##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - tail call ccc void @print_int(i64 %4) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @position.5, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - ret void +source_filename = "!ROOT!/final-dump/position.wybe" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c" (\00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c")\00", align 8 +@"cstring#2" = private unnamed_addr constant [ ?? x i8 ] c",\00", align 8 +@"string#3" = private unnamed_addr constant {i64, i64} { i64 2, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +@"string#4" = private unnamed_addr constant {i64, i64} { i64 1, i64 ptrtoint( ptr @"cstring#1" to i64 ) }, align 8 +@"string#5" = private unnamed_addr constant {i64, i64} { i64 1, i64 ptrtoint( ptr @"cstring#2" to i64 ) }, align 8 + +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"position.printPosition<0>"(i64 %"pos##0") { + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#3" to i64 )) + %"tmp#13##0" = inttoptr i64 %"pos##0" to ptr + %"tmp#0##0" = load i64, ptr %"tmp#13##0" + call ccc void @print_int(i64 %"tmp#0##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#5" to i64 )) + %"tmp#14##0" = add i64 %"pos##0", 8 + %"tmp#15##0" = inttoptr i64 %"tmp#14##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#15##0" + call ccc void @print_int(i64 %"tmp#1##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#4" to i64 )) + call ccc void @putchar(i8 10) + ret void } + -------------------------------------------------- Module position.position - representation : address + representation : pointer public submods : public resources: public procs : position.position.=<0> @@ -343,134 +301,110 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'position.position' - - - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i1 @"position.position.=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %"#right##0" to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = icmp eq i64 %1, %6 - br i1 %10, label %if.then, label %if.else -if.then: - %11 = icmp eq i64 %4, %9 - ret i1 %11 -if.else: - ret i1 0 +source_filename = "!ROOT!/final-dump/position.wybe" +target triple ???? + + +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc i1 @"position.position.=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#9##0" = inttoptr i64 %"#left##0" to ptr + %"#left#x##0" = load i64, ptr %"tmp#9##0" + %"tmp#10##0" = add i64 %"#left##0", 8 + %"tmp#11##0" = inttoptr i64 %"tmp#10##0" to ptr + %"#left#y##0" = load i64, ptr %"tmp#11##0" + %"tmp#12##0" = inttoptr i64 %"#right##0" to ptr + %"#right#x##0" = load i64, ptr %"tmp#12##0" + %"tmp#13##0" = add i64 %"#right##0", 8 + %"tmp#14##0" = inttoptr i64 %"tmp#13##0" to ptr + %"#right#y##0" = load i64, ptr %"tmp#14##0" + %"tmp#1##0" = icmp eq i64 %"#left#x##0", %"#right#x##0" + br i1 %"tmp#1##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#15##0" = icmp eq i64 %"#left#y##0", %"#right#y##0" + ret i1 %"tmp#15##0" +if.else.0: + ret i1 0 } - -define external fastcc i64 @"position.position.position<0>"(i64 %"x##0", i64 %"y##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"x##0", i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"y##0", i64* %5 - ret i64 %2 +define external fastcc i64 @"position.position.position<0>"(i64 %"x##0", i64 %"y##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 16) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"x##0", ptr %"tmp#1##0" + %"tmp#2##0" = add i64 %"#rec##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"y##0", ptr %"tmp#3##0" + ret i64 %"#rec##0" } - -define external fastcc {i64, i64} @"position.position.position<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#result##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#result##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = insertvalue {i64, i64} undef, i64 %1, 0 - %6 = insertvalue {i64, i64} %5, i64 %4, 1 - ret {i64, i64} %6 +define external fastcc {i64, i64} @"position.position.position<1>"(i64 %"#result##0") { + %"tmp#0##0" = inttoptr i64 %"#result##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + %"tmp#2##0" = add i64 %"#result##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#3##0" + %"tmp#5##0" = insertvalue {i64, i64} undef, i64 %"tmp#1##0", 0 + %"tmp#6##0" = insertvalue {i64, i64} %"tmp#5##0", i64 %"tmp#4##0", 1 + ret {i64, i64} %"tmp#6##0" } - -define external fastcc i64 @"position.position.x<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#rec##0" to i64* - %1 = load i64, i64* %0 - ret i64 %1 +define external fastcc i64 @"position.position.x<0>"(i64 %"#rec##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + ret i64 %"tmp#1##0" } - -define external fastcc i64 @"position.position.x<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = inttoptr i64 %2 to i64* - store i64 %"#field##0", i64* %6 - ret i64 %2 +define external fastcc i64 @"position.position.x<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"#field##0", ptr %"tmp#3##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"position.position.y<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = add i64 %"#rec##0", 8 - %1 = inttoptr i64 %0 to i64* - %2 = load i64, i64* %1 - ret i64 %2 +define external fastcc i64 @"position.position.y<0>"(i64 %"#rec##0") { + %"tmp#0##0" = add i64 %"#rec##0", 8 + %"tmp#1##0" = inttoptr i64 %"tmp#0##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"position.position.y<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = add i64 %2, 8 - %7 = inttoptr i64 %6 to i64* - store i64 %"#field##0", i64* %7 - ret i64 %2 +define external fastcc i64 @"position.position.y<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = add i64 %"tmp#2##0", 8 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 %"#field##0", ptr %"tmp#4##0" + ret i64 %"tmp#2##0" } - -define external fastcc i1 @"position.position.~=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %"#right##0" to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = icmp eq i64 %1, %6 - br i1 %10, label %if.then, label %if.else -if.then: - %11 = icmp eq i64 %4, %9 - %12 = xor i1 %11, 1 - ret i1 %12 -if.else: - %13 = xor i1 0, 1 - ret i1 %13 +define external fastcc i1 @"position.position.~=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#8##0" = inttoptr i64 %"#left##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#8##0" + %"tmp#9##0" = add i64 %"#left##0", 8 + %"tmp#10##0" = inttoptr i64 %"tmp#9##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#10##0" + %"tmp#11##0" = inttoptr i64 %"#right##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#11##0" + %"tmp#12##0" = add i64 %"#right##0", 8 + %"tmp#13##0" = inttoptr i64 %"tmp#12##0" to ptr + %"tmp#6##0" = load i64, ptr %"tmp#13##0" + %"tmp#7##0" = icmp eq i64 %"tmp#3##0", %"tmp#5##0" + br i1 %"tmp#7##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#0##0" = icmp eq i64 %"tmp#4##0", %"tmp#6##0" + %"tmp#14##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#14##0" +if.else.0: + %"tmp#15##0" = xor i1 0, 1 + ret i1 %"tmp#15##0" } diff --git a/test-cases/final-dump/alias_des2.exp b/test-cases/final-dump/alias_des2.exp index 59143c55f..395097a67 100644 --- a/test-cases/final-dump/alias_des2.exp +++ b/test-cases/final-dump/alias_des2.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module alias_des2 representation : (not a type) public submods : @@ -24,46 +27,35 @@ module top-level code > public {semipure} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'alias_des2' - - - - -@alias_des2.1 = constant {i64, i64} { i64 20, i64 ptrtoint ([?? x i8]* @alias_des2.0 to i64) } - - -@alias_des2.0 = constant [?? x i8] c"expect pos(200,100):\00" - - -declare external fastcc void @"position.printPosition<0>"(i64) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"alias_des2.<0>"() { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 100, i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 100, i64* %5 - %6 = inttoptr i64 %2 to i64* - store i64 200, i64* %6 - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_des2.1, i32 0, i32 0) to i64)) - tail call fastcc void @"position.printPosition<0>"(i64 %2) - ret void +source_filename = "!ROOT!/final-dump/alias_des2.wybe" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c"expect pos(200,100):\00", align 8 +@"string#1" = private unnamed_addr constant {i64, i64} { i64 20, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 + +declare external fastcc void @"position.printPosition<0>"(i64) +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"alias_des2.<0>"() { + %"tmp#7##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#3##0" = ptrtoint ptr %"tmp#7##0" to i64 + %"tmp#8##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 100, ptr %"tmp#8##0" + %"tmp#9##0" = add i64 %"tmp#3##0", 8 + %"tmp#10##0" = inttoptr i64 %"tmp#9##0" to ptr + store i64 100, ptr %"tmp#10##0" + %"tmp#11##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 200, ptr %"tmp#11##0" + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#1" to i64 )) + tail call fastcc void @"position.printPosition<0>"(i64 %"tmp#3##0") + ret void } + -------------------------------------------------- Module position representation : (not a type) @@ -106,63 +98,42 @@ printPosition(pos##0:position.position)<{<>}; {<>}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'position' - - - - -@position.3 = constant {i64, i64} { i64 1, i64 ptrtoint ([?? x i8]* @position.2 to i64) } - - -@position.5 = constant {i64, i64} { i64 1, i64 ptrtoint ([?? x i8]* @position.4 to i64) } - - -@position.1 = constant {i64, i64} { i64 2, i64 ptrtoint ([?? x i8]* @position.0 to i64) } - - -@position.0 = constant [?? x i8] c" (\00" - - -@position.4 = constant [?? x i8] c")\00" - - -@position.2 = constant [?? x i8] c",\00" - - -declare external ccc void @putchar(i8) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc void @print_int(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"position.printPosition<0>"(i64 %"pos##0") { -entry: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @position.1, i32 0, i32 0) to i64)) - %0 = inttoptr i64 %"pos##0" to i64* - %1 = load i64, i64* %0 - tail call ccc void @print_int(i64 %1) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @position.3, i32 0, i32 0) to i64)) - %2 = add i64 %"pos##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - tail call ccc void @print_int(i64 %4) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @position.5, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - ret void +source_filename = "!ROOT!/final-dump/position.wybe" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c" (\00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c")\00", align 8 +@"cstring#2" = private unnamed_addr constant [ ?? x i8 ] c",\00", align 8 +@"string#3" = private unnamed_addr constant {i64, i64} { i64 2, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +@"string#4" = private unnamed_addr constant {i64, i64} { i64 1, i64 ptrtoint( ptr @"cstring#1" to i64 ) }, align 8 +@"string#5" = private unnamed_addr constant {i64, i64} { i64 1, i64 ptrtoint( ptr @"cstring#2" to i64 ) }, align 8 + +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"position.printPosition<0>"(i64 %"pos##0") { + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#3" to i64 )) + %"tmp#13##0" = inttoptr i64 %"pos##0" to ptr + %"tmp#0##0" = load i64, ptr %"tmp#13##0" + call ccc void @print_int(i64 %"tmp#0##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#5" to i64 )) + %"tmp#14##0" = add i64 %"pos##0", 8 + %"tmp#15##0" = inttoptr i64 %"tmp#14##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#15##0" + call ccc void @print_int(i64 %"tmp#1##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#4" to i64 )) + call ccc void @putchar(i8 10) + ret void } + -------------------------------------------------- Module position.position - representation : address + representation : pointer public submods : public resources: public procs : position.position.=<0> @@ -264,134 +235,110 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'position.position' - - - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i1 @"position.position.=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %"#right##0" to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = icmp eq i64 %1, %6 - br i1 %10, label %if.then, label %if.else -if.then: - %11 = icmp eq i64 %4, %9 - ret i1 %11 -if.else: - ret i1 0 +source_filename = "!ROOT!/final-dump/position.wybe" +target triple ???? + + +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc i1 @"position.position.=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#9##0" = inttoptr i64 %"#left##0" to ptr + %"#left#x##0" = load i64, ptr %"tmp#9##0" + %"tmp#10##0" = add i64 %"#left##0", 8 + %"tmp#11##0" = inttoptr i64 %"tmp#10##0" to ptr + %"#left#y##0" = load i64, ptr %"tmp#11##0" + %"tmp#12##0" = inttoptr i64 %"#right##0" to ptr + %"#right#x##0" = load i64, ptr %"tmp#12##0" + %"tmp#13##0" = add i64 %"#right##0", 8 + %"tmp#14##0" = inttoptr i64 %"tmp#13##0" to ptr + %"#right#y##0" = load i64, ptr %"tmp#14##0" + %"tmp#1##0" = icmp eq i64 %"#left#x##0", %"#right#x##0" + br i1 %"tmp#1##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#15##0" = icmp eq i64 %"#left#y##0", %"#right#y##0" + ret i1 %"tmp#15##0" +if.else.0: + ret i1 0 } - -define external fastcc i64 @"position.position.position<0>"(i64 %"x##0", i64 %"y##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"x##0", i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"y##0", i64* %5 - ret i64 %2 +define external fastcc i64 @"position.position.position<0>"(i64 %"x##0", i64 %"y##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 16) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"x##0", ptr %"tmp#1##0" + %"tmp#2##0" = add i64 %"#rec##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"y##0", ptr %"tmp#3##0" + ret i64 %"#rec##0" } - -define external fastcc {i64, i64} @"position.position.position<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#result##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#result##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = insertvalue {i64, i64} undef, i64 %1, 0 - %6 = insertvalue {i64, i64} %5, i64 %4, 1 - ret {i64, i64} %6 +define external fastcc {i64, i64} @"position.position.position<1>"(i64 %"#result##0") { + %"tmp#0##0" = inttoptr i64 %"#result##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + %"tmp#2##0" = add i64 %"#result##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#3##0" + %"tmp#5##0" = insertvalue {i64, i64} undef, i64 %"tmp#1##0", 0 + %"tmp#6##0" = insertvalue {i64, i64} %"tmp#5##0", i64 %"tmp#4##0", 1 + ret {i64, i64} %"tmp#6##0" } - -define external fastcc i64 @"position.position.x<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#rec##0" to i64* - %1 = load i64, i64* %0 - ret i64 %1 +define external fastcc i64 @"position.position.x<0>"(i64 %"#rec##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + ret i64 %"tmp#1##0" } - -define external fastcc i64 @"position.position.x<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = inttoptr i64 %2 to i64* - store i64 %"#field##0", i64* %6 - ret i64 %2 +define external fastcc i64 @"position.position.x<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"#field##0", ptr %"tmp#3##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"position.position.y<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = add i64 %"#rec##0", 8 - %1 = inttoptr i64 %0 to i64* - %2 = load i64, i64* %1 - ret i64 %2 +define external fastcc i64 @"position.position.y<0>"(i64 %"#rec##0") { + %"tmp#0##0" = add i64 %"#rec##0", 8 + %"tmp#1##0" = inttoptr i64 %"tmp#0##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"position.position.y<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = add i64 %2, 8 - %7 = inttoptr i64 %6 to i64* - store i64 %"#field##0", i64* %7 - ret i64 %2 +define external fastcc i64 @"position.position.y<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = add i64 %"tmp#2##0", 8 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 %"#field##0", ptr %"tmp#4##0" + ret i64 %"tmp#2##0" } - -define external fastcc i1 @"position.position.~=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %"#right##0" to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = icmp eq i64 %1, %6 - br i1 %10, label %if.then, label %if.else -if.then: - %11 = icmp eq i64 %4, %9 - %12 = xor i1 %11, 1 - ret i1 %12 -if.else: - %13 = xor i1 0, 1 - ret i1 %13 +define external fastcc i1 @"position.position.~=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#8##0" = inttoptr i64 %"#left##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#8##0" + %"tmp#9##0" = add i64 %"#left##0", 8 + %"tmp#10##0" = inttoptr i64 %"tmp#9##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#10##0" + %"tmp#11##0" = inttoptr i64 %"#right##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#11##0" + %"tmp#12##0" = add i64 %"#right##0", 8 + %"tmp#13##0" = inttoptr i64 %"tmp#12##0" to ptr + %"tmp#6##0" = load i64, ptr %"tmp#13##0" + %"tmp#7##0" = icmp eq i64 %"tmp#3##0", %"tmp#5##0" + br i1 %"tmp#7##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#0##0" = icmp eq i64 %"tmp#4##0", %"tmp#6##0" + %"tmp#14##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#14##0" +if.else.0: + %"tmp#15##0" = xor i1 0, 1 + ret i1 %"tmp#15##0" } diff --git a/test-cases/final-dump/alias_fork1.exp b/test-cases/final-dump/alias_fork1.exp index 2841cd79d..7171ce3cd 100644 --- a/test-cases/final-dump/alias_fork1.exp +++ b/test-cases/final-dump/alias_fork1.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module alias_fork1 representation : (not a type) public submods : @@ -86,152 +89,126 @@ simpleMerge#cont#1(tmp#2##0:mytree.tree, ?#result##0:mytree.tree)<{}; {}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'alias_fork1' - - - - -@alias_fork1.1 = constant {i64, i64} { i64 1, i64 ptrtoint ([?? x i8]* @alias_fork1.0 to i64) } - - -@alias_fork1.3 = constant {i64, i64} { i64 1, i64 ptrtoint ([?? x i8]* @alias_fork1.2 to i64) } - - -@alias_fork1.0 = constant [?? x i8] c"{\00" - - -@alias_fork1.2 = constant [?? x i8] c"}\00" - - -declare external ccc void @putchar(i8) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external fastcc i64 @"mytree.printTree1<0>"(i64, i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"alias_fork1.<0>"() { -entry: - %0 = trunc i64 24 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 0, i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 222, i64* %5 - %6 = add i64 %2, 16 - %7 = inttoptr i64 %6 to i64* - store i64 0, i64* %7 - %8 = trunc i64 24 to i32 - %9 = tail call ccc i8* @wybe_malloc(i32 %8) - %10 = ptrtoint i8* %9 to i64 - %11 = inttoptr i64 %10 to i64* - store i64 0, i64* %11 - %12 = add i64 %10, 8 - %13 = inttoptr i64 %12 to i64* - store i64 111, i64* %13 - %14 = add i64 %10, 16 - %15 = inttoptr i64 %14 to i64* - store i64 0, i64* %15 - %16 = tail call fastcc i64 @"alias_fork1.simpleMerge<0>"(i64 %2, i64 %10) - %17 = tail call fastcc i64 @"mytree.printTree1<0>"(i64 %16, i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_fork1.1, i32 0, i32 0) to i64)) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_fork1.3, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - ret void +source_filename = "!ROOT!/final-dump/alias_fork1.wybe" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c"{\00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c"}\00", align 8 +@"string#2" = private unnamed_addr constant {i64, i64} { i64 1, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +@"string#3" = private unnamed_addr constant {i64, i64} { i64 1, i64 ptrtoint( ptr @"cstring#1" to i64 ) }, align 8 + +declare external fastcc i64 @"mytree.printTree1<0>"(i64, i64) +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @putchar(i8) +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"alias_fork1.<0>"() { + %"tmp#23##0" = call ccc ptr @wybe_malloc(i32 24) + %"tmp#10##0" = ptrtoint ptr %"tmp#23##0" to i64 + %"tmp#24##0" = inttoptr i64 %"tmp#10##0" to ptr + store i64 0, ptr %"tmp#24##0" + %"tmp#25##0" = add i64 %"tmp#10##0", 8 + %"tmp#26##0" = inttoptr i64 %"tmp#25##0" to ptr + store i64 222, ptr %"tmp#26##0" + %"tmp#27##0" = add i64 %"tmp#10##0", 16 + %"tmp#28##0" = inttoptr i64 %"tmp#27##0" to ptr + store i64 0, ptr %"tmp#28##0" + %"tmp#29##0" = call ccc ptr @wybe_malloc(i32 24) + %"tmp#16##0" = ptrtoint ptr %"tmp#29##0" to i64 + %"tmp#30##0" = inttoptr i64 %"tmp#16##0" to ptr + store i64 0, ptr %"tmp#30##0" + %"tmp#31##0" = add i64 %"tmp#16##0", 8 + %"tmp#32##0" = inttoptr i64 %"tmp#31##0" to ptr + store i64 111, ptr %"tmp#32##0" + %"tmp#33##0" = add i64 %"tmp#16##0", 16 + %"tmp#34##0" = inttoptr i64 %"tmp#33##0" to ptr + store i64 0, ptr %"tmp#34##0" + %"tmp#6##0" = tail call fastcc i64 @"alias_fork1.simpleMerge<0>"(i64 %"tmp#10##0", i64 %"tmp#16##0") + %"tmp#20##0" = tail call fastcc i64 @"mytree.printTree1<0>"(i64 %"tmp#6##0", i64 ptrtoint( ptr @"string#2" to i64 )) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#3" to i64 )) + call ccc void @putchar(i8 10) + ret void } - -define external fastcc i64 @"alias_fork1.simpleMerge<0>"(i64 %"tl##0", i64 %"tr##0") { -entry: - %0 = icmp ne i64 %"tl##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = add i64 %"tl##0", 8 - %2 = inttoptr i64 %1 to i64* - %3 = load i64, i64* %2 - %4 = add i64 %"tl##0", 16 - %5 = inttoptr i64 %4 to i64* - %6 = load i64, i64* %5 - %7 = icmp ne i64 %"tr##0", 0 - br i1 %7, label %if.then1, label %if.else1 -if.else: - %39 = trunc i64 24 to i32 - %40 = tail call ccc i8* @wybe_malloc(i32 %39) - %41 = ptrtoint i8* %40 to i64 - %42 = inttoptr i64 %41 to i64* - store i64 0, i64* %42 - %43 = add i64 %41, 8 - %44 = inttoptr i64 %43 to i64* - store i64 0, i64* %44 - %45 = add i64 %41, 16 - %46 = inttoptr i64 %45 to i64* - store i64 0, i64* %46 - ret i64 %41 -if.then1: - %8 = add i64 %"tr##0", 8 - %9 = inttoptr i64 %8 to i64* - %10 = load i64, i64* %9 - %11 = add i64 %"tr##0", 16 - %12 = inttoptr i64 %11 to i64* - %13 = load i64, i64* %12 - %14 = icmp slt i64 %3, %10 - br i1 %14, label %if.then2, label %if.else2 -if.else1: - %31 = trunc i64 24 to i32 - %32 = tail call ccc i8* @wybe_malloc(i32 %31) - %33 = ptrtoint i8* %32 to i64 - %34 = inttoptr i64 %33 to i64* - store i64 0, i64* %34 - %35 = add i64 %33, 8 - %36 = inttoptr i64 %35 to i64* - store i64 0, i64* %36 - %37 = add i64 %33, 16 - %38 = inttoptr i64 %37 to i64* - store i64 0, i64* %38 - ret i64 %33 -if.then2: - %15 = trunc i64 24 to i32 - %16 = tail call ccc i8* @wybe_malloc(i32 %15) - %17 = ptrtoint i8* %16 to i64 - %18 = inttoptr i64 %17 to i64* - store i64 %"tl##0", i64* %18 - %19 = add i64 %17, 8 - %20 = inttoptr i64 %19 to i64* - store i64 %10, i64* %20 - %21 = add i64 %17, 16 - %22 = inttoptr i64 %21 to i64* - store i64 %13, i64* %22 - ret i64 %17 -if.else2: - %23 = trunc i64 24 to i32 - %24 = tail call ccc i8* @wybe_malloc(i32 %23) - %25 = ptrtoint i8* %24 to i64 - %26 = inttoptr i64 %25 to i64* - store i64 %"tr##0", i64* %26 - %27 = add i64 %25, 8 - %28 = inttoptr i64 %27 to i64* - store i64 %3, i64* %28 - %29 = add i64 %25, 16 - %30 = inttoptr i64 %29 to i64* - store i64 %6, i64* %30 - ret i64 %25 +define external fastcc i64 @"alias_fork1.simpleMerge<0>"(i64 %"tl##0", i64 %"tr##0") { + %"tmp#15##0" = icmp ne i64 %"tl##0", 0 + br i1 %"tmp#15##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#46##0" = add i64 %"tl##0", 8 + %"tmp#47##0" = inttoptr i64 %"tmp#46##0" to ptr + %"k1##0" = load i64, ptr %"tmp#47##0" + %"tmp#48##0" = add i64 %"tl##0", 16 + %"tmp#49##0" = inttoptr i64 %"tmp#48##0" to ptr + %"r1##0" = load i64, ptr %"tmp#49##0" + %"tmp#23##0" = icmp ne i64 %"tr##0", 0 + br i1 %"tmp#23##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#50##0" = add i64 %"tr##0", 8 + %"tmp#51##0" = inttoptr i64 %"tmp#50##0" to ptr + %"k2##0" = load i64, ptr %"tmp#51##0" + %"tmp#52##0" = add i64 %"tr##0", 16 + %"tmp#53##0" = inttoptr i64 %"tmp#52##0" to ptr + %"r2##0" = load i64, ptr %"tmp#53##0" + %"tmp#11##0" = icmp slt i64 %"k1##0", %"k2##0" + br i1 %"tmp#11##0", label %if.then.2, label %if.else.2 +if.then.2: + %"tmp#54##0" = call ccc ptr @wybe_malloc(i32 24) + %"tmp#42##0" = ptrtoint ptr %"tmp#54##0" to i64 + %"tmp#55##0" = inttoptr i64 %"tmp#42##0" to ptr + store i64 %"tl##0", ptr %"tmp#55##0" + %"tmp#56##0" = add i64 %"tmp#42##0", 8 + %"tmp#57##0" = inttoptr i64 %"tmp#56##0" to ptr + store i64 %"k2##0", ptr %"tmp#57##0" + %"tmp#58##0" = add i64 %"tmp#42##0", 16 + %"tmp#59##0" = inttoptr i64 %"tmp#58##0" to ptr + store i64 %"r2##0", ptr %"tmp#59##0" + ret i64 %"tmp#42##0" +if.else.2: + %"tmp#60##0" = call ccc ptr @wybe_malloc(i32 24) + %"tmp#35##0" = ptrtoint ptr %"tmp#60##0" to i64 + %"tmp#61##0" = inttoptr i64 %"tmp#35##0" to ptr + store i64 %"tr##0", ptr %"tmp#61##0" + %"tmp#62##0" = add i64 %"tmp#35##0", 8 + %"tmp#63##0" = inttoptr i64 %"tmp#62##0" to ptr + store i64 %"k1##0", ptr %"tmp#63##0" + %"tmp#64##0" = add i64 %"tmp#35##0", 16 + %"tmp#65##0" = inttoptr i64 %"tmp#64##0" to ptr + store i64 %"r1##0", ptr %"tmp#65##0" + ret i64 %"tmp#35##0" +if.else.1: + %"tmp#66##0" = call ccc ptr @wybe_malloc(i32 24) + %"tmp#27##0" = ptrtoint ptr %"tmp#66##0" to i64 + %"tmp#67##0" = inttoptr i64 %"tmp#27##0" to ptr + store i64 0, ptr %"tmp#67##0" + %"tmp#68##0" = add i64 %"tmp#27##0", 8 + %"tmp#69##0" = inttoptr i64 %"tmp#68##0" to ptr + store i64 0, ptr %"tmp#69##0" + %"tmp#70##0" = add i64 %"tmp#27##0", 16 + %"tmp#71##0" = inttoptr i64 %"tmp#70##0" to ptr + store i64 0, ptr %"tmp#71##0" + ret i64 %"tmp#27##0" +if.else.0: + %"tmp#72##0" = call ccc ptr @wybe_malloc(i32 24) + %"tmp#19##0" = ptrtoint ptr %"tmp#72##0" to i64 + %"tmp#73##0" = inttoptr i64 %"tmp#19##0" to ptr + store i64 0, ptr %"tmp#73##0" + %"tmp#74##0" = add i64 %"tmp#19##0", 8 + %"tmp#75##0" = inttoptr i64 %"tmp#74##0" to ptr + store i64 0, ptr %"tmp#75##0" + %"tmp#76##0" = add i64 %"tmp#19##0", 16 + %"tmp#77##0" = inttoptr i64 %"tmp#76##0" to ptr + store i64 0, ptr %"tmp#77##0" + ret i64 %"tmp#19##0" } - -define external fastcc i64 @"alias_fork1.simpleMerge#cont#1<0>"(i64 %"tmp#2##0") alwaysinline { -entry: - ret i64 %"tmp#2##0" +define external fastcc i64 @"alias_fork1.simpleMerge#cont#1<0>"(i64 %"tmp#2##0") { + ret i64 %"tmp#2##0" } + -------------------------------------------------- Module mytree representation : (not a type) @@ -290,74 +267,53 @@ printTree1(t##0:mytree.tree, prefix##0:wybe.string, ?prefix##3:wybe.string)<{<"(i64) +declare external ccc void @print_int(i64) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) - -@mytree.5 = constant {i64, i64} { i64 2, i64 ptrtoint ([?? x i8]* @mytree.4 to i64) } - - -@mytree.4 = constant [?? x i8] c", \00" - - -@mytree.0 = constant [?? x i8] c"{\00" - - -@mytree.2 = constant [?? x i8] c"}\00" - - -declare external ccc void @print_int(i64) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"mytree.printTree<0>"(i64 %"t##0") alwaysinline { -entry: - %0 = tail call fastcc i64 @"mytree.printTree1<0>"(i64 %"t##0", i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @mytree.1, i32 0, i32 0) to i64)) - musttail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @mytree.3, i32 0, i32 0) to i64)) - ret void +define external fastcc void @"mytree.printTree<0>"(i64 %"t##0") { + %"prefix##1" = tail call fastcc i64 @"mytree.printTree1<0>"(i64 %"t##0", i64 ptrtoint( ptr @"string#4" to i64 )) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#5" to i64 )) + ret void } - -define external fastcc i64 @"mytree.printTree1<0>"(i64 %"t##0", i64 %"prefix##0") { -entry: - %0 = icmp ne i64 %"t##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"t##0" to i64* - %2 = load i64, i64* %1 - %3 = add i64 %"t##0", 8 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = add i64 %"t##0", 16 - %7 = inttoptr i64 %6 to i64* - %8 = load i64, i64* %7 - %9 = tail call fastcc i64 @"mytree.printTree1<0>"(i64 %2, i64 %"prefix##0") - tail call fastcc void @"wybe.string.print<0>"(i64 %9) - tail call ccc void @print_int(i64 %5) - %10 = musttail call fastcc i64 @"mytree.printTree1<0>"(i64 %8, i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @mytree.5, i32 0, i32 0) to i64)) - ret i64 %10 -if.else: - ret i64 %"prefix##0" +define external fastcc i64 @"mytree.printTree1<0>"(i64 %"t##0", i64 %"prefix##0") { + %"tmp#2##0" = icmp ne i64 %"t##0", 0 + br i1 %"tmp#2##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#6##0" = inttoptr i64 %"t##0" to ptr + %"l##0" = load i64, ptr %"tmp#6##0" + %"tmp#7##0" = add i64 %"t##0", 8 + %"tmp#8##0" = inttoptr i64 %"tmp#7##0" to ptr + %"k##0" = load i64, ptr %"tmp#8##0" + %"tmp#9##0" = add i64 %"t##0", 16 + %"tmp#10##0" = inttoptr i64 %"tmp#9##0" to ptr + %"r##0" = load i64, ptr %"tmp#10##0" + %"prefix##1" = tail call fastcc i64 @"mytree.printTree1<0>"(i64 %"l##0", i64 %"prefix##0") + tail call fastcc void @"wybe.string.print<0>"(i64 %"prefix##1") + call ccc void @print_int(i64 %"k##0") + %"tmp#11##0" = tail call fastcc i64 @"mytree.printTree1<0>"(i64 %"r##0", i64 ptrtoint( ptr @"string#3" to i64 )) + ret i64 %"tmp#11##0" +if.else.0: + ret i64 %"prefix##0" } + -------------------------------------------------- Module mytree.tree - representation : address + representation : pointer public submods : public resources: public procs : mytree.tree.=<0> @@ -562,242 +518,209 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'mytree.tree' - - - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i1 @"mytree.tree.=<0>"(i64 %"#left##0", i64 %"#right##0") { -entry: - %0 = icmp ne i64 %"#left##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"#left##0" to i64* - %2 = load i64, i64* %1 - %3 = add i64 %"#left##0", 8 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = add i64 %"#left##0", 16 - %7 = inttoptr i64 %6 to i64* - %8 = load i64, i64* %7 - %9 = icmp ne i64 %"#right##0", 0 - br i1 %9, label %if.then1, label %if.else1 -if.else: - %21 = icmp eq i64 %"#right##0", 0 - ret i1 %21 -if.then1: - %10 = inttoptr i64 %"#right##0" to i64* - %11 = load i64, i64* %10 - %12 = add i64 %"#right##0", 8 - %13 = inttoptr i64 %12 to i64* - %14 = load i64, i64* %13 - %15 = add i64 %"#right##0", 16 - %16 = inttoptr i64 %15 to i64* - %17 = load i64, i64* %16 - %18 = tail call fastcc i1 @"mytree.tree.=<0>"(i64 %2, i64 %11) - br i1 %18, label %if.then2, label %if.else2 -if.else1: - ret i1 0 -if.then2: - %19 = icmp eq i64 %5, %14 - br i1 %19, label %if.then3, label %if.else3 -if.else2: - ret i1 0 -if.then3: - %20 = musttail call fastcc i1 @"mytree.tree.=<0>"(i64 %8, i64 %17) - ret i1 %20 -if.else3: - ret i1 0 +source_filename = "!ROOT!/final-dump/mytree.wybe" +target triple ???? + + +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc i1 @"mytree.tree.=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#0##0" = icmp ne i64 %"#left##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#13##0" = inttoptr i64 %"#left##0" to ptr + %"#left#left##0" = load i64, ptr %"tmp#13##0" + %"tmp#14##0" = add i64 %"#left##0", 8 + %"tmp#15##0" = inttoptr i64 %"tmp#14##0" to ptr + %"#left#key##0" = load i64, ptr %"tmp#15##0" + %"tmp#16##0" = add i64 %"#left##0", 16 + %"tmp#17##0" = inttoptr i64 %"tmp#16##0" to ptr + %"#left#right##0" = load i64, ptr %"tmp#17##0" + %"tmp#10##0" = icmp ne i64 %"#right##0", 0 + br i1 %"tmp#10##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#18##0" = inttoptr i64 %"#right##0" to ptr + %"#right#left##0" = load i64, ptr %"tmp#18##0" + %"tmp#19##0" = add i64 %"#right##0", 8 + %"tmp#20##0" = inttoptr i64 %"tmp#19##0" to ptr + %"#right#key##0" = load i64, ptr %"tmp#20##0" + %"tmp#21##0" = add i64 %"#right##0", 16 + %"tmp#22##0" = inttoptr i64 %"tmp#21##0" to ptr + %"#right#right##0" = load i64, ptr %"tmp#22##0" + %"tmp#4##0" = tail call fastcc i1 @"mytree.tree.=<0>"(i64 %"#left#left##0", i64 %"#right#left##0") + br i1 %"tmp#4##0", label %if.then.2, label %if.else.2 +if.then.2: + %"tmp#5##0" = icmp eq i64 %"#left#key##0", %"#right#key##0" + br i1 %"tmp#5##0", label %if.then.3, label %if.else.3 +if.then.3: + %"tmp#23##0" = tail call fastcc i1 @"mytree.tree.=<0>"(i64 %"#left#right##0", i64 %"#right#right##0") + ret i1 %"tmp#23##0" +if.else.3: + ret i1 0 +if.else.2: + ret i1 0 +if.else.1: + ret i1 0 +if.else.0: + %"tmp#24##0" = icmp eq i64 %"#right##0", 0 + ret i1 %"tmp#24##0" } - -define external fastcc i64 @"mytree.tree.empty<0>"() alwaysinline { -entry: - ret i64 0 +define external fastcc i64 @"mytree.tree.empty<0>"() { + ret i64 0 } - -define external fastcc {i64, i1} @"mytree.tree.key<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = add i64 %"#rec##0", 8 - %2 = inttoptr i64 %1 to i64* - %3 = load i64, i64* %2 - %4 = insertvalue {i64, i1} undef, i64 %3, 0 - %5 = insertvalue {i64, i1} %4, i1 1, 1 - ret {i64, i1} %5 -if.else: - %6 = insertvalue {i64, i1} undef, i64 undef, 0 - %7 = insertvalue {i64, i1} %6, i1 0, 1 - ret {i64, i1} %7 +define external fastcc {i64, i1} @"mytree.tree.key<0>"(i64 %"#rec##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = add i64 %"#rec##0", 8 + %"tmp#2##0" = inttoptr i64 %"tmp#1##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#2##0" + %"tmp#4##0" = insertvalue {i64, i1} undef, i64 %"tmp#3##0", 0 + %"tmp#5##0" = insertvalue {i64, i1} %"tmp#4##0", i1 1, 1 + ret {i64, i1} %"tmp#5##0" +if.else.0: + %"tmp#6##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#7##0" = insertvalue {i64, i1} %"tmp#6##0", i1 0, 1 + ret {i64, i1} %"tmp#7##0" } - -define external fastcc {i64, i1} @"mytree.tree.key<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = trunc i64 24 to i32 - %2 = tail call ccc i8* @wybe_malloc(i32 %1) - %3 = ptrtoint i8* %2 to i64 - %4 = inttoptr i64 %3 to i8* - %5 = inttoptr i64 %"#rec##0" to i8* - %6 = trunc i64 24 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %4, i8* %5, i32 %6, i1 0) - %7 = add i64 %3, 8 - %8 = inttoptr i64 %7 to i64* - store i64 %"#field##0", i64* %8 - %9 = insertvalue {i64, i1} undef, i64 %3, 0 - %10 = insertvalue {i64, i1} %9, i1 1, 1 - ret {i64, i1} %10 -if.else: - %11 = insertvalue {i64, i1} undef, i64 0, 0 - %12 = insertvalue {i64, i1} %11, i1 0, 1 - ret {i64, i1} %12 +define external fastcc {i64, i1} @"mytree.tree.key<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#2##0" = call ccc ptr @wybe_malloc(i32 24) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#2##0", ptr %"tmp#1##0", i64 24, i1 0) + %"tmp#3##0" = ptrtoint ptr %"tmp#2##0" to i64 + %"tmp#4##0" = add i64 %"tmp#3##0", 8 + %"tmp#5##0" = inttoptr i64 %"tmp#4##0" to ptr + store i64 %"#field##0", ptr %"tmp#5##0" + %"tmp#6##0" = insertvalue {i64, i1} undef, i64 %"tmp#3##0", 0 + %"tmp#7##0" = insertvalue {i64, i1} %"tmp#6##0", i1 1, 1 + ret {i64, i1} %"tmp#7##0" +if.else.0: + %"tmp#8##0" = insertvalue {i64, i1} undef, i64 0, 0 + %"tmp#9##0" = insertvalue {i64, i1} %"tmp#8##0", i1 0, 1 + ret {i64, i1} %"tmp#9##0" } - -define external fastcc {i64, i1} @"mytree.tree.left<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"#rec##0" to i64* - %2 = load i64, i64* %1 - %3 = insertvalue {i64, i1} undef, i64 %2, 0 - %4 = insertvalue {i64, i1} %3, i1 1, 1 - ret {i64, i1} %4 -if.else: - %5 = insertvalue {i64, i1} undef, i64 undef, 0 - %6 = insertvalue {i64, i1} %5, i1 0, 1 - ret {i64, i1} %6 +define external fastcc {i64, i1} @"mytree.tree.left<0>"(i64 %"#rec##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + %"tmp#3##0" = insertvalue {i64, i1} undef, i64 %"tmp#2##0", 0 + %"tmp#4##0" = insertvalue {i64, i1} %"tmp#3##0", i1 1, 1 + ret {i64, i1} %"tmp#4##0" +if.else.0: + %"tmp#5##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#6##0" = insertvalue {i64, i1} %"tmp#5##0", i1 0, 1 + ret {i64, i1} %"tmp#6##0" } - -define external fastcc {i64, i1} @"mytree.tree.left<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = trunc i64 24 to i32 - %2 = tail call ccc i8* @wybe_malloc(i32 %1) - %3 = ptrtoint i8* %2 to i64 - %4 = inttoptr i64 %3 to i8* - %5 = inttoptr i64 %"#rec##0" to i8* - %6 = trunc i64 24 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %4, i8* %5, i32 %6, i1 0) - %7 = inttoptr i64 %3 to i64* - store i64 %"#field##0", i64* %7 - %8 = insertvalue {i64, i1} undef, i64 %3, 0 - %9 = insertvalue {i64, i1} %8, i1 1, 1 - ret {i64, i1} %9 -if.else: - %10 = insertvalue {i64, i1} undef, i64 0, 0 - %11 = insertvalue {i64, i1} %10, i1 0, 1 - ret {i64, i1} %11 +define external fastcc {i64, i1} @"mytree.tree.left<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#2##0" = call ccc ptr @wybe_malloc(i32 24) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#2##0", ptr %"tmp#1##0", i64 24, i1 0) + %"tmp#3##0" = ptrtoint ptr %"tmp#2##0" to i64 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 %"#field##0", ptr %"tmp#4##0" + %"tmp#5##0" = insertvalue {i64, i1} undef, i64 %"tmp#3##0", 0 + %"tmp#6##0" = insertvalue {i64, i1} %"tmp#5##0", i1 1, 1 + ret {i64, i1} %"tmp#6##0" +if.else.0: + %"tmp#7##0" = insertvalue {i64, i1} undef, i64 0, 0 + %"tmp#8##0" = insertvalue {i64, i1} %"tmp#7##0", i1 0, 1 + ret {i64, i1} %"tmp#8##0" } - -define external fastcc i64 @"mytree.tree.node<0>"(i64 %"left##0", i64 %"key##0", i64 %"right##0") alwaysinline { -entry: - %0 = trunc i64 24 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"left##0", i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"key##0", i64* %5 - %6 = add i64 %2, 16 - %7 = inttoptr i64 %6 to i64* - store i64 %"right##0", i64* %7 - ret i64 %2 +define external fastcc i64 @"mytree.tree.node<0>"(i64 %"left##0", i64 %"key##0", i64 %"right##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 24) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"left##0", ptr %"tmp#1##0" + %"tmp#2##0" = add i64 %"#rec##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"key##0", ptr %"tmp#3##0" + %"tmp#4##0" = add i64 %"#rec##0", 16 + %"tmp#5##0" = inttoptr i64 %"tmp#4##0" to ptr + store i64 %"right##0", ptr %"tmp#5##0" + ret i64 %"#rec##0" } - -define external fastcc {i64, i64, i64, i1} @"mytree.tree.node<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#result##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"#result##0" to i64* - %2 = load i64, i64* %1 - %3 = add i64 %"#result##0", 8 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = add i64 %"#result##0", 16 - %7 = inttoptr i64 %6 to i64* - %8 = load i64, i64* %7 - %9 = insertvalue {i64, i64, i64, i1} undef, i64 %2, 0 - %10 = insertvalue {i64, i64, i64, i1} %9, i64 %5, 1 - %11 = insertvalue {i64, i64, i64, i1} %10, i64 %8, 2 - %12 = insertvalue {i64, i64, i64, i1} %11, i1 1, 3 - ret {i64, i64, i64, i1} %12 -if.else: - %13 = insertvalue {i64, i64, i64, i1} undef, i64 undef, 0 - %14 = insertvalue {i64, i64, i64, i1} %13, i64 undef, 1 - %15 = insertvalue {i64, i64, i64, i1} %14, i64 undef, 2 - %16 = insertvalue {i64, i64, i64, i1} %15, i1 0, 3 - ret {i64, i64, i64, i1} %16 +define external fastcc {i64, i64, i64, i1} @"mytree.tree.node<1>"(i64 %"#result##0") { + %"tmp#0##0" = icmp ne i64 %"#result##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = inttoptr i64 %"#result##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + %"tmp#3##0" = add i64 %"#result##0", 8 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#4##0" + %"tmp#6##0" = add i64 %"#result##0", 16 + %"tmp#7##0" = inttoptr i64 %"tmp#6##0" to ptr + %"tmp#8##0" = load i64, ptr %"tmp#7##0" + %"tmp#9##0" = insertvalue {i64, i64, i64, i1} undef, i64 %"tmp#2##0", 0 + %"tmp#10##0" = insertvalue {i64, i64, i64, i1} %"tmp#9##0", i64 %"tmp#5##0", 1 + %"tmp#11##0" = insertvalue {i64, i64, i64, i1} %"tmp#10##0", i64 %"tmp#8##0", 2 + %"tmp#12##0" = insertvalue {i64, i64, i64, i1} %"tmp#11##0", i1 1, 3 + ret {i64, i64, i64, i1} %"tmp#12##0" +if.else.0: + %"tmp#13##0" = insertvalue {i64, i64, i64, i1} undef, i64 undef, 0 + %"tmp#14##0" = insertvalue {i64, i64, i64, i1} %"tmp#13##0", i64 undef, 1 + %"tmp#15##0" = insertvalue {i64, i64, i64, i1} %"tmp#14##0", i64 undef, 2 + %"tmp#16##0" = insertvalue {i64, i64, i64, i1} %"tmp#15##0", i1 0, 3 + ret {i64, i64, i64, i1} %"tmp#16##0" } - -define external fastcc {i64, i1} @"mytree.tree.right<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = add i64 %"#rec##0", 16 - %2 = inttoptr i64 %1 to i64* - %3 = load i64, i64* %2 - %4 = insertvalue {i64, i1} undef, i64 %3, 0 - %5 = insertvalue {i64, i1} %4, i1 1, 1 - ret {i64, i1} %5 -if.else: - %6 = insertvalue {i64, i1} undef, i64 undef, 0 - %7 = insertvalue {i64, i1} %6, i1 0, 1 - ret {i64, i1} %7 +define external fastcc {i64, i1} @"mytree.tree.right<0>"(i64 %"#rec##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = add i64 %"#rec##0", 16 + %"tmp#2##0" = inttoptr i64 %"tmp#1##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#2##0" + %"tmp#4##0" = insertvalue {i64, i1} undef, i64 %"tmp#3##0", 0 + %"tmp#5##0" = insertvalue {i64, i1} %"tmp#4##0", i1 1, 1 + ret {i64, i1} %"tmp#5##0" +if.else.0: + %"tmp#6##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#7##0" = insertvalue {i64, i1} %"tmp#6##0", i1 0, 1 + ret {i64, i1} %"tmp#7##0" } - -define external fastcc {i64, i1} @"mytree.tree.right<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = trunc i64 24 to i32 - %2 = tail call ccc i8* @wybe_malloc(i32 %1) - %3 = ptrtoint i8* %2 to i64 - %4 = inttoptr i64 %3 to i8* - %5 = inttoptr i64 %"#rec##0" to i8* - %6 = trunc i64 24 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %4, i8* %5, i32 %6, i1 0) - %7 = add i64 %3, 16 - %8 = inttoptr i64 %7 to i64* - store i64 %"#field##0", i64* %8 - %9 = insertvalue {i64, i1} undef, i64 %3, 0 - %10 = insertvalue {i64, i1} %9, i1 1, 1 - ret {i64, i1} %10 -if.else: - %11 = insertvalue {i64, i1} undef, i64 0, 0 - %12 = insertvalue {i64, i1} %11, i1 0, 1 - ret {i64, i1} %12 +define external fastcc {i64, i1} @"mytree.tree.right<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#2##0" = call ccc ptr @wybe_malloc(i32 24) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#2##0", ptr %"tmp#1##0", i64 24, i1 0) + %"tmp#3##0" = ptrtoint ptr %"tmp#2##0" to i64 + %"tmp#4##0" = add i64 %"tmp#3##0", 16 + %"tmp#5##0" = inttoptr i64 %"tmp#4##0" to ptr + store i64 %"#field##0", ptr %"tmp#5##0" + %"tmp#6##0" = insertvalue {i64, i1} undef, i64 %"tmp#3##0", 0 + %"tmp#7##0" = insertvalue {i64, i1} %"tmp#6##0", i1 1, 1 + ret {i64, i1} %"tmp#7##0" +if.else.0: + %"tmp#8##0" = insertvalue {i64, i1} undef, i64 0, 0 + %"tmp#9##0" = insertvalue {i64, i1} %"tmp#8##0", i1 0, 1 + ret {i64, i1} %"tmp#9##0" } - -define external fastcc i1 @"mytree.tree.~=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = tail call fastcc i1 @"mytree.tree.=<0>"(i64 %"#left##0", i64 %"#right##0") - %1 = xor i1 %0, 1 - ret i1 %1 +define external fastcc i1 @"mytree.tree.~=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#0##0" = tail call fastcc i1 @"mytree.tree.=<0>"(i64 %"#left##0", i64 %"#right##0") + %"tmp#1##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#1##0" } diff --git a/test-cases/final-dump/alias_fork2.exp b/test-cases/final-dump/alias_fork2.exp index 6731fe00e..61f131536 100644 --- a/test-cases/final-dump/alias_fork2.exp +++ b/test-cases/final-dump/alias_fork2.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module alias_fork2 representation : (not a type) public submods : @@ -85,140 +88,101 @@ simpleMerge(tl##0:mytree.tree, ?#result##0:mytree.tree)<{}; {}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'alias_fork2' - - - - -@alias_fork2.7 = constant {i64, i64} { i64 0, i64 ptrtoint ([?? x i8]* @alias_fork2.6 to i64) } - - -@alias_fork2.3 = constant {i64, i64} { i64 1, i64 ptrtoint ([?? x i8]* @alias_fork2.2 to i64) } - - -@alias_fork2.5 = constant {i64, i64} { i64 1, i64 ptrtoint ([?? x i8]* @alias_fork2.4 to i64) } - - -@alias_fork2.9 = constant {i64, i64} { i64 17, i64 ptrtoint ([?? x i8]* @alias_fork2.8 to i64) } - - -@alias_fork2.1 = constant {i64, i64} { i64 18, i64 ptrtoint ([?? x i8]* @alias_fork2.0 to i64) } - - -@alias_fork2.11 = constant {i64, i64} { i64 18, i64 ptrtoint ([?? x i8]* @alias_fork2.10 to i64) } - - -@alias_fork2.6 = constant [?? x i8] c"\00" - - -@alias_fork2.0 = constant [?? x i8] c"expect t - 1 200:\00" - - -@alias_fork2.10 = constant [?? x i8] c"expect t1 - 1 200:\00" - - -@alias_fork2.8 = constant [?? x i8] c"expect t1 - 1000:\00" - - -@alias_fork2.2 = constant [?? x i8] c"{\00" - - -@alias_fork2.4 = constant [?? x i8] c"}\00" - - -declare external ccc void @putchar(i8) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external fastcc i64 @"mytree.printTree1<0>"(i64, i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"alias_fork2.<0>"() { -entry: - %0 = trunc i64 24 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 0, i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 1, i64* %5 - %6 = add i64 %2, 16 - %7 = inttoptr i64 %6 to i64* - store i64 0, i64* %7 - %8 = tail call fastcc i64 @"alias_fork2.simpleMerge<0>"(i64 %2) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_fork2.1, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - %9 = tail call fastcc i64 @"mytree.printTree1<0>"(i64 %8, i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_fork2.3, i32 0, i32 0) to i64)) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_fork2.5, i32 0, i32 0) to i64)) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_fork2.7, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - %10 = icmp ne i64 %2, 0 - br i1 %10, label %if.then, label %if.else -if.then: - %11 = inttoptr i64 %2 to i64* - %12 = load i64, i64* %11 - %13 = trunc i64 24 to i32 - %14 = tail call ccc i8* @wybe_malloc(i32 %13) - %15 = ptrtoint i8* %14 to i64 - %16 = inttoptr i64 %15 to i64* - store i64 %12, i64* %16 - %17 = add i64 %15, 8 - %18 = inttoptr i64 %17 to i64* - store i64 1000, i64* %18 - %19 = add i64 %15, 16 - %20 = inttoptr i64 %19 to i64* - store i64 0, i64* %20 - tail call fastcc void @"alias_fork2.#cont#1<0>"(i64 %8, i64 %15) - ret void -if.else: - tail call fastcc void @"alias_fork2.#cont#1<0>"(i64 %8, i64 0) - ret void +source_filename = "!ROOT!/final-dump/alias_fork2.wybe" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c"\00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c"expect t - 1 200:\00", align 8 +@"cstring#2" = private unnamed_addr constant [ ?? x i8 ] c"expect t1 - 1 200:\00", align 8 +@"cstring#3" = private unnamed_addr constant [ ?? x i8 ] c"expect t1 - 1000:\00", align 8 +@"cstring#4" = private unnamed_addr constant [ ?? x i8 ] c"{\00", align 8 +@"cstring#5" = private unnamed_addr constant [ ?? x i8 ] c"}\00", align 8 +@"string#6" = private unnamed_addr constant {i64, i64} { i64 0, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +@"string#7" = private unnamed_addr constant {i64, i64} { i64 18, i64 ptrtoint( ptr @"cstring#1" to i64 ) }, align 8 +@"string#8" = private unnamed_addr constant {i64, i64} { i64 18, i64 ptrtoint( ptr @"cstring#2" to i64 ) }, align 8 +@"string#9" = private unnamed_addr constant {i64, i64} { i64 17, i64 ptrtoint( ptr @"cstring#3" to i64 ) }, align 8 +@"string#10" = private unnamed_addr constant {i64, i64} { i64 1, i64 ptrtoint( ptr @"cstring#4" to i64 ) }, align 8 +@"string#11" = private unnamed_addr constant {i64, i64} { i64 1, i64 ptrtoint( ptr @"cstring#5" to i64 ) }, align 8 + +declare external fastcc i64 @"mytree.printTree1<0>"(i64, i64) +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @putchar(i8) +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"alias_fork2.<0>"() { + %"tmp#28##0" = call ccc ptr @wybe_malloc(i32 24) + %"tmp#9##0" = ptrtoint ptr %"tmp#28##0" to i64 + %"tmp#29##0" = inttoptr i64 %"tmp#9##0" to ptr + store i64 0, ptr %"tmp#29##0" + %"tmp#30##0" = add i64 %"tmp#9##0", 8 + %"tmp#31##0" = inttoptr i64 %"tmp#30##0" to ptr + store i64 1, ptr %"tmp#31##0" + %"tmp#32##0" = add i64 %"tmp#9##0", 16 + %"tmp#33##0" = inttoptr i64 %"tmp#32##0" to ptr + store i64 0, ptr %"tmp#33##0" + %"tmp#3##0" = tail call fastcc i64 @"alias_fork2.simpleMerge<0>"(i64 %"tmp#9##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#7" to i64 )) + call ccc void @putchar(i8 10) + %"tmp#16##0" = tail call fastcc i64 @"mytree.printTree1<0>"(i64 %"tmp#3##0", i64 ptrtoint( ptr @"string#10" to i64 )) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#11" to i64 )) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#6" to i64 )) + call ccc void @putchar(i8 10) + %"tmp#21##0" = icmp ne i64 %"tmp#9##0", 0 + br i1 %"tmp#21##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#34##0" = inttoptr i64 %"tmp#9##0" to ptr + %"l##0" = load i64, ptr %"tmp#34##0" + %"tmp#35##0" = call ccc ptr @wybe_malloc(i32 24) + %"tmp#25##0" = ptrtoint ptr %"tmp#35##0" to i64 + %"tmp#36##0" = inttoptr i64 %"tmp#25##0" to ptr + store i64 %"l##0", ptr %"tmp#36##0" + %"tmp#37##0" = add i64 %"tmp#25##0", 8 + %"tmp#38##0" = inttoptr i64 %"tmp#37##0" to ptr + store i64 1000, ptr %"tmp#38##0" + %"tmp#39##0" = add i64 %"tmp#25##0", 16 + %"tmp#40##0" = inttoptr i64 %"tmp#39##0" to ptr + store i64 0, ptr %"tmp#40##0" + tail call fastcc void @"alias_fork2.#cont#1<0>"(i64 %"tmp#3##0", i64 %"tmp#25##0") + ret void +if.else.0: + tail call fastcc void @"alias_fork2.#cont#1<0>"(i64 %"tmp#3##0", i64 0) + ret void } - -define external fastcc void @"alias_fork2.#cont#1<0>"(i64 %"t##0", i64 %"t1##0") { -entry: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_fork2.9, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - %0 = tail call fastcc i64 @"mytree.printTree1<0>"(i64 %"t1##0", i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_fork2.3, i32 0, i32 0) to i64)) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_fork2.5, i32 0, i32 0) to i64)) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_fork2.7, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_fork2.11, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - %1 = tail call fastcc i64 @"mytree.printTree1<0>"(i64 %"t##0", i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_fork2.3, i32 0, i32 0) to i64)) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_fork2.5, i32 0, i32 0) to i64)) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_fork2.7, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"alias_fork2.#cont#1<0>"(i64 %"t##0", i64 %"t1##0") { + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#9" to i64 )) + call ccc void @putchar(i8 10) + %"tmp#9##0" = tail call fastcc i64 @"mytree.printTree1<0>"(i64 %"t1##0", i64 ptrtoint( ptr @"string#10" to i64 )) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#11" to i64 )) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#6" to i64 )) + call ccc void @putchar(i8 10) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#8" to i64 )) + call ccc void @putchar(i8 10) + %"tmp#17##0" = tail call fastcc i64 @"mytree.printTree1<0>"(i64 %"t##0", i64 ptrtoint( ptr @"string#10" to i64 )) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#11" to i64 )) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#6" to i64 )) + call ccc void @putchar(i8 10) + ret void } - -define external fastcc i64 @"alias_fork2.simpleMerge<0>"(i64 %"tl##0") { -entry: - %0 = trunc i64 24 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"tl##0", i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 200, i64* %5 - %6 = add i64 %2, 16 - %7 = inttoptr i64 %6 to i64* - store i64 0, i64* %7 - ret i64 %2 +define external fastcc i64 @"alias_fork2.simpleMerge<0>"(i64 %"tl##0") { + %"tmp#8##0" = call ccc ptr @wybe_malloc(i32 24) + %"tmp#5##0" = ptrtoint ptr %"tmp#8##0" to i64 + %"tmp#9##0" = inttoptr i64 %"tmp#5##0" to ptr + store i64 %"tl##0", ptr %"tmp#9##0" + %"tmp#10##0" = add i64 %"tmp#5##0", 8 + %"tmp#11##0" = inttoptr i64 %"tmp#10##0" to ptr + store i64 200, ptr %"tmp#11##0" + %"tmp#12##0" = add i64 %"tmp#5##0", 16 + %"tmp#13##0" = inttoptr i64 %"tmp#12##0" to ptr + store i64 0, ptr %"tmp#13##0" + ret i64 %"tmp#5##0" } + -------------------------------------------------- Module mytree representation : (not a type) @@ -277,74 +241,53 @@ printTree1(t##0:mytree.tree, prefix##0:wybe.string, ?prefix##3:wybe.string)<{<"(i64) +declare external ccc void @print_int(i64) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"mytree.printTree<0>"(i64 %"t##0") alwaysinline { -entry: - %0 = tail call fastcc i64 @"mytree.printTree1<0>"(i64 %"t##0", i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @mytree.1, i32 0, i32 0) to i64)) - musttail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @mytree.3, i32 0, i32 0) to i64)) - ret void +define external fastcc void @"mytree.printTree<0>"(i64 %"t##0") { + %"prefix##1" = tail call fastcc i64 @"mytree.printTree1<0>"(i64 %"t##0", i64 ptrtoint( ptr @"string#4" to i64 )) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#5" to i64 )) + ret void } - -define external fastcc i64 @"mytree.printTree1<0>"(i64 %"t##0", i64 %"prefix##0") { -entry: - %0 = icmp ne i64 %"t##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"t##0" to i64* - %2 = load i64, i64* %1 - %3 = add i64 %"t##0", 8 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = add i64 %"t##0", 16 - %7 = inttoptr i64 %6 to i64* - %8 = load i64, i64* %7 - %9 = tail call fastcc i64 @"mytree.printTree1<0>"(i64 %2, i64 %"prefix##0") - tail call fastcc void @"wybe.string.print<0>"(i64 %9) - tail call ccc void @print_int(i64 %5) - %10 = musttail call fastcc i64 @"mytree.printTree1<0>"(i64 %8, i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @mytree.5, i32 0, i32 0) to i64)) - ret i64 %10 -if.else: - ret i64 %"prefix##0" +define external fastcc i64 @"mytree.printTree1<0>"(i64 %"t##0", i64 %"prefix##0") { + %"tmp#2##0" = icmp ne i64 %"t##0", 0 + br i1 %"tmp#2##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#6##0" = inttoptr i64 %"t##0" to ptr + %"l##0" = load i64, ptr %"tmp#6##0" + %"tmp#7##0" = add i64 %"t##0", 8 + %"tmp#8##0" = inttoptr i64 %"tmp#7##0" to ptr + %"k##0" = load i64, ptr %"tmp#8##0" + %"tmp#9##0" = add i64 %"t##0", 16 + %"tmp#10##0" = inttoptr i64 %"tmp#9##0" to ptr + %"r##0" = load i64, ptr %"tmp#10##0" + %"prefix##1" = tail call fastcc i64 @"mytree.printTree1<0>"(i64 %"l##0", i64 %"prefix##0") + tail call fastcc void @"wybe.string.print<0>"(i64 %"prefix##1") + call ccc void @print_int(i64 %"k##0") + %"tmp#11##0" = tail call fastcc i64 @"mytree.printTree1<0>"(i64 %"r##0", i64 ptrtoint( ptr @"string#3" to i64 )) + ret i64 %"tmp#11##0" +if.else.0: + ret i64 %"prefix##0" } + -------------------------------------------------- Module mytree.tree - representation : address + representation : pointer public submods : public resources: public procs : mytree.tree.=<0> @@ -549,242 +492,209 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'mytree.tree' - - - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i1 @"mytree.tree.=<0>"(i64 %"#left##0", i64 %"#right##0") { -entry: - %0 = icmp ne i64 %"#left##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"#left##0" to i64* - %2 = load i64, i64* %1 - %3 = add i64 %"#left##0", 8 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = add i64 %"#left##0", 16 - %7 = inttoptr i64 %6 to i64* - %8 = load i64, i64* %7 - %9 = icmp ne i64 %"#right##0", 0 - br i1 %9, label %if.then1, label %if.else1 -if.else: - %21 = icmp eq i64 %"#right##0", 0 - ret i1 %21 -if.then1: - %10 = inttoptr i64 %"#right##0" to i64* - %11 = load i64, i64* %10 - %12 = add i64 %"#right##0", 8 - %13 = inttoptr i64 %12 to i64* - %14 = load i64, i64* %13 - %15 = add i64 %"#right##0", 16 - %16 = inttoptr i64 %15 to i64* - %17 = load i64, i64* %16 - %18 = tail call fastcc i1 @"mytree.tree.=<0>"(i64 %2, i64 %11) - br i1 %18, label %if.then2, label %if.else2 -if.else1: - ret i1 0 -if.then2: - %19 = icmp eq i64 %5, %14 - br i1 %19, label %if.then3, label %if.else3 -if.else2: - ret i1 0 -if.then3: - %20 = musttail call fastcc i1 @"mytree.tree.=<0>"(i64 %8, i64 %17) - ret i1 %20 -if.else3: - ret i1 0 +source_filename = "!ROOT!/final-dump/mytree.wybe" +target triple ???? + + +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc i1 @"mytree.tree.=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#0##0" = icmp ne i64 %"#left##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#13##0" = inttoptr i64 %"#left##0" to ptr + %"#left#left##0" = load i64, ptr %"tmp#13##0" + %"tmp#14##0" = add i64 %"#left##0", 8 + %"tmp#15##0" = inttoptr i64 %"tmp#14##0" to ptr + %"#left#key##0" = load i64, ptr %"tmp#15##0" + %"tmp#16##0" = add i64 %"#left##0", 16 + %"tmp#17##0" = inttoptr i64 %"tmp#16##0" to ptr + %"#left#right##0" = load i64, ptr %"tmp#17##0" + %"tmp#10##0" = icmp ne i64 %"#right##0", 0 + br i1 %"tmp#10##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#18##0" = inttoptr i64 %"#right##0" to ptr + %"#right#left##0" = load i64, ptr %"tmp#18##0" + %"tmp#19##0" = add i64 %"#right##0", 8 + %"tmp#20##0" = inttoptr i64 %"tmp#19##0" to ptr + %"#right#key##0" = load i64, ptr %"tmp#20##0" + %"tmp#21##0" = add i64 %"#right##0", 16 + %"tmp#22##0" = inttoptr i64 %"tmp#21##0" to ptr + %"#right#right##0" = load i64, ptr %"tmp#22##0" + %"tmp#4##0" = tail call fastcc i1 @"mytree.tree.=<0>"(i64 %"#left#left##0", i64 %"#right#left##0") + br i1 %"tmp#4##0", label %if.then.2, label %if.else.2 +if.then.2: + %"tmp#5##0" = icmp eq i64 %"#left#key##0", %"#right#key##0" + br i1 %"tmp#5##0", label %if.then.3, label %if.else.3 +if.then.3: + %"tmp#23##0" = tail call fastcc i1 @"mytree.tree.=<0>"(i64 %"#left#right##0", i64 %"#right#right##0") + ret i1 %"tmp#23##0" +if.else.3: + ret i1 0 +if.else.2: + ret i1 0 +if.else.1: + ret i1 0 +if.else.0: + %"tmp#24##0" = icmp eq i64 %"#right##0", 0 + ret i1 %"tmp#24##0" } - -define external fastcc i64 @"mytree.tree.empty<0>"() alwaysinline { -entry: - ret i64 0 +define external fastcc i64 @"mytree.tree.empty<0>"() { + ret i64 0 } - -define external fastcc {i64, i1} @"mytree.tree.key<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = add i64 %"#rec##0", 8 - %2 = inttoptr i64 %1 to i64* - %3 = load i64, i64* %2 - %4 = insertvalue {i64, i1} undef, i64 %3, 0 - %5 = insertvalue {i64, i1} %4, i1 1, 1 - ret {i64, i1} %5 -if.else: - %6 = insertvalue {i64, i1} undef, i64 undef, 0 - %7 = insertvalue {i64, i1} %6, i1 0, 1 - ret {i64, i1} %7 +define external fastcc {i64, i1} @"mytree.tree.key<0>"(i64 %"#rec##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = add i64 %"#rec##0", 8 + %"tmp#2##0" = inttoptr i64 %"tmp#1##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#2##0" + %"tmp#4##0" = insertvalue {i64, i1} undef, i64 %"tmp#3##0", 0 + %"tmp#5##0" = insertvalue {i64, i1} %"tmp#4##0", i1 1, 1 + ret {i64, i1} %"tmp#5##0" +if.else.0: + %"tmp#6##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#7##0" = insertvalue {i64, i1} %"tmp#6##0", i1 0, 1 + ret {i64, i1} %"tmp#7##0" } - -define external fastcc {i64, i1} @"mytree.tree.key<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = trunc i64 24 to i32 - %2 = tail call ccc i8* @wybe_malloc(i32 %1) - %3 = ptrtoint i8* %2 to i64 - %4 = inttoptr i64 %3 to i8* - %5 = inttoptr i64 %"#rec##0" to i8* - %6 = trunc i64 24 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %4, i8* %5, i32 %6, i1 0) - %7 = add i64 %3, 8 - %8 = inttoptr i64 %7 to i64* - store i64 %"#field##0", i64* %8 - %9 = insertvalue {i64, i1} undef, i64 %3, 0 - %10 = insertvalue {i64, i1} %9, i1 1, 1 - ret {i64, i1} %10 -if.else: - %11 = insertvalue {i64, i1} undef, i64 0, 0 - %12 = insertvalue {i64, i1} %11, i1 0, 1 - ret {i64, i1} %12 +define external fastcc {i64, i1} @"mytree.tree.key<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#2##0" = call ccc ptr @wybe_malloc(i32 24) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#2##0", ptr %"tmp#1##0", i64 24, i1 0) + %"tmp#3##0" = ptrtoint ptr %"tmp#2##0" to i64 + %"tmp#4##0" = add i64 %"tmp#3##0", 8 + %"tmp#5##0" = inttoptr i64 %"tmp#4##0" to ptr + store i64 %"#field##0", ptr %"tmp#5##0" + %"tmp#6##0" = insertvalue {i64, i1} undef, i64 %"tmp#3##0", 0 + %"tmp#7##0" = insertvalue {i64, i1} %"tmp#6##0", i1 1, 1 + ret {i64, i1} %"tmp#7##0" +if.else.0: + %"tmp#8##0" = insertvalue {i64, i1} undef, i64 0, 0 + %"tmp#9##0" = insertvalue {i64, i1} %"tmp#8##0", i1 0, 1 + ret {i64, i1} %"tmp#9##0" } - -define external fastcc {i64, i1} @"mytree.tree.left<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"#rec##0" to i64* - %2 = load i64, i64* %1 - %3 = insertvalue {i64, i1} undef, i64 %2, 0 - %4 = insertvalue {i64, i1} %3, i1 1, 1 - ret {i64, i1} %4 -if.else: - %5 = insertvalue {i64, i1} undef, i64 undef, 0 - %6 = insertvalue {i64, i1} %5, i1 0, 1 - ret {i64, i1} %6 +define external fastcc {i64, i1} @"mytree.tree.left<0>"(i64 %"#rec##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + %"tmp#3##0" = insertvalue {i64, i1} undef, i64 %"tmp#2##0", 0 + %"tmp#4##0" = insertvalue {i64, i1} %"tmp#3##0", i1 1, 1 + ret {i64, i1} %"tmp#4##0" +if.else.0: + %"tmp#5##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#6##0" = insertvalue {i64, i1} %"tmp#5##0", i1 0, 1 + ret {i64, i1} %"tmp#6##0" } - -define external fastcc {i64, i1} @"mytree.tree.left<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = trunc i64 24 to i32 - %2 = tail call ccc i8* @wybe_malloc(i32 %1) - %3 = ptrtoint i8* %2 to i64 - %4 = inttoptr i64 %3 to i8* - %5 = inttoptr i64 %"#rec##0" to i8* - %6 = trunc i64 24 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %4, i8* %5, i32 %6, i1 0) - %7 = inttoptr i64 %3 to i64* - store i64 %"#field##0", i64* %7 - %8 = insertvalue {i64, i1} undef, i64 %3, 0 - %9 = insertvalue {i64, i1} %8, i1 1, 1 - ret {i64, i1} %9 -if.else: - %10 = insertvalue {i64, i1} undef, i64 0, 0 - %11 = insertvalue {i64, i1} %10, i1 0, 1 - ret {i64, i1} %11 +define external fastcc {i64, i1} @"mytree.tree.left<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#2##0" = call ccc ptr @wybe_malloc(i32 24) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#2##0", ptr %"tmp#1##0", i64 24, i1 0) + %"tmp#3##0" = ptrtoint ptr %"tmp#2##0" to i64 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 %"#field##0", ptr %"tmp#4##0" + %"tmp#5##0" = insertvalue {i64, i1} undef, i64 %"tmp#3##0", 0 + %"tmp#6##0" = insertvalue {i64, i1} %"tmp#5##0", i1 1, 1 + ret {i64, i1} %"tmp#6##0" +if.else.0: + %"tmp#7##0" = insertvalue {i64, i1} undef, i64 0, 0 + %"tmp#8##0" = insertvalue {i64, i1} %"tmp#7##0", i1 0, 1 + ret {i64, i1} %"tmp#8##0" } - -define external fastcc i64 @"mytree.tree.node<0>"(i64 %"left##0", i64 %"key##0", i64 %"right##0") alwaysinline { -entry: - %0 = trunc i64 24 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"left##0", i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"key##0", i64* %5 - %6 = add i64 %2, 16 - %7 = inttoptr i64 %6 to i64* - store i64 %"right##0", i64* %7 - ret i64 %2 +define external fastcc i64 @"mytree.tree.node<0>"(i64 %"left##0", i64 %"key##0", i64 %"right##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 24) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"left##0", ptr %"tmp#1##0" + %"tmp#2##0" = add i64 %"#rec##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"key##0", ptr %"tmp#3##0" + %"tmp#4##0" = add i64 %"#rec##0", 16 + %"tmp#5##0" = inttoptr i64 %"tmp#4##0" to ptr + store i64 %"right##0", ptr %"tmp#5##0" + ret i64 %"#rec##0" } - -define external fastcc {i64, i64, i64, i1} @"mytree.tree.node<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#result##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"#result##0" to i64* - %2 = load i64, i64* %1 - %3 = add i64 %"#result##0", 8 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = add i64 %"#result##0", 16 - %7 = inttoptr i64 %6 to i64* - %8 = load i64, i64* %7 - %9 = insertvalue {i64, i64, i64, i1} undef, i64 %2, 0 - %10 = insertvalue {i64, i64, i64, i1} %9, i64 %5, 1 - %11 = insertvalue {i64, i64, i64, i1} %10, i64 %8, 2 - %12 = insertvalue {i64, i64, i64, i1} %11, i1 1, 3 - ret {i64, i64, i64, i1} %12 -if.else: - %13 = insertvalue {i64, i64, i64, i1} undef, i64 undef, 0 - %14 = insertvalue {i64, i64, i64, i1} %13, i64 undef, 1 - %15 = insertvalue {i64, i64, i64, i1} %14, i64 undef, 2 - %16 = insertvalue {i64, i64, i64, i1} %15, i1 0, 3 - ret {i64, i64, i64, i1} %16 +define external fastcc {i64, i64, i64, i1} @"mytree.tree.node<1>"(i64 %"#result##0") { + %"tmp#0##0" = icmp ne i64 %"#result##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = inttoptr i64 %"#result##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + %"tmp#3##0" = add i64 %"#result##0", 8 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#4##0" + %"tmp#6##0" = add i64 %"#result##0", 16 + %"tmp#7##0" = inttoptr i64 %"tmp#6##0" to ptr + %"tmp#8##0" = load i64, ptr %"tmp#7##0" + %"tmp#9##0" = insertvalue {i64, i64, i64, i1} undef, i64 %"tmp#2##0", 0 + %"tmp#10##0" = insertvalue {i64, i64, i64, i1} %"tmp#9##0", i64 %"tmp#5##0", 1 + %"tmp#11##0" = insertvalue {i64, i64, i64, i1} %"tmp#10##0", i64 %"tmp#8##0", 2 + %"tmp#12##0" = insertvalue {i64, i64, i64, i1} %"tmp#11##0", i1 1, 3 + ret {i64, i64, i64, i1} %"tmp#12##0" +if.else.0: + %"tmp#13##0" = insertvalue {i64, i64, i64, i1} undef, i64 undef, 0 + %"tmp#14##0" = insertvalue {i64, i64, i64, i1} %"tmp#13##0", i64 undef, 1 + %"tmp#15##0" = insertvalue {i64, i64, i64, i1} %"tmp#14##0", i64 undef, 2 + %"tmp#16##0" = insertvalue {i64, i64, i64, i1} %"tmp#15##0", i1 0, 3 + ret {i64, i64, i64, i1} %"tmp#16##0" } - -define external fastcc {i64, i1} @"mytree.tree.right<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = add i64 %"#rec##0", 16 - %2 = inttoptr i64 %1 to i64* - %3 = load i64, i64* %2 - %4 = insertvalue {i64, i1} undef, i64 %3, 0 - %5 = insertvalue {i64, i1} %4, i1 1, 1 - ret {i64, i1} %5 -if.else: - %6 = insertvalue {i64, i1} undef, i64 undef, 0 - %7 = insertvalue {i64, i1} %6, i1 0, 1 - ret {i64, i1} %7 +define external fastcc {i64, i1} @"mytree.tree.right<0>"(i64 %"#rec##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = add i64 %"#rec##0", 16 + %"tmp#2##0" = inttoptr i64 %"tmp#1##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#2##0" + %"tmp#4##0" = insertvalue {i64, i1} undef, i64 %"tmp#3##0", 0 + %"tmp#5##0" = insertvalue {i64, i1} %"tmp#4##0", i1 1, 1 + ret {i64, i1} %"tmp#5##0" +if.else.0: + %"tmp#6##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#7##0" = insertvalue {i64, i1} %"tmp#6##0", i1 0, 1 + ret {i64, i1} %"tmp#7##0" } - -define external fastcc {i64, i1} @"mytree.tree.right<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = trunc i64 24 to i32 - %2 = tail call ccc i8* @wybe_malloc(i32 %1) - %3 = ptrtoint i8* %2 to i64 - %4 = inttoptr i64 %3 to i8* - %5 = inttoptr i64 %"#rec##0" to i8* - %6 = trunc i64 24 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %4, i8* %5, i32 %6, i1 0) - %7 = add i64 %3, 16 - %8 = inttoptr i64 %7 to i64* - store i64 %"#field##0", i64* %8 - %9 = insertvalue {i64, i1} undef, i64 %3, 0 - %10 = insertvalue {i64, i1} %9, i1 1, 1 - ret {i64, i1} %10 -if.else: - %11 = insertvalue {i64, i1} undef, i64 0, 0 - %12 = insertvalue {i64, i1} %11, i1 0, 1 - ret {i64, i1} %12 +define external fastcc {i64, i1} @"mytree.tree.right<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#2##0" = call ccc ptr @wybe_malloc(i32 24) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#2##0", ptr %"tmp#1##0", i64 24, i1 0) + %"tmp#3##0" = ptrtoint ptr %"tmp#2##0" to i64 + %"tmp#4##0" = add i64 %"tmp#3##0", 16 + %"tmp#5##0" = inttoptr i64 %"tmp#4##0" to ptr + store i64 %"#field##0", ptr %"tmp#5##0" + %"tmp#6##0" = insertvalue {i64, i1} undef, i64 %"tmp#3##0", 0 + %"tmp#7##0" = insertvalue {i64, i1} %"tmp#6##0", i1 1, 1 + ret {i64, i1} %"tmp#7##0" +if.else.0: + %"tmp#8##0" = insertvalue {i64, i1} undef, i64 0, 0 + %"tmp#9##0" = insertvalue {i64, i1} %"tmp#8##0", i1 0, 1 + ret {i64, i1} %"tmp#9##0" } - -define external fastcc i1 @"mytree.tree.~=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = tail call fastcc i1 @"mytree.tree.=<0>"(i64 %"#left##0", i64 %"#right##0") - %1 = xor i1 %0, 1 - ret i1 %1 +define external fastcc i1 @"mytree.tree.~=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#0##0" = tail call fastcc i1 @"mytree.tree.=<0>"(i64 %"#left##0", i64 %"#right##0") + %"tmp#1##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#1##0" } diff --git a/test-cases/final-dump/alias_fork3.exp b/test-cases/final-dump/alias_fork3.exp index 76575b719..10473cae0 100644 --- a/test-cases/final-dump/alias_fork3.exp +++ b/test-cases/final-dump/alias_fork3.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module alias_fork3 representation : (not a type) public submods : @@ -56,108 +59,79 @@ simpleSlice(tr##0:mytree.tree, ?#result##0:mytree.tree)<{}; {}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'alias_fork3' - - - - -@alias_fork3.7 = constant {i64, i64} { i64 0, i64 ptrtoint ([?? x i8]* @alias_fork3.6 to i64) } - - -@alias_fork3.3 = constant {i64, i64} { i64 1, i64 ptrtoint ([?? x i8]* @alias_fork3.2 to i64) } - - -@alias_fork3.5 = constant {i64, i64} { i64 1, i64 ptrtoint ([?? x i8]* @alias_fork3.4 to i64) } - - -@alias_fork3.1 = constant {i64, i64} { i64 15, i64 ptrtoint ([?? x i8]* @alias_fork3.0 to i64) } - - -@alias_fork3.6 = constant [?? x i8] c"\00" - - -@alias_fork3.0 = constant [?? x i8] c"expect t - 100:\00" - - -@alias_fork3.2 = constant [?? x i8] c"{\00" - - -@alias_fork3.4 = constant [?? x i8] c"}\00" - - -declare external ccc void @putchar(i8) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external fastcc i64 @"mytree.printTree1<0>"(i64, i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"alias_fork3.<0>"() { -entry: - %0 = trunc i64 24 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 0, i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 100, i64* %5 - %6 = add i64 %2, 16 - %7 = inttoptr i64 %6 to i64* - store i64 0, i64* %7 - %8 = trunc i64 24 to i32 - %9 = tail call ccc i8* @wybe_malloc(i32 %8) - %10 = ptrtoint i8* %9 to i64 - %11 = inttoptr i64 %10 to i64* - store i64 %2, i64* %11 - %12 = add i64 %10, 8 - %13 = inttoptr i64 %12 to i64* - store i64 200, i64* %13 - %14 = add i64 %10, 16 - %15 = inttoptr i64 %14 to i64* - store i64 0, i64* %15 - %16 = tail call fastcc i64 @"alias_fork3.simpleSlice<0>"(i64 %10) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_fork3.1, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - %17 = tail call fastcc i64 @"mytree.printTree1<0>"(i64 %16, i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_fork3.3, i32 0, i32 0) to i64)) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_fork3.5, i32 0, i32 0) to i64)) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_fork3.7, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - ret void +source_filename = "!ROOT!/final-dump/alias_fork3.wybe" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c"\00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c"expect t - 100:\00", align 8 +@"cstring#2" = private unnamed_addr constant [ ?? x i8 ] c"{\00", align 8 +@"cstring#3" = private unnamed_addr constant [ ?? x i8 ] c"}\00", align 8 +@"string#4" = private unnamed_addr constant {i64, i64} { i64 0, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +@"string#5" = private unnamed_addr constant {i64, i64} { i64 15, i64 ptrtoint( ptr @"cstring#1" to i64 ) }, align 8 +@"string#6" = private unnamed_addr constant {i64, i64} { i64 1, i64 ptrtoint( ptr @"cstring#2" to i64 ) }, align 8 +@"string#7" = private unnamed_addr constant {i64, i64} { i64 1, i64 ptrtoint( ptr @"cstring#3" to i64 ) }, align 8 + +declare external fastcc i64 @"mytree.printTree1<0>"(i64, i64) +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @putchar(i8) +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"alias_fork3.<0>"() { + %"tmp#26##0" = call ccc ptr @wybe_malloc(i32 24) + %"tmp#9##0" = ptrtoint ptr %"tmp#26##0" to i64 + %"tmp#27##0" = inttoptr i64 %"tmp#9##0" to ptr + store i64 0, ptr %"tmp#27##0" + %"tmp#28##0" = add i64 %"tmp#9##0", 8 + %"tmp#29##0" = inttoptr i64 %"tmp#28##0" to ptr + store i64 100, ptr %"tmp#29##0" + %"tmp#30##0" = add i64 %"tmp#9##0", 16 + %"tmp#31##0" = inttoptr i64 %"tmp#30##0" to ptr + store i64 0, ptr %"tmp#31##0" + %"tmp#32##0" = call ccc ptr @wybe_malloc(i32 24) + %"tmp#15##0" = ptrtoint ptr %"tmp#32##0" to i64 + %"tmp#33##0" = inttoptr i64 %"tmp#15##0" to ptr + store i64 %"tmp#9##0", ptr %"tmp#33##0" + %"tmp#34##0" = add i64 %"tmp#15##0", 8 + %"tmp#35##0" = inttoptr i64 %"tmp#34##0" to ptr + store i64 200, ptr %"tmp#35##0" + %"tmp#36##0" = add i64 %"tmp#15##0", 16 + %"tmp#37##0" = inttoptr i64 %"tmp#36##0" to ptr + store i64 0, ptr %"tmp#37##0" + %"tmp#5##0" = tail call fastcc i64 @"alias_fork3.simpleSlice<0>"(i64 %"tmp#15##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#5" to i64 )) + call ccc void @putchar(i8 10) + %"tmp#22##0" = tail call fastcc i64 @"mytree.printTree1<0>"(i64 %"tmp#5##0", i64 ptrtoint( ptr @"string#6" to i64 )) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#7" to i64 )) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#4" to i64 )) + call ccc void @putchar(i8 10) + ret void } - -define external fastcc i64 @"alias_fork3.simpleSlice<0>"(i64 %"tr##0") { -entry: - %0 = icmp ne i64 %"tr##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"tr##0" to i64* - %2 = load i64, i64* %1 - ret i64 %2 -if.else: - %3 = trunc i64 24 to i32 - %4 = tail call ccc i8* @wybe_malloc(i32 %3) - %5 = ptrtoint i8* %4 to i64 - %6 = inttoptr i64 %5 to i64* - store i64 0, i64* %6 - %7 = add i64 %5, 8 - %8 = inttoptr i64 %7 to i64* - store i64 -1, i64* %8 - %9 = add i64 %5, 16 - %10 = inttoptr i64 %9 to i64* - store i64 0, i64* %10 - ret i64 %5 +define external fastcc i64 @"alias_fork3.simpleSlice<0>"(i64 %"tr##0") { + %"tmp#6##0" = icmp ne i64 %"tr##0", 0 + br i1 %"tmp#6##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#13##0" = inttoptr i64 %"tr##0" to ptr + %"tmp#14##0" = load i64, ptr %"tmp#13##0" + ret i64 %"tmp#14##0" +if.else.0: + %"tmp#15##0" = call ccc ptr @wybe_malloc(i32 24) + %"tmp#10##0" = ptrtoint ptr %"tmp#15##0" to i64 + %"tmp#16##0" = inttoptr i64 %"tmp#10##0" to ptr + store i64 0, ptr %"tmp#16##0" + %"tmp#17##0" = add i64 %"tmp#10##0", 8 + %"tmp#18##0" = inttoptr i64 %"tmp#17##0" to ptr + store i64 -1, ptr %"tmp#18##0" + %"tmp#19##0" = add i64 %"tmp#10##0", 16 + %"tmp#20##0" = inttoptr i64 %"tmp#19##0" to ptr + store i64 0, ptr %"tmp#20##0" + ret i64 %"tmp#10##0" } + -------------------------------------------------- Module mytree representation : (not a type) @@ -216,74 +190,53 @@ printTree1(t##0:mytree.tree, prefix##0:wybe.string, ?prefix##3:wybe.string)<{<"(i64) +declare external ccc void @print_int(i64) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -@mytree.1 = constant {i64, i64} { i64 1, i64 ptrtoint ([?? x i8]* @mytree.0 to i64) } - - -@mytree.3 = constant {i64, i64} { i64 1, i64 ptrtoint ([?? x i8]* @mytree.2 to i64) } - - -@mytree.5 = constant {i64, i64} { i64 2, i64 ptrtoint ([?? x i8]* @mytree.4 to i64) } - - -@mytree.4 = constant [?? x i8] c", \00" - - -@mytree.0 = constant [?? x i8] c"{\00" - - -@mytree.2 = constant [?? x i8] c"}\00" - - -declare external ccc void @print_int(i64) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"mytree.printTree<0>"(i64 %"t##0") alwaysinline { -entry: - %0 = tail call fastcc i64 @"mytree.printTree1<0>"(i64 %"t##0", i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @mytree.1, i32 0, i32 0) to i64)) - musttail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @mytree.3, i32 0, i32 0) to i64)) - ret void +define external fastcc void @"mytree.printTree<0>"(i64 %"t##0") { + %"prefix##1" = tail call fastcc i64 @"mytree.printTree1<0>"(i64 %"t##0", i64 ptrtoint( ptr @"string#4" to i64 )) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#5" to i64 )) + ret void } - -define external fastcc i64 @"mytree.printTree1<0>"(i64 %"t##0", i64 %"prefix##0") { -entry: - %0 = icmp ne i64 %"t##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"t##0" to i64* - %2 = load i64, i64* %1 - %3 = add i64 %"t##0", 8 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = add i64 %"t##0", 16 - %7 = inttoptr i64 %6 to i64* - %8 = load i64, i64* %7 - %9 = tail call fastcc i64 @"mytree.printTree1<0>"(i64 %2, i64 %"prefix##0") - tail call fastcc void @"wybe.string.print<0>"(i64 %9) - tail call ccc void @print_int(i64 %5) - %10 = musttail call fastcc i64 @"mytree.printTree1<0>"(i64 %8, i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @mytree.5, i32 0, i32 0) to i64)) - ret i64 %10 -if.else: - ret i64 %"prefix##0" +define external fastcc i64 @"mytree.printTree1<0>"(i64 %"t##0", i64 %"prefix##0") { + %"tmp#2##0" = icmp ne i64 %"t##0", 0 + br i1 %"tmp#2##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#6##0" = inttoptr i64 %"t##0" to ptr + %"l##0" = load i64, ptr %"tmp#6##0" + %"tmp#7##0" = add i64 %"t##0", 8 + %"tmp#8##0" = inttoptr i64 %"tmp#7##0" to ptr + %"k##0" = load i64, ptr %"tmp#8##0" + %"tmp#9##0" = add i64 %"t##0", 16 + %"tmp#10##0" = inttoptr i64 %"tmp#9##0" to ptr + %"r##0" = load i64, ptr %"tmp#10##0" + %"prefix##1" = tail call fastcc i64 @"mytree.printTree1<0>"(i64 %"l##0", i64 %"prefix##0") + tail call fastcc void @"wybe.string.print<0>"(i64 %"prefix##1") + call ccc void @print_int(i64 %"k##0") + %"tmp#11##0" = tail call fastcc i64 @"mytree.printTree1<0>"(i64 %"r##0", i64 ptrtoint( ptr @"string#3" to i64 )) + ret i64 %"tmp#11##0" +if.else.0: + ret i64 %"prefix##0" } + -------------------------------------------------- Module mytree.tree - representation : address + representation : pointer public submods : public resources: public procs : mytree.tree.=<0> @@ -488,242 +441,209 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'mytree.tree' - - - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i1 @"mytree.tree.=<0>"(i64 %"#left##0", i64 %"#right##0") { -entry: - %0 = icmp ne i64 %"#left##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"#left##0" to i64* - %2 = load i64, i64* %1 - %3 = add i64 %"#left##0", 8 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = add i64 %"#left##0", 16 - %7 = inttoptr i64 %6 to i64* - %8 = load i64, i64* %7 - %9 = icmp ne i64 %"#right##0", 0 - br i1 %9, label %if.then1, label %if.else1 -if.else: - %21 = icmp eq i64 %"#right##0", 0 - ret i1 %21 -if.then1: - %10 = inttoptr i64 %"#right##0" to i64* - %11 = load i64, i64* %10 - %12 = add i64 %"#right##0", 8 - %13 = inttoptr i64 %12 to i64* - %14 = load i64, i64* %13 - %15 = add i64 %"#right##0", 16 - %16 = inttoptr i64 %15 to i64* - %17 = load i64, i64* %16 - %18 = tail call fastcc i1 @"mytree.tree.=<0>"(i64 %2, i64 %11) - br i1 %18, label %if.then2, label %if.else2 -if.else1: - ret i1 0 -if.then2: - %19 = icmp eq i64 %5, %14 - br i1 %19, label %if.then3, label %if.else3 -if.else2: - ret i1 0 -if.then3: - %20 = musttail call fastcc i1 @"mytree.tree.=<0>"(i64 %8, i64 %17) - ret i1 %20 -if.else3: - ret i1 0 +source_filename = "!ROOT!/final-dump/mytree.wybe" +target triple ???? + + +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc i1 @"mytree.tree.=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#0##0" = icmp ne i64 %"#left##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#13##0" = inttoptr i64 %"#left##0" to ptr + %"#left#left##0" = load i64, ptr %"tmp#13##0" + %"tmp#14##0" = add i64 %"#left##0", 8 + %"tmp#15##0" = inttoptr i64 %"tmp#14##0" to ptr + %"#left#key##0" = load i64, ptr %"tmp#15##0" + %"tmp#16##0" = add i64 %"#left##0", 16 + %"tmp#17##0" = inttoptr i64 %"tmp#16##0" to ptr + %"#left#right##0" = load i64, ptr %"tmp#17##0" + %"tmp#10##0" = icmp ne i64 %"#right##0", 0 + br i1 %"tmp#10##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#18##0" = inttoptr i64 %"#right##0" to ptr + %"#right#left##0" = load i64, ptr %"tmp#18##0" + %"tmp#19##0" = add i64 %"#right##0", 8 + %"tmp#20##0" = inttoptr i64 %"tmp#19##0" to ptr + %"#right#key##0" = load i64, ptr %"tmp#20##0" + %"tmp#21##0" = add i64 %"#right##0", 16 + %"tmp#22##0" = inttoptr i64 %"tmp#21##0" to ptr + %"#right#right##0" = load i64, ptr %"tmp#22##0" + %"tmp#4##0" = tail call fastcc i1 @"mytree.tree.=<0>"(i64 %"#left#left##0", i64 %"#right#left##0") + br i1 %"tmp#4##0", label %if.then.2, label %if.else.2 +if.then.2: + %"tmp#5##0" = icmp eq i64 %"#left#key##0", %"#right#key##0" + br i1 %"tmp#5##0", label %if.then.3, label %if.else.3 +if.then.3: + %"tmp#23##0" = tail call fastcc i1 @"mytree.tree.=<0>"(i64 %"#left#right##0", i64 %"#right#right##0") + ret i1 %"tmp#23##0" +if.else.3: + ret i1 0 +if.else.2: + ret i1 0 +if.else.1: + ret i1 0 +if.else.0: + %"tmp#24##0" = icmp eq i64 %"#right##0", 0 + ret i1 %"tmp#24##0" } - -define external fastcc i64 @"mytree.tree.empty<0>"() alwaysinline { -entry: - ret i64 0 +define external fastcc i64 @"mytree.tree.empty<0>"() { + ret i64 0 } - -define external fastcc {i64, i1} @"mytree.tree.key<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = add i64 %"#rec##0", 8 - %2 = inttoptr i64 %1 to i64* - %3 = load i64, i64* %2 - %4 = insertvalue {i64, i1} undef, i64 %3, 0 - %5 = insertvalue {i64, i1} %4, i1 1, 1 - ret {i64, i1} %5 -if.else: - %6 = insertvalue {i64, i1} undef, i64 undef, 0 - %7 = insertvalue {i64, i1} %6, i1 0, 1 - ret {i64, i1} %7 +define external fastcc {i64, i1} @"mytree.tree.key<0>"(i64 %"#rec##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = add i64 %"#rec##0", 8 + %"tmp#2##0" = inttoptr i64 %"tmp#1##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#2##0" + %"tmp#4##0" = insertvalue {i64, i1} undef, i64 %"tmp#3##0", 0 + %"tmp#5##0" = insertvalue {i64, i1} %"tmp#4##0", i1 1, 1 + ret {i64, i1} %"tmp#5##0" +if.else.0: + %"tmp#6##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#7##0" = insertvalue {i64, i1} %"tmp#6##0", i1 0, 1 + ret {i64, i1} %"tmp#7##0" } - -define external fastcc {i64, i1} @"mytree.tree.key<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = trunc i64 24 to i32 - %2 = tail call ccc i8* @wybe_malloc(i32 %1) - %3 = ptrtoint i8* %2 to i64 - %4 = inttoptr i64 %3 to i8* - %5 = inttoptr i64 %"#rec##0" to i8* - %6 = trunc i64 24 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %4, i8* %5, i32 %6, i1 0) - %7 = add i64 %3, 8 - %8 = inttoptr i64 %7 to i64* - store i64 %"#field##0", i64* %8 - %9 = insertvalue {i64, i1} undef, i64 %3, 0 - %10 = insertvalue {i64, i1} %9, i1 1, 1 - ret {i64, i1} %10 -if.else: - %11 = insertvalue {i64, i1} undef, i64 0, 0 - %12 = insertvalue {i64, i1} %11, i1 0, 1 - ret {i64, i1} %12 +define external fastcc {i64, i1} @"mytree.tree.key<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#2##0" = call ccc ptr @wybe_malloc(i32 24) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#2##0", ptr %"tmp#1##0", i64 24, i1 0) + %"tmp#3##0" = ptrtoint ptr %"tmp#2##0" to i64 + %"tmp#4##0" = add i64 %"tmp#3##0", 8 + %"tmp#5##0" = inttoptr i64 %"tmp#4##0" to ptr + store i64 %"#field##0", ptr %"tmp#5##0" + %"tmp#6##0" = insertvalue {i64, i1} undef, i64 %"tmp#3##0", 0 + %"tmp#7##0" = insertvalue {i64, i1} %"tmp#6##0", i1 1, 1 + ret {i64, i1} %"tmp#7##0" +if.else.0: + %"tmp#8##0" = insertvalue {i64, i1} undef, i64 0, 0 + %"tmp#9##0" = insertvalue {i64, i1} %"tmp#8##0", i1 0, 1 + ret {i64, i1} %"tmp#9##0" } - -define external fastcc {i64, i1} @"mytree.tree.left<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"#rec##0" to i64* - %2 = load i64, i64* %1 - %3 = insertvalue {i64, i1} undef, i64 %2, 0 - %4 = insertvalue {i64, i1} %3, i1 1, 1 - ret {i64, i1} %4 -if.else: - %5 = insertvalue {i64, i1} undef, i64 undef, 0 - %6 = insertvalue {i64, i1} %5, i1 0, 1 - ret {i64, i1} %6 +define external fastcc {i64, i1} @"mytree.tree.left<0>"(i64 %"#rec##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + %"tmp#3##0" = insertvalue {i64, i1} undef, i64 %"tmp#2##0", 0 + %"tmp#4##0" = insertvalue {i64, i1} %"tmp#3##0", i1 1, 1 + ret {i64, i1} %"tmp#4##0" +if.else.0: + %"tmp#5##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#6##0" = insertvalue {i64, i1} %"tmp#5##0", i1 0, 1 + ret {i64, i1} %"tmp#6##0" } - -define external fastcc {i64, i1} @"mytree.tree.left<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = trunc i64 24 to i32 - %2 = tail call ccc i8* @wybe_malloc(i32 %1) - %3 = ptrtoint i8* %2 to i64 - %4 = inttoptr i64 %3 to i8* - %5 = inttoptr i64 %"#rec##0" to i8* - %6 = trunc i64 24 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %4, i8* %5, i32 %6, i1 0) - %7 = inttoptr i64 %3 to i64* - store i64 %"#field##0", i64* %7 - %8 = insertvalue {i64, i1} undef, i64 %3, 0 - %9 = insertvalue {i64, i1} %8, i1 1, 1 - ret {i64, i1} %9 -if.else: - %10 = insertvalue {i64, i1} undef, i64 0, 0 - %11 = insertvalue {i64, i1} %10, i1 0, 1 - ret {i64, i1} %11 +define external fastcc {i64, i1} @"mytree.tree.left<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#2##0" = call ccc ptr @wybe_malloc(i32 24) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#2##0", ptr %"tmp#1##0", i64 24, i1 0) + %"tmp#3##0" = ptrtoint ptr %"tmp#2##0" to i64 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 %"#field##0", ptr %"tmp#4##0" + %"tmp#5##0" = insertvalue {i64, i1} undef, i64 %"tmp#3##0", 0 + %"tmp#6##0" = insertvalue {i64, i1} %"tmp#5##0", i1 1, 1 + ret {i64, i1} %"tmp#6##0" +if.else.0: + %"tmp#7##0" = insertvalue {i64, i1} undef, i64 0, 0 + %"tmp#8##0" = insertvalue {i64, i1} %"tmp#7##0", i1 0, 1 + ret {i64, i1} %"tmp#8##0" } - -define external fastcc i64 @"mytree.tree.node<0>"(i64 %"left##0", i64 %"key##0", i64 %"right##0") alwaysinline { -entry: - %0 = trunc i64 24 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"left##0", i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"key##0", i64* %5 - %6 = add i64 %2, 16 - %7 = inttoptr i64 %6 to i64* - store i64 %"right##0", i64* %7 - ret i64 %2 +define external fastcc i64 @"mytree.tree.node<0>"(i64 %"left##0", i64 %"key##0", i64 %"right##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 24) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"left##0", ptr %"tmp#1##0" + %"tmp#2##0" = add i64 %"#rec##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"key##0", ptr %"tmp#3##0" + %"tmp#4##0" = add i64 %"#rec##0", 16 + %"tmp#5##0" = inttoptr i64 %"tmp#4##0" to ptr + store i64 %"right##0", ptr %"tmp#5##0" + ret i64 %"#rec##0" } - -define external fastcc {i64, i64, i64, i1} @"mytree.tree.node<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#result##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"#result##0" to i64* - %2 = load i64, i64* %1 - %3 = add i64 %"#result##0", 8 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = add i64 %"#result##0", 16 - %7 = inttoptr i64 %6 to i64* - %8 = load i64, i64* %7 - %9 = insertvalue {i64, i64, i64, i1} undef, i64 %2, 0 - %10 = insertvalue {i64, i64, i64, i1} %9, i64 %5, 1 - %11 = insertvalue {i64, i64, i64, i1} %10, i64 %8, 2 - %12 = insertvalue {i64, i64, i64, i1} %11, i1 1, 3 - ret {i64, i64, i64, i1} %12 -if.else: - %13 = insertvalue {i64, i64, i64, i1} undef, i64 undef, 0 - %14 = insertvalue {i64, i64, i64, i1} %13, i64 undef, 1 - %15 = insertvalue {i64, i64, i64, i1} %14, i64 undef, 2 - %16 = insertvalue {i64, i64, i64, i1} %15, i1 0, 3 - ret {i64, i64, i64, i1} %16 +define external fastcc {i64, i64, i64, i1} @"mytree.tree.node<1>"(i64 %"#result##0") { + %"tmp#0##0" = icmp ne i64 %"#result##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = inttoptr i64 %"#result##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + %"tmp#3##0" = add i64 %"#result##0", 8 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#4##0" + %"tmp#6##0" = add i64 %"#result##0", 16 + %"tmp#7##0" = inttoptr i64 %"tmp#6##0" to ptr + %"tmp#8##0" = load i64, ptr %"tmp#7##0" + %"tmp#9##0" = insertvalue {i64, i64, i64, i1} undef, i64 %"tmp#2##0", 0 + %"tmp#10##0" = insertvalue {i64, i64, i64, i1} %"tmp#9##0", i64 %"tmp#5##0", 1 + %"tmp#11##0" = insertvalue {i64, i64, i64, i1} %"tmp#10##0", i64 %"tmp#8##0", 2 + %"tmp#12##0" = insertvalue {i64, i64, i64, i1} %"tmp#11##0", i1 1, 3 + ret {i64, i64, i64, i1} %"tmp#12##0" +if.else.0: + %"tmp#13##0" = insertvalue {i64, i64, i64, i1} undef, i64 undef, 0 + %"tmp#14##0" = insertvalue {i64, i64, i64, i1} %"tmp#13##0", i64 undef, 1 + %"tmp#15##0" = insertvalue {i64, i64, i64, i1} %"tmp#14##0", i64 undef, 2 + %"tmp#16##0" = insertvalue {i64, i64, i64, i1} %"tmp#15##0", i1 0, 3 + ret {i64, i64, i64, i1} %"tmp#16##0" } - -define external fastcc {i64, i1} @"mytree.tree.right<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = add i64 %"#rec##0", 16 - %2 = inttoptr i64 %1 to i64* - %3 = load i64, i64* %2 - %4 = insertvalue {i64, i1} undef, i64 %3, 0 - %5 = insertvalue {i64, i1} %4, i1 1, 1 - ret {i64, i1} %5 -if.else: - %6 = insertvalue {i64, i1} undef, i64 undef, 0 - %7 = insertvalue {i64, i1} %6, i1 0, 1 - ret {i64, i1} %7 +define external fastcc {i64, i1} @"mytree.tree.right<0>"(i64 %"#rec##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = add i64 %"#rec##0", 16 + %"tmp#2##0" = inttoptr i64 %"tmp#1##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#2##0" + %"tmp#4##0" = insertvalue {i64, i1} undef, i64 %"tmp#3##0", 0 + %"tmp#5##0" = insertvalue {i64, i1} %"tmp#4##0", i1 1, 1 + ret {i64, i1} %"tmp#5##0" +if.else.0: + %"tmp#6##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#7##0" = insertvalue {i64, i1} %"tmp#6##0", i1 0, 1 + ret {i64, i1} %"tmp#7##0" } - -define external fastcc {i64, i1} @"mytree.tree.right<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = trunc i64 24 to i32 - %2 = tail call ccc i8* @wybe_malloc(i32 %1) - %3 = ptrtoint i8* %2 to i64 - %4 = inttoptr i64 %3 to i8* - %5 = inttoptr i64 %"#rec##0" to i8* - %6 = trunc i64 24 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %4, i8* %5, i32 %6, i1 0) - %7 = add i64 %3, 16 - %8 = inttoptr i64 %7 to i64* - store i64 %"#field##0", i64* %8 - %9 = insertvalue {i64, i1} undef, i64 %3, 0 - %10 = insertvalue {i64, i1} %9, i1 1, 1 - ret {i64, i1} %10 -if.else: - %11 = insertvalue {i64, i1} undef, i64 0, 0 - %12 = insertvalue {i64, i1} %11, i1 0, 1 - ret {i64, i1} %12 +define external fastcc {i64, i1} @"mytree.tree.right<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#2##0" = call ccc ptr @wybe_malloc(i32 24) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#2##0", ptr %"tmp#1##0", i64 24, i1 0) + %"tmp#3##0" = ptrtoint ptr %"tmp#2##0" to i64 + %"tmp#4##0" = add i64 %"tmp#3##0", 16 + %"tmp#5##0" = inttoptr i64 %"tmp#4##0" to ptr + store i64 %"#field##0", ptr %"tmp#5##0" + %"tmp#6##0" = insertvalue {i64, i1} undef, i64 %"tmp#3##0", 0 + %"tmp#7##0" = insertvalue {i64, i1} %"tmp#6##0", i1 1, 1 + ret {i64, i1} %"tmp#7##0" +if.else.0: + %"tmp#8##0" = insertvalue {i64, i1} undef, i64 0, 0 + %"tmp#9##0" = insertvalue {i64, i1} %"tmp#8##0", i1 0, 1 + ret {i64, i1} %"tmp#9##0" } - -define external fastcc i1 @"mytree.tree.~=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = tail call fastcc i1 @"mytree.tree.=<0>"(i64 %"#left##0", i64 %"#right##0") - %1 = xor i1 %0, 1 - ret i1 %1 +define external fastcc i1 @"mytree.tree.~=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#0##0" = tail call fastcc i1 @"mytree.tree.=<0>"(i64 %"#left##0", i64 %"#right##0") + %"tmp#1##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#1##0" } diff --git a/test-cases/final-dump/alias_m.exp b/test-cases/final-dump/alias_m.exp index 30a275dae..b75aff163 100644 --- a/test-cases/final-dump/alias_m.exp +++ b/test-cases/final-dump/alias_m.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module alias_m representation : (not a type) public submods : @@ -29,66 +32,45 @@ module top-level code > public {semipure} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'alias_m' - - - - -@alias_m.1 = constant {i64, i64} { i64 14, i64 ptrtoint ([?? x i8]* @alias_m.0 to i64) } - - -@alias_m.3 = constant {i64, i64} { i64 14, i64 ptrtoint ([?? x i8]* @alias_m.2 to i64) } - - -@alias_m.5 = constant {i64, i64} { i64 14, i64 ptrtoint ([?? x i8]* @alias_m.4 to i64) } - - -@alias_m.0 = constant [?? x i8] c"expect p1(2,2)\00" - - -@alias_m.2 = constant [?? x i8] c"expect p2(2,2)\00" - - -@alias_m.4 = constant [?? x i8] c"expect p3(3,3)\00" - - -declare external fastcc void @"position.printPosition<0>"(i64) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external fastcc {i64, i64} @"alias_mfoo.foo<0>"(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"alias_m.<0>"() { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 1, i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 1, i64* %5 - %6 = tail call fastcc {i64, i64} @"alias_mfoo.foo<0>"(i64 %2) - %7 = extractvalue {i64, i64} %6, 0 - %8 = extractvalue {i64, i64} %6, 1 - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_m.1, i32 0, i32 0) to i64)) - tail call fastcc void @"position.printPosition<0>"(i64 %2) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_m.3, i32 0, i32 0) to i64)) - tail call fastcc void @"position.printPosition<0>"(i64 %7) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_m.5, i32 0, i32 0) to i64)) - tail call fastcc void @"position.printPosition<0>"(i64 %8) - ret void +source_filename = "!ROOT!/final-dump/alias_m.wybe" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c"expect p1(2,2)\00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c"expect p2(2,2)\00", align 8 +@"cstring#2" = private unnamed_addr constant [ ?? x i8 ] c"expect p3(3,3)\00", align 8 +@"string#3" = private unnamed_addr constant {i64, i64} { i64 14, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +@"string#4" = private unnamed_addr constant {i64, i64} { i64 14, i64 ptrtoint( ptr @"cstring#1" to i64 ) }, align 8 +@"string#5" = private unnamed_addr constant {i64, i64} { i64 14, i64 ptrtoint( ptr @"cstring#2" to i64 ) }, align 8 + +declare external fastcc {i64, i64} @"alias_mfoo.foo<0>"(i64) +declare external fastcc void @"position.printPosition<0>"(i64) +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"alias_m.<0>"() { + %"tmp#5##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#3##0" = ptrtoint ptr %"tmp#5##0" to i64 + %"tmp#6##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 1, ptr %"tmp#6##0" + %"tmp#7##0" = add i64 %"tmp#3##0", 8 + %"tmp#8##0" = inttoptr i64 %"tmp#7##0" to ptr + store i64 1, ptr %"tmp#8##0" + %"tmp#9##0" = tail call fastcc {i64, i64} @"alias_mfoo.foo<0>"(i64 %"tmp#3##0") + %"p2##0" = extractvalue {i64, i64}%"tmp#9##0", 0 + %"p3##0" = extractvalue {i64, i64}%"tmp#9##0", 1 + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#3" to i64 )) + tail call fastcc void @"position.printPosition<0>"(i64 %"tmp#3##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#4" to i64 )) + tail call fastcc void @"position.printPosition<0>"(i64 %"p2##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#5" to i64 )) + tail call fastcc void @"position.printPosition<0>"(i64 %"p3##0") + ret void } + -------------------------------------------------- Module alias_mbar representation : (not a type) @@ -133,68 +115,59 @@ bar(p1##0:position.position, ?p3##1:position.position)<{<>}; {<[410bae77d3]"(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i64 @"alias_mbar.bar<0>"(i64 %"p1##0") { -entry: - %0 = add i64 %"p1##0", 8 - %1 = inttoptr i64 %0 to i64* - %2 = load i64, i64* %1 - %3 = icmp sgt i64 %2, 1 - br i1 %3, label %if.then, label %if.else -if.then: - ret i64 %"p1##0" -if.else: - %4 = add i64 %2, 1 - %5 = trunc i64 16 to i32 - %6 = tail call ccc i8* @wybe_malloc(i32 %5) - %7 = ptrtoint i8* %6 to i64 - %8 = inttoptr i64 %7 to i8* - %9 = inttoptr i64 %"p1##0" to i8* - %10 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %8, i8* %9, i32 %10, i1 0) - %11 = add i64 %7, 8 - %12 = inttoptr i64 %11 to i64* - store i64 %4, i64* %12 - %13 = tail call fastcc {i64, i64} @"alias_mfoo.foo<0>[410bae77d3]"(i64 %7) - %14 = extractvalue {i64, i64} %13, 0 - %15 = extractvalue {i64, i64} %13, 1 - ret i64 %15 +source_filename = "!ROOT!/final-dump/alias_mbar.wybe" +target triple ???? + + +declare external fastcc {i64, i64} @"alias_mfoo.foo<0>[410bae77d3]"(i64) +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc i64 @"alias_mbar.bar<0>"(i64 %"p1##0") { + %"tmp#12##0" = add i64 %"p1##0", 8 + %"tmp#13##0" = inttoptr i64 %"tmp#12##0" to ptr + %"tmp#0##0" = load i64, ptr %"tmp#13##0" + %"tmp#3##0" = icmp sgt i64 %"tmp#0##0", 1 + br i1 %"tmp#3##0", label %if.then.0, label %if.else.0 +if.then.0: + ret i64 %"p1##0" +if.else.0: + %"tmp#2##0" = add i64 %"tmp#0##0", 1 + %"tmp#14##0" = inttoptr i64 %"p1##0" to ptr + %"tmp#15##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#15##0", ptr %"tmp#14##0", i64 16, i1 0) + %"tmp#16##0" = ptrtoint ptr %"tmp#15##0" to i64 + %"tmp#17##0" = add i64 %"tmp#16##0", 8 + %"tmp#18##0" = inttoptr i64 %"tmp#17##0" to ptr + store i64 %"tmp#2##0", ptr %"tmp#18##0" + %"tmp#19##0" = tail call fastcc {i64, i64} @"alias_mfoo.foo<0>[410bae77d3]"(i64 %"tmp#16##0") + %"p2##0" = extractvalue {i64, i64}%"tmp#19##0", 0 + %"tmp#20##0" = extractvalue {i64, i64}%"tmp#19##0", 1 + ret i64 %"tmp#20##0" } - -define external fastcc i64 @"alias_mbar.bar<0>[410bae77d3]"(i64 %"p1##0") { -entry: - %0 = add i64 %"p1##0", 8 - %1 = inttoptr i64 %0 to i64* - %2 = load i64, i64* %1 - %3 = icmp sgt i64 %2, 1 - br i1 %3, label %if.then, label %if.else -if.then: - ret i64 %"p1##0" -if.else: - %4 = add i64 %2, 1 - %5 = add i64 %"p1##0", 8 - %6 = inttoptr i64 %5 to i64* - store i64 %4, i64* %6 - %7 = tail call fastcc {i64, i64} @"alias_mfoo.foo<0>[410bae77d3]"(i64 %"p1##0") - %8 = extractvalue {i64, i64} %7, 0 - %9 = extractvalue {i64, i64} %7, 1 - ret i64 %9 +define external fastcc i64 @"alias_mbar.bar<0>[410bae77d3]"(i64 %"p1##0") { + %"tmp#12##0" = add i64 %"p1##0", 8 + %"tmp#13##0" = inttoptr i64 %"tmp#12##0" to ptr + %"tmp#0##0" = load i64, ptr %"tmp#13##0" + %"tmp#3##0" = icmp sgt i64 %"tmp#0##0", 1 + br i1 %"tmp#3##0", label %if.then.0, label %if.else.0 +if.then.0: + ret i64 %"p1##0" +if.else.0: + %"tmp#2##0" = add i64 %"tmp#0##0", 1 + %"tmp#14##0" = add i64 %"p1##0", 8 + %"tmp#15##0" = inttoptr i64 %"tmp#14##0" to ptr + store i64 %"tmp#2##0", ptr %"tmp#15##0" + %"tmp#16##0" = tail call fastcc {i64, i64} @"alias_mfoo.foo<0>[410bae77d3]"(i64 %"p1##0") + %"p2##0" = extractvalue {i64, i64}%"tmp#16##0", 0 + %"tmp#17##0" = extractvalue {i64, i64}%"tmp#16##0", 1 + ret i64 %"tmp#17##0" } + -------------------------------------------------- Module alias_mfoo representation : (not a type) @@ -257,116 +230,95 @@ foo(p1##0:position.position, ?p2##0:position.position, ?p3##0:position.position) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'alias_mfoo' - - - - -@alias_mfoo.1 = constant {i64, i64} { i64 3, i64 ptrtoint ([?? x i8]* @alias_mfoo.0 to i64) } - - -@alias_mfoo.0 = constant [?? x i8] c"p3:\00" - - -declare external fastcc i64 @"alias_mbar.bar<0>[410bae77d3]"(i64) - - -declare external fastcc void @"position.printPosition<0>"(i64) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc {i64, i64} @"alias_mfoo.foo<0>"(i64 %"p1##0") { -entry: - %0 = inttoptr i64 %"p1##0" to i64* - %1 = load i64, i64* %0 - %2 = icmp sgt i64 %1, 1 - br i1 %2, label %if.then, label %if.else -if.then: - %3 = trunc i64 16 to i32 - %4 = tail call ccc i8* @wybe_malloc(i32 %3) - %5 = ptrtoint i8* %4 to i64 - %6 = inttoptr i64 %5 to i64* - store i64 3, i64* %6 - %7 = add i64 %5, 8 - %8 = inttoptr i64 %7 to i64* - store i64 3, i64* %8 - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_mfoo.1, i32 0, i32 0) to i64)) - tail call fastcc void @"position.printPosition<0>"(i64 %5) - %9 = insertvalue {i64, i64} undef, i64 %"p1##0", 0 - %10 = insertvalue {i64, i64} %9, i64 %5, 1 - ret {i64, i64} %10 -if.else: - %11 = add i64 %1, 1 - %12 = trunc i64 16 to i32 - %13 = tail call ccc i8* @wybe_malloc(i32 %12) - %14 = ptrtoint i8* %13 to i64 - %15 = inttoptr i64 %14 to i8* - %16 = inttoptr i64 %"p1##0" to i8* - %17 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %15, i8* %16, i32 %17, i1 0) - %18 = inttoptr i64 %14 to i64* - store i64 %11, i64* %18 - %19 = tail call fastcc i64 @"alias_mbar.bar<0>[410bae77d3]"(i64 %14) - %20 = trunc i64 16 to i32 - %21 = tail call ccc i8* @wybe_malloc(i32 %20) - %22 = ptrtoint i8* %21 to i64 - %23 = inttoptr i64 %22 to i64* - store i64 2, i64* %23 - %24 = add i64 %22, 8 - %25 = inttoptr i64 %24 to i64* - store i64 2, i64* %25 - %26 = insertvalue {i64, i64} undef, i64 %22, 0 - %27 = insertvalue {i64, i64} %26, i64 %19, 1 - ret {i64, i64} %27 +source_filename = "!ROOT!/final-dump/alias_mfoo.wybe" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c"p3:\00", align 8 +@"string#1" = private unnamed_addr constant {i64, i64} { i64 3, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 + +declare external fastcc i64 @"alias_mbar.bar<0>[410bae77d3]"(i64) +declare external fastcc void @"position.printPosition<0>"(i64) +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc {i64, i64} @"alias_mfoo.foo<0>"(i64 %"p1##0") { + %"tmp#22##0" = inttoptr i64 %"p1##0" to ptr + %"tmp#0##0" = load i64, ptr %"tmp#22##0" + %"tmp#5##0" = icmp sgt i64 %"tmp#0##0", 1 + br i1 %"tmp#5##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#23##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#20##0" = ptrtoint ptr %"tmp#23##0" to i64 + %"tmp#24##0" = inttoptr i64 %"tmp#20##0" to ptr + store i64 3, ptr %"tmp#24##0" + %"tmp#25##0" = add i64 %"tmp#20##0", 8 + %"tmp#26##0" = inttoptr i64 %"tmp#25##0" to ptr + store i64 3, ptr %"tmp#26##0" + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#1" to i64 )) + tail call fastcc void @"position.printPosition<0>"(i64 %"tmp#20##0") + %"tmp#27##0" = insertvalue {i64, i64} undef, i64 %"p1##0", 0 + %"tmp#28##0" = insertvalue {i64, i64} %"tmp#27##0", i64 %"tmp#20##0", 1 + ret {i64, i64} %"tmp#28##0" +if.else.0: + %"tmp#3##0" = add i64 %"tmp#0##0", 1 + %"tmp#29##0" = inttoptr i64 %"p1##0" to ptr + %"tmp#30##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#30##0", ptr %"tmp#29##0", i64 16, i1 0) + %"tmp#31##0" = ptrtoint ptr %"tmp#30##0" to i64 + %"tmp#32##0" = inttoptr i64 %"tmp#31##0" to ptr + store i64 %"tmp#3##0", ptr %"tmp#32##0" + %"tmp#33##0" = tail call fastcc i64 @"alias_mbar.bar<0>[410bae77d3]"(i64 %"tmp#31##0") + %"tmp#34##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#16##0" = ptrtoint ptr %"tmp#34##0" to i64 + %"tmp#35##0" = inttoptr i64 %"tmp#16##0" to ptr + store i64 2, ptr %"tmp#35##0" + %"tmp#36##0" = add i64 %"tmp#16##0", 8 + %"tmp#37##0" = inttoptr i64 %"tmp#36##0" to ptr + store i64 2, ptr %"tmp#37##0" + %"tmp#38##0" = insertvalue {i64, i64} undef, i64 %"tmp#16##0", 0 + %"tmp#39##0" = insertvalue {i64, i64} %"tmp#38##0", i64 %"tmp#33##0", 1 + ret {i64, i64} %"tmp#39##0" } - -define external fastcc {i64, i64} @"alias_mfoo.foo<0>[410bae77d3]"(i64 %"p1##0") { -entry: - %0 = inttoptr i64 %"p1##0" to i64* - %1 = load i64, i64* %0 - %2 = icmp sgt i64 %1, 1 - br i1 %2, label %if.then, label %if.else -if.then: - %3 = trunc i64 16 to i32 - %4 = tail call ccc i8* @wybe_malloc(i32 %3) - %5 = ptrtoint i8* %4 to i64 - %6 = inttoptr i64 %5 to i64* - store i64 3, i64* %6 - %7 = add i64 %5, 8 - %8 = inttoptr i64 %7 to i64* - store i64 3, i64* %8 - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_mfoo.1, i32 0, i32 0) to i64)) - tail call fastcc void @"position.printPosition<0>"(i64 %5) - %9 = insertvalue {i64, i64} undef, i64 %"p1##0", 0 - %10 = insertvalue {i64, i64} %9, i64 %5, 1 - ret {i64, i64} %10 -if.else: - %11 = add i64 %1, 1 - %12 = inttoptr i64 %"p1##0" to i64* - store i64 %11, i64* %12 - %13 = tail call fastcc i64 @"alias_mbar.bar<0>[410bae77d3]"(i64 %"p1##0") - %14 = trunc i64 16 to i32 - %15 = tail call ccc i8* @wybe_malloc(i32 %14) - %16 = ptrtoint i8* %15 to i64 - %17 = inttoptr i64 %16 to i64* - store i64 2, i64* %17 - %18 = add i64 %16, 8 - %19 = inttoptr i64 %18 to i64* - store i64 2, i64* %19 - %20 = insertvalue {i64, i64} undef, i64 %16, 0 - %21 = insertvalue {i64, i64} %20, i64 %13, 1 - ret {i64, i64} %21 +define external fastcc {i64, i64} @"alias_mfoo.foo<0>[410bae77d3]"(i64 %"p1##0") { + %"tmp#22##0" = inttoptr i64 %"p1##0" to ptr + %"tmp#0##0" = load i64, ptr %"tmp#22##0" + %"tmp#5##0" = icmp sgt i64 %"tmp#0##0", 1 + br i1 %"tmp#5##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#23##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#20##0" = ptrtoint ptr %"tmp#23##0" to i64 + %"tmp#24##0" = inttoptr i64 %"tmp#20##0" to ptr + store i64 3, ptr %"tmp#24##0" + %"tmp#25##0" = add i64 %"tmp#20##0", 8 + %"tmp#26##0" = inttoptr i64 %"tmp#25##0" to ptr + store i64 3, ptr %"tmp#26##0" + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#1" to i64 )) + tail call fastcc void @"position.printPosition<0>"(i64 %"tmp#20##0") + %"tmp#27##0" = insertvalue {i64, i64} undef, i64 %"p1##0", 0 + %"tmp#28##0" = insertvalue {i64, i64} %"tmp#27##0", i64 %"tmp#20##0", 1 + ret {i64, i64} %"tmp#28##0" +if.else.0: + %"tmp#3##0" = add i64 %"tmp#0##0", 1 + %"tmp#29##0" = inttoptr i64 %"p1##0" to ptr + store i64 %"tmp#3##0", ptr %"tmp#29##0" + %"tmp#30##0" = tail call fastcc i64 @"alias_mbar.bar<0>[410bae77d3]"(i64 %"p1##0") + %"tmp#31##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#16##0" = ptrtoint ptr %"tmp#31##0" to i64 + %"tmp#32##0" = inttoptr i64 %"tmp#16##0" to ptr + store i64 2, ptr %"tmp#32##0" + %"tmp#33##0" = add i64 %"tmp#16##0", 8 + %"tmp#34##0" = inttoptr i64 %"tmp#33##0" to ptr + store i64 2, ptr %"tmp#34##0" + %"tmp#35##0" = insertvalue {i64, i64} undef, i64 %"tmp#16##0", 0 + %"tmp#36##0" = insertvalue {i64, i64} %"tmp#35##0", i64 %"tmp#30##0", 1 + ret {i64, i64} %"tmp#36##0" } + -------------------------------------------------- Module position representation : (not a type) @@ -409,63 +361,42 @@ printPosition(pos##0:position.position)<{<>}; {<>}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'position' - - - - -@position.3 = constant {i64, i64} { i64 1, i64 ptrtoint ([?? x i8]* @position.2 to i64) } - - -@position.5 = constant {i64, i64} { i64 1, i64 ptrtoint ([?? x i8]* @position.4 to i64) } - - -@position.1 = constant {i64, i64} { i64 2, i64 ptrtoint ([?? x i8]* @position.0 to i64) } - - -@position.0 = constant [?? x i8] c" (\00" - - -@position.4 = constant [?? x i8] c")\00" - - -@position.2 = constant [?? x i8] c",\00" - - -declare external ccc void @putchar(i8) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc void @print_int(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"position.printPosition<0>"(i64 %"pos##0") { -entry: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @position.1, i32 0, i32 0) to i64)) - %0 = inttoptr i64 %"pos##0" to i64* - %1 = load i64, i64* %0 - tail call ccc void @print_int(i64 %1) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @position.3, i32 0, i32 0) to i64)) - %2 = add i64 %"pos##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - tail call ccc void @print_int(i64 %4) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @position.5, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - ret void +source_filename = "!ROOT!/final-dump/position.wybe" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c" (\00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c")\00", align 8 +@"cstring#2" = private unnamed_addr constant [ ?? x i8 ] c",\00", align 8 +@"string#3" = private unnamed_addr constant {i64, i64} { i64 2, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +@"string#4" = private unnamed_addr constant {i64, i64} { i64 1, i64 ptrtoint( ptr @"cstring#1" to i64 ) }, align 8 +@"string#5" = private unnamed_addr constant {i64, i64} { i64 1, i64 ptrtoint( ptr @"cstring#2" to i64 ) }, align 8 + +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"position.printPosition<0>"(i64 %"pos##0") { + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#3" to i64 )) + %"tmp#13##0" = inttoptr i64 %"pos##0" to ptr + %"tmp#0##0" = load i64, ptr %"tmp#13##0" + call ccc void @print_int(i64 %"tmp#0##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#5" to i64 )) + %"tmp#14##0" = add i64 %"pos##0", 8 + %"tmp#15##0" = inttoptr i64 %"tmp#14##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#15##0" + call ccc void @print_int(i64 %"tmp#1##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#4" to i64 )) + call ccc void @putchar(i8 10) + ret void } + -------------------------------------------------- Module position.position - representation : address + representation : pointer public submods : public resources: public procs : position.position.=<0> @@ -567,134 +498,110 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'position.position' - - - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i1 @"position.position.=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %"#right##0" to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = icmp eq i64 %1, %6 - br i1 %10, label %if.then, label %if.else -if.then: - %11 = icmp eq i64 %4, %9 - ret i1 %11 -if.else: - ret i1 0 +source_filename = "!ROOT!/final-dump/position.wybe" +target triple ???? + + +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc i1 @"position.position.=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#9##0" = inttoptr i64 %"#left##0" to ptr + %"#left#x##0" = load i64, ptr %"tmp#9##0" + %"tmp#10##0" = add i64 %"#left##0", 8 + %"tmp#11##0" = inttoptr i64 %"tmp#10##0" to ptr + %"#left#y##0" = load i64, ptr %"tmp#11##0" + %"tmp#12##0" = inttoptr i64 %"#right##0" to ptr + %"#right#x##0" = load i64, ptr %"tmp#12##0" + %"tmp#13##0" = add i64 %"#right##0", 8 + %"tmp#14##0" = inttoptr i64 %"tmp#13##0" to ptr + %"#right#y##0" = load i64, ptr %"tmp#14##0" + %"tmp#1##0" = icmp eq i64 %"#left#x##0", %"#right#x##0" + br i1 %"tmp#1##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#15##0" = icmp eq i64 %"#left#y##0", %"#right#y##0" + ret i1 %"tmp#15##0" +if.else.0: + ret i1 0 } - -define external fastcc i64 @"position.position.position<0>"(i64 %"x##0", i64 %"y##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"x##0", i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"y##0", i64* %5 - ret i64 %2 +define external fastcc i64 @"position.position.position<0>"(i64 %"x##0", i64 %"y##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 16) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"x##0", ptr %"tmp#1##0" + %"tmp#2##0" = add i64 %"#rec##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"y##0", ptr %"tmp#3##0" + ret i64 %"#rec##0" } - -define external fastcc {i64, i64} @"position.position.position<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#result##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#result##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = insertvalue {i64, i64} undef, i64 %1, 0 - %6 = insertvalue {i64, i64} %5, i64 %4, 1 - ret {i64, i64} %6 +define external fastcc {i64, i64} @"position.position.position<1>"(i64 %"#result##0") { + %"tmp#0##0" = inttoptr i64 %"#result##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + %"tmp#2##0" = add i64 %"#result##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#3##0" + %"tmp#5##0" = insertvalue {i64, i64} undef, i64 %"tmp#1##0", 0 + %"tmp#6##0" = insertvalue {i64, i64} %"tmp#5##0", i64 %"tmp#4##0", 1 + ret {i64, i64} %"tmp#6##0" } - -define external fastcc i64 @"position.position.x<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#rec##0" to i64* - %1 = load i64, i64* %0 - ret i64 %1 +define external fastcc i64 @"position.position.x<0>"(i64 %"#rec##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + ret i64 %"tmp#1##0" } - -define external fastcc i64 @"position.position.x<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = inttoptr i64 %2 to i64* - store i64 %"#field##0", i64* %6 - ret i64 %2 +define external fastcc i64 @"position.position.x<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"#field##0", ptr %"tmp#3##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"position.position.y<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = add i64 %"#rec##0", 8 - %1 = inttoptr i64 %0 to i64* - %2 = load i64, i64* %1 - ret i64 %2 +define external fastcc i64 @"position.position.y<0>"(i64 %"#rec##0") { + %"tmp#0##0" = add i64 %"#rec##0", 8 + %"tmp#1##0" = inttoptr i64 %"tmp#0##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"position.position.y<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = add i64 %2, 8 - %7 = inttoptr i64 %6 to i64* - store i64 %"#field##0", i64* %7 - ret i64 %2 +define external fastcc i64 @"position.position.y<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = add i64 %"tmp#2##0", 8 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 %"#field##0", ptr %"tmp#4##0" + ret i64 %"tmp#2##0" } - -define external fastcc i1 @"position.position.~=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %"#right##0" to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = icmp eq i64 %1, %6 - br i1 %10, label %if.then, label %if.else -if.then: - %11 = icmp eq i64 %4, %9 - %12 = xor i1 %11, 1 - ret i1 %12 -if.else: - %13 = xor i1 0, 1 - ret i1 %13 +define external fastcc i1 @"position.position.~=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#8##0" = inttoptr i64 %"#left##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#8##0" + %"tmp#9##0" = add i64 %"#left##0", 8 + %"tmp#10##0" = inttoptr i64 %"tmp#9##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#10##0" + %"tmp#11##0" = inttoptr i64 %"#right##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#11##0" + %"tmp#12##0" = add i64 %"#right##0", 8 + %"tmp#13##0" = inttoptr i64 %"tmp#12##0" to ptr + %"tmp#6##0" = load i64, ptr %"tmp#13##0" + %"tmp#7##0" = icmp eq i64 %"tmp#3##0", %"tmp#5##0" + br i1 %"tmp#7##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#0##0" = icmp eq i64 %"tmp#4##0", %"tmp#6##0" + %"tmp#14##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#14##0" +if.else.0: + %"tmp#15##0" = xor i1 0, 1 + ret i1 %"tmp#15##0" } diff --git a/test-cases/final-dump/alias_mbar.exp b/test-cases/final-dump/alias_mbar.exp index bca19e239..9014dabd9 100644 --- a/test-cases/final-dump/alias_mbar.exp +++ b/test-cases/final-dump/alias_mbar.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module alias_mbar representation : (not a type) public submods : @@ -43,68 +46,59 @@ bar(p1##0:position.position, ?p3##1:position.position)<{<>}; {<[410bae77d3]"(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i64 @"alias_mbar.bar<0>"(i64 %"p1##0") { -entry: - %0 = add i64 %"p1##0", 8 - %1 = inttoptr i64 %0 to i64* - %2 = load i64, i64* %1 - %3 = icmp sgt i64 %2, 1 - br i1 %3, label %if.then, label %if.else -if.then: - ret i64 %"p1##0" -if.else: - %4 = add i64 %2, 1 - %5 = trunc i64 16 to i32 - %6 = tail call ccc i8* @wybe_malloc(i32 %5) - %7 = ptrtoint i8* %6 to i64 - %8 = inttoptr i64 %7 to i8* - %9 = inttoptr i64 %"p1##0" to i8* - %10 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %8, i8* %9, i32 %10, i1 0) - %11 = add i64 %7, 8 - %12 = inttoptr i64 %11 to i64* - store i64 %4, i64* %12 - %13 = tail call fastcc {i64, i64} @"alias_mfoo.foo<0>[410bae77d3]"(i64 %7) - %14 = extractvalue {i64, i64} %13, 0 - %15 = extractvalue {i64, i64} %13, 1 - ret i64 %15 +source_filename = "!ROOT!/final-dump/alias_mbar.wybe" +target triple ???? + + +declare external fastcc {i64, i64} @"alias_mfoo.foo<0>[410bae77d3]"(i64) +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc i64 @"alias_mbar.bar<0>"(i64 %"p1##0") { + %"tmp#12##0" = add i64 %"p1##0", 8 + %"tmp#13##0" = inttoptr i64 %"tmp#12##0" to ptr + %"tmp#0##0" = load i64, ptr %"tmp#13##0" + %"tmp#3##0" = icmp sgt i64 %"tmp#0##0", 1 + br i1 %"tmp#3##0", label %if.then.0, label %if.else.0 +if.then.0: + ret i64 %"p1##0" +if.else.0: + %"tmp#2##0" = add i64 %"tmp#0##0", 1 + %"tmp#14##0" = inttoptr i64 %"p1##0" to ptr + %"tmp#15##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#15##0", ptr %"tmp#14##0", i64 16, i1 0) + %"tmp#16##0" = ptrtoint ptr %"tmp#15##0" to i64 + %"tmp#17##0" = add i64 %"tmp#16##0", 8 + %"tmp#18##0" = inttoptr i64 %"tmp#17##0" to ptr + store i64 %"tmp#2##0", ptr %"tmp#18##0" + %"tmp#19##0" = tail call fastcc {i64, i64} @"alias_mfoo.foo<0>[410bae77d3]"(i64 %"tmp#16##0") + %"p2##0" = extractvalue {i64, i64}%"tmp#19##0", 0 + %"tmp#20##0" = extractvalue {i64, i64}%"tmp#19##0", 1 + ret i64 %"tmp#20##0" } - -define external fastcc i64 @"alias_mbar.bar<0>[410bae77d3]"(i64 %"p1##0") { -entry: - %0 = add i64 %"p1##0", 8 - %1 = inttoptr i64 %0 to i64* - %2 = load i64, i64* %1 - %3 = icmp sgt i64 %2, 1 - br i1 %3, label %if.then, label %if.else -if.then: - ret i64 %"p1##0" -if.else: - %4 = add i64 %2, 1 - %5 = add i64 %"p1##0", 8 - %6 = inttoptr i64 %5 to i64* - store i64 %4, i64* %6 - %7 = tail call fastcc {i64, i64} @"alias_mfoo.foo<0>[410bae77d3]"(i64 %"p1##0") - %8 = extractvalue {i64, i64} %7, 0 - %9 = extractvalue {i64, i64} %7, 1 - ret i64 %9 +define external fastcc i64 @"alias_mbar.bar<0>[410bae77d3]"(i64 %"p1##0") { + %"tmp#12##0" = add i64 %"p1##0", 8 + %"tmp#13##0" = inttoptr i64 %"tmp#12##0" to ptr + %"tmp#0##0" = load i64, ptr %"tmp#13##0" + %"tmp#3##0" = icmp sgt i64 %"tmp#0##0", 1 + br i1 %"tmp#3##0", label %if.then.0, label %if.else.0 +if.then.0: + ret i64 %"p1##0" +if.else.0: + %"tmp#2##0" = add i64 %"tmp#0##0", 1 + %"tmp#14##0" = add i64 %"p1##0", 8 + %"tmp#15##0" = inttoptr i64 %"tmp#14##0" to ptr + store i64 %"tmp#2##0", ptr %"tmp#15##0" + %"tmp#16##0" = tail call fastcc {i64, i64} @"alias_mfoo.foo<0>[410bae77d3]"(i64 %"p1##0") + %"p2##0" = extractvalue {i64, i64}%"tmp#16##0", 0 + %"tmp#17##0" = extractvalue {i64, i64}%"tmp#16##0", 1 + ret i64 %"tmp#17##0" } + -------------------------------------------------- Module alias_mfoo representation : (not a type) @@ -167,116 +161,95 @@ foo(p1##0:position.position, ?p2##0:position.position, ?p3##0:position.position) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'alias_mfoo' - - - - -@alias_mfoo.1 = constant {i64, i64} { i64 3, i64 ptrtoint ([?? x i8]* @alias_mfoo.0 to i64) } - - -@alias_mfoo.0 = constant [?? x i8] c"p3:\00" - - -declare external fastcc i64 @"alias_mbar.bar<0>[410bae77d3]"(i64) - - -declare external fastcc void @"position.printPosition<0>"(i64) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc {i64, i64} @"alias_mfoo.foo<0>"(i64 %"p1##0") { -entry: - %0 = inttoptr i64 %"p1##0" to i64* - %1 = load i64, i64* %0 - %2 = icmp sgt i64 %1, 1 - br i1 %2, label %if.then, label %if.else -if.then: - %3 = trunc i64 16 to i32 - %4 = tail call ccc i8* @wybe_malloc(i32 %3) - %5 = ptrtoint i8* %4 to i64 - %6 = inttoptr i64 %5 to i64* - store i64 3, i64* %6 - %7 = add i64 %5, 8 - %8 = inttoptr i64 %7 to i64* - store i64 3, i64* %8 - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_mfoo.1, i32 0, i32 0) to i64)) - tail call fastcc void @"position.printPosition<0>"(i64 %5) - %9 = insertvalue {i64, i64} undef, i64 %"p1##0", 0 - %10 = insertvalue {i64, i64} %9, i64 %5, 1 - ret {i64, i64} %10 -if.else: - %11 = add i64 %1, 1 - %12 = trunc i64 16 to i32 - %13 = tail call ccc i8* @wybe_malloc(i32 %12) - %14 = ptrtoint i8* %13 to i64 - %15 = inttoptr i64 %14 to i8* - %16 = inttoptr i64 %"p1##0" to i8* - %17 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %15, i8* %16, i32 %17, i1 0) - %18 = inttoptr i64 %14 to i64* - store i64 %11, i64* %18 - %19 = tail call fastcc i64 @"alias_mbar.bar<0>[410bae77d3]"(i64 %14) - %20 = trunc i64 16 to i32 - %21 = tail call ccc i8* @wybe_malloc(i32 %20) - %22 = ptrtoint i8* %21 to i64 - %23 = inttoptr i64 %22 to i64* - store i64 2, i64* %23 - %24 = add i64 %22, 8 - %25 = inttoptr i64 %24 to i64* - store i64 2, i64* %25 - %26 = insertvalue {i64, i64} undef, i64 %22, 0 - %27 = insertvalue {i64, i64} %26, i64 %19, 1 - ret {i64, i64} %27 +source_filename = "!ROOT!/final-dump/alias_mfoo.wybe" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c"p3:\00", align 8 +@"string#1" = private unnamed_addr constant {i64, i64} { i64 3, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 + +declare external fastcc i64 @"alias_mbar.bar<0>[410bae77d3]"(i64) +declare external fastcc void @"position.printPosition<0>"(i64) +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc {i64, i64} @"alias_mfoo.foo<0>"(i64 %"p1##0") { + %"tmp#22##0" = inttoptr i64 %"p1##0" to ptr + %"tmp#0##0" = load i64, ptr %"tmp#22##0" + %"tmp#5##0" = icmp sgt i64 %"tmp#0##0", 1 + br i1 %"tmp#5##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#23##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#20##0" = ptrtoint ptr %"tmp#23##0" to i64 + %"tmp#24##0" = inttoptr i64 %"tmp#20##0" to ptr + store i64 3, ptr %"tmp#24##0" + %"tmp#25##0" = add i64 %"tmp#20##0", 8 + %"tmp#26##0" = inttoptr i64 %"tmp#25##0" to ptr + store i64 3, ptr %"tmp#26##0" + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#1" to i64 )) + tail call fastcc void @"position.printPosition<0>"(i64 %"tmp#20##0") + %"tmp#27##0" = insertvalue {i64, i64} undef, i64 %"p1##0", 0 + %"tmp#28##0" = insertvalue {i64, i64} %"tmp#27##0", i64 %"tmp#20##0", 1 + ret {i64, i64} %"tmp#28##0" +if.else.0: + %"tmp#3##0" = add i64 %"tmp#0##0", 1 + %"tmp#29##0" = inttoptr i64 %"p1##0" to ptr + %"tmp#30##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#30##0", ptr %"tmp#29##0", i64 16, i1 0) + %"tmp#31##0" = ptrtoint ptr %"tmp#30##0" to i64 + %"tmp#32##0" = inttoptr i64 %"tmp#31##0" to ptr + store i64 %"tmp#3##0", ptr %"tmp#32##0" + %"tmp#33##0" = tail call fastcc i64 @"alias_mbar.bar<0>[410bae77d3]"(i64 %"tmp#31##0") + %"tmp#34##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#16##0" = ptrtoint ptr %"tmp#34##0" to i64 + %"tmp#35##0" = inttoptr i64 %"tmp#16##0" to ptr + store i64 2, ptr %"tmp#35##0" + %"tmp#36##0" = add i64 %"tmp#16##0", 8 + %"tmp#37##0" = inttoptr i64 %"tmp#36##0" to ptr + store i64 2, ptr %"tmp#37##0" + %"tmp#38##0" = insertvalue {i64, i64} undef, i64 %"tmp#16##0", 0 + %"tmp#39##0" = insertvalue {i64, i64} %"tmp#38##0", i64 %"tmp#33##0", 1 + ret {i64, i64} %"tmp#39##0" } - -define external fastcc {i64, i64} @"alias_mfoo.foo<0>[410bae77d3]"(i64 %"p1##0") { -entry: - %0 = inttoptr i64 %"p1##0" to i64* - %1 = load i64, i64* %0 - %2 = icmp sgt i64 %1, 1 - br i1 %2, label %if.then, label %if.else -if.then: - %3 = trunc i64 16 to i32 - %4 = tail call ccc i8* @wybe_malloc(i32 %3) - %5 = ptrtoint i8* %4 to i64 - %6 = inttoptr i64 %5 to i64* - store i64 3, i64* %6 - %7 = add i64 %5, 8 - %8 = inttoptr i64 %7 to i64* - store i64 3, i64* %8 - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_mfoo.1, i32 0, i32 0) to i64)) - tail call fastcc void @"position.printPosition<0>"(i64 %5) - %9 = insertvalue {i64, i64} undef, i64 %"p1##0", 0 - %10 = insertvalue {i64, i64} %9, i64 %5, 1 - ret {i64, i64} %10 -if.else: - %11 = add i64 %1, 1 - %12 = inttoptr i64 %"p1##0" to i64* - store i64 %11, i64* %12 - %13 = tail call fastcc i64 @"alias_mbar.bar<0>[410bae77d3]"(i64 %"p1##0") - %14 = trunc i64 16 to i32 - %15 = tail call ccc i8* @wybe_malloc(i32 %14) - %16 = ptrtoint i8* %15 to i64 - %17 = inttoptr i64 %16 to i64* - store i64 2, i64* %17 - %18 = add i64 %16, 8 - %19 = inttoptr i64 %18 to i64* - store i64 2, i64* %19 - %20 = insertvalue {i64, i64} undef, i64 %16, 0 - %21 = insertvalue {i64, i64} %20, i64 %13, 1 - ret {i64, i64} %21 +define external fastcc {i64, i64} @"alias_mfoo.foo<0>[410bae77d3]"(i64 %"p1##0") { + %"tmp#22##0" = inttoptr i64 %"p1##0" to ptr + %"tmp#0##0" = load i64, ptr %"tmp#22##0" + %"tmp#5##0" = icmp sgt i64 %"tmp#0##0", 1 + br i1 %"tmp#5##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#23##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#20##0" = ptrtoint ptr %"tmp#23##0" to i64 + %"tmp#24##0" = inttoptr i64 %"tmp#20##0" to ptr + store i64 3, ptr %"tmp#24##0" + %"tmp#25##0" = add i64 %"tmp#20##0", 8 + %"tmp#26##0" = inttoptr i64 %"tmp#25##0" to ptr + store i64 3, ptr %"tmp#26##0" + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#1" to i64 )) + tail call fastcc void @"position.printPosition<0>"(i64 %"tmp#20##0") + %"tmp#27##0" = insertvalue {i64, i64} undef, i64 %"p1##0", 0 + %"tmp#28##0" = insertvalue {i64, i64} %"tmp#27##0", i64 %"tmp#20##0", 1 + ret {i64, i64} %"tmp#28##0" +if.else.0: + %"tmp#3##0" = add i64 %"tmp#0##0", 1 + %"tmp#29##0" = inttoptr i64 %"p1##0" to ptr + store i64 %"tmp#3##0", ptr %"tmp#29##0" + %"tmp#30##0" = tail call fastcc i64 @"alias_mbar.bar<0>[410bae77d3]"(i64 %"p1##0") + %"tmp#31##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#16##0" = ptrtoint ptr %"tmp#31##0" to i64 + %"tmp#32##0" = inttoptr i64 %"tmp#16##0" to ptr + store i64 2, ptr %"tmp#32##0" + %"tmp#33##0" = add i64 %"tmp#16##0", 8 + %"tmp#34##0" = inttoptr i64 %"tmp#33##0" to ptr + store i64 2, ptr %"tmp#34##0" + %"tmp#35##0" = insertvalue {i64, i64} undef, i64 %"tmp#16##0", 0 + %"tmp#36##0" = insertvalue {i64, i64} %"tmp#35##0", i64 %"tmp#30##0", 1 + ret {i64, i64} %"tmp#36##0" } + -------------------------------------------------- Module position representation : (not a type) @@ -319,63 +292,42 @@ printPosition(pos##0:position.position)<{<>}; {<>}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'position' - - - - -@position.3 = constant {i64, i64} { i64 1, i64 ptrtoint ([?? x i8]* @position.2 to i64) } - - -@position.5 = constant {i64, i64} { i64 1, i64 ptrtoint ([?? x i8]* @position.4 to i64) } - - -@position.1 = constant {i64, i64} { i64 2, i64 ptrtoint ([?? x i8]* @position.0 to i64) } - - -@position.0 = constant [?? x i8] c" (\00" - - -@position.4 = constant [?? x i8] c")\00" - - -@position.2 = constant [?? x i8] c",\00" - - -declare external ccc void @putchar(i8) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc void @print_int(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"position.printPosition<0>"(i64 %"pos##0") { -entry: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @position.1, i32 0, i32 0) to i64)) - %0 = inttoptr i64 %"pos##0" to i64* - %1 = load i64, i64* %0 - tail call ccc void @print_int(i64 %1) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @position.3, i32 0, i32 0) to i64)) - %2 = add i64 %"pos##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - tail call ccc void @print_int(i64 %4) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @position.5, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - ret void +source_filename = "!ROOT!/final-dump/position.wybe" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c" (\00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c")\00", align 8 +@"cstring#2" = private unnamed_addr constant [ ?? x i8 ] c",\00", align 8 +@"string#3" = private unnamed_addr constant {i64, i64} { i64 2, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +@"string#4" = private unnamed_addr constant {i64, i64} { i64 1, i64 ptrtoint( ptr @"cstring#1" to i64 ) }, align 8 +@"string#5" = private unnamed_addr constant {i64, i64} { i64 1, i64 ptrtoint( ptr @"cstring#2" to i64 ) }, align 8 + +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"position.printPosition<0>"(i64 %"pos##0") { + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#3" to i64 )) + %"tmp#13##0" = inttoptr i64 %"pos##0" to ptr + %"tmp#0##0" = load i64, ptr %"tmp#13##0" + call ccc void @print_int(i64 %"tmp#0##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#5" to i64 )) + %"tmp#14##0" = add i64 %"pos##0", 8 + %"tmp#15##0" = inttoptr i64 %"tmp#14##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#15##0" + call ccc void @print_int(i64 %"tmp#1##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#4" to i64 )) + call ccc void @putchar(i8 10) + ret void } + -------------------------------------------------- Module position.position - representation : address + representation : pointer public submods : public resources: public procs : position.position.=<0> @@ -477,134 +429,110 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'position.position' - - - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i1 @"position.position.=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %"#right##0" to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = icmp eq i64 %1, %6 - br i1 %10, label %if.then, label %if.else -if.then: - %11 = icmp eq i64 %4, %9 - ret i1 %11 -if.else: - ret i1 0 +source_filename = "!ROOT!/final-dump/position.wybe" +target triple ???? + + +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc i1 @"position.position.=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#9##0" = inttoptr i64 %"#left##0" to ptr + %"#left#x##0" = load i64, ptr %"tmp#9##0" + %"tmp#10##0" = add i64 %"#left##0", 8 + %"tmp#11##0" = inttoptr i64 %"tmp#10##0" to ptr + %"#left#y##0" = load i64, ptr %"tmp#11##0" + %"tmp#12##0" = inttoptr i64 %"#right##0" to ptr + %"#right#x##0" = load i64, ptr %"tmp#12##0" + %"tmp#13##0" = add i64 %"#right##0", 8 + %"tmp#14##0" = inttoptr i64 %"tmp#13##0" to ptr + %"#right#y##0" = load i64, ptr %"tmp#14##0" + %"tmp#1##0" = icmp eq i64 %"#left#x##0", %"#right#x##0" + br i1 %"tmp#1##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#15##0" = icmp eq i64 %"#left#y##0", %"#right#y##0" + ret i1 %"tmp#15##0" +if.else.0: + ret i1 0 } - -define external fastcc i64 @"position.position.position<0>"(i64 %"x##0", i64 %"y##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"x##0", i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"y##0", i64* %5 - ret i64 %2 +define external fastcc i64 @"position.position.position<0>"(i64 %"x##0", i64 %"y##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 16) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"x##0", ptr %"tmp#1##0" + %"tmp#2##0" = add i64 %"#rec##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"y##0", ptr %"tmp#3##0" + ret i64 %"#rec##0" } - -define external fastcc {i64, i64} @"position.position.position<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#result##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#result##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = insertvalue {i64, i64} undef, i64 %1, 0 - %6 = insertvalue {i64, i64} %5, i64 %4, 1 - ret {i64, i64} %6 +define external fastcc {i64, i64} @"position.position.position<1>"(i64 %"#result##0") { + %"tmp#0##0" = inttoptr i64 %"#result##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + %"tmp#2##0" = add i64 %"#result##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#3##0" + %"tmp#5##0" = insertvalue {i64, i64} undef, i64 %"tmp#1##0", 0 + %"tmp#6##0" = insertvalue {i64, i64} %"tmp#5##0", i64 %"tmp#4##0", 1 + ret {i64, i64} %"tmp#6##0" } - -define external fastcc i64 @"position.position.x<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#rec##0" to i64* - %1 = load i64, i64* %0 - ret i64 %1 +define external fastcc i64 @"position.position.x<0>"(i64 %"#rec##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + ret i64 %"tmp#1##0" } - -define external fastcc i64 @"position.position.x<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = inttoptr i64 %2 to i64* - store i64 %"#field##0", i64* %6 - ret i64 %2 +define external fastcc i64 @"position.position.x<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"#field##0", ptr %"tmp#3##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"position.position.y<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = add i64 %"#rec##0", 8 - %1 = inttoptr i64 %0 to i64* - %2 = load i64, i64* %1 - ret i64 %2 +define external fastcc i64 @"position.position.y<0>"(i64 %"#rec##0") { + %"tmp#0##0" = add i64 %"#rec##0", 8 + %"tmp#1##0" = inttoptr i64 %"tmp#0##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"position.position.y<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = add i64 %2, 8 - %7 = inttoptr i64 %6 to i64* - store i64 %"#field##0", i64* %7 - ret i64 %2 +define external fastcc i64 @"position.position.y<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = add i64 %"tmp#2##0", 8 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 %"#field##0", ptr %"tmp#4##0" + ret i64 %"tmp#2##0" } - -define external fastcc i1 @"position.position.~=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %"#right##0" to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = icmp eq i64 %1, %6 - br i1 %10, label %if.then, label %if.else -if.then: - %11 = icmp eq i64 %4, %9 - %12 = xor i1 %11, 1 - ret i1 %12 -if.else: - %13 = xor i1 0, 1 - ret i1 %13 +define external fastcc i1 @"position.position.~=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#8##0" = inttoptr i64 %"#left##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#8##0" + %"tmp#9##0" = add i64 %"#left##0", 8 + %"tmp#10##0" = inttoptr i64 %"tmp#9##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#10##0" + %"tmp#11##0" = inttoptr i64 %"#right##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#11##0" + %"tmp#12##0" = add i64 %"#right##0", 8 + %"tmp#13##0" = inttoptr i64 %"tmp#12##0" to ptr + %"tmp#6##0" = load i64, ptr %"tmp#13##0" + %"tmp#7##0" = icmp eq i64 %"tmp#3##0", %"tmp#5##0" + br i1 %"tmp#7##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#0##0" = icmp eq i64 %"tmp#4##0", %"tmp#6##0" + %"tmp#14##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#14##0" +if.else.0: + %"tmp#15##0" = xor i1 0, 1 + ret i1 %"tmp#15##0" } diff --git a/test-cases/final-dump/alias_mfoo.exp b/test-cases/final-dump/alias_mfoo.exp index bca19e239..9014dabd9 100644 --- a/test-cases/final-dump/alias_mfoo.exp +++ b/test-cases/final-dump/alias_mfoo.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module alias_mbar representation : (not a type) public submods : @@ -43,68 +46,59 @@ bar(p1##0:position.position, ?p3##1:position.position)<{<>}; {<[410bae77d3]"(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i64 @"alias_mbar.bar<0>"(i64 %"p1##0") { -entry: - %0 = add i64 %"p1##0", 8 - %1 = inttoptr i64 %0 to i64* - %2 = load i64, i64* %1 - %3 = icmp sgt i64 %2, 1 - br i1 %3, label %if.then, label %if.else -if.then: - ret i64 %"p1##0" -if.else: - %4 = add i64 %2, 1 - %5 = trunc i64 16 to i32 - %6 = tail call ccc i8* @wybe_malloc(i32 %5) - %7 = ptrtoint i8* %6 to i64 - %8 = inttoptr i64 %7 to i8* - %9 = inttoptr i64 %"p1##0" to i8* - %10 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %8, i8* %9, i32 %10, i1 0) - %11 = add i64 %7, 8 - %12 = inttoptr i64 %11 to i64* - store i64 %4, i64* %12 - %13 = tail call fastcc {i64, i64} @"alias_mfoo.foo<0>[410bae77d3]"(i64 %7) - %14 = extractvalue {i64, i64} %13, 0 - %15 = extractvalue {i64, i64} %13, 1 - ret i64 %15 +source_filename = "!ROOT!/final-dump/alias_mbar.wybe" +target triple ???? + + +declare external fastcc {i64, i64} @"alias_mfoo.foo<0>[410bae77d3]"(i64) +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc i64 @"alias_mbar.bar<0>"(i64 %"p1##0") { + %"tmp#12##0" = add i64 %"p1##0", 8 + %"tmp#13##0" = inttoptr i64 %"tmp#12##0" to ptr + %"tmp#0##0" = load i64, ptr %"tmp#13##0" + %"tmp#3##0" = icmp sgt i64 %"tmp#0##0", 1 + br i1 %"tmp#3##0", label %if.then.0, label %if.else.0 +if.then.0: + ret i64 %"p1##0" +if.else.0: + %"tmp#2##0" = add i64 %"tmp#0##0", 1 + %"tmp#14##0" = inttoptr i64 %"p1##0" to ptr + %"tmp#15##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#15##0", ptr %"tmp#14##0", i64 16, i1 0) + %"tmp#16##0" = ptrtoint ptr %"tmp#15##0" to i64 + %"tmp#17##0" = add i64 %"tmp#16##0", 8 + %"tmp#18##0" = inttoptr i64 %"tmp#17##0" to ptr + store i64 %"tmp#2##0", ptr %"tmp#18##0" + %"tmp#19##0" = tail call fastcc {i64, i64} @"alias_mfoo.foo<0>[410bae77d3]"(i64 %"tmp#16##0") + %"p2##0" = extractvalue {i64, i64}%"tmp#19##0", 0 + %"tmp#20##0" = extractvalue {i64, i64}%"tmp#19##0", 1 + ret i64 %"tmp#20##0" } - -define external fastcc i64 @"alias_mbar.bar<0>[410bae77d3]"(i64 %"p1##0") { -entry: - %0 = add i64 %"p1##0", 8 - %1 = inttoptr i64 %0 to i64* - %2 = load i64, i64* %1 - %3 = icmp sgt i64 %2, 1 - br i1 %3, label %if.then, label %if.else -if.then: - ret i64 %"p1##0" -if.else: - %4 = add i64 %2, 1 - %5 = add i64 %"p1##0", 8 - %6 = inttoptr i64 %5 to i64* - store i64 %4, i64* %6 - %7 = tail call fastcc {i64, i64} @"alias_mfoo.foo<0>[410bae77d3]"(i64 %"p1##0") - %8 = extractvalue {i64, i64} %7, 0 - %9 = extractvalue {i64, i64} %7, 1 - ret i64 %9 +define external fastcc i64 @"alias_mbar.bar<0>[410bae77d3]"(i64 %"p1##0") { + %"tmp#12##0" = add i64 %"p1##0", 8 + %"tmp#13##0" = inttoptr i64 %"tmp#12##0" to ptr + %"tmp#0##0" = load i64, ptr %"tmp#13##0" + %"tmp#3##0" = icmp sgt i64 %"tmp#0##0", 1 + br i1 %"tmp#3##0", label %if.then.0, label %if.else.0 +if.then.0: + ret i64 %"p1##0" +if.else.0: + %"tmp#2##0" = add i64 %"tmp#0##0", 1 + %"tmp#14##0" = add i64 %"p1##0", 8 + %"tmp#15##0" = inttoptr i64 %"tmp#14##0" to ptr + store i64 %"tmp#2##0", ptr %"tmp#15##0" + %"tmp#16##0" = tail call fastcc {i64, i64} @"alias_mfoo.foo<0>[410bae77d3]"(i64 %"p1##0") + %"p2##0" = extractvalue {i64, i64}%"tmp#16##0", 0 + %"tmp#17##0" = extractvalue {i64, i64}%"tmp#16##0", 1 + ret i64 %"tmp#17##0" } + -------------------------------------------------- Module alias_mfoo representation : (not a type) @@ -167,116 +161,95 @@ foo(p1##0:position.position, ?p2##0:position.position, ?p3##0:position.position) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'alias_mfoo' - - - - -@alias_mfoo.1 = constant {i64, i64} { i64 3, i64 ptrtoint ([?? x i8]* @alias_mfoo.0 to i64) } - - -@alias_mfoo.0 = constant [?? x i8] c"p3:\00" - - -declare external fastcc i64 @"alias_mbar.bar<0>[410bae77d3]"(i64) - - -declare external fastcc void @"position.printPosition<0>"(i64) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc {i64, i64} @"alias_mfoo.foo<0>"(i64 %"p1##0") { -entry: - %0 = inttoptr i64 %"p1##0" to i64* - %1 = load i64, i64* %0 - %2 = icmp sgt i64 %1, 1 - br i1 %2, label %if.then, label %if.else -if.then: - %3 = trunc i64 16 to i32 - %4 = tail call ccc i8* @wybe_malloc(i32 %3) - %5 = ptrtoint i8* %4 to i64 - %6 = inttoptr i64 %5 to i64* - store i64 3, i64* %6 - %7 = add i64 %5, 8 - %8 = inttoptr i64 %7 to i64* - store i64 3, i64* %8 - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_mfoo.1, i32 0, i32 0) to i64)) - tail call fastcc void @"position.printPosition<0>"(i64 %5) - %9 = insertvalue {i64, i64} undef, i64 %"p1##0", 0 - %10 = insertvalue {i64, i64} %9, i64 %5, 1 - ret {i64, i64} %10 -if.else: - %11 = add i64 %1, 1 - %12 = trunc i64 16 to i32 - %13 = tail call ccc i8* @wybe_malloc(i32 %12) - %14 = ptrtoint i8* %13 to i64 - %15 = inttoptr i64 %14 to i8* - %16 = inttoptr i64 %"p1##0" to i8* - %17 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %15, i8* %16, i32 %17, i1 0) - %18 = inttoptr i64 %14 to i64* - store i64 %11, i64* %18 - %19 = tail call fastcc i64 @"alias_mbar.bar<0>[410bae77d3]"(i64 %14) - %20 = trunc i64 16 to i32 - %21 = tail call ccc i8* @wybe_malloc(i32 %20) - %22 = ptrtoint i8* %21 to i64 - %23 = inttoptr i64 %22 to i64* - store i64 2, i64* %23 - %24 = add i64 %22, 8 - %25 = inttoptr i64 %24 to i64* - store i64 2, i64* %25 - %26 = insertvalue {i64, i64} undef, i64 %22, 0 - %27 = insertvalue {i64, i64} %26, i64 %19, 1 - ret {i64, i64} %27 +source_filename = "!ROOT!/final-dump/alias_mfoo.wybe" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c"p3:\00", align 8 +@"string#1" = private unnamed_addr constant {i64, i64} { i64 3, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 + +declare external fastcc i64 @"alias_mbar.bar<0>[410bae77d3]"(i64) +declare external fastcc void @"position.printPosition<0>"(i64) +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc {i64, i64} @"alias_mfoo.foo<0>"(i64 %"p1##0") { + %"tmp#22##0" = inttoptr i64 %"p1##0" to ptr + %"tmp#0##0" = load i64, ptr %"tmp#22##0" + %"tmp#5##0" = icmp sgt i64 %"tmp#0##0", 1 + br i1 %"tmp#5##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#23##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#20##0" = ptrtoint ptr %"tmp#23##0" to i64 + %"tmp#24##0" = inttoptr i64 %"tmp#20##0" to ptr + store i64 3, ptr %"tmp#24##0" + %"tmp#25##0" = add i64 %"tmp#20##0", 8 + %"tmp#26##0" = inttoptr i64 %"tmp#25##0" to ptr + store i64 3, ptr %"tmp#26##0" + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#1" to i64 )) + tail call fastcc void @"position.printPosition<0>"(i64 %"tmp#20##0") + %"tmp#27##0" = insertvalue {i64, i64} undef, i64 %"p1##0", 0 + %"tmp#28##0" = insertvalue {i64, i64} %"tmp#27##0", i64 %"tmp#20##0", 1 + ret {i64, i64} %"tmp#28##0" +if.else.0: + %"tmp#3##0" = add i64 %"tmp#0##0", 1 + %"tmp#29##0" = inttoptr i64 %"p1##0" to ptr + %"tmp#30##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#30##0", ptr %"tmp#29##0", i64 16, i1 0) + %"tmp#31##0" = ptrtoint ptr %"tmp#30##0" to i64 + %"tmp#32##0" = inttoptr i64 %"tmp#31##0" to ptr + store i64 %"tmp#3##0", ptr %"tmp#32##0" + %"tmp#33##0" = tail call fastcc i64 @"alias_mbar.bar<0>[410bae77d3]"(i64 %"tmp#31##0") + %"tmp#34##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#16##0" = ptrtoint ptr %"tmp#34##0" to i64 + %"tmp#35##0" = inttoptr i64 %"tmp#16##0" to ptr + store i64 2, ptr %"tmp#35##0" + %"tmp#36##0" = add i64 %"tmp#16##0", 8 + %"tmp#37##0" = inttoptr i64 %"tmp#36##0" to ptr + store i64 2, ptr %"tmp#37##0" + %"tmp#38##0" = insertvalue {i64, i64} undef, i64 %"tmp#16##0", 0 + %"tmp#39##0" = insertvalue {i64, i64} %"tmp#38##0", i64 %"tmp#33##0", 1 + ret {i64, i64} %"tmp#39##0" } - -define external fastcc {i64, i64} @"alias_mfoo.foo<0>[410bae77d3]"(i64 %"p1##0") { -entry: - %0 = inttoptr i64 %"p1##0" to i64* - %1 = load i64, i64* %0 - %2 = icmp sgt i64 %1, 1 - br i1 %2, label %if.then, label %if.else -if.then: - %3 = trunc i64 16 to i32 - %4 = tail call ccc i8* @wybe_malloc(i32 %3) - %5 = ptrtoint i8* %4 to i64 - %6 = inttoptr i64 %5 to i64* - store i64 3, i64* %6 - %7 = add i64 %5, 8 - %8 = inttoptr i64 %7 to i64* - store i64 3, i64* %8 - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_mfoo.1, i32 0, i32 0) to i64)) - tail call fastcc void @"position.printPosition<0>"(i64 %5) - %9 = insertvalue {i64, i64} undef, i64 %"p1##0", 0 - %10 = insertvalue {i64, i64} %9, i64 %5, 1 - ret {i64, i64} %10 -if.else: - %11 = add i64 %1, 1 - %12 = inttoptr i64 %"p1##0" to i64* - store i64 %11, i64* %12 - %13 = tail call fastcc i64 @"alias_mbar.bar<0>[410bae77d3]"(i64 %"p1##0") - %14 = trunc i64 16 to i32 - %15 = tail call ccc i8* @wybe_malloc(i32 %14) - %16 = ptrtoint i8* %15 to i64 - %17 = inttoptr i64 %16 to i64* - store i64 2, i64* %17 - %18 = add i64 %16, 8 - %19 = inttoptr i64 %18 to i64* - store i64 2, i64* %19 - %20 = insertvalue {i64, i64} undef, i64 %16, 0 - %21 = insertvalue {i64, i64} %20, i64 %13, 1 - ret {i64, i64} %21 +define external fastcc {i64, i64} @"alias_mfoo.foo<0>[410bae77d3]"(i64 %"p1##0") { + %"tmp#22##0" = inttoptr i64 %"p1##0" to ptr + %"tmp#0##0" = load i64, ptr %"tmp#22##0" + %"tmp#5##0" = icmp sgt i64 %"tmp#0##0", 1 + br i1 %"tmp#5##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#23##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#20##0" = ptrtoint ptr %"tmp#23##0" to i64 + %"tmp#24##0" = inttoptr i64 %"tmp#20##0" to ptr + store i64 3, ptr %"tmp#24##0" + %"tmp#25##0" = add i64 %"tmp#20##0", 8 + %"tmp#26##0" = inttoptr i64 %"tmp#25##0" to ptr + store i64 3, ptr %"tmp#26##0" + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#1" to i64 )) + tail call fastcc void @"position.printPosition<0>"(i64 %"tmp#20##0") + %"tmp#27##0" = insertvalue {i64, i64} undef, i64 %"p1##0", 0 + %"tmp#28##0" = insertvalue {i64, i64} %"tmp#27##0", i64 %"tmp#20##0", 1 + ret {i64, i64} %"tmp#28##0" +if.else.0: + %"tmp#3##0" = add i64 %"tmp#0##0", 1 + %"tmp#29##0" = inttoptr i64 %"p1##0" to ptr + store i64 %"tmp#3##0", ptr %"tmp#29##0" + %"tmp#30##0" = tail call fastcc i64 @"alias_mbar.bar<0>[410bae77d3]"(i64 %"p1##0") + %"tmp#31##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#16##0" = ptrtoint ptr %"tmp#31##0" to i64 + %"tmp#32##0" = inttoptr i64 %"tmp#16##0" to ptr + store i64 2, ptr %"tmp#32##0" + %"tmp#33##0" = add i64 %"tmp#16##0", 8 + %"tmp#34##0" = inttoptr i64 %"tmp#33##0" to ptr + store i64 2, ptr %"tmp#34##0" + %"tmp#35##0" = insertvalue {i64, i64} undef, i64 %"tmp#16##0", 0 + %"tmp#36##0" = insertvalue {i64, i64} %"tmp#35##0", i64 %"tmp#30##0", 1 + ret {i64, i64} %"tmp#36##0" } + -------------------------------------------------- Module position representation : (not a type) @@ -319,63 +292,42 @@ printPosition(pos##0:position.position)<{<>}; {<>}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'position' - - - - -@position.3 = constant {i64, i64} { i64 1, i64 ptrtoint ([?? x i8]* @position.2 to i64) } - - -@position.5 = constant {i64, i64} { i64 1, i64 ptrtoint ([?? x i8]* @position.4 to i64) } - - -@position.1 = constant {i64, i64} { i64 2, i64 ptrtoint ([?? x i8]* @position.0 to i64) } - - -@position.0 = constant [?? x i8] c" (\00" - - -@position.4 = constant [?? x i8] c")\00" - - -@position.2 = constant [?? x i8] c",\00" - - -declare external ccc void @putchar(i8) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc void @print_int(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"position.printPosition<0>"(i64 %"pos##0") { -entry: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @position.1, i32 0, i32 0) to i64)) - %0 = inttoptr i64 %"pos##0" to i64* - %1 = load i64, i64* %0 - tail call ccc void @print_int(i64 %1) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @position.3, i32 0, i32 0) to i64)) - %2 = add i64 %"pos##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - tail call ccc void @print_int(i64 %4) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @position.5, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - ret void +source_filename = "!ROOT!/final-dump/position.wybe" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c" (\00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c")\00", align 8 +@"cstring#2" = private unnamed_addr constant [ ?? x i8 ] c",\00", align 8 +@"string#3" = private unnamed_addr constant {i64, i64} { i64 2, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +@"string#4" = private unnamed_addr constant {i64, i64} { i64 1, i64 ptrtoint( ptr @"cstring#1" to i64 ) }, align 8 +@"string#5" = private unnamed_addr constant {i64, i64} { i64 1, i64 ptrtoint( ptr @"cstring#2" to i64 ) }, align 8 + +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"position.printPosition<0>"(i64 %"pos##0") { + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#3" to i64 )) + %"tmp#13##0" = inttoptr i64 %"pos##0" to ptr + %"tmp#0##0" = load i64, ptr %"tmp#13##0" + call ccc void @print_int(i64 %"tmp#0##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#5" to i64 )) + %"tmp#14##0" = add i64 %"pos##0", 8 + %"tmp#15##0" = inttoptr i64 %"tmp#14##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#15##0" + call ccc void @print_int(i64 %"tmp#1##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#4" to i64 )) + call ccc void @putchar(i8 10) + ret void } + -------------------------------------------------- Module position.position - representation : address + representation : pointer public submods : public resources: public procs : position.position.=<0> @@ -477,134 +429,110 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'position.position' - - - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i1 @"position.position.=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %"#right##0" to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = icmp eq i64 %1, %6 - br i1 %10, label %if.then, label %if.else -if.then: - %11 = icmp eq i64 %4, %9 - ret i1 %11 -if.else: - ret i1 0 +source_filename = "!ROOT!/final-dump/position.wybe" +target triple ???? + + +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc i1 @"position.position.=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#9##0" = inttoptr i64 %"#left##0" to ptr + %"#left#x##0" = load i64, ptr %"tmp#9##0" + %"tmp#10##0" = add i64 %"#left##0", 8 + %"tmp#11##0" = inttoptr i64 %"tmp#10##0" to ptr + %"#left#y##0" = load i64, ptr %"tmp#11##0" + %"tmp#12##0" = inttoptr i64 %"#right##0" to ptr + %"#right#x##0" = load i64, ptr %"tmp#12##0" + %"tmp#13##0" = add i64 %"#right##0", 8 + %"tmp#14##0" = inttoptr i64 %"tmp#13##0" to ptr + %"#right#y##0" = load i64, ptr %"tmp#14##0" + %"tmp#1##0" = icmp eq i64 %"#left#x##0", %"#right#x##0" + br i1 %"tmp#1##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#15##0" = icmp eq i64 %"#left#y##0", %"#right#y##0" + ret i1 %"tmp#15##0" +if.else.0: + ret i1 0 } - -define external fastcc i64 @"position.position.position<0>"(i64 %"x##0", i64 %"y##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"x##0", i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"y##0", i64* %5 - ret i64 %2 +define external fastcc i64 @"position.position.position<0>"(i64 %"x##0", i64 %"y##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 16) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"x##0", ptr %"tmp#1##0" + %"tmp#2##0" = add i64 %"#rec##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"y##0", ptr %"tmp#3##0" + ret i64 %"#rec##0" } - -define external fastcc {i64, i64} @"position.position.position<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#result##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#result##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = insertvalue {i64, i64} undef, i64 %1, 0 - %6 = insertvalue {i64, i64} %5, i64 %4, 1 - ret {i64, i64} %6 +define external fastcc {i64, i64} @"position.position.position<1>"(i64 %"#result##0") { + %"tmp#0##0" = inttoptr i64 %"#result##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + %"tmp#2##0" = add i64 %"#result##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#3##0" + %"tmp#5##0" = insertvalue {i64, i64} undef, i64 %"tmp#1##0", 0 + %"tmp#6##0" = insertvalue {i64, i64} %"tmp#5##0", i64 %"tmp#4##0", 1 + ret {i64, i64} %"tmp#6##0" } - -define external fastcc i64 @"position.position.x<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#rec##0" to i64* - %1 = load i64, i64* %0 - ret i64 %1 +define external fastcc i64 @"position.position.x<0>"(i64 %"#rec##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + ret i64 %"tmp#1##0" } - -define external fastcc i64 @"position.position.x<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = inttoptr i64 %2 to i64* - store i64 %"#field##0", i64* %6 - ret i64 %2 +define external fastcc i64 @"position.position.x<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"#field##0", ptr %"tmp#3##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"position.position.y<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = add i64 %"#rec##0", 8 - %1 = inttoptr i64 %0 to i64* - %2 = load i64, i64* %1 - ret i64 %2 +define external fastcc i64 @"position.position.y<0>"(i64 %"#rec##0") { + %"tmp#0##0" = add i64 %"#rec##0", 8 + %"tmp#1##0" = inttoptr i64 %"tmp#0##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"position.position.y<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = add i64 %2, 8 - %7 = inttoptr i64 %6 to i64* - store i64 %"#field##0", i64* %7 - ret i64 %2 +define external fastcc i64 @"position.position.y<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = add i64 %"tmp#2##0", 8 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 %"#field##0", ptr %"tmp#4##0" + ret i64 %"tmp#2##0" } - -define external fastcc i1 @"position.position.~=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %"#right##0" to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = icmp eq i64 %1, %6 - br i1 %10, label %if.then, label %if.else -if.then: - %11 = icmp eq i64 %4, %9 - %12 = xor i1 %11, 1 - ret i1 %12 -if.else: - %13 = xor i1 0, 1 - ret i1 %13 +define external fastcc i1 @"position.position.~=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#8##0" = inttoptr i64 %"#left##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#8##0" + %"tmp#9##0" = add i64 %"#left##0", 8 + %"tmp#10##0" = inttoptr i64 %"tmp#9##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#10##0" + %"tmp#11##0" = inttoptr i64 %"#right##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#11##0" + %"tmp#12##0" = add i64 %"#right##0", 8 + %"tmp#13##0" = inttoptr i64 %"tmp#12##0" to ptr + %"tmp#6##0" = load i64, ptr %"tmp#13##0" + %"tmp#7##0" = icmp eq i64 %"tmp#3##0", %"tmp#5##0" + br i1 %"tmp#7##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#0##0" = icmp eq i64 %"tmp#4##0", %"tmp#6##0" + %"tmp#14##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#14##0" +if.else.0: + %"tmp#15##0" = xor i1 0, 1 + ret i1 %"tmp#15##0" } diff --git a/test-cases/final-dump/alias_mod_param.exp b/test-cases/final-dump/alias_mod_param.exp index db9fa44c4..5e899e2c9 100644 --- a/test-cases/final-dump/alias_mod_param.exp +++ b/test-cases/final-dump/alias_mod_param.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module alias_mod_param representation : (not a type) public submods : @@ -35,68 +38,48 @@ foo(pa##0:position.position)<{<>}; {<>}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'alias_mod_param' - - - - -@alias_mod_param.1 = constant {i64, i64} { i64 17, i64 ptrtoint ([?? x i8]* @alias_mod_param.0 to i64) } - - -@alias_mod_param.3 = constant {i64, i64} { i64 19, i64 ptrtoint ([?? x i8]* @alias_mod_param.2 to i64) } - - -@alias_mod_param.0 = constant [?? x i8] c"expect p1(10,10):\00" - - -@alias_mod_param.2 = constant [?? x i8] c"expect pa(1111,10):\00" - - -declare external fastcc void @"position.printPosition<0>"(i64) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"alias_mod_param.<0>"() { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 10, i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 10, i64* %5 - tail call fastcc void @"alias_mod_param.foo<0>"(i64 %2) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_mod_param.1, i32 0, i32 0) to i64)) - tail call fastcc void @"position.printPosition<0>"(i64 %2) - ret void +source_filename = "!ROOT!/final-dump/alias_mod_param.wybe" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c"expect p1(10,10):\00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c"expect pa(1111,10):\00", align 8 +@"string#2" = private unnamed_addr constant {i64, i64} { i64 17, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +@"string#3" = private unnamed_addr constant {i64, i64} { i64 19, i64 ptrtoint( ptr @"cstring#1" to i64 ) }, align 8 + +declare external fastcc void @"position.printPosition<0>"(i64) +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"alias_mod_param.<0>"() { + %"tmp#5##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#3##0" = ptrtoint ptr %"tmp#5##0" to i64 + %"tmp#6##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 10, ptr %"tmp#6##0" + %"tmp#7##0" = add i64 %"tmp#3##0", 8 + %"tmp#8##0" = inttoptr i64 %"tmp#7##0" to ptr + store i64 10, ptr %"tmp#8##0" + tail call fastcc void @"alias_mod_param.foo<0>"(i64 %"tmp#3##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#2" to i64 )) + tail call fastcc void @"position.printPosition<0>"(i64 %"tmp#3##0") + ret void } - -define external fastcc void @"alias_mod_param.foo<0>"(i64 %"pa##0") { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"pa##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = inttoptr i64 %2 to i64* - store i64 1111, i64* %6 - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_mod_param.3, i32 0, i32 0) to i64)) - musttail call fastcc void @"position.printPosition<0>"(i64 %2) - ret void +define external fastcc void @"alias_mod_param.foo<0>"(i64 %"pa##0") { + %"tmp#2##0" = inttoptr i64 %"pa##0" to ptr + %"tmp#3##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#3##0", ptr %"tmp#2##0", i64 16, i1 0) + %"tmp#4##0" = ptrtoint ptr %"tmp#3##0" to i64 + %"tmp#5##0" = inttoptr i64 %"tmp#4##0" to ptr + store i64 1111, ptr %"tmp#5##0" + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#3" to i64 )) + tail call fastcc void @"position.printPosition<0>"(i64 %"tmp#4##0") + ret void } + -------------------------------------------------- Module position representation : (not a type) @@ -139,63 +122,42 @@ printPosition(pos##0:position.position)<{<>}; {<>}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'position' - - - - -@position.3 = constant {i64, i64} { i64 1, i64 ptrtoint ([?? x i8]* @position.2 to i64) } - - -@position.5 = constant {i64, i64} { i64 1, i64 ptrtoint ([?? x i8]* @position.4 to i64) } - - -@position.1 = constant {i64, i64} { i64 2, i64 ptrtoint ([?? x i8]* @position.0 to i64) } - - -@position.0 = constant [?? x i8] c" (\00" - - -@position.4 = constant [?? x i8] c")\00" - - -@position.2 = constant [?? x i8] c",\00" - - -declare external ccc void @putchar(i8) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc void @print_int(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"position.printPosition<0>"(i64 %"pos##0") { -entry: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @position.1, i32 0, i32 0) to i64)) - %0 = inttoptr i64 %"pos##0" to i64* - %1 = load i64, i64* %0 - tail call ccc void @print_int(i64 %1) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @position.3, i32 0, i32 0) to i64)) - %2 = add i64 %"pos##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - tail call ccc void @print_int(i64 %4) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @position.5, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - ret void +source_filename = "!ROOT!/final-dump/position.wybe" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c" (\00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c")\00", align 8 +@"cstring#2" = private unnamed_addr constant [ ?? x i8 ] c",\00", align 8 +@"string#3" = private unnamed_addr constant {i64, i64} { i64 2, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +@"string#4" = private unnamed_addr constant {i64, i64} { i64 1, i64 ptrtoint( ptr @"cstring#1" to i64 ) }, align 8 +@"string#5" = private unnamed_addr constant {i64, i64} { i64 1, i64 ptrtoint( ptr @"cstring#2" to i64 ) }, align 8 + +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"position.printPosition<0>"(i64 %"pos##0") { + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#3" to i64 )) + %"tmp#13##0" = inttoptr i64 %"pos##0" to ptr + %"tmp#0##0" = load i64, ptr %"tmp#13##0" + call ccc void @print_int(i64 %"tmp#0##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#5" to i64 )) + %"tmp#14##0" = add i64 %"pos##0", 8 + %"tmp#15##0" = inttoptr i64 %"tmp#14##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#15##0" + call ccc void @print_int(i64 %"tmp#1##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#4" to i64 )) + call ccc void @putchar(i8 10) + ret void } + -------------------------------------------------- Module position.position - representation : address + representation : pointer public submods : public resources: public procs : position.position.=<0> @@ -297,134 +259,110 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'position.position' - - - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i1 @"position.position.=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %"#right##0" to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = icmp eq i64 %1, %6 - br i1 %10, label %if.then, label %if.else -if.then: - %11 = icmp eq i64 %4, %9 - ret i1 %11 -if.else: - ret i1 0 +source_filename = "!ROOT!/final-dump/position.wybe" +target triple ???? + + +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc i1 @"position.position.=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#9##0" = inttoptr i64 %"#left##0" to ptr + %"#left#x##0" = load i64, ptr %"tmp#9##0" + %"tmp#10##0" = add i64 %"#left##0", 8 + %"tmp#11##0" = inttoptr i64 %"tmp#10##0" to ptr + %"#left#y##0" = load i64, ptr %"tmp#11##0" + %"tmp#12##0" = inttoptr i64 %"#right##0" to ptr + %"#right#x##0" = load i64, ptr %"tmp#12##0" + %"tmp#13##0" = add i64 %"#right##0", 8 + %"tmp#14##0" = inttoptr i64 %"tmp#13##0" to ptr + %"#right#y##0" = load i64, ptr %"tmp#14##0" + %"tmp#1##0" = icmp eq i64 %"#left#x##0", %"#right#x##0" + br i1 %"tmp#1##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#15##0" = icmp eq i64 %"#left#y##0", %"#right#y##0" + ret i1 %"tmp#15##0" +if.else.0: + ret i1 0 } - -define external fastcc i64 @"position.position.position<0>"(i64 %"x##0", i64 %"y##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"x##0", i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"y##0", i64* %5 - ret i64 %2 +define external fastcc i64 @"position.position.position<0>"(i64 %"x##0", i64 %"y##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 16) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"x##0", ptr %"tmp#1##0" + %"tmp#2##0" = add i64 %"#rec##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"y##0", ptr %"tmp#3##0" + ret i64 %"#rec##0" } - -define external fastcc {i64, i64} @"position.position.position<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#result##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#result##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = insertvalue {i64, i64} undef, i64 %1, 0 - %6 = insertvalue {i64, i64} %5, i64 %4, 1 - ret {i64, i64} %6 +define external fastcc {i64, i64} @"position.position.position<1>"(i64 %"#result##0") { + %"tmp#0##0" = inttoptr i64 %"#result##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + %"tmp#2##0" = add i64 %"#result##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#3##0" + %"tmp#5##0" = insertvalue {i64, i64} undef, i64 %"tmp#1##0", 0 + %"tmp#6##0" = insertvalue {i64, i64} %"tmp#5##0", i64 %"tmp#4##0", 1 + ret {i64, i64} %"tmp#6##0" } - -define external fastcc i64 @"position.position.x<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#rec##0" to i64* - %1 = load i64, i64* %0 - ret i64 %1 +define external fastcc i64 @"position.position.x<0>"(i64 %"#rec##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + ret i64 %"tmp#1##0" } - -define external fastcc i64 @"position.position.x<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = inttoptr i64 %2 to i64* - store i64 %"#field##0", i64* %6 - ret i64 %2 +define external fastcc i64 @"position.position.x<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"#field##0", ptr %"tmp#3##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"position.position.y<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = add i64 %"#rec##0", 8 - %1 = inttoptr i64 %0 to i64* - %2 = load i64, i64* %1 - ret i64 %2 +define external fastcc i64 @"position.position.y<0>"(i64 %"#rec##0") { + %"tmp#0##0" = add i64 %"#rec##0", 8 + %"tmp#1##0" = inttoptr i64 %"tmp#0##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"position.position.y<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = add i64 %2, 8 - %7 = inttoptr i64 %6 to i64* - store i64 %"#field##0", i64* %7 - ret i64 %2 +define external fastcc i64 @"position.position.y<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = add i64 %"tmp#2##0", 8 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 %"#field##0", ptr %"tmp#4##0" + ret i64 %"tmp#2##0" } - -define external fastcc i1 @"position.position.~=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %"#right##0" to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = icmp eq i64 %1, %6 - br i1 %10, label %if.then, label %if.else -if.then: - %11 = icmp eq i64 %4, %9 - %12 = xor i1 %11, 1 - ret i1 %12 -if.else: - %13 = xor i1 0, 1 - ret i1 %13 +define external fastcc i1 @"position.position.~=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#8##0" = inttoptr i64 %"#left##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#8##0" + %"tmp#9##0" = add i64 %"#left##0", 8 + %"tmp#10##0" = inttoptr i64 %"tmp#9##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#10##0" + %"tmp#11##0" = inttoptr i64 %"#right##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#11##0" + %"tmp#12##0" = add i64 %"#right##0", 8 + %"tmp#13##0" = inttoptr i64 %"tmp#12##0" to ptr + %"tmp#6##0" = load i64, ptr %"tmp#13##0" + %"tmp#7##0" = icmp eq i64 %"tmp#3##0", %"tmp#5##0" + br i1 %"tmp#7##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#0##0" = icmp eq i64 %"tmp#4##0", %"tmp#6##0" + %"tmp#14##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#14##0" +if.else.0: + %"tmp#15##0" = xor i1 0, 1 + ret i1 %"tmp#15##0" } diff --git a/test-cases/final-dump/alias_multifunc.exp b/test-cases/final-dump/alias_multifunc.exp index a21adbb72..b3bc329cf 100644 --- a/test-cases/final-dump/alias_multifunc.exp +++ b/test-cases/final-dump/alias_multifunc.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module alias_multifunc representation : (not a type) public submods : @@ -89,166 +92,112 @@ replicate2(p1##0:position.position, ?p2##0:position.position)<{<>}; LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'alias_multifunc' - - - - -@alias_multifunc.13 = constant {i64, i64} { i64 18, i64 ptrtoint ([?? x i8]* @alias_multifunc.12 to i64) } - - -@alias_multifunc.15 = constant {i64, i64} { i64 18, i64 ptrtoint ([?? x i8]* @alias_multifunc.14 to i64) } - - -@alias_multifunc.11 = constant {i64, i64} { i64 19, i64 ptrtoint ([?? x i8]* @alias_multifunc.10 to i64) } - - -@alias_multifunc.3 = constant {i64, i64} { i64 19, i64 ptrtoint ([?? x i8]* @alias_multifunc.2 to i64) } - - -@alias_multifunc.5 = constant {i64, i64} { i64 19, i64 ptrtoint ([?? x i8]* @alias_multifunc.4 to i64) } - - -@alias_multifunc.7 = constant {i64, i64} { i64 19, i64 ptrtoint ([?? x i8]* @alias_multifunc.6 to i64) } - - -@alias_multifunc.1 = constant {i64, i64} { i64 30, i64 ptrtoint ([?? x i8]* @alias_multifunc.0 to i64) } - - -@alias_multifunc.9 = constant {i64, i64} { i64 31, i64 ptrtoint ([?? x i8]* @alias_multifunc.8 to i64) } - - -@alias_multifunc.0 = constant [?? x i8] c"--- After calling replicate1: \00" - - -@alias_multifunc.8 = constant [?? x i8] c"--- After calling x(!p1, 555): \00" - - -@alias_multifunc.2 = constant [?? x i8] c"expect p1(101,102):\00" - - -@alias_multifunc.10 = constant [?? x i8] c"expect p1(555,102):\00" - - -@alias_multifunc.4 = constant [?? x i8] c"expect p2(101,102):\00" - - -@alias_multifunc.6 = constant [?? x i8] c"expect p3(101,102):\00" - - -@alias_multifunc.12 = constant [?? x i8] c"random replicate1 \00" - - -@alias_multifunc.14 = constant [?? x i8] c"random replicate2 \00" - - -declare external ccc void @putchar(i8) - - -declare external ccc void @print_int(i64) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external fastcc void @"position.printPosition<0>"(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"alias_multifunc.<0>"() alwaysinline { -entry: - musttail call fastcc void @"alias_multifunc.bar<0>"() - ret void +source_filename = "!ROOT!/final-dump/alias_multifunc.wybe" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c"--- After calling replicate1: \00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c"--- After calling x(!p1, 555): \00", align 8 +@"cstring#2" = private unnamed_addr constant [ ?? x i8 ] c"expect p1(101,102):\00", align 8 +@"cstring#3" = private unnamed_addr constant [ ?? x i8 ] c"expect p1(555,102):\00", align 8 +@"cstring#4" = private unnamed_addr constant [ ?? x i8 ] c"expect p2(101,102):\00", align 8 +@"cstring#5" = private unnamed_addr constant [ ?? x i8 ] c"expect p3(101,102):\00", align 8 +@"cstring#6" = private unnamed_addr constant [ ?? x i8 ] c"random replicate1 \00", align 8 +@"cstring#7" = private unnamed_addr constant [ ?? x i8 ] c"random replicate2 \00", align 8 +@"string#8" = private unnamed_addr constant {i64, i64} { i64 30, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +@"string#9" = private unnamed_addr constant {i64, i64} { i64 31, i64 ptrtoint( ptr @"cstring#1" to i64 ) }, align 8 +@"string#10" = private unnamed_addr constant {i64, i64} { i64 19, i64 ptrtoint( ptr @"cstring#2" to i64 ) }, align 8 +@"string#11" = private unnamed_addr constant {i64, i64} { i64 19, i64 ptrtoint( ptr @"cstring#3" to i64 ) }, align 8 +@"string#12" = private unnamed_addr constant {i64, i64} { i64 19, i64 ptrtoint( ptr @"cstring#4" to i64 ) }, align 8 +@"string#13" = private unnamed_addr constant {i64, i64} { i64 19, i64 ptrtoint( ptr @"cstring#5" to i64 ) }, align 8 +@"string#14" = private unnamed_addr constant {i64, i64} { i64 18, i64 ptrtoint( ptr @"cstring#6" to i64 ) }, align 8 +@"string#15" = private unnamed_addr constant {i64, i64} { i64 18, i64 ptrtoint( ptr @"cstring#7" to i64 ) }, align 8 + +declare external fastcc void @"position.printPosition<0>"(i64) +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"alias_multifunc.<0>"() { + tail call fastcc void @"alias_multifunc.bar<0>"() + ret void } - -define external fastcc void @"alias_multifunc.bar<0>"() { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 101, i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 102, i64* %5 - %6 = tail call fastcc {i64, i64} @"alias_multifunc.replicate1<0>"(i64 %2) - %7 = extractvalue {i64, i64} %6, 0 - %8 = extractvalue {i64, i64} %6, 1 - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_multifunc.1, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_multifunc.3, i32 0, i32 0) to i64)) - tail call fastcc void @"position.printPosition<0>"(i64 %2) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_multifunc.5, i32 0, i32 0) to i64)) - tail call fastcc void @"position.printPosition<0>"(i64 %7) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_multifunc.7, i32 0, i32 0) to i64)) - tail call fastcc void @"position.printPosition<0>"(i64 %8) - %9 = trunc i64 16 to i32 - %10 = tail call ccc i8* @wybe_malloc(i32 %9) - %11 = ptrtoint i8* %10 to i64 - %12 = inttoptr i64 %11 to i8* - %13 = inttoptr i64 %2 to i8* - %14 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %12, i8* %13, i32 %14, i1 0) - %15 = inttoptr i64 %11 to i64* - store i64 555, i64* %15 - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_multifunc.9, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_multifunc.11, i32 0, i32 0) to i64)) - tail call fastcc void @"position.printPosition<0>"(i64 %11) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_multifunc.5, i32 0, i32 0) to i64)) - tail call fastcc void @"position.printPosition<0>"(i64 %7) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_multifunc.7, i32 0, i32 0) to i64)) - tail call fastcc void @"position.printPosition<0>"(i64 %8) - ret void +define external fastcc void @"alias_multifunc.bar<0>"() { + %"tmp#13##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#3##0" = ptrtoint ptr %"tmp#13##0" to i64 + %"tmp#14##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 101, ptr %"tmp#14##0" + %"tmp#15##0" = add i64 %"tmp#3##0", 8 + %"tmp#16##0" = inttoptr i64 %"tmp#15##0" to ptr + store i64 102, ptr %"tmp#16##0" + %"tmp#17##0" = tail call fastcc {i64, i64} @"alias_multifunc.replicate1<0>"(i64 %"tmp#3##0") + %"p2##0" = extractvalue {i64, i64}%"tmp#17##0", 0 + %"p3##0" = extractvalue {i64, i64}%"tmp#17##0", 1 + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#8" to i64 )) + call ccc void @putchar(i8 10) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#10" to i64 )) + tail call fastcc void @"position.printPosition<0>"(i64 %"tmp#3##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#12" to i64 )) + tail call fastcc void @"position.printPosition<0>"(i64 %"p2##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#13" to i64 )) + tail call fastcc void @"position.printPosition<0>"(i64 %"p3##0") + %"tmp#18##0" = inttoptr i64 %"tmp#3##0" to ptr + %"tmp#19##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#19##0", ptr %"tmp#18##0", i64 16, i1 0) + %"tmp#20##0" = ptrtoint ptr %"tmp#19##0" to i64 + %"tmp#21##0" = inttoptr i64 %"tmp#20##0" to ptr + store i64 555, ptr %"tmp#21##0" + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#9" to i64 )) + call ccc void @putchar(i8 10) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#11" to i64 )) + tail call fastcc void @"position.printPosition<0>"(i64 %"tmp#20##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#12" to i64 )) + tail call fastcc void @"position.printPosition<0>"(i64 %"p2##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#13" to i64 )) + tail call fastcc void @"position.printPosition<0>"(i64 %"p3##0") + ret void } - -define external fastcc {i64, i64} @"alias_multifunc.replicate1<0>"(i64 %"p1##0") { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 0, i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 0, i64* %5 - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_multifunc.13, i32 0, i32 0) to i64)) - %6 = inttoptr i64 %2 to i64* - %7 = load i64, i64* %6 - tail call ccc void @print_int(i64 %7) - tail call ccc void @putchar(i8 10) - %8 = tail call fastcc i64 @"alias_multifunc.replicate2<0>"(i64 %"p1##0") - %9 = insertvalue {i64, i64} undef, i64 %"p1##0", 0 - %10 = insertvalue {i64, i64} %9, i64 %8, 1 - ret {i64, i64} %10 +define external fastcc {i64, i64} @"alias_multifunc.replicate1<0>"(i64 %"p1##0") { + %"tmp#11##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#4##0" = ptrtoint ptr %"tmp#11##0" to i64 + %"tmp#12##0" = inttoptr i64 %"tmp#4##0" to ptr + store i64 0, ptr %"tmp#12##0" + %"tmp#13##0" = add i64 %"tmp#4##0", 8 + %"tmp#14##0" = inttoptr i64 %"tmp#13##0" to ptr + store i64 0, ptr %"tmp#14##0" + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#14" to i64 )) + %"tmp#15##0" = inttoptr i64 %"tmp#4##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#15##0" + call ccc void @print_int(i64 %"tmp#1##0") + call ccc void @putchar(i8 10) + %"tmp#16##0" = tail call fastcc i64 @"alias_multifunc.replicate2<0>"(i64 %"p1##0") + %"tmp#17##0" = insertvalue {i64, i64} undef, i64 %"p1##0", 0 + %"tmp#18##0" = insertvalue {i64, i64} %"tmp#17##0", i64 %"tmp#16##0", 1 + ret {i64, i64} %"tmp#18##0" } - -define external fastcc i64 @"alias_multifunc.replicate2<0>"(i64 %"p1##0") { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 0, i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 0, i64* %5 - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_multifunc.15, i32 0, i32 0) to i64)) - %6 = inttoptr i64 %2 to i64* - %7 = load i64, i64* %6 - tail call ccc void @print_int(i64 %7) - tail call ccc void @putchar(i8 10) - ret i64 %"p1##0" +define external fastcc i64 @"alias_multifunc.replicate2<0>"(i64 %"p1##0") { + %"tmp#11##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#4##0" = ptrtoint ptr %"tmp#11##0" to i64 + %"tmp#12##0" = inttoptr i64 %"tmp#4##0" to ptr + store i64 0, ptr %"tmp#12##0" + %"tmp#13##0" = add i64 %"tmp#4##0", 8 + %"tmp#14##0" = inttoptr i64 %"tmp#13##0" to ptr + store i64 0, ptr %"tmp#14##0" + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#15" to i64 )) + %"tmp#15##0" = inttoptr i64 %"tmp#4##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#15##0" + call ccc void @print_int(i64 %"tmp#1##0") + call ccc void @putchar(i8 10) + ret i64 %"p1##0" } + -------------------------------------------------- Module position representation : (not a type) @@ -291,63 +240,42 @@ printPosition(pos##0:position.position)<{<>}; {<>}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'position' - - - - -@position.3 = constant {i64, i64} { i64 1, i64 ptrtoint ([?? x i8]* @position.2 to i64) } - - -@position.5 = constant {i64, i64} { i64 1, i64 ptrtoint ([?? x i8]* @position.4 to i64) } - - -@position.1 = constant {i64, i64} { i64 2, i64 ptrtoint ([?? x i8]* @position.0 to i64) } - - -@position.0 = constant [?? x i8] c" (\00" - - -@position.4 = constant [?? x i8] c")\00" - - -@position.2 = constant [?? x i8] c",\00" - - -declare external ccc void @putchar(i8) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc void @print_int(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"position.printPosition<0>"(i64 %"pos##0") { -entry: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @position.1, i32 0, i32 0) to i64)) - %0 = inttoptr i64 %"pos##0" to i64* - %1 = load i64, i64* %0 - tail call ccc void @print_int(i64 %1) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @position.3, i32 0, i32 0) to i64)) - %2 = add i64 %"pos##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - tail call ccc void @print_int(i64 %4) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @position.5, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - ret void +source_filename = "!ROOT!/final-dump/position.wybe" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c" (\00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c")\00", align 8 +@"cstring#2" = private unnamed_addr constant [ ?? x i8 ] c",\00", align 8 +@"string#3" = private unnamed_addr constant {i64, i64} { i64 2, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +@"string#4" = private unnamed_addr constant {i64, i64} { i64 1, i64 ptrtoint( ptr @"cstring#1" to i64 ) }, align 8 +@"string#5" = private unnamed_addr constant {i64, i64} { i64 1, i64 ptrtoint( ptr @"cstring#2" to i64 ) }, align 8 + +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"position.printPosition<0>"(i64 %"pos##0") { + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#3" to i64 )) + %"tmp#13##0" = inttoptr i64 %"pos##0" to ptr + %"tmp#0##0" = load i64, ptr %"tmp#13##0" + call ccc void @print_int(i64 %"tmp#0##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#5" to i64 )) + %"tmp#14##0" = add i64 %"pos##0", 8 + %"tmp#15##0" = inttoptr i64 %"tmp#14##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#15##0" + call ccc void @print_int(i64 %"tmp#1##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#4" to i64 )) + call ccc void @putchar(i8 10) + ret void } + -------------------------------------------------- Module position.position - representation : address + representation : pointer public submods : public resources: public procs : position.position.=<0> @@ -449,134 +377,110 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'position.position' - - - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i1 @"position.position.=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %"#right##0" to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = icmp eq i64 %1, %6 - br i1 %10, label %if.then, label %if.else -if.then: - %11 = icmp eq i64 %4, %9 - ret i1 %11 -if.else: - ret i1 0 +source_filename = "!ROOT!/final-dump/position.wybe" +target triple ???? + + +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc i1 @"position.position.=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#9##0" = inttoptr i64 %"#left##0" to ptr + %"#left#x##0" = load i64, ptr %"tmp#9##0" + %"tmp#10##0" = add i64 %"#left##0", 8 + %"tmp#11##0" = inttoptr i64 %"tmp#10##0" to ptr + %"#left#y##0" = load i64, ptr %"tmp#11##0" + %"tmp#12##0" = inttoptr i64 %"#right##0" to ptr + %"#right#x##0" = load i64, ptr %"tmp#12##0" + %"tmp#13##0" = add i64 %"#right##0", 8 + %"tmp#14##0" = inttoptr i64 %"tmp#13##0" to ptr + %"#right#y##0" = load i64, ptr %"tmp#14##0" + %"tmp#1##0" = icmp eq i64 %"#left#x##0", %"#right#x##0" + br i1 %"tmp#1##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#15##0" = icmp eq i64 %"#left#y##0", %"#right#y##0" + ret i1 %"tmp#15##0" +if.else.0: + ret i1 0 } - -define external fastcc i64 @"position.position.position<0>"(i64 %"x##0", i64 %"y##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"x##0", i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"y##0", i64* %5 - ret i64 %2 +define external fastcc i64 @"position.position.position<0>"(i64 %"x##0", i64 %"y##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 16) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"x##0", ptr %"tmp#1##0" + %"tmp#2##0" = add i64 %"#rec##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"y##0", ptr %"tmp#3##0" + ret i64 %"#rec##0" } - -define external fastcc {i64, i64} @"position.position.position<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#result##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#result##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = insertvalue {i64, i64} undef, i64 %1, 0 - %6 = insertvalue {i64, i64} %5, i64 %4, 1 - ret {i64, i64} %6 +define external fastcc {i64, i64} @"position.position.position<1>"(i64 %"#result##0") { + %"tmp#0##0" = inttoptr i64 %"#result##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + %"tmp#2##0" = add i64 %"#result##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#3##0" + %"tmp#5##0" = insertvalue {i64, i64} undef, i64 %"tmp#1##0", 0 + %"tmp#6##0" = insertvalue {i64, i64} %"tmp#5##0", i64 %"tmp#4##0", 1 + ret {i64, i64} %"tmp#6##0" } - -define external fastcc i64 @"position.position.x<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#rec##0" to i64* - %1 = load i64, i64* %0 - ret i64 %1 +define external fastcc i64 @"position.position.x<0>"(i64 %"#rec##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + ret i64 %"tmp#1##0" } - -define external fastcc i64 @"position.position.x<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = inttoptr i64 %2 to i64* - store i64 %"#field##0", i64* %6 - ret i64 %2 +define external fastcc i64 @"position.position.x<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"#field##0", ptr %"tmp#3##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"position.position.y<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = add i64 %"#rec##0", 8 - %1 = inttoptr i64 %0 to i64* - %2 = load i64, i64* %1 - ret i64 %2 +define external fastcc i64 @"position.position.y<0>"(i64 %"#rec##0") { + %"tmp#0##0" = add i64 %"#rec##0", 8 + %"tmp#1##0" = inttoptr i64 %"tmp#0##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"position.position.y<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = add i64 %2, 8 - %7 = inttoptr i64 %6 to i64* - store i64 %"#field##0", i64* %7 - ret i64 %2 +define external fastcc i64 @"position.position.y<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = add i64 %"tmp#2##0", 8 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 %"#field##0", ptr %"tmp#4##0" + ret i64 %"tmp#2##0" } - -define external fastcc i1 @"position.position.~=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %"#right##0" to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = icmp eq i64 %1, %6 - br i1 %10, label %if.then, label %if.else -if.then: - %11 = icmp eq i64 %4, %9 - %12 = xor i1 %11, 1 - ret i1 %12 -if.else: - %13 = xor i1 0, 1 - ret i1 %13 +define external fastcc i1 @"position.position.~=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#8##0" = inttoptr i64 %"#left##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#8##0" + %"tmp#9##0" = add i64 %"#left##0", 8 + %"tmp#10##0" = inttoptr i64 %"tmp#9##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#10##0" + %"tmp#11##0" = inttoptr i64 %"#right##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#11##0" + %"tmp#12##0" = add i64 %"#right##0", 8 + %"tmp#13##0" = inttoptr i64 %"tmp#12##0" to ptr + %"tmp#6##0" = load i64, ptr %"tmp#13##0" + %"tmp#7##0" = icmp eq i64 %"tmp#3##0", %"tmp#5##0" + br i1 %"tmp#7##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#0##0" = icmp eq i64 %"tmp#4##0", %"tmp#6##0" + %"tmp#14##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#14##0" +if.else.0: + %"tmp#15##0" = xor i1 0, 1 + ret i1 %"tmp#15##0" } diff --git a/test-cases/final-dump/alias_multifunc1.exp b/test-cases/final-dump/alias_multifunc1.exp index 5caa26570..aa37a71e9 100644 --- a/test-cases/final-dump/alias_multifunc1.exp +++ b/test-cases/final-dump/alias_multifunc1.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module alias_multifunc1 representation : (not a type) public submods : @@ -77,166 +80,108 @@ replicate2(p1##0:position.position, ?p2##0:position.position)<{<>}; LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'alias_multifunc1' - - - - -@alias_multifunc1.17 = constant {i64, i64} { i64 13, i64 ptrtoint ([?? x i8]* @alias_multifunc1.16 to i64) } - - -@alias_multifunc1.15 = constant {i64, i64} { i64 17, i64 ptrtoint ([?? x i8]* @alias_multifunc1.14 to i64) } - - -@alias_multifunc1.3 = constant {i64, i64} { i64 17, i64 ptrtoint ([?? x i8]* @alias_multifunc1.2 to i64) } - - -@alias_multifunc1.5 = constant {i64, i64} { i64 17, i64 ptrtoint ([?? x i8]* @alias_multifunc1.4 to i64) } - - -@alias_multifunc1.7 = constant {i64, i64} { i64 17, i64 ptrtoint ([?? x i8]* @alias_multifunc1.6 to i64) } - - -@alias_multifunc1.11 = constant {i64, i64} { i64 22, i64 ptrtoint ([?? x i8]* @alias_multifunc1.10 to i64) } - - -@alias_multifunc1.1 = constant {i64, i64} { i64 30, i64 ptrtoint ([?? x i8]* @alias_multifunc1.0 to i64) } - - -@alias_multifunc1.13 = constant {i64, i64} { i64 30, i64 ptrtoint ([?? x i8]* @alias_multifunc1.12 to i64) } - - -@alias_multifunc1.9 = constant {i64, i64} { i64 35, i64 ptrtoint ([?? x i8]* @alias_multifunc1.8 to i64) } - - -@alias_multifunc1.0 = constant [?? x i8] c"--- After calling replicate1: \00" - - -@alias_multifunc1.12 = constant [?? x i8] c"--- After calling x(!p1, 11): \00" - - -@alias_multifunc1.8 = constant [?? x i8] c"--- After calling x(!p2, 2222222): \00" - - -@alias_multifunc1.2 = constant [?? x i8] c"expect p1(10,10):\00" - - -@alias_multifunc1.14 = constant [?? x i8] c"expect p1(11,10):\00" - - -@alias_multifunc1.4 = constant [?? x i8] c"expect p2(22,10):\00" - - -@alias_multifunc1.10 = constant [?? x i8] c"expect p2(2222222,10):\00" - - -@alias_multifunc1.6 = constant [?? x i8] c"expect p3(10,10):\00" - - -@alias_multifunc1.16 = constant [?? x i8] c"some noise...\00" - - -declare external ccc void @putchar(i8) - - -declare external ccc void @print_int(i64) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external fastcc void @"position.printPosition<0>"(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"alias_multifunc1.<0>"() { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 10, i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 10, i64* %5 - %6 = tail call fastcc {i64, i64} @"alias_multifunc1.replicate1<0>"(i64 %2) - %7 = extractvalue {i64, i64} %6, 0 - %8 = extractvalue {i64, i64} %6, 1 - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_multifunc1.1, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_multifunc1.3, i32 0, i32 0) to i64)) - tail call fastcc void @"position.printPosition<0>"(i64 %2) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_multifunc1.5, i32 0, i32 0) to i64)) - tail call fastcc void @"position.printPosition<0>"(i64 %7) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_multifunc1.7, i32 0, i32 0) to i64)) - tail call fastcc void @"position.printPosition<0>"(i64 %8) - %9 = inttoptr i64 %7 to i64* - store i64 2222222, i64* %9 - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_multifunc1.9, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_multifunc1.11, i32 0, i32 0) to i64)) - tail call fastcc void @"position.printPosition<0>"(i64 %7) - %10 = trunc i64 16 to i32 - %11 = tail call ccc i8* @wybe_malloc(i32 %10) - %12 = ptrtoint i8* %11 to i64 - %13 = inttoptr i64 %12 to i8* - %14 = inttoptr i64 %2 to i8* - %15 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %13, i8* %14, i32 %15, i1 0) - %16 = inttoptr i64 %12 to i64* - store i64 11, i64* %16 - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_multifunc1.13, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_multifunc1.15, i32 0, i32 0) to i64)) - tail call fastcc void @"position.printPosition<0>"(i64 %12) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_multifunc1.7, i32 0, i32 0) to i64)) - tail call fastcc void @"position.printPosition<0>"(i64 %8) - ret void +source_filename = "!ROOT!/final-dump/alias_multifunc1.wybe" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c"--- After calling replicate1: \00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c"--- After calling x(!p1, 11): \00", align 8 +@"cstring#2" = private unnamed_addr constant [ ?? x i8 ] c"--- After calling x(!p2, 2222222): \00", align 8 +@"cstring#3" = private unnamed_addr constant [ ?? x i8 ] c"expect p1(10,10):\00", align 8 +@"cstring#4" = private unnamed_addr constant [ ?? x i8 ] c"expect p1(11,10):\00", align 8 +@"cstring#5" = private unnamed_addr constant [ ?? x i8 ] c"expect p2(22,10):\00", align 8 +@"cstring#6" = private unnamed_addr constant [ ?? x i8 ] c"expect p2(2222222,10):\00", align 8 +@"cstring#7" = private unnamed_addr constant [ ?? x i8 ] c"expect p3(10,10):\00", align 8 +@"cstring#8" = private unnamed_addr constant [ ?? x i8 ] c"some noise...\00", align 8 +@"string#9" = private unnamed_addr constant {i64, i64} { i64 30, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +@"string#10" = private unnamed_addr constant {i64, i64} { i64 30, i64 ptrtoint( ptr @"cstring#1" to i64 ) }, align 8 +@"string#11" = private unnamed_addr constant {i64, i64} { i64 35, i64 ptrtoint( ptr @"cstring#2" to i64 ) }, align 8 +@"string#12" = private unnamed_addr constant {i64, i64} { i64 17, i64 ptrtoint( ptr @"cstring#3" to i64 ) }, align 8 +@"string#13" = private unnamed_addr constant {i64, i64} { i64 17, i64 ptrtoint( ptr @"cstring#4" to i64 ) }, align 8 +@"string#14" = private unnamed_addr constant {i64, i64} { i64 17, i64 ptrtoint( ptr @"cstring#5" to i64 ) }, align 8 +@"string#15" = private unnamed_addr constant {i64, i64} { i64 22, i64 ptrtoint( ptr @"cstring#6" to i64 ) }, align 8 +@"string#16" = private unnamed_addr constant {i64, i64} { i64 17, i64 ptrtoint( ptr @"cstring#7" to i64 ) }, align 8 +@"string#17" = private unnamed_addr constant {i64, i64} { i64 13, i64 ptrtoint( ptr @"cstring#8" to i64 ) }, align 8 + +declare external fastcc void @"position.printPosition<0>"(i64) +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"alias_multifunc1.<0>"() { + %"tmp#18##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#3##0" = ptrtoint ptr %"tmp#18##0" to i64 + %"tmp#19##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 10, ptr %"tmp#19##0" + %"tmp#20##0" = add i64 %"tmp#3##0", 8 + %"tmp#21##0" = inttoptr i64 %"tmp#20##0" to ptr + store i64 10, ptr %"tmp#21##0" + %"tmp#22##0" = tail call fastcc {i64, i64} @"alias_multifunc1.replicate1<0>"(i64 %"tmp#3##0") + %"p2##0" = extractvalue {i64, i64}%"tmp#22##0", 0 + %"p3##0" = extractvalue {i64, i64}%"tmp#22##0", 1 + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#9" to i64 )) + call ccc void @putchar(i8 10) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#12" to i64 )) + tail call fastcc void @"position.printPosition<0>"(i64 %"tmp#3##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#14" to i64 )) + tail call fastcc void @"position.printPosition<0>"(i64 %"p2##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#16" to i64 )) + tail call fastcc void @"position.printPosition<0>"(i64 %"p3##0") + %"tmp#23##0" = inttoptr i64 %"p2##0" to ptr + store i64 2222222, ptr %"tmp#23##0" + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#11" to i64 )) + call ccc void @putchar(i8 10) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#15" to i64 )) + tail call fastcc void @"position.printPosition<0>"(i64 %"p2##0") + %"tmp#24##0" = inttoptr i64 %"tmp#3##0" to ptr + %"tmp#25##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#25##0", ptr %"tmp#24##0", i64 16, i1 0) + %"tmp#26##0" = ptrtoint ptr %"tmp#25##0" to i64 + %"tmp#27##0" = inttoptr i64 %"tmp#26##0" to ptr + store i64 11, ptr %"tmp#27##0" + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#10" to i64 )) + call ccc void @putchar(i8 10) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#13" to i64 )) + tail call fastcc void @"position.printPosition<0>"(i64 %"tmp#26##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#16" to i64 )) + tail call fastcc void @"position.printPosition<0>"(i64 %"p3##0") + ret void } - -define external fastcc {i64, i64} @"alias_multifunc1.replicate1<0>"(i64 %"p1##0") { -entry: - %0 = tail call fastcc i64 @"alias_multifunc1.replicate2<0>"(i64 %"p1##0") - %1 = tail call fastcc i64 @"alias_multifunc1.replicate2<0>"(i64 %0) - %2 = trunc i64 16 to i32 - %3 = tail call ccc i8* @wybe_malloc(i32 %2) - %4 = ptrtoint i8* %3 to i64 - %5 = inttoptr i64 %4 to i8* - %6 = inttoptr i64 %0 to i8* - %7 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %5, i8* %6, i32 %7, i1 0) - %8 = inttoptr i64 %4 to i64* - store i64 22, i64* %8 - %9 = insertvalue {i64, i64} undef, i64 %4, 0 - %10 = insertvalue {i64, i64} %9, i64 %1, 1 - ret {i64, i64} %10 +define external fastcc {i64, i64} @"alias_multifunc1.replicate1<0>"(i64 %"p1##0") { + %"p2##0" = tail call fastcc i64 @"alias_multifunc1.replicate2<0>"(i64 %"p1##0") + %"tmp#2##0" = tail call fastcc i64 @"alias_multifunc1.replicate2<0>"(i64 %"p2##0") + %"tmp#3##0" = inttoptr i64 %"p2##0" to ptr + %"tmp#4##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#4##0", ptr %"tmp#3##0", i64 16, i1 0) + %"tmp#5##0" = ptrtoint ptr %"tmp#4##0" to i64 + %"tmp#6##0" = inttoptr i64 %"tmp#5##0" to ptr + store i64 22, ptr %"tmp#6##0" + %"tmp#7##0" = insertvalue {i64, i64} undef, i64 %"tmp#5##0", 0 + %"tmp#8##0" = insertvalue {i64, i64} %"tmp#7##0", i64 %"tmp#2##0", 1 + ret {i64, i64} %"tmp#8##0" } - -define external fastcc i64 @"alias_multifunc1.replicate2<0>"(i64 %"p1##0") { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 0, i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 0, i64* %5 - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_multifunc1.17, i32 0, i32 0) to i64)) - %6 = inttoptr i64 %2 to i64* - %7 = load i64, i64* %6 - tail call ccc void @print_int(i64 %7) - tail call ccc void @putchar(i8 10) - ret i64 %"p1##0" +define external fastcc i64 @"alias_multifunc1.replicate2<0>"(i64 %"p1##0") { + %"tmp#11##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#4##0" = ptrtoint ptr %"tmp#11##0" to i64 + %"tmp#12##0" = inttoptr i64 %"tmp#4##0" to ptr + store i64 0, ptr %"tmp#12##0" + %"tmp#13##0" = add i64 %"tmp#4##0", 8 + %"tmp#14##0" = inttoptr i64 %"tmp#13##0" to ptr + store i64 0, ptr %"tmp#14##0" + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#17" to i64 )) + %"tmp#15##0" = inttoptr i64 %"tmp#4##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#15##0" + call ccc void @print_int(i64 %"tmp#1##0") + call ccc void @putchar(i8 10) + ret i64 %"p1##0" } + -------------------------------------------------- Module position representation : (not a type) @@ -279,63 +224,42 @@ printPosition(pos##0:position.position)<{<>}; {<>}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'position' - - - - -@position.3 = constant {i64, i64} { i64 1, i64 ptrtoint ([?? x i8]* @position.2 to i64) } - - -@position.5 = constant {i64, i64} { i64 1, i64 ptrtoint ([?? x i8]* @position.4 to i64) } - - -@position.1 = constant {i64, i64} { i64 2, i64 ptrtoint ([?? x i8]* @position.0 to i64) } - - -@position.0 = constant [?? x i8] c" (\00" - - -@position.4 = constant [?? x i8] c")\00" - - -@position.2 = constant [?? x i8] c",\00" - - -declare external ccc void @putchar(i8) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc void @print_int(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"position.printPosition<0>"(i64 %"pos##0") { -entry: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @position.1, i32 0, i32 0) to i64)) - %0 = inttoptr i64 %"pos##0" to i64* - %1 = load i64, i64* %0 - tail call ccc void @print_int(i64 %1) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @position.3, i32 0, i32 0) to i64)) - %2 = add i64 %"pos##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - tail call ccc void @print_int(i64 %4) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @position.5, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - ret void +source_filename = "!ROOT!/final-dump/position.wybe" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c" (\00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c")\00", align 8 +@"cstring#2" = private unnamed_addr constant [ ?? x i8 ] c",\00", align 8 +@"string#3" = private unnamed_addr constant {i64, i64} { i64 2, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +@"string#4" = private unnamed_addr constant {i64, i64} { i64 1, i64 ptrtoint( ptr @"cstring#1" to i64 ) }, align 8 +@"string#5" = private unnamed_addr constant {i64, i64} { i64 1, i64 ptrtoint( ptr @"cstring#2" to i64 ) }, align 8 + +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"position.printPosition<0>"(i64 %"pos##0") { + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#3" to i64 )) + %"tmp#13##0" = inttoptr i64 %"pos##0" to ptr + %"tmp#0##0" = load i64, ptr %"tmp#13##0" + call ccc void @print_int(i64 %"tmp#0##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#5" to i64 )) + %"tmp#14##0" = add i64 %"pos##0", 8 + %"tmp#15##0" = inttoptr i64 %"tmp#14##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#15##0" + call ccc void @print_int(i64 %"tmp#1##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#4" to i64 )) + call ccc void @putchar(i8 10) + ret void } + -------------------------------------------------- Module position.position - representation : address + representation : pointer public submods : public resources: public procs : position.position.=<0> @@ -437,134 +361,110 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'position.position' - - - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i1 @"position.position.=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %"#right##0" to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = icmp eq i64 %1, %6 - br i1 %10, label %if.then, label %if.else -if.then: - %11 = icmp eq i64 %4, %9 - ret i1 %11 -if.else: - ret i1 0 +source_filename = "!ROOT!/final-dump/position.wybe" +target triple ???? + + +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc i1 @"position.position.=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#9##0" = inttoptr i64 %"#left##0" to ptr + %"#left#x##0" = load i64, ptr %"tmp#9##0" + %"tmp#10##0" = add i64 %"#left##0", 8 + %"tmp#11##0" = inttoptr i64 %"tmp#10##0" to ptr + %"#left#y##0" = load i64, ptr %"tmp#11##0" + %"tmp#12##0" = inttoptr i64 %"#right##0" to ptr + %"#right#x##0" = load i64, ptr %"tmp#12##0" + %"tmp#13##0" = add i64 %"#right##0", 8 + %"tmp#14##0" = inttoptr i64 %"tmp#13##0" to ptr + %"#right#y##0" = load i64, ptr %"tmp#14##0" + %"tmp#1##0" = icmp eq i64 %"#left#x##0", %"#right#x##0" + br i1 %"tmp#1##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#15##0" = icmp eq i64 %"#left#y##0", %"#right#y##0" + ret i1 %"tmp#15##0" +if.else.0: + ret i1 0 } - -define external fastcc i64 @"position.position.position<0>"(i64 %"x##0", i64 %"y##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"x##0", i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"y##0", i64* %5 - ret i64 %2 +define external fastcc i64 @"position.position.position<0>"(i64 %"x##0", i64 %"y##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 16) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"x##0", ptr %"tmp#1##0" + %"tmp#2##0" = add i64 %"#rec##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"y##0", ptr %"tmp#3##0" + ret i64 %"#rec##0" } - -define external fastcc {i64, i64} @"position.position.position<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#result##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#result##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = insertvalue {i64, i64} undef, i64 %1, 0 - %6 = insertvalue {i64, i64} %5, i64 %4, 1 - ret {i64, i64} %6 +define external fastcc {i64, i64} @"position.position.position<1>"(i64 %"#result##0") { + %"tmp#0##0" = inttoptr i64 %"#result##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + %"tmp#2##0" = add i64 %"#result##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#3##0" + %"tmp#5##0" = insertvalue {i64, i64} undef, i64 %"tmp#1##0", 0 + %"tmp#6##0" = insertvalue {i64, i64} %"tmp#5##0", i64 %"tmp#4##0", 1 + ret {i64, i64} %"tmp#6##0" } - -define external fastcc i64 @"position.position.x<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#rec##0" to i64* - %1 = load i64, i64* %0 - ret i64 %1 +define external fastcc i64 @"position.position.x<0>"(i64 %"#rec##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + ret i64 %"tmp#1##0" } - -define external fastcc i64 @"position.position.x<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = inttoptr i64 %2 to i64* - store i64 %"#field##0", i64* %6 - ret i64 %2 +define external fastcc i64 @"position.position.x<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"#field##0", ptr %"tmp#3##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"position.position.y<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = add i64 %"#rec##0", 8 - %1 = inttoptr i64 %0 to i64* - %2 = load i64, i64* %1 - ret i64 %2 +define external fastcc i64 @"position.position.y<0>"(i64 %"#rec##0") { + %"tmp#0##0" = add i64 %"#rec##0", 8 + %"tmp#1##0" = inttoptr i64 %"tmp#0##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"position.position.y<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = add i64 %2, 8 - %7 = inttoptr i64 %6 to i64* - store i64 %"#field##0", i64* %7 - ret i64 %2 +define external fastcc i64 @"position.position.y<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = add i64 %"tmp#2##0", 8 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 %"#field##0", ptr %"tmp#4##0" + ret i64 %"tmp#2##0" } - -define external fastcc i1 @"position.position.~=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %"#right##0" to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = icmp eq i64 %1, %6 - br i1 %10, label %if.then, label %if.else -if.then: - %11 = icmp eq i64 %4, %9 - %12 = xor i1 %11, 1 - ret i1 %12 -if.else: - %13 = xor i1 0, 1 - ret i1 %13 +define external fastcc i1 @"position.position.~=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#8##0" = inttoptr i64 %"#left##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#8##0" + %"tmp#9##0" = add i64 %"#left##0", 8 + %"tmp#10##0" = inttoptr i64 %"tmp#9##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#10##0" + %"tmp#11##0" = inttoptr i64 %"#right##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#11##0" + %"tmp#12##0" = add i64 %"#right##0", 8 + %"tmp#13##0" = inttoptr i64 %"tmp#12##0" to ptr + %"tmp#6##0" = load i64, ptr %"tmp#13##0" + %"tmp#7##0" = icmp eq i64 %"tmp#3##0", %"tmp#5##0" + br i1 %"tmp#7##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#0##0" = icmp eq i64 %"tmp#4##0", %"tmp#6##0" + %"tmp#14##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#14##0" +if.else.0: + %"tmp#15##0" = xor i1 0, 1 + ret i1 %"tmp#15##0" } diff --git a/test-cases/final-dump/alias_multifunc2.exp b/test-cases/final-dump/alias_multifunc2.exp index f9aee455e..38869b40d 100644 --- a/test-cases/final-dump/alias_multifunc2.exp +++ b/test-cases/final-dump/alias_multifunc2.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module alias_multifunc2 representation : (not a type) public submods : @@ -72,150 +75,100 @@ replicate2(p1##0:position.position, ?p2##0:position.position)<{<>}; LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'alias_multifunc2' - - - - -@alias_multifunc2.11 = constant {i64, i64} { i64 17, i64 ptrtoint ([?? x i8]* @alias_multifunc2.10 to i64) } - - -@alias_multifunc2.3 = constant {i64, i64} { i64 17, i64 ptrtoint ([?? x i8]* @alias_multifunc2.2 to i64) } - - -@alias_multifunc2.5 = constant {i64, i64} { i64 17, i64 ptrtoint ([?? x i8]* @alias_multifunc2.4 to i64) } - - -@alias_multifunc2.7 = constant {i64, i64} { i64 17, i64 ptrtoint ([?? x i8]* @alias_multifunc2.6 to i64) } - - -@alias_multifunc2.13 = constant {i64, i64} { i64 18, i64 ptrtoint ([?? x i8]* @alias_multifunc2.12 to i64) } - - -@alias_multifunc2.1 = constant {i64, i64} { i64 30, i64 ptrtoint ([?? x i8]* @alias_multifunc2.0 to i64) } - - -@alias_multifunc2.9 = constant {i64, i64} { i64 30, i64 ptrtoint ([?? x i8]* @alias_multifunc2.8 to i64) } - - -@alias_multifunc2.0 = constant [?? x i8] c"--- After calling replicate1: \00" - - -@alias_multifunc2.8 = constant [?? x i8] c"--- After calling x(!p1, 11): \00" - - -@alias_multifunc2.2 = constant [?? x i8] c"expect p1(10,10):\00" - - -@alias_multifunc2.10 = constant [?? x i8] c"expect p1(11,10):\00" - - -@alias_multifunc2.4 = constant [?? x i8] c"expect p2(22,10):\00" - - -@alias_multifunc2.6 = constant [?? x i8] c"expect p3(10,10):\00" - - -@alias_multifunc2.12 = constant [?? x i8] c"random replicate2 \00" - - -declare external ccc void @putchar(i8) - - -declare external ccc void @print_int(i64) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external fastcc void @"position.printPosition<0>"(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"alias_multifunc2.<0>"() { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 10, i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 10, i64* %5 - %6 = tail call fastcc {i64, i64} @"alias_multifunc2.replicate1<0>"(i64 %2) - %7 = extractvalue {i64, i64} %6, 0 - %8 = extractvalue {i64, i64} %6, 1 - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_multifunc2.1, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_multifunc2.3, i32 0, i32 0) to i64)) - tail call fastcc void @"position.printPosition<0>"(i64 %2) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_multifunc2.5, i32 0, i32 0) to i64)) - tail call fastcc void @"position.printPosition<0>"(i64 %7) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_multifunc2.7, i32 0, i32 0) to i64)) - tail call fastcc void @"position.printPosition<0>"(i64 %8) - %9 = trunc i64 16 to i32 - %10 = tail call ccc i8* @wybe_malloc(i32 %9) - %11 = ptrtoint i8* %10 to i64 - %12 = inttoptr i64 %11 to i8* - %13 = inttoptr i64 %2 to i8* - %14 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %12, i8* %13, i32 %14, i1 0) - %15 = inttoptr i64 %11 to i64* - store i64 11, i64* %15 - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_multifunc2.9, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_multifunc2.11, i32 0, i32 0) to i64)) - tail call fastcc void @"position.printPosition<0>"(i64 %11) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_multifunc2.5, i32 0, i32 0) to i64)) - tail call fastcc void @"position.printPosition<0>"(i64 %7) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_multifunc2.7, i32 0, i32 0) to i64)) - tail call fastcc void @"position.printPosition<0>"(i64 %8) - ret void +source_filename = "!ROOT!/final-dump/alias_multifunc2.wybe" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c"--- After calling replicate1: \00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c"--- After calling x(!p1, 11): \00", align 8 +@"cstring#2" = private unnamed_addr constant [ ?? x i8 ] c"expect p1(10,10):\00", align 8 +@"cstring#3" = private unnamed_addr constant [ ?? x i8 ] c"expect p1(11,10):\00", align 8 +@"cstring#4" = private unnamed_addr constant [ ?? x i8 ] c"expect p2(22,10):\00", align 8 +@"cstring#5" = private unnamed_addr constant [ ?? x i8 ] c"expect p3(10,10):\00", align 8 +@"cstring#6" = private unnamed_addr constant [ ?? x i8 ] c"random replicate2 \00", align 8 +@"string#7" = private unnamed_addr constant {i64, i64} { i64 30, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +@"string#8" = private unnamed_addr constant {i64, i64} { i64 30, i64 ptrtoint( ptr @"cstring#1" to i64 ) }, align 8 +@"string#9" = private unnamed_addr constant {i64, i64} { i64 17, i64 ptrtoint( ptr @"cstring#2" to i64 ) }, align 8 +@"string#10" = private unnamed_addr constant {i64, i64} { i64 17, i64 ptrtoint( ptr @"cstring#3" to i64 ) }, align 8 +@"string#11" = private unnamed_addr constant {i64, i64} { i64 17, i64 ptrtoint( ptr @"cstring#4" to i64 ) }, align 8 +@"string#12" = private unnamed_addr constant {i64, i64} { i64 17, i64 ptrtoint( ptr @"cstring#5" to i64 ) }, align 8 +@"string#13" = private unnamed_addr constant {i64, i64} { i64 18, i64 ptrtoint( ptr @"cstring#6" to i64 ) }, align 8 + +declare external fastcc void @"position.printPosition<0>"(i64) +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"alias_multifunc2.<0>"() { + %"tmp#13##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#3##0" = ptrtoint ptr %"tmp#13##0" to i64 + %"tmp#14##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 10, ptr %"tmp#14##0" + %"tmp#15##0" = add i64 %"tmp#3##0", 8 + %"tmp#16##0" = inttoptr i64 %"tmp#15##0" to ptr + store i64 10, ptr %"tmp#16##0" + %"tmp#17##0" = tail call fastcc {i64, i64} @"alias_multifunc2.replicate1<0>"(i64 %"tmp#3##0") + %"p2##0" = extractvalue {i64, i64}%"tmp#17##0", 0 + %"p3##0" = extractvalue {i64, i64}%"tmp#17##0", 1 + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#7" to i64 )) + call ccc void @putchar(i8 10) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#9" to i64 )) + tail call fastcc void @"position.printPosition<0>"(i64 %"tmp#3##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#11" to i64 )) + tail call fastcc void @"position.printPosition<0>"(i64 %"p2##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#12" to i64 )) + tail call fastcc void @"position.printPosition<0>"(i64 %"p3##0") + %"tmp#18##0" = inttoptr i64 %"tmp#3##0" to ptr + %"tmp#19##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#19##0", ptr %"tmp#18##0", i64 16, i1 0) + %"tmp#20##0" = ptrtoint ptr %"tmp#19##0" to i64 + %"tmp#21##0" = inttoptr i64 %"tmp#20##0" to ptr + store i64 11, ptr %"tmp#21##0" + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#8" to i64 )) + call ccc void @putchar(i8 10) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#10" to i64 )) + tail call fastcc void @"position.printPosition<0>"(i64 %"tmp#20##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#11" to i64 )) + tail call fastcc void @"position.printPosition<0>"(i64 %"p2##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#12" to i64 )) + tail call fastcc void @"position.printPosition<0>"(i64 %"p3##0") + ret void } - -define external fastcc {i64, i64} @"alias_multifunc2.replicate1<0>"(i64 %"p1##0") { -entry: - %0 = tail call fastcc i64 @"alias_multifunc2.replicate2<0>"(i64 %"p1##0") - %1 = tail call fastcc i64 @"alias_multifunc2.replicate2<0>"(i64 %0) - %2 = trunc i64 16 to i32 - %3 = tail call ccc i8* @wybe_malloc(i32 %2) - %4 = ptrtoint i8* %3 to i64 - %5 = inttoptr i64 %4 to i8* - %6 = inttoptr i64 %0 to i8* - %7 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %5, i8* %6, i32 %7, i1 0) - %8 = inttoptr i64 %4 to i64* - store i64 22, i64* %8 - %9 = insertvalue {i64, i64} undef, i64 %4, 0 - %10 = insertvalue {i64, i64} %9, i64 %1, 1 - ret {i64, i64} %10 +define external fastcc {i64, i64} @"alias_multifunc2.replicate1<0>"(i64 %"p1##0") { + %"p2##0" = tail call fastcc i64 @"alias_multifunc2.replicate2<0>"(i64 %"p1##0") + %"tmp#2##0" = tail call fastcc i64 @"alias_multifunc2.replicate2<0>"(i64 %"p2##0") + %"tmp#3##0" = inttoptr i64 %"p2##0" to ptr + %"tmp#4##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#4##0", ptr %"tmp#3##0", i64 16, i1 0) + %"tmp#5##0" = ptrtoint ptr %"tmp#4##0" to i64 + %"tmp#6##0" = inttoptr i64 %"tmp#5##0" to ptr + store i64 22, ptr %"tmp#6##0" + %"tmp#7##0" = insertvalue {i64, i64} undef, i64 %"tmp#5##0", 0 + %"tmp#8##0" = insertvalue {i64, i64} %"tmp#7##0", i64 %"tmp#2##0", 1 + ret {i64, i64} %"tmp#8##0" } - -define external fastcc i64 @"alias_multifunc2.replicate2<0>"(i64 %"p1##0") { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 0, i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 0, i64* %5 - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_multifunc2.13, i32 0, i32 0) to i64)) - %6 = inttoptr i64 %2 to i64* - %7 = load i64, i64* %6 - tail call ccc void @print_int(i64 %7) - tail call ccc void @putchar(i8 10) - ret i64 %"p1##0" +define external fastcc i64 @"alias_multifunc2.replicate2<0>"(i64 %"p1##0") { + %"tmp#11##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#4##0" = ptrtoint ptr %"tmp#11##0" to i64 + %"tmp#12##0" = inttoptr i64 %"tmp#4##0" to ptr + store i64 0, ptr %"tmp#12##0" + %"tmp#13##0" = add i64 %"tmp#4##0", 8 + %"tmp#14##0" = inttoptr i64 %"tmp#13##0" to ptr + store i64 0, ptr %"tmp#14##0" + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#13" to i64 )) + %"tmp#15##0" = inttoptr i64 %"tmp#4##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#15##0" + call ccc void @print_int(i64 %"tmp#1##0") + call ccc void @putchar(i8 10) + ret i64 %"p1##0" } + -------------------------------------------------- Module position representation : (not a type) @@ -258,63 +211,42 @@ printPosition(pos##0:position.position)<{<>}; {<>}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'position' - - - - -@position.3 = constant {i64, i64} { i64 1, i64 ptrtoint ([?? x i8]* @position.2 to i64) } - - -@position.5 = constant {i64, i64} { i64 1, i64 ptrtoint ([?? x i8]* @position.4 to i64) } - - -@position.1 = constant {i64, i64} { i64 2, i64 ptrtoint ([?? x i8]* @position.0 to i64) } - - -@position.0 = constant [?? x i8] c" (\00" - - -@position.4 = constant [?? x i8] c")\00" - - -@position.2 = constant [?? x i8] c",\00" - - -declare external ccc void @putchar(i8) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc void @print_int(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"position.printPosition<0>"(i64 %"pos##0") { -entry: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @position.1, i32 0, i32 0) to i64)) - %0 = inttoptr i64 %"pos##0" to i64* - %1 = load i64, i64* %0 - tail call ccc void @print_int(i64 %1) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @position.3, i32 0, i32 0) to i64)) - %2 = add i64 %"pos##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - tail call ccc void @print_int(i64 %4) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @position.5, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - ret void +source_filename = "!ROOT!/final-dump/position.wybe" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c" (\00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c")\00", align 8 +@"cstring#2" = private unnamed_addr constant [ ?? x i8 ] c",\00", align 8 +@"string#3" = private unnamed_addr constant {i64, i64} { i64 2, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +@"string#4" = private unnamed_addr constant {i64, i64} { i64 1, i64 ptrtoint( ptr @"cstring#1" to i64 ) }, align 8 +@"string#5" = private unnamed_addr constant {i64, i64} { i64 1, i64 ptrtoint( ptr @"cstring#2" to i64 ) }, align 8 + +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"position.printPosition<0>"(i64 %"pos##0") { + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#3" to i64 )) + %"tmp#13##0" = inttoptr i64 %"pos##0" to ptr + %"tmp#0##0" = load i64, ptr %"tmp#13##0" + call ccc void @print_int(i64 %"tmp#0##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#5" to i64 )) + %"tmp#14##0" = add i64 %"pos##0", 8 + %"tmp#15##0" = inttoptr i64 %"tmp#14##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#15##0" + call ccc void @print_int(i64 %"tmp#1##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#4" to i64 )) + call ccc void @putchar(i8 10) + ret void } + -------------------------------------------------- Module position.position - representation : address + representation : pointer public submods : public resources: public procs : position.position.=<0> @@ -416,134 +348,110 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'position.position' - - - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i1 @"position.position.=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %"#right##0" to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = icmp eq i64 %1, %6 - br i1 %10, label %if.then, label %if.else -if.then: - %11 = icmp eq i64 %4, %9 - ret i1 %11 -if.else: - ret i1 0 +source_filename = "!ROOT!/final-dump/position.wybe" +target triple ???? + + +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc i1 @"position.position.=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#9##0" = inttoptr i64 %"#left##0" to ptr + %"#left#x##0" = load i64, ptr %"tmp#9##0" + %"tmp#10##0" = add i64 %"#left##0", 8 + %"tmp#11##0" = inttoptr i64 %"tmp#10##0" to ptr + %"#left#y##0" = load i64, ptr %"tmp#11##0" + %"tmp#12##0" = inttoptr i64 %"#right##0" to ptr + %"#right#x##0" = load i64, ptr %"tmp#12##0" + %"tmp#13##0" = add i64 %"#right##0", 8 + %"tmp#14##0" = inttoptr i64 %"tmp#13##0" to ptr + %"#right#y##0" = load i64, ptr %"tmp#14##0" + %"tmp#1##0" = icmp eq i64 %"#left#x##0", %"#right#x##0" + br i1 %"tmp#1##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#15##0" = icmp eq i64 %"#left#y##0", %"#right#y##0" + ret i1 %"tmp#15##0" +if.else.0: + ret i1 0 } - -define external fastcc i64 @"position.position.position<0>"(i64 %"x##0", i64 %"y##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"x##0", i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"y##0", i64* %5 - ret i64 %2 +define external fastcc i64 @"position.position.position<0>"(i64 %"x##0", i64 %"y##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 16) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"x##0", ptr %"tmp#1##0" + %"tmp#2##0" = add i64 %"#rec##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"y##0", ptr %"tmp#3##0" + ret i64 %"#rec##0" } - -define external fastcc {i64, i64} @"position.position.position<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#result##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#result##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = insertvalue {i64, i64} undef, i64 %1, 0 - %6 = insertvalue {i64, i64} %5, i64 %4, 1 - ret {i64, i64} %6 +define external fastcc {i64, i64} @"position.position.position<1>"(i64 %"#result##0") { + %"tmp#0##0" = inttoptr i64 %"#result##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + %"tmp#2##0" = add i64 %"#result##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#3##0" + %"tmp#5##0" = insertvalue {i64, i64} undef, i64 %"tmp#1##0", 0 + %"tmp#6##0" = insertvalue {i64, i64} %"tmp#5##0", i64 %"tmp#4##0", 1 + ret {i64, i64} %"tmp#6##0" } - -define external fastcc i64 @"position.position.x<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#rec##0" to i64* - %1 = load i64, i64* %0 - ret i64 %1 +define external fastcc i64 @"position.position.x<0>"(i64 %"#rec##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + ret i64 %"tmp#1##0" } - -define external fastcc i64 @"position.position.x<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = inttoptr i64 %2 to i64* - store i64 %"#field##0", i64* %6 - ret i64 %2 +define external fastcc i64 @"position.position.x<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"#field##0", ptr %"tmp#3##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"position.position.y<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = add i64 %"#rec##0", 8 - %1 = inttoptr i64 %0 to i64* - %2 = load i64, i64* %1 - ret i64 %2 +define external fastcc i64 @"position.position.y<0>"(i64 %"#rec##0") { + %"tmp#0##0" = add i64 %"#rec##0", 8 + %"tmp#1##0" = inttoptr i64 %"tmp#0##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"position.position.y<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = add i64 %2, 8 - %7 = inttoptr i64 %6 to i64* - store i64 %"#field##0", i64* %7 - ret i64 %2 +define external fastcc i64 @"position.position.y<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = add i64 %"tmp#2##0", 8 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 %"#field##0", ptr %"tmp#4##0" + ret i64 %"tmp#2##0" } - -define external fastcc i1 @"position.position.~=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %"#right##0" to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = icmp eq i64 %1, %6 - br i1 %10, label %if.then, label %if.else -if.then: - %11 = icmp eq i64 %4, %9 - %12 = xor i1 %11, 1 - ret i1 %12 -if.else: - %13 = xor i1 0, 1 - ret i1 %13 +define external fastcc i1 @"position.position.~=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#8##0" = inttoptr i64 %"#left##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#8##0" + %"tmp#9##0" = add i64 %"#left##0", 8 + %"tmp#10##0" = inttoptr i64 %"tmp#9##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#10##0" + %"tmp#11##0" = inttoptr i64 %"#right##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#11##0" + %"tmp#12##0" = add i64 %"#right##0", 8 + %"tmp#13##0" = inttoptr i64 %"tmp#12##0" to ptr + %"tmp#6##0" = load i64, ptr %"tmp#13##0" + %"tmp#7##0" = icmp eq i64 %"tmp#3##0", %"tmp#5##0" + br i1 %"tmp#7##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#0##0" = icmp eq i64 %"tmp#4##0", %"tmp#6##0" + %"tmp#14##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#14##0" +if.else.0: + %"tmp#15##0" = xor i1 0, 1 + ret i1 %"tmp#15##0" } diff --git a/test-cases/final-dump/alias_multifunc3.exp b/test-cases/final-dump/alias_multifunc3.exp index 02a95bd77..80c2b0d21 100644 --- a/test-cases/final-dump/alias_multifunc3.exp +++ b/test-cases/final-dump/alias_multifunc3.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module alias_multifunc3 representation : (not a type) public submods : @@ -57,130 +60,81 @@ replicate1(pa##0:position.position, ?pb##0:position.position)<{<>}; LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'alias_multifunc3' - - - - -@alias_multifunc3.15 = constant {i64, i64} { i64 17, i64 ptrtoint ([?? x i8]* @alias_multifunc3.14 to i64) } - - -@alias_multifunc3.3 = constant {i64, i64} { i64 17, i64 ptrtoint ([?? x i8]* @alias_multifunc3.2 to i64) } - - -@alias_multifunc3.5 = constant {i64, i64} { i64 17, i64 ptrtoint ([?? x i8]* @alias_multifunc3.4 to i64) } - - -@alias_multifunc3.9 = constant {i64, i64} { i64 18, i64 ptrtoint ([?? x i8]* @alias_multifunc3.8 to i64) } - - -@alias_multifunc3.13 = constant {i64, i64} { i64 19, i64 ptrtoint ([?? x i8]* @alias_multifunc3.12 to i64) } - - -@alias_multifunc3.11 = constant {i64, i64} { i64 22, i64 ptrtoint ([?? x i8]* @alias_multifunc3.10 to i64) } - - -@alias_multifunc3.1 = constant {i64, i64} { i64 29, i64 ptrtoint ([?? x i8]* @alias_multifunc3.0 to i64) } - - -@alias_multifunc3.7 = constant {i64, i64} { i64 29, i64 ptrtoint ([?? x i8]* @alias_multifunc3.6 to i64) } - - -@alias_multifunc3.6 = constant [?? x i8] c"--- After called x(!p1, 999):\00" - - -@alias_multifunc3.0 = constant [?? x i8] c"--- After calling replicate1:\00" - - -@alias_multifunc3.10 = constant [?? x i8] c"--- Inside replicate1:\00" - - -@alias_multifunc3.2 = constant [?? x i8] c"expect p1(10,10):\00" - - -@alias_multifunc3.8 = constant [?? x i8] c"expect p1(999,10):\00" - - -@alias_multifunc3.4 = constant [?? x i8] c"expect p2(10,10):\00" - - -@alias_multifunc3.12 = constant [?? x i8] c"expect pa(1111,10):\00" - - -@alias_multifunc3.14 = constant [?? x i8] c"expect pb(10,10):\00" - - -declare external fastcc void @"position.printPosition<0>"(i64) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc void @putchar(i8) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"alias_multifunc3.<0>"() { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 10, i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 10, i64* %5 - %6 = tail call fastcc i64 @"alias_multifunc3.replicate1<0>"(i64 %2) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_multifunc3.1, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_multifunc3.3, i32 0, i32 0) to i64)) - tail call fastcc void @"position.printPosition<0>"(i64 %2) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_multifunc3.5, i32 0, i32 0) to i64)) - tail call fastcc void @"position.printPosition<0>"(i64 %6) - %7 = trunc i64 16 to i32 - %8 = tail call ccc i8* @wybe_malloc(i32 %7) - %9 = ptrtoint i8* %8 to i64 - %10 = inttoptr i64 %9 to i8* - %11 = inttoptr i64 %2 to i8* - %12 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %10, i8* %11, i32 %12, i1 0) - %13 = inttoptr i64 %9 to i64* - store i64 999, i64* %13 - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_multifunc3.7, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_multifunc3.9, i32 0, i32 0) to i64)) - tail call fastcc void @"position.printPosition<0>"(i64 %9) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_multifunc3.5, i32 0, i32 0) to i64)) - tail call fastcc void @"position.printPosition<0>"(i64 %6) - ret void +source_filename = "!ROOT!/final-dump/alias_multifunc3.wybe" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c"--- After called x(!p1, 999):\00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c"--- After calling replicate1:\00", align 8 +@"cstring#2" = private unnamed_addr constant [ ?? x i8 ] c"--- Inside replicate1:\00", align 8 +@"cstring#3" = private unnamed_addr constant [ ?? x i8 ] c"expect p1(10,10):\00", align 8 +@"cstring#4" = private unnamed_addr constant [ ?? x i8 ] c"expect p1(999,10):\00", align 8 +@"cstring#5" = private unnamed_addr constant [ ?? x i8 ] c"expect p2(10,10):\00", align 8 +@"cstring#6" = private unnamed_addr constant [ ?? x i8 ] c"expect pa(1111,10):\00", align 8 +@"cstring#7" = private unnamed_addr constant [ ?? x i8 ] c"expect pb(10,10):\00", align 8 +@"string#8" = private unnamed_addr constant {i64, i64} { i64 29, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +@"string#9" = private unnamed_addr constant {i64, i64} { i64 29, i64 ptrtoint( ptr @"cstring#1" to i64 ) }, align 8 +@"string#10" = private unnamed_addr constant {i64, i64} { i64 22, i64 ptrtoint( ptr @"cstring#2" to i64 ) }, align 8 +@"string#11" = private unnamed_addr constant {i64, i64} { i64 17, i64 ptrtoint( ptr @"cstring#3" to i64 ) }, align 8 +@"string#12" = private unnamed_addr constant {i64, i64} { i64 18, i64 ptrtoint( ptr @"cstring#4" to i64 ) }, align 8 +@"string#13" = private unnamed_addr constant {i64, i64} { i64 17, i64 ptrtoint( ptr @"cstring#5" to i64 ) }, align 8 +@"string#14" = private unnamed_addr constant {i64, i64} { i64 19, i64 ptrtoint( ptr @"cstring#6" to i64 ) }, align 8 +@"string#15" = private unnamed_addr constant {i64, i64} { i64 17, i64 ptrtoint( ptr @"cstring#7" to i64 ) }, align 8 + +declare external fastcc void @"position.printPosition<0>"(i64) +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @putchar(i8) +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"alias_multifunc3.<0>"() { + %"tmp#13##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#3##0" = ptrtoint ptr %"tmp#13##0" to i64 + %"tmp#14##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 10, ptr %"tmp#14##0" + %"tmp#15##0" = add i64 %"tmp#3##0", 8 + %"tmp#16##0" = inttoptr i64 %"tmp#15##0" to ptr + store i64 10, ptr %"tmp#16##0" + %"p2##0" = tail call fastcc i64 @"alias_multifunc3.replicate1<0>"(i64 %"tmp#3##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#9" to i64 )) + call ccc void @putchar(i8 10) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#11" to i64 )) + tail call fastcc void @"position.printPosition<0>"(i64 %"tmp#3##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#13" to i64 )) + tail call fastcc void @"position.printPosition<0>"(i64 %"p2##0") + %"tmp#17##0" = inttoptr i64 %"tmp#3##0" to ptr + %"tmp#18##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#18##0", ptr %"tmp#17##0", i64 16, i1 0) + %"tmp#19##0" = ptrtoint ptr %"tmp#18##0" to i64 + %"tmp#20##0" = inttoptr i64 %"tmp#19##0" to ptr + store i64 999, ptr %"tmp#20##0" + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#8" to i64 )) + call ccc void @putchar(i8 10) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#12" to i64 )) + tail call fastcc void @"position.printPosition<0>"(i64 %"tmp#19##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#13" to i64 )) + tail call fastcc void @"position.printPosition<0>"(i64 %"p2##0") + ret void } - -define external fastcc i64 @"alias_multifunc3.replicate1<0>"(i64 %"pa##0") { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"pa##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = inttoptr i64 %2 to i64* - store i64 1111, i64* %6 - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_multifunc3.11, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_multifunc3.13, i32 0, i32 0) to i64)) - tail call fastcc void @"position.printPosition<0>"(i64 %2) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_multifunc3.15, i32 0, i32 0) to i64)) - tail call fastcc void @"position.printPosition<0>"(i64 %"pa##0") - ret i64 %"pa##0" +define external fastcc i64 @"alias_multifunc3.replicate1<0>"(i64 %"pa##0") { + %"tmp#5##0" = inttoptr i64 %"pa##0" to ptr + %"tmp#6##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#6##0", ptr %"tmp#5##0", i64 16, i1 0) + %"tmp#7##0" = ptrtoint ptr %"tmp#6##0" to i64 + %"tmp#8##0" = inttoptr i64 %"tmp#7##0" to ptr + store i64 1111, ptr %"tmp#8##0" + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#10" to i64 )) + call ccc void @putchar(i8 10) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#14" to i64 )) + tail call fastcc void @"position.printPosition<0>"(i64 %"tmp#7##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#15" to i64 )) + tail call fastcc void @"position.printPosition<0>"(i64 %"pa##0") + ret i64 %"pa##0" } + -------------------------------------------------- Module position representation : (not a type) @@ -223,63 +177,42 @@ printPosition(pos##0:position.position)<{<>}; {<>}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'position' - - - - -@position.3 = constant {i64, i64} { i64 1, i64 ptrtoint ([?? x i8]* @position.2 to i64) } - - -@position.5 = constant {i64, i64} { i64 1, i64 ptrtoint ([?? x i8]* @position.4 to i64) } - - -@position.1 = constant {i64, i64} { i64 2, i64 ptrtoint ([?? x i8]* @position.0 to i64) } - - -@position.0 = constant [?? x i8] c" (\00" - - -@position.4 = constant [?? x i8] c")\00" - - -@position.2 = constant [?? x i8] c",\00" - - -declare external ccc void @putchar(i8) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc void @print_int(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"position.printPosition<0>"(i64 %"pos##0") { -entry: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @position.1, i32 0, i32 0) to i64)) - %0 = inttoptr i64 %"pos##0" to i64* - %1 = load i64, i64* %0 - tail call ccc void @print_int(i64 %1) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @position.3, i32 0, i32 0) to i64)) - %2 = add i64 %"pos##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - tail call ccc void @print_int(i64 %4) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @position.5, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - ret void +source_filename = "!ROOT!/final-dump/position.wybe" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c" (\00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c")\00", align 8 +@"cstring#2" = private unnamed_addr constant [ ?? x i8 ] c",\00", align 8 +@"string#3" = private unnamed_addr constant {i64, i64} { i64 2, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +@"string#4" = private unnamed_addr constant {i64, i64} { i64 1, i64 ptrtoint( ptr @"cstring#1" to i64 ) }, align 8 +@"string#5" = private unnamed_addr constant {i64, i64} { i64 1, i64 ptrtoint( ptr @"cstring#2" to i64 ) }, align 8 + +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"position.printPosition<0>"(i64 %"pos##0") { + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#3" to i64 )) + %"tmp#13##0" = inttoptr i64 %"pos##0" to ptr + %"tmp#0##0" = load i64, ptr %"tmp#13##0" + call ccc void @print_int(i64 %"tmp#0##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#5" to i64 )) + %"tmp#14##0" = add i64 %"pos##0", 8 + %"tmp#15##0" = inttoptr i64 %"tmp#14##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#15##0" + call ccc void @print_int(i64 %"tmp#1##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#4" to i64 )) + call ccc void @putchar(i8 10) + ret void } + -------------------------------------------------- Module position.position - representation : address + representation : pointer public submods : public resources: public procs : position.position.=<0> @@ -381,134 +314,110 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'position.position' - - - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i1 @"position.position.=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %"#right##0" to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = icmp eq i64 %1, %6 - br i1 %10, label %if.then, label %if.else -if.then: - %11 = icmp eq i64 %4, %9 - ret i1 %11 -if.else: - ret i1 0 +source_filename = "!ROOT!/final-dump/position.wybe" +target triple ???? + + +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc i1 @"position.position.=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#9##0" = inttoptr i64 %"#left##0" to ptr + %"#left#x##0" = load i64, ptr %"tmp#9##0" + %"tmp#10##0" = add i64 %"#left##0", 8 + %"tmp#11##0" = inttoptr i64 %"tmp#10##0" to ptr + %"#left#y##0" = load i64, ptr %"tmp#11##0" + %"tmp#12##0" = inttoptr i64 %"#right##0" to ptr + %"#right#x##0" = load i64, ptr %"tmp#12##0" + %"tmp#13##0" = add i64 %"#right##0", 8 + %"tmp#14##0" = inttoptr i64 %"tmp#13##0" to ptr + %"#right#y##0" = load i64, ptr %"tmp#14##0" + %"tmp#1##0" = icmp eq i64 %"#left#x##0", %"#right#x##0" + br i1 %"tmp#1##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#15##0" = icmp eq i64 %"#left#y##0", %"#right#y##0" + ret i1 %"tmp#15##0" +if.else.0: + ret i1 0 } - -define external fastcc i64 @"position.position.position<0>"(i64 %"x##0", i64 %"y##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"x##0", i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"y##0", i64* %5 - ret i64 %2 +define external fastcc i64 @"position.position.position<0>"(i64 %"x##0", i64 %"y##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 16) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"x##0", ptr %"tmp#1##0" + %"tmp#2##0" = add i64 %"#rec##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"y##0", ptr %"tmp#3##0" + ret i64 %"#rec##0" } - -define external fastcc {i64, i64} @"position.position.position<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#result##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#result##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = insertvalue {i64, i64} undef, i64 %1, 0 - %6 = insertvalue {i64, i64} %5, i64 %4, 1 - ret {i64, i64} %6 +define external fastcc {i64, i64} @"position.position.position<1>"(i64 %"#result##0") { + %"tmp#0##0" = inttoptr i64 %"#result##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + %"tmp#2##0" = add i64 %"#result##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#3##0" + %"tmp#5##0" = insertvalue {i64, i64} undef, i64 %"tmp#1##0", 0 + %"tmp#6##0" = insertvalue {i64, i64} %"tmp#5##0", i64 %"tmp#4##0", 1 + ret {i64, i64} %"tmp#6##0" } - -define external fastcc i64 @"position.position.x<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#rec##0" to i64* - %1 = load i64, i64* %0 - ret i64 %1 +define external fastcc i64 @"position.position.x<0>"(i64 %"#rec##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + ret i64 %"tmp#1##0" } - -define external fastcc i64 @"position.position.x<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = inttoptr i64 %2 to i64* - store i64 %"#field##0", i64* %6 - ret i64 %2 +define external fastcc i64 @"position.position.x<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"#field##0", ptr %"tmp#3##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"position.position.y<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = add i64 %"#rec##0", 8 - %1 = inttoptr i64 %0 to i64* - %2 = load i64, i64* %1 - ret i64 %2 +define external fastcc i64 @"position.position.y<0>"(i64 %"#rec##0") { + %"tmp#0##0" = add i64 %"#rec##0", 8 + %"tmp#1##0" = inttoptr i64 %"tmp#0##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"position.position.y<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = add i64 %2, 8 - %7 = inttoptr i64 %6 to i64* - store i64 %"#field##0", i64* %7 - ret i64 %2 +define external fastcc i64 @"position.position.y<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = add i64 %"tmp#2##0", 8 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 %"#field##0", ptr %"tmp#4##0" + ret i64 %"tmp#2##0" } - -define external fastcc i1 @"position.position.~=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %"#right##0" to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = icmp eq i64 %1, %6 - br i1 %10, label %if.then, label %if.else -if.then: - %11 = icmp eq i64 %4, %9 - %12 = xor i1 %11, 1 - ret i1 %12 -if.else: - %13 = xor i1 0, 1 - ret i1 %13 +define external fastcc i1 @"position.position.~=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#8##0" = inttoptr i64 %"#left##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#8##0" + %"tmp#9##0" = add i64 %"#left##0", 8 + %"tmp#10##0" = inttoptr i64 %"tmp#9##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#10##0" + %"tmp#11##0" = inttoptr i64 %"#right##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#11##0" + %"tmp#12##0" = add i64 %"#right##0", 8 + %"tmp#13##0" = inttoptr i64 %"tmp#12##0" to ptr + %"tmp#6##0" = load i64, ptr %"tmp#13##0" + %"tmp#7##0" = icmp eq i64 %"tmp#3##0", %"tmp#5##0" + br i1 %"tmp#7##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#0##0" = icmp eq i64 %"tmp#4##0", %"tmp#6##0" + %"tmp#14##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#14##0" +if.else.0: + %"tmp#15##0" = xor i1 0, 1 + ret i1 %"tmp#15##0" } diff --git a/test-cases/final-dump/alias_multifunc4.exp b/test-cases/final-dump/alias_multifunc4.exp index cf49e71ff..2e598299e 100644 --- a/test-cases/final-dump/alias_multifunc4.exp +++ b/test-cases/final-dump/alias_multifunc4.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module alias_multifunc4 representation : (not a type) public submods : @@ -94,217 +97,142 @@ replicate22(?pb##0:position.position, ?pc##1:position.position)<{<>} LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'alias_multifunc4' - - - - -@alias_multifunc4.3 = constant {i64, i64} { i64 17, i64 ptrtoint ([?? x i8]* @alias_multifunc4.2 to i64) } - - -@alias_multifunc4.5 = constant {i64, i64} { i64 17, i64 ptrtoint ([?? x i8]* @alias_multifunc4.4 to i64) } - - -@alias_multifunc4.7 = constant {i64, i64} { i64 17, i64 ptrtoint ([?? x i8]* @alias_multifunc4.6 to i64) } - - -@alias_multifunc4.11 = constant {i64, i64} { i64 23, i64 ptrtoint ([?? x i8]* @alias_multifunc4.10 to i64) } - - -@alias_multifunc4.15 = constant {i64, i64} { i64 23, i64 ptrtoint ([?? x i8]* @alias_multifunc4.14 to i64) } - - -@alias_multifunc4.17 = constant {i64, i64} { i64 28, i64 ptrtoint ([?? x i8]* @alias_multifunc4.16 to i64) } - - -@alias_multifunc4.1 = constant {i64, i64} { i64 29, i64 ptrtoint ([?? x i8]* @alias_multifunc4.0 to i64) } - - -@alias_multifunc4.13 = constant {i64, i64} { i64 30, i64 ptrtoint ([?? x i8]* @alias_multifunc4.12 to i64) } - - -@alias_multifunc4.9 = constant {i64, i64} { i64 30, i64 ptrtoint ([?? x i8]* @alias_multifunc4.8 to i64) } - - -@alias_multifunc4.21 = constant {i64, i64} { i64 47, i64 ptrtoint ([?? x i8]* @alias_multifunc4.20 to i64) } - - -@alias_multifunc4.19 = constant {i64, i64} { i64 53, i64 ptrtoint ([?? x i8]* @alias_multifunc4.18 to i64) } - - -@alias_multifunc4.23 = constant {i64, i64} { i64 86, i64 ptrtoint ([?? x i8]* @alias_multifunc4.22 to i64) } - - -@alias_multifunc4.0 = constant [?? x i8] c"--- After calling replicate1:\00" - - -@alias_multifunc4.8 = constant [?? x i8] c"--- After calling replicate21:\00" - - -@alias_multifunc4.12 = constant [?? x i8] c"--- After calling replicate22:\00" - - -@alias_multifunc4.18 = constant [?? x i8] c"--- Inside replicate21, expect pc(1111111111,99999): \00" - - -@alias_multifunc4.22 = constant [?? x i8] c"--- Inside replicate22, after calling x(!pc,1111111111), expect pc(1111111111,99999): \00" - - -@alias_multifunc4.20 = constant [?? x i8] c"--- Inside replicate22, expect pc(99999,99999):\00" - - -@alias_multifunc4.2 = constant [?? x i8] c"expect p1(10,10):\00" - - -@alias_multifunc4.4 = constant [?? x i8] c"expect p2(99,10):\00" - - -@alias_multifunc4.6 = constant [?? x i8] c"expect p3(10,10):\00" - - -@alias_multifunc4.10 = constant [?? x i8] c"expect p4(99999,99999):\00" - - -@alias_multifunc4.14 = constant [?? x i8] c"expect p6(99999,99999):\00" - - -@alias_multifunc4.16 = constant [?? x i8] c"expect p7(1111111111,99999):\00" - - -declare external fastcc void @"position.printPosition<0>"(i64) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc void @putchar(i8) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"alias_multifunc4.<0>"() { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 10, i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 10, i64* %5 - %6 = tail call fastcc {i64, i64} @"alias_multifunc4.replicate1<0>"(i64 %2) - %7 = extractvalue {i64, i64} %6, 0 - %8 = extractvalue {i64, i64} %6, 1 - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_multifunc4.1, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_multifunc4.3, i32 0, i32 0) to i64)) - tail call fastcc void @"position.printPosition<0>"(i64 %2) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_multifunc4.5, i32 0, i32 0) to i64)) - tail call fastcc void @"position.printPosition<0>"(i64 %7) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_multifunc4.7, i32 0, i32 0) to i64)) - tail call fastcc void @"position.printPosition<0>"(i64 %8) - %9 = tail call fastcc i64 @"alias_multifunc4.replicate21<0>"() - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_multifunc4.9, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_multifunc4.11, i32 0, i32 0) to i64)) - tail call fastcc void @"position.printPosition<0>"(i64 %9) - %10 = tail call fastcc {i64, i64} @"alias_multifunc4.replicate22<0>"() - %11 = extractvalue {i64, i64} %10, 0 - %12 = extractvalue {i64, i64} %10, 1 - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_multifunc4.13, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_multifunc4.15, i32 0, i32 0) to i64)) - tail call fastcc void @"position.printPosition<0>"(i64 %11) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_multifunc4.17, i32 0, i32 0) to i64)) - tail call fastcc void @"position.printPosition<0>"(i64 %12) - ret void +source_filename = "!ROOT!/final-dump/alias_multifunc4.wybe" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c"--- After calling replicate1:\00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c"--- After calling replicate21:\00", align 8 +@"cstring#2" = private unnamed_addr constant [ ?? x i8 ] c"--- After calling replicate22:\00", align 8 +@"cstring#3" = private unnamed_addr constant [ ?? x i8 ] c"--- Inside replicate21, expect pc(1111111111,99999): \00", align 8 +@"cstring#4" = private unnamed_addr constant [ ?? x i8 ] c"--- Inside replicate22, after calling x(!pc,1111111111), expect pc(1111111111,99999): \00", align 8 +@"cstring#5" = private unnamed_addr constant [ ?? x i8 ] c"--- Inside replicate22, expect pc(99999,99999):\00", align 8 +@"cstring#6" = private unnamed_addr constant [ ?? x i8 ] c"expect p1(10,10):\00", align 8 +@"cstring#7" = private unnamed_addr constant [ ?? x i8 ] c"expect p2(99,10):\00", align 8 +@"cstring#8" = private unnamed_addr constant [ ?? x i8 ] c"expect p3(10,10):\00", align 8 +@"cstring#9" = private unnamed_addr constant [ ?? x i8 ] c"expect p4(99999,99999):\00", align 8 +@"cstring#10" = private unnamed_addr constant [ ?? x i8 ] c"expect p6(99999,99999):\00", align 8 +@"cstring#11" = private unnamed_addr constant [ ?? x i8 ] c"expect p7(1111111111,99999):\00", align 8 +@"string#12" = private unnamed_addr constant {i64, i64} { i64 29, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +@"string#13" = private unnamed_addr constant {i64, i64} { i64 30, i64 ptrtoint( ptr @"cstring#1" to i64 ) }, align 8 +@"string#14" = private unnamed_addr constant {i64, i64} { i64 30, i64 ptrtoint( ptr @"cstring#2" to i64 ) }, align 8 +@"string#15" = private unnamed_addr constant {i64, i64} { i64 53, i64 ptrtoint( ptr @"cstring#3" to i64 ) }, align 8 +@"string#16" = private unnamed_addr constant {i64, i64} { i64 86, i64 ptrtoint( ptr @"cstring#4" to i64 ) }, align 8 +@"string#17" = private unnamed_addr constant {i64, i64} { i64 47, i64 ptrtoint( ptr @"cstring#5" to i64 ) }, align 8 +@"string#18" = private unnamed_addr constant {i64, i64} { i64 17, i64 ptrtoint( ptr @"cstring#6" to i64 ) }, align 8 +@"string#19" = private unnamed_addr constant {i64, i64} { i64 17, i64 ptrtoint( ptr @"cstring#7" to i64 ) }, align 8 +@"string#20" = private unnamed_addr constant {i64, i64} { i64 17, i64 ptrtoint( ptr @"cstring#8" to i64 ) }, align 8 +@"string#21" = private unnamed_addr constant {i64, i64} { i64 23, i64 ptrtoint( ptr @"cstring#9" to i64 ) }, align 8 +@"string#22" = private unnamed_addr constant {i64, i64} { i64 23, i64 ptrtoint( ptr @"cstring#10" to i64 ) }, align 8 +@"string#23" = private unnamed_addr constant {i64, i64} { i64 28, i64 ptrtoint( ptr @"cstring#11" to i64 ) }, align 8 + +declare external fastcc void @"position.printPosition<0>"(i64) +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @putchar(i8) +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"alias_multifunc4.<0>"() { + %"tmp#14##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#3##0" = ptrtoint ptr %"tmp#14##0" to i64 + %"tmp#15##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 10, ptr %"tmp#15##0" + %"tmp#16##0" = add i64 %"tmp#3##0", 8 + %"tmp#17##0" = inttoptr i64 %"tmp#16##0" to ptr + store i64 10, ptr %"tmp#17##0" + %"tmp#18##0" = tail call fastcc {i64, i64} @"alias_multifunc4.replicate1<0>"(i64 %"tmp#3##0") + %"p2##0" = extractvalue {i64, i64}%"tmp#18##0", 0 + %"p3##0" = extractvalue {i64, i64}%"tmp#18##0", 1 + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#12" to i64 )) + call ccc void @putchar(i8 10) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#18" to i64 )) + tail call fastcc void @"position.printPosition<0>"(i64 %"tmp#3##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#19" to i64 )) + tail call fastcc void @"position.printPosition<0>"(i64 %"p2##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#20" to i64 )) + tail call fastcc void @"position.printPosition<0>"(i64 %"p3##0") + %"p4##0" = tail call fastcc i64 @"alias_multifunc4.replicate21<0>"() + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#13" to i64 )) + call ccc void @putchar(i8 10) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#21" to i64 )) + tail call fastcc void @"position.printPosition<0>"(i64 %"p4##0") + %"tmp#19##0" = tail call fastcc {i64, i64} @"alias_multifunc4.replicate22<0>"() + %"p6##0" = extractvalue {i64, i64}%"tmp#19##0", 0 + %"p7##0" = extractvalue {i64, i64}%"tmp#19##0", 1 + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#14" to i64 )) + call ccc void @putchar(i8 10) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#22" to i64 )) + tail call fastcc void @"position.printPosition<0>"(i64 %"p6##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#23" to i64 )) + tail call fastcc void @"position.printPosition<0>"(i64 %"p7##0") + ret void } - -define external fastcc {i64, i64} @"alias_multifunc4.replicate1<0>"(i64 %"pa##0") { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 99, i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 99, i64* %5 - %6 = inttoptr i64 %2 to i64* - %7 = load i64, i64* %6 - %8 = trunc i64 16 to i32 - %9 = tail call ccc i8* @wybe_malloc(i32 %8) - %10 = ptrtoint i8* %9 to i64 - %11 = inttoptr i64 %10 to i8* - %12 = inttoptr i64 %"pa##0" to i8* - %13 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %11, i8* %12, i32 %13, i1 0) - %14 = inttoptr i64 %10 to i64* - store i64 %7, i64* %14 - %15 = insertvalue {i64, i64} undef, i64 %10, 0 - %16 = insertvalue {i64, i64} %15, i64 %"pa##0", 1 - ret {i64, i64} %16 +define external fastcc {i64, i64} @"alias_multifunc4.replicate1<0>"(i64 %"pa##0") { + %"tmp#9##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#4##0" = ptrtoint ptr %"tmp#9##0" to i64 + %"tmp#10##0" = inttoptr i64 %"tmp#4##0" to ptr + store i64 99, ptr %"tmp#10##0" + %"tmp#11##0" = add i64 %"tmp#4##0", 8 + %"tmp#12##0" = inttoptr i64 %"tmp#11##0" to ptr + store i64 99, ptr %"tmp#12##0" + %"tmp#13##0" = inttoptr i64 %"tmp#4##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#13##0" + %"tmp#14##0" = inttoptr i64 %"pa##0" to ptr + %"tmp#15##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#15##0", ptr %"tmp#14##0", i64 16, i1 0) + %"tmp#16##0" = ptrtoint ptr %"tmp#15##0" to i64 + %"tmp#17##0" = inttoptr i64 %"tmp#16##0" to ptr + store i64 %"tmp#1##0", ptr %"tmp#17##0" + %"tmp#18##0" = insertvalue {i64, i64} undef, i64 %"tmp#16##0", 0 + %"tmp#19##0" = insertvalue {i64, i64} %"tmp#18##0", i64 %"pa##0", 1 + ret {i64, i64} %"tmp#19##0" } - -define external fastcc i64 @"alias_multifunc4.replicate21<0>"() { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 99999, i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 99999, i64* %5 - %6 = trunc i64 16 to i32 - %7 = tail call ccc i8* @wybe_malloc(i32 %6) - %8 = ptrtoint i8* %7 to i64 - %9 = inttoptr i64 %8 to i8* - %10 = inttoptr i64 %2 to i8* - %11 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %9, i8* %10, i32 %11, i1 0) - %12 = inttoptr i64 %8 to i64* - store i64 1111111111, i64* %12 - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_multifunc4.19, i32 0, i32 0) to i64)) - tail call fastcc void @"position.printPosition<0>"(i64 %8) - ret i64 %2 +define external fastcc i64 @"alias_multifunc4.replicate21<0>"() { + %"tmp#7##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#3##0" = ptrtoint ptr %"tmp#7##0" to i64 + %"tmp#8##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 99999, ptr %"tmp#8##0" + %"tmp#9##0" = add i64 %"tmp#3##0", 8 + %"tmp#10##0" = inttoptr i64 %"tmp#9##0" to ptr + store i64 99999, ptr %"tmp#10##0" + %"tmp#11##0" = inttoptr i64 %"tmp#3##0" to ptr + %"tmp#12##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#12##0", ptr %"tmp#11##0", i64 16, i1 0) + %"tmp#13##0" = ptrtoint ptr %"tmp#12##0" to i64 + %"tmp#14##0" = inttoptr i64 %"tmp#13##0" to ptr + store i64 1111111111, ptr %"tmp#14##0" + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#15" to i64 )) + tail call fastcc void @"position.printPosition<0>"(i64 %"tmp#13##0") + ret i64 %"tmp#3##0" } - -define external fastcc {i64, i64} @"alias_multifunc4.replicate22<0>"() { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 99999, i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 99999, i64* %5 - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_multifunc4.21, i32 0, i32 0) to i64)) - tail call fastcc void @"position.printPosition<0>"(i64 %2) - %6 = trunc i64 16 to i32 - %7 = tail call ccc i8* @wybe_malloc(i32 %6) - %8 = ptrtoint i8* %7 to i64 - %9 = inttoptr i64 %8 to i8* - %10 = inttoptr i64 %2 to i8* - %11 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %9, i8* %10, i32 %11, i1 0) - %12 = inttoptr i64 %8 to i64* - store i64 1111111111, i64* %12 - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_multifunc4.23, i32 0, i32 0) to i64)) - tail call fastcc void @"position.printPosition<0>"(i64 %8) - %13 = insertvalue {i64, i64} undef, i64 %2, 0 - %14 = insertvalue {i64, i64} %13, i64 %8, 1 - ret {i64, i64} %14 +define external fastcc {i64, i64} @"alias_multifunc4.replicate22<0>"() { + %"tmp#7##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#3##0" = ptrtoint ptr %"tmp#7##0" to i64 + %"tmp#8##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 99999, ptr %"tmp#8##0" + %"tmp#9##0" = add i64 %"tmp#3##0", 8 + %"tmp#10##0" = inttoptr i64 %"tmp#9##0" to ptr + store i64 99999, ptr %"tmp#10##0" + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#17" to i64 )) + tail call fastcc void @"position.printPosition<0>"(i64 %"tmp#3##0") + %"tmp#11##0" = inttoptr i64 %"tmp#3##0" to ptr + %"tmp#12##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#12##0", ptr %"tmp#11##0", i64 16, i1 0) + %"tmp#13##0" = ptrtoint ptr %"tmp#12##0" to i64 + %"tmp#14##0" = inttoptr i64 %"tmp#13##0" to ptr + store i64 1111111111, ptr %"tmp#14##0" + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#16" to i64 )) + tail call fastcc void @"position.printPosition<0>"(i64 %"tmp#13##0") + %"tmp#15##0" = insertvalue {i64, i64} undef, i64 %"tmp#3##0", 0 + %"tmp#16##0" = insertvalue {i64, i64} %"tmp#15##0", i64 %"tmp#13##0", 1 + ret {i64, i64} %"tmp#16##0" } + -------------------------------------------------- Module position representation : (not a type) @@ -347,63 +275,42 @@ printPosition(pos##0:position.position)<{<>}; {<>}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'position' - - - - -@position.3 = constant {i64, i64} { i64 1, i64 ptrtoint ([?? x i8]* @position.2 to i64) } - - -@position.5 = constant {i64, i64} { i64 1, i64 ptrtoint ([?? x i8]* @position.4 to i64) } - - -@position.1 = constant {i64, i64} { i64 2, i64 ptrtoint ([?? x i8]* @position.0 to i64) } - - -@position.0 = constant [?? x i8] c" (\00" - - -@position.4 = constant [?? x i8] c")\00" - - -@position.2 = constant [?? x i8] c",\00" - - -declare external ccc void @putchar(i8) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc void @print_int(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"position.printPosition<0>"(i64 %"pos##0") { -entry: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @position.1, i32 0, i32 0) to i64)) - %0 = inttoptr i64 %"pos##0" to i64* - %1 = load i64, i64* %0 - tail call ccc void @print_int(i64 %1) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @position.3, i32 0, i32 0) to i64)) - %2 = add i64 %"pos##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - tail call ccc void @print_int(i64 %4) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @position.5, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - ret void +source_filename = "!ROOT!/final-dump/position.wybe" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c" (\00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c")\00", align 8 +@"cstring#2" = private unnamed_addr constant [ ?? x i8 ] c",\00", align 8 +@"string#3" = private unnamed_addr constant {i64, i64} { i64 2, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +@"string#4" = private unnamed_addr constant {i64, i64} { i64 1, i64 ptrtoint( ptr @"cstring#1" to i64 ) }, align 8 +@"string#5" = private unnamed_addr constant {i64, i64} { i64 1, i64 ptrtoint( ptr @"cstring#2" to i64 ) }, align 8 + +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"position.printPosition<0>"(i64 %"pos##0") { + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#3" to i64 )) + %"tmp#13##0" = inttoptr i64 %"pos##0" to ptr + %"tmp#0##0" = load i64, ptr %"tmp#13##0" + call ccc void @print_int(i64 %"tmp#0##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#5" to i64 )) + %"tmp#14##0" = add i64 %"pos##0", 8 + %"tmp#15##0" = inttoptr i64 %"tmp#14##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#15##0" + call ccc void @print_int(i64 %"tmp#1##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#4" to i64 )) + call ccc void @putchar(i8 10) + ret void } + -------------------------------------------------- Module position.position - representation : address + representation : pointer public submods : public resources: public procs : position.position.=<0> @@ -505,134 +412,110 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'position.position' - - - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i1 @"position.position.=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %"#right##0" to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = icmp eq i64 %1, %6 - br i1 %10, label %if.then, label %if.else -if.then: - %11 = icmp eq i64 %4, %9 - ret i1 %11 -if.else: - ret i1 0 +source_filename = "!ROOT!/final-dump/position.wybe" +target triple ???? + + +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc i1 @"position.position.=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#9##0" = inttoptr i64 %"#left##0" to ptr + %"#left#x##0" = load i64, ptr %"tmp#9##0" + %"tmp#10##0" = add i64 %"#left##0", 8 + %"tmp#11##0" = inttoptr i64 %"tmp#10##0" to ptr + %"#left#y##0" = load i64, ptr %"tmp#11##0" + %"tmp#12##0" = inttoptr i64 %"#right##0" to ptr + %"#right#x##0" = load i64, ptr %"tmp#12##0" + %"tmp#13##0" = add i64 %"#right##0", 8 + %"tmp#14##0" = inttoptr i64 %"tmp#13##0" to ptr + %"#right#y##0" = load i64, ptr %"tmp#14##0" + %"tmp#1##0" = icmp eq i64 %"#left#x##0", %"#right#x##0" + br i1 %"tmp#1##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#15##0" = icmp eq i64 %"#left#y##0", %"#right#y##0" + ret i1 %"tmp#15##0" +if.else.0: + ret i1 0 } - -define external fastcc i64 @"position.position.position<0>"(i64 %"x##0", i64 %"y##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"x##0", i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"y##0", i64* %5 - ret i64 %2 +define external fastcc i64 @"position.position.position<0>"(i64 %"x##0", i64 %"y##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 16) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"x##0", ptr %"tmp#1##0" + %"tmp#2##0" = add i64 %"#rec##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"y##0", ptr %"tmp#3##0" + ret i64 %"#rec##0" } - -define external fastcc {i64, i64} @"position.position.position<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#result##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#result##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = insertvalue {i64, i64} undef, i64 %1, 0 - %6 = insertvalue {i64, i64} %5, i64 %4, 1 - ret {i64, i64} %6 +define external fastcc {i64, i64} @"position.position.position<1>"(i64 %"#result##0") { + %"tmp#0##0" = inttoptr i64 %"#result##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + %"tmp#2##0" = add i64 %"#result##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#3##0" + %"tmp#5##0" = insertvalue {i64, i64} undef, i64 %"tmp#1##0", 0 + %"tmp#6##0" = insertvalue {i64, i64} %"tmp#5##0", i64 %"tmp#4##0", 1 + ret {i64, i64} %"tmp#6##0" } - -define external fastcc i64 @"position.position.x<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#rec##0" to i64* - %1 = load i64, i64* %0 - ret i64 %1 +define external fastcc i64 @"position.position.x<0>"(i64 %"#rec##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + ret i64 %"tmp#1##0" } - -define external fastcc i64 @"position.position.x<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = inttoptr i64 %2 to i64* - store i64 %"#field##0", i64* %6 - ret i64 %2 +define external fastcc i64 @"position.position.x<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"#field##0", ptr %"tmp#3##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"position.position.y<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = add i64 %"#rec##0", 8 - %1 = inttoptr i64 %0 to i64* - %2 = load i64, i64* %1 - ret i64 %2 +define external fastcc i64 @"position.position.y<0>"(i64 %"#rec##0") { + %"tmp#0##0" = add i64 %"#rec##0", 8 + %"tmp#1##0" = inttoptr i64 %"tmp#0##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"position.position.y<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = add i64 %2, 8 - %7 = inttoptr i64 %6 to i64* - store i64 %"#field##0", i64* %7 - ret i64 %2 +define external fastcc i64 @"position.position.y<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = add i64 %"tmp#2##0", 8 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 %"#field##0", ptr %"tmp#4##0" + ret i64 %"tmp#2##0" } - -define external fastcc i1 @"position.position.~=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %"#right##0" to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = icmp eq i64 %1, %6 - br i1 %10, label %if.then, label %if.else -if.then: - %11 = icmp eq i64 %4, %9 - %12 = xor i1 %11, 1 - ret i1 %12 -if.else: - %13 = xor i1 0, 1 - ret i1 %13 +define external fastcc i1 @"position.position.~=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#8##0" = inttoptr i64 %"#left##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#8##0" + %"tmp#9##0" = add i64 %"#left##0", 8 + %"tmp#10##0" = inttoptr i64 %"tmp#9##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#10##0" + %"tmp#11##0" = inttoptr i64 %"#right##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#11##0" + %"tmp#12##0" = add i64 %"#right##0", 8 + %"tmp#13##0" = inttoptr i64 %"tmp#12##0" to ptr + %"tmp#6##0" = load i64, ptr %"tmp#13##0" + %"tmp#7##0" = icmp eq i64 %"tmp#3##0", %"tmp#5##0" + br i1 %"tmp#7##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#0##0" = icmp eq i64 %"tmp#4##0", %"tmp#6##0" + %"tmp#14##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#14##0" +if.else.0: + %"tmp#15##0" = xor i1 0, 1 + ret i1 %"tmp#15##0" } diff --git a/test-cases/final-dump/alias_recursion1.exp b/test-cases/final-dump/alias_recursion1.exp index 6e785a0a9..0fd04314d 100644 --- a/test-cases/final-dump/alias_recursion1.exp +++ b/test-cases/final-dump/alias_recursion1.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module alias_recursion1 representation : (not a type) public submods : @@ -73,147 +76,96 @@ if_test(a##0:position.position, b##0:position.position, ?r##0:position.position) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'alias_recursion1' - - - - -@alias_recursion1.13 = constant {i64, i64} { i64 17, i64 ptrtoint ([?? x i8]* @alias_recursion1.12 to i64) } - - -@alias_recursion1.3 = constant {i64, i64} { i64 19, i64 ptrtoint ([?? x i8]* @alias_recursion1.2 to i64) } - - -@alias_recursion1.11 = constant {i64, i64} { i64 20, i64 ptrtoint ([?? x i8]* @alias_recursion1.10 to i64) } - - -@alias_recursion1.15 = constant {i64, i64} { i64 21, i64 ptrtoint ([?? x i8]* @alias_recursion1.14 to i64) } - - -@alias_recursion1.5 = constant {i64, i64} { i64 21, i64 ptrtoint ([?? x i8]* @alias_recursion1.4 to i64) } - - -@alias_recursion1.1 = constant {i64, i64} { i64 22, i64 ptrtoint ([?? x i8]* @alias_recursion1.0 to i64) } - - -@alias_recursion1.17 = constant {i64, i64} { i64 27, i64 ptrtoint ([?? x i8]* @alias_recursion1.16 to i64) } - - -@alias_recursion1.9 = constant {i64, i64} { i64 38, i64 ptrtoint ([?? x i8]* @alias_recursion1.8 to i64) } - - -@alias_recursion1.7 = constant {i64, i64} { i64 57, i64 ptrtoint ([?? x i8]* @alias_recursion1.6 to i64) } - - -@alias_recursion1.6 = constant [?? x i8] c"--- after calling if_test, pa and pb should be the same: \00" - - -@alias_recursion1.0 = constant [?? x i8] c"--- before proc call: \00" - - -@alias_recursion1.8 = constant [?? x i8] c"--- expected result to be same as pb: \00" - - -@alias_recursion1.12 = constant [?? x i8] c"--- modify pa^x: \00" - - -@alias_recursion1.14 = constant [?? x i8] c"expect pa(-1000,101):\00" - - -@alias_recursion1.2 = constant [?? x i8] c"expect pa(100,101):\00" - - -@alias_recursion1.4 = constant [?? x i8] c"expect pb(-200,-201):\00" - - -@alias_recursion1.16 = constant [?? x i8] c"expect r still (-200,-201):\00" - - -@alias_recursion1.10 = constant [?? x i8] c"expect r(-200,-201):\00" - - -declare external fastcc void @"position.printPosition<0>"(i64) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc void @putchar(i8) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"alias_recursion1.<0>"() { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 100, i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 101, i64* %5 - %6 = trunc i64 16 to i32 - %7 = tail call ccc i8* @wybe_malloc(i32 %6) - %8 = ptrtoint i8* %7 to i64 - %9 = inttoptr i64 %8 to i64* - store i64 -200, i64* %9 - %10 = add i64 %8, 8 - %11 = inttoptr i64 %10 to i64* - store i64 -201, i64* %11 - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_recursion1.1, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_recursion1.3, i32 0, i32 0) to i64)) - tail call fastcc void @"position.printPosition<0>"(i64 %2) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_recursion1.5, i32 0, i32 0) to i64)) - tail call fastcc void @"position.printPosition<0>"(i64 %8) - %12 = tail call fastcc i64 @"alias_recursion1.if_test<0>"(i64 %2, i64 %8) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_recursion1.7, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_recursion1.3, i32 0, i32 0) to i64)) - tail call fastcc void @"position.printPosition<0>"(i64 %2) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_recursion1.5, i32 0, i32 0) to i64)) - tail call fastcc void @"position.printPosition<0>"(i64 %8) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_recursion1.9, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_recursion1.11, i32 0, i32 0) to i64)) - tail call fastcc void @"position.printPosition<0>"(i64 %12) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_recursion1.13, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - %13 = trunc i64 16 to i32 - %14 = tail call ccc i8* @wybe_malloc(i32 %13) - %15 = ptrtoint i8* %14 to i64 - %16 = inttoptr i64 %15 to i8* - %17 = inttoptr i64 %2 to i8* - %18 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %16, i8* %17, i32 %18, i1 0) - %19 = inttoptr i64 %15 to i64* - store i64 -1000, i64* %19 - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_recursion1.15, i32 0, i32 0) to i64)) - tail call fastcc void @"position.printPosition<0>"(i64 %15) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_recursion1.17, i32 0, i32 0) to i64)) - tail call fastcc void @"position.printPosition<0>"(i64 %12) - ret void +source_filename = "!ROOT!/final-dump/alias_recursion1.wybe" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c"--- after calling if_test, pa and pb should be the same: \00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c"--- before proc call: \00", align 8 +@"cstring#2" = private unnamed_addr constant [ ?? x i8 ] c"--- expected result to be same as pb: \00", align 8 +@"cstring#3" = private unnamed_addr constant [ ?? x i8 ] c"--- modify pa^x: \00", align 8 +@"cstring#4" = private unnamed_addr constant [ ?? x i8 ] c"expect pa(-1000,101):\00", align 8 +@"cstring#5" = private unnamed_addr constant [ ?? x i8 ] c"expect pa(100,101):\00", align 8 +@"cstring#6" = private unnamed_addr constant [ ?? x i8 ] c"expect pb(-200,-201):\00", align 8 +@"cstring#7" = private unnamed_addr constant [ ?? x i8 ] c"expect r still (-200,-201):\00", align 8 +@"cstring#8" = private unnamed_addr constant [ ?? x i8 ] c"expect r(-200,-201):\00", align 8 +@"string#9" = private unnamed_addr constant {i64, i64} { i64 57, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +@"string#10" = private unnamed_addr constant {i64, i64} { i64 22, i64 ptrtoint( ptr @"cstring#1" to i64 ) }, align 8 +@"string#11" = private unnamed_addr constant {i64, i64} { i64 38, i64 ptrtoint( ptr @"cstring#2" to i64 ) }, align 8 +@"string#12" = private unnamed_addr constant {i64, i64} { i64 17, i64 ptrtoint( ptr @"cstring#3" to i64 ) }, align 8 +@"string#13" = private unnamed_addr constant {i64, i64} { i64 21, i64 ptrtoint( ptr @"cstring#4" to i64 ) }, align 8 +@"string#14" = private unnamed_addr constant {i64, i64} { i64 19, i64 ptrtoint( ptr @"cstring#5" to i64 ) }, align 8 +@"string#15" = private unnamed_addr constant {i64, i64} { i64 21, i64 ptrtoint( ptr @"cstring#6" to i64 ) }, align 8 +@"string#16" = private unnamed_addr constant {i64, i64} { i64 27, i64 ptrtoint( ptr @"cstring#7" to i64 ) }, align 8 +@"string#17" = private unnamed_addr constant {i64, i64} { i64 20, i64 ptrtoint( ptr @"cstring#8" to i64 ) }, align 8 + +declare external fastcc void @"position.printPosition<0>"(i64) +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @putchar(i8) +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"alias_recursion1.<0>"() { + %"tmp#24##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#4##0" = ptrtoint ptr %"tmp#24##0" to i64 + %"tmp#25##0" = inttoptr i64 %"tmp#4##0" to ptr + store i64 100, ptr %"tmp#25##0" + %"tmp#26##0" = add i64 %"tmp#4##0", 8 + %"tmp#27##0" = inttoptr i64 %"tmp#26##0" to ptr + store i64 101, ptr %"tmp#27##0" + %"tmp#28##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#8##0" = ptrtoint ptr %"tmp#28##0" to i64 + %"tmp#29##0" = inttoptr i64 %"tmp#8##0" to ptr + store i64 -200, ptr %"tmp#29##0" + %"tmp#30##0" = add i64 %"tmp#8##0", 8 + %"tmp#31##0" = inttoptr i64 %"tmp#30##0" to ptr + store i64 -201, ptr %"tmp#31##0" + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#10" to i64 )) + call ccc void @putchar(i8 10) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#14" to i64 )) + tail call fastcc void @"position.printPosition<0>"(i64 %"tmp#4##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#15" to i64 )) + tail call fastcc void @"position.printPosition<0>"(i64 %"tmp#8##0") + %"r##0" = tail call fastcc i64 @"alias_recursion1.if_test<0>"(i64 %"tmp#4##0", i64 %"tmp#8##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#9" to i64 )) + call ccc void @putchar(i8 10) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#14" to i64 )) + tail call fastcc void @"position.printPosition<0>"(i64 %"tmp#4##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#15" to i64 )) + tail call fastcc void @"position.printPosition<0>"(i64 %"tmp#8##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#11" to i64 )) + call ccc void @putchar(i8 10) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#17" to i64 )) + tail call fastcc void @"position.printPosition<0>"(i64 %"r##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#12" to i64 )) + call ccc void @putchar(i8 10) + %"tmp#32##0" = inttoptr i64 %"tmp#4##0" to ptr + %"tmp#33##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#33##0", ptr %"tmp#32##0", i64 16, i1 0) + %"tmp#34##0" = ptrtoint ptr %"tmp#33##0" to i64 + %"tmp#35##0" = inttoptr i64 %"tmp#34##0" to ptr + store i64 -1000, ptr %"tmp#35##0" + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#13" to i64 )) + tail call fastcc void @"position.printPosition<0>"(i64 %"tmp#34##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#16" to i64 )) + tail call fastcc void @"position.printPosition<0>"(i64 %"r##0") + ret void } - -define external fastcc i64 @"alias_recursion1.if_test<0>"(i64 %"a##0", i64 %"b##0") { -entry: - %0 = inttoptr i64 %"a##0" to i64* - %1 = load i64, i64* %0 - %2 = icmp sgt i64 %1, 0 - br i1 %2, label %if.then, label %if.else -if.then: - %3 = musttail call fastcc i64 @"alias_recursion1.if_test<0>"(i64 %"b##0", i64 %"a##0") - ret i64 %3 -if.else: - ret i64 %"a##0" +define external fastcc i64 @"alias_recursion1.if_test<0>"(i64 %"a##0", i64 %"b##0") { + %"tmp#5##0" = inttoptr i64 %"a##0" to ptr + %"tmp#0##0" = load i64, ptr %"tmp#5##0" + %"tmp#1##0" = icmp sgt i64 %"tmp#0##0", 0 + br i1 %"tmp#1##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#6##0" = tail call fastcc i64 @"alias_recursion1.if_test<0>"(i64 %"b##0", i64 %"a##0") + ret i64 %"tmp#6##0" +if.else.0: + ret i64 %"a##0" } + -------------------------------------------------- Module position representation : (not a type) @@ -256,63 +208,42 @@ printPosition(pos##0:position.position)<{<>}; {<>}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'position' - - - - -@position.3 = constant {i64, i64} { i64 1, i64 ptrtoint ([?? x i8]* @position.2 to i64) } - - -@position.5 = constant {i64, i64} { i64 1, i64 ptrtoint ([?? x i8]* @position.4 to i64) } - - -@position.1 = constant {i64, i64} { i64 2, i64 ptrtoint ([?? x i8]* @position.0 to i64) } - - -@position.0 = constant [?? x i8] c" (\00" - - -@position.4 = constant [?? x i8] c")\00" - - -@position.2 = constant [?? x i8] c",\00" - - -declare external ccc void @putchar(i8) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc void @print_int(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"position.printPosition<0>"(i64 %"pos##0") { -entry: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @position.1, i32 0, i32 0) to i64)) - %0 = inttoptr i64 %"pos##0" to i64* - %1 = load i64, i64* %0 - tail call ccc void @print_int(i64 %1) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @position.3, i32 0, i32 0) to i64)) - %2 = add i64 %"pos##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - tail call ccc void @print_int(i64 %4) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @position.5, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - ret void +source_filename = "!ROOT!/final-dump/position.wybe" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c" (\00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c")\00", align 8 +@"cstring#2" = private unnamed_addr constant [ ?? x i8 ] c",\00", align 8 +@"string#3" = private unnamed_addr constant {i64, i64} { i64 2, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +@"string#4" = private unnamed_addr constant {i64, i64} { i64 1, i64 ptrtoint( ptr @"cstring#1" to i64 ) }, align 8 +@"string#5" = private unnamed_addr constant {i64, i64} { i64 1, i64 ptrtoint( ptr @"cstring#2" to i64 ) }, align 8 + +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"position.printPosition<0>"(i64 %"pos##0") { + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#3" to i64 )) + %"tmp#13##0" = inttoptr i64 %"pos##0" to ptr + %"tmp#0##0" = load i64, ptr %"tmp#13##0" + call ccc void @print_int(i64 %"tmp#0##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#5" to i64 )) + %"tmp#14##0" = add i64 %"pos##0", 8 + %"tmp#15##0" = inttoptr i64 %"tmp#14##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#15##0" + call ccc void @print_int(i64 %"tmp#1##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#4" to i64 )) + call ccc void @putchar(i8 10) + ret void } + -------------------------------------------------- Module position.position - representation : address + representation : pointer public submods : public resources: public procs : position.position.=<0> @@ -414,134 +345,110 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'position.position' - - - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i1 @"position.position.=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %"#right##0" to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = icmp eq i64 %1, %6 - br i1 %10, label %if.then, label %if.else -if.then: - %11 = icmp eq i64 %4, %9 - ret i1 %11 -if.else: - ret i1 0 +source_filename = "!ROOT!/final-dump/position.wybe" +target triple ???? + + +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc i1 @"position.position.=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#9##0" = inttoptr i64 %"#left##0" to ptr + %"#left#x##0" = load i64, ptr %"tmp#9##0" + %"tmp#10##0" = add i64 %"#left##0", 8 + %"tmp#11##0" = inttoptr i64 %"tmp#10##0" to ptr + %"#left#y##0" = load i64, ptr %"tmp#11##0" + %"tmp#12##0" = inttoptr i64 %"#right##0" to ptr + %"#right#x##0" = load i64, ptr %"tmp#12##0" + %"tmp#13##0" = add i64 %"#right##0", 8 + %"tmp#14##0" = inttoptr i64 %"tmp#13##0" to ptr + %"#right#y##0" = load i64, ptr %"tmp#14##0" + %"tmp#1##0" = icmp eq i64 %"#left#x##0", %"#right#x##0" + br i1 %"tmp#1##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#15##0" = icmp eq i64 %"#left#y##0", %"#right#y##0" + ret i1 %"tmp#15##0" +if.else.0: + ret i1 0 } - -define external fastcc i64 @"position.position.position<0>"(i64 %"x##0", i64 %"y##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"x##0", i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"y##0", i64* %5 - ret i64 %2 +define external fastcc i64 @"position.position.position<0>"(i64 %"x##0", i64 %"y##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 16) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"x##0", ptr %"tmp#1##0" + %"tmp#2##0" = add i64 %"#rec##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"y##0", ptr %"tmp#3##0" + ret i64 %"#rec##0" } - -define external fastcc {i64, i64} @"position.position.position<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#result##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#result##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = insertvalue {i64, i64} undef, i64 %1, 0 - %6 = insertvalue {i64, i64} %5, i64 %4, 1 - ret {i64, i64} %6 +define external fastcc {i64, i64} @"position.position.position<1>"(i64 %"#result##0") { + %"tmp#0##0" = inttoptr i64 %"#result##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + %"tmp#2##0" = add i64 %"#result##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#3##0" + %"tmp#5##0" = insertvalue {i64, i64} undef, i64 %"tmp#1##0", 0 + %"tmp#6##0" = insertvalue {i64, i64} %"tmp#5##0", i64 %"tmp#4##0", 1 + ret {i64, i64} %"tmp#6##0" } - -define external fastcc i64 @"position.position.x<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#rec##0" to i64* - %1 = load i64, i64* %0 - ret i64 %1 +define external fastcc i64 @"position.position.x<0>"(i64 %"#rec##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + ret i64 %"tmp#1##0" } - -define external fastcc i64 @"position.position.x<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = inttoptr i64 %2 to i64* - store i64 %"#field##0", i64* %6 - ret i64 %2 +define external fastcc i64 @"position.position.x<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"#field##0", ptr %"tmp#3##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"position.position.y<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = add i64 %"#rec##0", 8 - %1 = inttoptr i64 %0 to i64* - %2 = load i64, i64* %1 - ret i64 %2 +define external fastcc i64 @"position.position.y<0>"(i64 %"#rec##0") { + %"tmp#0##0" = add i64 %"#rec##0", 8 + %"tmp#1##0" = inttoptr i64 %"tmp#0##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"position.position.y<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = add i64 %2, 8 - %7 = inttoptr i64 %6 to i64* - store i64 %"#field##0", i64* %7 - ret i64 %2 +define external fastcc i64 @"position.position.y<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = add i64 %"tmp#2##0", 8 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 %"#field##0", ptr %"tmp#4##0" + ret i64 %"tmp#2##0" } - -define external fastcc i1 @"position.position.~=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %"#right##0" to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = icmp eq i64 %1, %6 - br i1 %10, label %if.then, label %if.else -if.then: - %11 = icmp eq i64 %4, %9 - %12 = xor i1 %11, 1 - ret i1 %12 -if.else: - %13 = xor i1 0, 1 - ret i1 %13 +define external fastcc i1 @"position.position.~=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#8##0" = inttoptr i64 %"#left##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#8##0" + %"tmp#9##0" = add i64 %"#left##0", 8 + %"tmp#10##0" = inttoptr i64 %"tmp#9##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#10##0" + %"tmp#11##0" = inttoptr i64 %"#right##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#11##0" + %"tmp#12##0" = add i64 %"#right##0", 8 + %"tmp#13##0" = inttoptr i64 %"tmp#12##0" to ptr + %"tmp#6##0" = load i64, ptr %"tmp#13##0" + %"tmp#7##0" = icmp eq i64 %"tmp#3##0", %"tmp#5##0" + br i1 %"tmp#7##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#0##0" = icmp eq i64 %"tmp#4##0", %"tmp#6##0" + %"tmp#14##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#14##0" +if.else.0: + %"tmp#15##0" = xor i1 0, 1 + ret i1 %"tmp#15##0" } diff --git a/test-cases/final-dump/alias_scc_proc.exp b/test-cases/final-dump/alias_scc_proc.exp index 81a2e074b..4dbb1833c 100644 --- a/test-cases/final-dump/alias_scc_proc.exp +++ b/test-cases/final-dump/alias_scc_proc.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module alias_scc_proc representation : (not a type) public submods : @@ -34,7 +37,7 @@ module top-level code > public {semipure} (0 calls) proc bar > public (1 calls) -0: alias_scc_proc.bar<0>[410bae77d3] +0: alias_scc_proc.bar<0> bar(p1##0:position.position, ?p3##1:position.position)<{<>}; {<>}; {}>: AliasPairs: [(p1##0,p3##1)] InterestingCallProperties: [InterestingUnaliased 0] @@ -65,7 +68,7 @@ bar(p1##0:position.position, ?p3##1:position.position)<{<>}; {< public (2 calls) -0: alias_scc_proc.foo<0>[410bae77d3] +0: alias_scc_proc.foo<0> foo(p1##0:position.position, ?p2##0:position.position, ?p3##0:position.position)<{<>}; {<>}; {}>: AliasPairs: [(p1##0,p2##0)] InterestingCallProperties: [InterestingUnaliased 0] @@ -114,214 +117,167 @@ foo(p1##0:position.position, ?p2##0:position.position, ?p3##0:position.position) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'alias_scc_proc' - - - - -@alias_scc_proc.3 = constant {i64, i64} { i64 15, i64 ptrtoint ([?? x i8]* @alias_scc_proc.2 to i64) } - - -@alias_scc_proc.5 = constant {i64, i64} { i64 15, i64 ptrtoint ([?? x i8]* @alias_scc_proc.4 to i64) } - - -@alias_scc_proc.7 = constant {i64, i64} { i64 15, i64 ptrtoint ([?? x i8]* @alias_scc_proc.6 to i64) } - - -@alias_scc_proc.1 = constant {i64, i64} { i64 23, i64 ptrtoint ([?? x i8]* @alias_scc_proc.0 to i64) } - - -@alias_scc_proc.9 = constant {i64, i64} { i64 31, i64 ptrtoint ([?? x i8]* @alias_scc_proc.8 to i64) } - - -@alias_scc_proc.0 = constant [?? x i8] c"--- After calling foo: \00" - - -@alias_scc_proc.8 = constant [?? x i8] c"--- Inside foo: expect p3(3,3):\00" - - -@alias_scc_proc.2 = constant [?? x i8] c"expect p1(2,2):\00" - - -@alias_scc_proc.4 = constant [?? x i8] c"expect p2(2,2):\00" - - -@alias_scc_proc.6 = constant [?? x i8] c"expect p3(3,3):\00" - - -declare external fastcc void @"position.printPosition<0>"(i64) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc void @putchar(i8) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"alias_scc_proc.<0>"() { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 1, i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 1, i64* %5 - %6 = tail call fastcc {i64, i64} @"alias_scc_proc.foo<0>"(i64 %2) - %7 = extractvalue {i64, i64} %6, 0 - %8 = extractvalue {i64, i64} %6, 1 - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_scc_proc.1, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_scc_proc.3, i32 0, i32 0) to i64)) - tail call fastcc void @"position.printPosition<0>"(i64 %2) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_scc_proc.5, i32 0, i32 0) to i64)) - tail call fastcc void @"position.printPosition<0>"(i64 %7) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_scc_proc.7, i32 0, i32 0) to i64)) - tail call fastcc void @"position.printPosition<0>"(i64 %8) - ret void +source_filename = "!ROOT!/final-dump/alias_scc_proc.wybe" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c"--- After calling foo: \00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c"--- Inside foo: expect p3(3,3):\00", align 8 +@"cstring#2" = private unnamed_addr constant [ ?? x i8 ] c"expect p1(2,2):\00", align 8 +@"cstring#3" = private unnamed_addr constant [ ?? x i8 ] c"expect p2(2,2):\00", align 8 +@"cstring#4" = private unnamed_addr constant [ ?? x i8 ] c"expect p3(3,3):\00", align 8 +@"string#5" = private unnamed_addr constant {i64, i64} { i64 23, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +@"string#6" = private unnamed_addr constant {i64, i64} { i64 31, i64 ptrtoint( ptr @"cstring#1" to i64 ) }, align 8 +@"string#7" = private unnamed_addr constant {i64, i64} { i64 15, i64 ptrtoint( ptr @"cstring#2" to i64 ) }, align 8 +@"string#8" = private unnamed_addr constant {i64, i64} { i64 15, i64 ptrtoint( ptr @"cstring#3" to i64 ) }, align 8 +@"string#9" = private unnamed_addr constant {i64, i64} { i64 15, i64 ptrtoint( ptr @"cstring#4" to i64 ) }, align 8 + +declare external fastcc void @"position.printPosition<0>"(i64) +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @putchar(i8) +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"alias_scc_proc.<0>"() { + %"tmp#8##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#3##0" = ptrtoint ptr %"tmp#8##0" to i64 + %"tmp#9##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 1, ptr %"tmp#9##0" + %"tmp#10##0" = add i64 %"tmp#3##0", 8 + %"tmp#11##0" = inttoptr i64 %"tmp#10##0" to ptr + store i64 1, ptr %"tmp#11##0" + %"tmp#12##0" = tail call fastcc {i64, i64} @"alias_scc_proc.foo<0>"(i64 %"tmp#3##0") + %"p2##0" = extractvalue {i64, i64}%"tmp#12##0", 0 + %"p3##0" = extractvalue {i64, i64}%"tmp#12##0", 1 + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#5" to i64 )) + call ccc void @putchar(i8 10) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#7" to i64 )) + tail call fastcc void @"position.printPosition<0>"(i64 %"tmp#3##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#8" to i64 )) + tail call fastcc void @"position.printPosition<0>"(i64 %"p2##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#9" to i64 )) + tail call fastcc void @"position.printPosition<0>"(i64 %"p3##0") + ret void } - -define external fastcc i64 @"alias_scc_proc.bar<0>"(i64 %"p1##0") { -entry: - %0 = add i64 %"p1##0", 8 - %1 = inttoptr i64 %0 to i64* - %2 = load i64, i64* %1 - %3 = icmp sgt i64 %2, 1 - br i1 %3, label %if.then, label %if.else -if.then: - ret i64 %"p1##0" -if.else: - %4 = add i64 %2, 1 - %5 = trunc i64 16 to i32 - %6 = tail call ccc i8* @wybe_malloc(i32 %5) - %7 = ptrtoint i8* %6 to i64 - %8 = inttoptr i64 %7 to i8* - %9 = inttoptr i64 %"p1##0" to i8* - %10 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %8, i8* %9, i32 %10, i1 0) - %11 = add i64 %7, 8 - %12 = inttoptr i64 %11 to i64* - store i64 %4, i64* %12 - %13 = tail call fastcc {i64, i64} @"alias_scc_proc.foo<0>[410bae77d3]"(i64 %7) - %14 = extractvalue {i64, i64} %13, 0 - %15 = extractvalue {i64, i64} %13, 1 - ret i64 %15 +define external fastcc i64 @"alias_scc_proc.bar<0>"(i64 %"p1##0") { + %"tmp#12##0" = add i64 %"p1##0", 8 + %"tmp#13##0" = inttoptr i64 %"tmp#12##0" to ptr + %"tmp#0##0" = load i64, ptr %"tmp#13##0" + %"tmp#3##0" = icmp sgt i64 %"tmp#0##0", 1 + br i1 %"tmp#3##0", label %if.then.0, label %if.else.0 +if.then.0: + ret i64 %"p1##0" +if.else.0: + %"tmp#2##0" = add i64 %"tmp#0##0", 1 + %"tmp#14##0" = inttoptr i64 %"p1##0" to ptr + %"tmp#15##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#15##0", ptr %"tmp#14##0", i64 16, i1 0) + %"tmp#16##0" = ptrtoint ptr %"tmp#15##0" to i64 + %"tmp#17##0" = add i64 %"tmp#16##0", 8 + %"tmp#18##0" = inttoptr i64 %"tmp#17##0" to ptr + store i64 %"tmp#2##0", ptr %"tmp#18##0" + %"tmp#19##0" = tail call fastcc {i64, i64} @"alias_scc_proc.foo<0>[410bae77d3]"(i64 %"tmp#16##0") + %"p2##0" = extractvalue {i64, i64}%"tmp#19##0", 0 + %"tmp#20##0" = extractvalue {i64, i64}%"tmp#19##0", 1 + ret i64 %"tmp#20##0" } - -define external fastcc i64 @"alias_scc_proc.bar<0>[410bae77d3]"(i64 %"p1##0") { -entry: - %0 = add i64 %"p1##0", 8 - %1 = inttoptr i64 %0 to i64* - %2 = load i64, i64* %1 - %3 = icmp sgt i64 %2, 1 - br i1 %3, label %if.then, label %if.else -if.then: - ret i64 %"p1##0" -if.else: - %4 = add i64 %2, 1 - %5 = add i64 %"p1##0", 8 - %6 = inttoptr i64 %5 to i64* - store i64 %4, i64* %6 - %7 = tail call fastcc {i64, i64} @"alias_scc_proc.foo<0>[410bae77d3]"(i64 %"p1##0") - %8 = extractvalue {i64, i64} %7, 0 - %9 = extractvalue {i64, i64} %7, 1 - ret i64 %9 +define external fastcc i64 @"alias_scc_proc.bar<0>[410bae77d3]"(i64 %"p1##0") { + %"tmp#12##0" = add i64 %"p1##0", 8 + %"tmp#13##0" = inttoptr i64 %"tmp#12##0" to ptr + %"tmp#0##0" = load i64, ptr %"tmp#13##0" + %"tmp#3##0" = icmp sgt i64 %"tmp#0##0", 1 + br i1 %"tmp#3##0", label %if.then.0, label %if.else.0 +if.then.0: + ret i64 %"p1##0" +if.else.0: + %"tmp#2##0" = add i64 %"tmp#0##0", 1 + %"tmp#14##0" = add i64 %"p1##0", 8 + %"tmp#15##0" = inttoptr i64 %"tmp#14##0" to ptr + store i64 %"tmp#2##0", ptr %"tmp#15##0" + %"tmp#16##0" = tail call fastcc {i64, i64} @"alias_scc_proc.foo<0>[410bae77d3]"(i64 %"p1##0") + %"p2##0" = extractvalue {i64, i64}%"tmp#16##0", 0 + %"tmp#17##0" = extractvalue {i64, i64}%"tmp#16##0", 1 + ret i64 %"tmp#17##0" } - -define external fastcc {i64, i64} @"alias_scc_proc.foo<0>"(i64 %"p1##0") { -entry: - %0 = inttoptr i64 %"p1##0" to i64* - %1 = load i64, i64* %0 - %2 = icmp sgt i64 %1, 1 - br i1 %2, label %if.then, label %if.else -if.then: - %3 = trunc i64 16 to i32 - %4 = tail call ccc i8* @wybe_malloc(i32 %3) - %5 = ptrtoint i8* %4 to i64 - %6 = inttoptr i64 %5 to i64* - store i64 3, i64* %6 - %7 = add i64 %5, 8 - %8 = inttoptr i64 %7 to i64* - store i64 3, i64* %8 - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_scc_proc.9, i32 0, i32 0) to i64)) - tail call fastcc void @"position.printPosition<0>"(i64 %5) - %9 = insertvalue {i64, i64} undef, i64 %"p1##0", 0 - %10 = insertvalue {i64, i64} %9, i64 %5, 1 - ret {i64, i64} %10 -if.else: - %11 = add i64 %1, 1 - %12 = trunc i64 16 to i32 - %13 = tail call ccc i8* @wybe_malloc(i32 %12) - %14 = ptrtoint i8* %13 to i64 - %15 = inttoptr i64 %14 to i8* - %16 = inttoptr i64 %"p1##0" to i8* - %17 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %15, i8* %16, i32 %17, i1 0) - %18 = inttoptr i64 %14 to i64* - store i64 %11, i64* %18 - %19 = tail call fastcc i64 @"alias_scc_proc.bar<0>[410bae77d3]"(i64 %14) - %20 = trunc i64 16 to i32 - %21 = tail call ccc i8* @wybe_malloc(i32 %20) - %22 = ptrtoint i8* %21 to i64 - %23 = inttoptr i64 %22 to i64* - store i64 2, i64* %23 - %24 = add i64 %22, 8 - %25 = inttoptr i64 %24 to i64* - store i64 2, i64* %25 - %26 = insertvalue {i64, i64} undef, i64 %22, 0 - %27 = insertvalue {i64, i64} %26, i64 %19, 1 - ret {i64, i64} %27 +define external fastcc {i64, i64} @"alias_scc_proc.foo<0>"(i64 %"p1##0") { + %"tmp#22##0" = inttoptr i64 %"p1##0" to ptr + %"tmp#0##0" = load i64, ptr %"tmp#22##0" + %"tmp#5##0" = icmp sgt i64 %"tmp#0##0", 1 + br i1 %"tmp#5##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#23##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#20##0" = ptrtoint ptr %"tmp#23##0" to i64 + %"tmp#24##0" = inttoptr i64 %"tmp#20##0" to ptr + store i64 3, ptr %"tmp#24##0" + %"tmp#25##0" = add i64 %"tmp#20##0", 8 + %"tmp#26##0" = inttoptr i64 %"tmp#25##0" to ptr + store i64 3, ptr %"tmp#26##0" + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#6" to i64 )) + tail call fastcc void @"position.printPosition<0>"(i64 %"tmp#20##0") + %"tmp#27##0" = insertvalue {i64, i64} undef, i64 %"p1##0", 0 + %"tmp#28##0" = insertvalue {i64, i64} %"tmp#27##0", i64 %"tmp#20##0", 1 + ret {i64, i64} %"tmp#28##0" +if.else.0: + %"tmp#3##0" = add i64 %"tmp#0##0", 1 + %"tmp#29##0" = inttoptr i64 %"p1##0" to ptr + %"tmp#30##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#30##0", ptr %"tmp#29##0", i64 16, i1 0) + %"tmp#31##0" = ptrtoint ptr %"tmp#30##0" to i64 + %"tmp#32##0" = inttoptr i64 %"tmp#31##0" to ptr + store i64 %"tmp#3##0", ptr %"tmp#32##0" + %"tmp#33##0" = tail call fastcc i64 @"alias_scc_proc.bar<0>[410bae77d3]"(i64 %"tmp#31##0") + %"tmp#34##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#16##0" = ptrtoint ptr %"tmp#34##0" to i64 + %"tmp#35##0" = inttoptr i64 %"tmp#16##0" to ptr + store i64 2, ptr %"tmp#35##0" + %"tmp#36##0" = add i64 %"tmp#16##0", 8 + %"tmp#37##0" = inttoptr i64 %"tmp#36##0" to ptr + store i64 2, ptr %"tmp#37##0" + %"tmp#38##0" = insertvalue {i64, i64} undef, i64 %"tmp#16##0", 0 + %"tmp#39##0" = insertvalue {i64, i64} %"tmp#38##0", i64 %"tmp#33##0", 1 + ret {i64, i64} %"tmp#39##0" } - -define external fastcc {i64, i64} @"alias_scc_proc.foo<0>[410bae77d3]"(i64 %"p1##0") { -entry: - %0 = inttoptr i64 %"p1##0" to i64* - %1 = load i64, i64* %0 - %2 = icmp sgt i64 %1, 1 - br i1 %2, label %if.then, label %if.else -if.then: - %3 = trunc i64 16 to i32 - %4 = tail call ccc i8* @wybe_malloc(i32 %3) - %5 = ptrtoint i8* %4 to i64 - %6 = inttoptr i64 %5 to i64* - store i64 3, i64* %6 - %7 = add i64 %5, 8 - %8 = inttoptr i64 %7 to i64* - store i64 3, i64* %8 - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @alias_scc_proc.9, i32 0, i32 0) to i64)) - tail call fastcc void @"position.printPosition<0>"(i64 %5) - %9 = insertvalue {i64, i64} undef, i64 %"p1##0", 0 - %10 = insertvalue {i64, i64} %9, i64 %5, 1 - ret {i64, i64} %10 -if.else: - %11 = add i64 %1, 1 - %12 = inttoptr i64 %"p1##0" to i64* - store i64 %11, i64* %12 - %13 = tail call fastcc i64 @"alias_scc_proc.bar<0>[410bae77d3]"(i64 %"p1##0") - %14 = trunc i64 16 to i32 - %15 = tail call ccc i8* @wybe_malloc(i32 %14) - %16 = ptrtoint i8* %15 to i64 - %17 = inttoptr i64 %16 to i64* - store i64 2, i64* %17 - %18 = add i64 %16, 8 - %19 = inttoptr i64 %18 to i64* - store i64 2, i64* %19 - %20 = insertvalue {i64, i64} undef, i64 %16, 0 - %21 = insertvalue {i64, i64} %20, i64 %13, 1 - ret {i64, i64} %21 +define external fastcc {i64, i64} @"alias_scc_proc.foo<0>[410bae77d3]"(i64 %"p1##0") { + %"tmp#22##0" = inttoptr i64 %"p1##0" to ptr + %"tmp#0##0" = load i64, ptr %"tmp#22##0" + %"tmp#5##0" = icmp sgt i64 %"tmp#0##0", 1 + br i1 %"tmp#5##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#23##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#20##0" = ptrtoint ptr %"tmp#23##0" to i64 + %"tmp#24##0" = inttoptr i64 %"tmp#20##0" to ptr + store i64 3, ptr %"tmp#24##0" + %"tmp#25##0" = add i64 %"tmp#20##0", 8 + %"tmp#26##0" = inttoptr i64 %"tmp#25##0" to ptr + store i64 3, ptr %"tmp#26##0" + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#6" to i64 )) + tail call fastcc void @"position.printPosition<0>"(i64 %"tmp#20##0") + %"tmp#27##0" = insertvalue {i64, i64} undef, i64 %"p1##0", 0 + %"tmp#28##0" = insertvalue {i64, i64} %"tmp#27##0", i64 %"tmp#20##0", 1 + ret {i64, i64} %"tmp#28##0" +if.else.0: + %"tmp#3##0" = add i64 %"tmp#0##0", 1 + %"tmp#29##0" = inttoptr i64 %"p1##0" to ptr + store i64 %"tmp#3##0", ptr %"tmp#29##0" + %"tmp#30##0" = tail call fastcc i64 @"alias_scc_proc.bar<0>[410bae77d3]"(i64 %"p1##0") + %"tmp#31##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#16##0" = ptrtoint ptr %"tmp#31##0" to i64 + %"tmp#32##0" = inttoptr i64 %"tmp#16##0" to ptr + store i64 2, ptr %"tmp#32##0" + %"tmp#33##0" = add i64 %"tmp#16##0", 8 + %"tmp#34##0" = inttoptr i64 %"tmp#33##0" to ptr + store i64 2, ptr %"tmp#34##0" + %"tmp#35##0" = insertvalue {i64, i64} undef, i64 %"tmp#16##0", 0 + %"tmp#36##0" = insertvalue {i64, i64} %"tmp#35##0", i64 %"tmp#30##0", 1 + ret {i64, i64} %"tmp#36##0" } + -------------------------------------------------- Module position representation : (not a type) @@ -364,63 +320,42 @@ printPosition(pos##0:position.position)<{<>}; {<>}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'position' - - - - -@position.3 = constant {i64, i64} { i64 1, i64 ptrtoint ([?? x i8]* @position.2 to i64) } - - -@position.5 = constant {i64, i64} { i64 1, i64 ptrtoint ([?? x i8]* @position.4 to i64) } - - -@position.1 = constant {i64, i64} { i64 2, i64 ptrtoint ([?? x i8]* @position.0 to i64) } - - -@position.0 = constant [?? x i8] c" (\00" - - -@position.4 = constant [?? x i8] c")\00" - - -@position.2 = constant [?? x i8] c",\00" - - -declare external ccc void @putchar(i8) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc void @print_int(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"position.printPosition<0>"(i64 %"pos##0") { -entry: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @position.1, i32 0, i32 0) to i64)) - %0 = inttoptr i64 %"pos##0" to i64* - %1 = load i64, i64* %0 - tail call ccc void @print_int(i64 %1) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @position.3, i32 0, i32 0) to i64)) - %2 = add i64 %"pos##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - tail call ccc void @print_int(i64 %4) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @position.5, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - ret void +source_filename = "!ROOT!/final-dump/position.wybe" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c" (\00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c")\00", align 8 +@"cstring#2" = private unnamed_addr constant [ ?? x i8 ] c",\00", align 8 +@"string#3" = private unnamed_addr constant {i64, i64} { i64 2, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +@"string#4" = private unnamed_addr constant {i64, i64} { i64 1, i64 ptrtoint( ptr @"cstring#1" to i64 ) }, align 8 +@"string#5" = private unnamed_addr constant {i64, i64} { i64 1, i64 ptrtoint( ptr @"cstring#2" to i64 ) }, align 8 + +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"position.printPosition<0>"(i64 %"pos##0") { + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#3" to i64 )) + %"tmp#13##0" = inttoptr i64 %"pos##0" to ptr + %"tmp#0##0" = load i64, ptr %"tmp#13##0" + call ccc void @print_int(i64 %"tmp#0##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#5" to i64 )) + %"tmp#14##0" = add i64 %"pos##0", 8 + %"tmp#15##0" = inttoptr i64 %"tmp#14##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#15##0" + call ccc void @print_int(i64 %"tmp#1##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#4" to i64 )) + call ccc void @putchar(i8 10) + ret void } + -------------------------------------------------- Module position.position - representation : address + representation : pointer public submods : public resources: public procs : position.position.=<0> @@ -522,134 +457,110 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'position.position' - - - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i1 @"position.position.=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %"#right##0" to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = icmp eq i64 %1, %6 - br i1 %10, label %if.then, label %if.else -if.then: - %11 = icmp eq i64 %4, %9 - ret i1 %11 -if.else: - ret i1 0 +source_filename = "!ROOT!/final-dump/position.wybe" +target triple ???? + + +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc i1 @"position.position.=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#9##0" = inttoptr i64 %"#left##0" to ptr + %"#left#x##0" = load i64, ptr %"tmp#9##0" + %"tmp#10##0" = add i64 %"#left##0", 8 + %"tmp#11##0" = inttoptr i64 %"tmp#10##0" to ptr + %"#left#y##0" = load i64, ptr %"tmp#11##0" + %"tmp#12##0" = inttoptr i64 %"#right##0" to ptr + %"#right#x##0" = load i64, ptr %"tmp#12##0" + %"tmp#13##0" = add i64 %"#right##0", 8 + %"tmp#14##0" = inttoptr i64 %"tmp#13##0" to ptr + %"#right#y##0" = load i64, ptr %"tmp#14##0" + %"tmp#1##0" = icmp eq i64 %"#left#x##0", %"#right#x##0" + br i1 %"tmp#1##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#15##0" = icmp eq i64 %"#left#y##0", %"#right#y##0" + ret i1 %"tmp#15##0" +if.else.0: + ret i1 0 } - -define external fastcc i64 @"position.position.position<0>"(i64 %"x##0", i64 %"y##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"x##0", i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"y##0", i64* %5 - ret i64 %2 +define external fastcc i64 @"position.position.position<0>"(i64 %"x##0", i64 %"y##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 16) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"x##0", ptr %"tmp#1##0" + %"tmp#2##0" = add i64 %"#rec##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"y##0", ptr %"tmp#3##0" + ret i64 %"#rec##0" } - -define external fastcc {i64, i64} @"position.position.position<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#result##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#result##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = insertvalue {i64, i64} undef, i64 %1, 0 - %6 = insertvalue {i64, i64} %5, i64 %4, 1 - ret {i64, i64} %6 +define external fastcc {i64, i64} @"position.position.position<1>"(i64 %"#result##0") { + %"tmp#0##0" = inttoptr i64 %"#result##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + %"tmp#2##0" = add i64 %"#result##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#3##0" + %"tmp#5##0" = insertvalue {i64, i64} undef, i64 %"tmp#1##0", 0 + %"tmp#6##0" = insertvalue {i64, i64} %"tmp#5##0", i64 %"tmp#4##0", 1 + ret {i64, i64} %"tmp#6##0" } - -define external fastcc i64 @"position.position.x<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#rec##0" to i64* - %1 = load i64, i64* %0 - ret i64 %1 +define external fastcc i64 @"position.position.x<0>"(i64 %"#rec##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + ret i64 %"tmp#1##0" } - -define external fastcc i64 @"position.position.x<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = inttoptr i64 %2 to i64* - store i64 %"#field##0", i64* %6 - ret i64 %2 +define external fastcc i64 @"position.position.x<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"#field##0", ptr %"tmp#3##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"position.position.y<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = add i64 %"#rec##0", 8 - %1 = inttoptr i64 %0 to i64* - %2 = load i64, i64* %1 - ret i64 %2 +define external fastcc i64 @"position.position.y<0>"(i64 %"#rec##0") { + %"tmp#0##0" = add i64 %"#rec##0", 8 + %"tmp#1##0" = inttoptr i64 %"tmp#0##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"position.position.y<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = add i64 %2, 8 - %7 = inttoptr i64 %6 to i64* - store i64 %"#field##0", i64* %7 - ret i64 %2 +define external fastcc i64 @"position.position.y<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = add i64 %"tmp#2##0", 8 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 %"#field##0", ptr %"tmp#4##0" + ret i64 %"tmp#2##0" } - -define external fastcc i1 @"position.position.~=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %"#right##0" to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = icmp eq i64 %1, %6 - br i1 %10, label %if.then, label %if.else -if.then: - %11 = icmp eq i64 %4, %9 - %12 = xor i1 %11, 1 - ret i1 %12 -if.else: - %13 = xor i1 0, 1 - ret i1 %13 +define external fastcc i1 @"position.position.~=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#8##0" = inttoptr i64 %"#left##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#8##0" + %"tmp#9##0" = add i64 %"#left##0", 8 + %"tmp#10##0" = inttoptr i64 %"tmp#9##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#10##0" + %"tmp#11##0" = inttoptr i64 %"#right##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#11##0" + %"tmp#12##0" = add i64 %"#right##0", 8 + %"tmp#13##0" = inttoptr i64 %"tmp#12##0" to ptr + %"tmp#6##0" = load i64, ptr %"tmp#13##0" + %"tmp#7##0" = icmp eq i64 %"tmp#3##0", %"tmp#5##0" + br i1 %"tmp#7##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#0##0" = icmp eq i64 %"tmp#4##0", %"tmp#6##0" + %"tmp#14##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#14##0" +if.else.0: + %"tmp#15##0" = xor i1 0, 1 + ret i1 %"tmp#15##0" } diff --git a/test-cases/final-dump/alias_type1.exp b/test-cases/final-dump/alias_type1.exp index 79ff1a528..1ae27e01a 100644 --- a/test-cases/final-dump/alias_type1.exp +++ b/test-cases/final-dump/alias_type1.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module alias_type1 representation : (not a type) public submods : position -> alias_type1.position @@ -52,64 +55,53 @@ module top-level code > public {semipure} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'alias_type1' - - - - -declare external ccc void @putchar(i8) - - -declare external ccc void @print_int(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"alias_type1.<0>"() { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 100, i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 100, i64* %5 - %6 = trunc i64 16 to i32 - %7 = tail call ccc i8* @wybe_malloc(i32 %6) - %8 = ptrtoint i8* %7 to i64 - %9 = inttoptr i64 %8 to i64* - store i64 1, i64* %9 - %10 = add i64 %8, 8 - %11 = inttoptr i64 %10 to i64* - store i64 %2, i64* %11 - %12 = trunc i64 16 to i32 - %13 = tail call ccc i8* @wybe_malloc(i32 %12) - %14 = ptrtoint i8* %13 to i64 - %15 = inttoptr i64 %14 to i8* - %16 = inttoptr i64 %2 to i8* - %17 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %15, i8* %16, i32 %17, i1 0) - %18 = inttoptr i64 %14 to i64* - store i64 200, i64* %18 - %19 = inttoptr i64 %14 to i64* - %20 = load i64, i64* %19 - tail call ccc void @print_int(i64 %20) - tail call ccc void @putchar(i8 10) - %21 = inttoptr i64 %8 to i64* - %22 = load i64, i64* %21 - tail call ccc void @print_int(i64 %22) - tail call ccc void @putchar(i8 10) - ret void +source_filename = "!ROOT!/final-dump/alias_type1.wybe" +target triple ???? + + +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"alias_type1.<0>"() { + %"tmp#26##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#6##0" = ptrtoint ptr %"tmp#26##0" to i64 + %"tmp#27##0" = inttoptr i64 %"tmp#6##0" to ptr + store i64 100, ptr %"tmp#27##0" + %"tmp#28##0" = add i64 %"tmp#6##0", 8 + %"tmp#29##0" = inttoptr i64 %"tmp#28##0" to ptr + store i64 100, ptr %"tmp#29##0" + %"tmp#30##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#11##0" = ptrtoint ptr %"tmp#30##0" to i64 + %"tmp#31##0" = inttoptr i64 %"tmp#11##0" to ptr + store i64 1, ptr %"tmp#31##0" + %"tmp#32##0" = add i64 %"tmp#11##0", 8 + %"tmp#33##0" = inttoptr i64 %"tmp#32##0" to ptr + store i64 %"tmp#6##0", ptr %"tmp#33##0" + %"tmp#34##0" = inttoptr i64 %"tmp#6##0" to ptr + %"tmp#35##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#35##0", ptr %"tmp#34##0", i64 16, i1 0) + %"tmp#36##0" = ptrtoint ptr %"tmp#35##0" to i64 + %"tmp#37##0" = inttoptr i64 %"tmp#36##0" to ptr + store i64 200, ptr %"tmp#37##0" + %"tmp#38##0" = inttoptr i64 %"tmp#36##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#38##0" + call ccc void @print_int(i64 %"tmp#2##0") + call ccc void @putchar(i8 10) + %"tmp#39##0" = inttoptr i64 %"tmp#11##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#39##0" + call ccc void @print_int(i64 %"tmp#3##0") + call ccc void @putchar(i8 10) + ret void } + -------------------------------------------------- Module alias_type1.position - representation : address + representation : pointer public submods : public resources: public procs : alias_type1.position.=<0> @@ -211,140 +203,117 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'alias_type1.position' - - - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i1 @"alias_type1.position.=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %"#right##0" to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = icmp eq i64 %1, %6 - br i1 %10, label %if.then, label %if.else -if.then: - %11 = icmp eq i64 %4, %9 - ret i1 %11 -if.else: - ret i1 0 +source_filename = "!ROOT!/final-dump/alias_type1.wybe" +target triple ???? + + +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc i1 @"alias_type1.position.=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#9##0" = inttoptr i64 %"#left##0" to ptr + %"#left#x##0" = load i64, ptr %"tmp#9##0" + %"tmp#10##0" = add i64 %"#left##0", 8 + %"tmp#11##0" = inttoptr i64 %"tmp#10##0" to ptr + %"#left#y##0" = load i64, ptr %"tmp#11##0" + %"tmp#12##0" = inttoptr i64 %"#right##0" to ptr + %"#right#x##0" = load i64, ptr %"tmp#12##0" + %"tmp#13##0" = add i64 %"#right##0", 8 + %"tmp#14##0" = inttoptr i64 %"tmp#13##0" to ptr + %"#right#y##0" = load i64, ptr %"tmp#14##0" + %"tmp#1##0" = icmp eq i64 %"#left#x##0", %"#right#x##0" + br i1 %"tmp#1##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#15##0" = icmp eq i64 %"#left#y##0", %"#right#y##0" + ret i1 %"tmp#15##0" +if.else.0: + ret i1 0 } - -define external fastcc i64 @"alias_type1.position.position<0>"(i64 %"x##0", i64 %"y##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"x##0", i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"y##0", i64* %5 - ret i64 %2 +define external fastcc i64 @"alias_type1.position.position<0>"(i64 %"x##0", i64 %"y##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 16) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"x##0", ptr %"tmp#1##0" + %"tmp#2##0" = add i64 %"#rec##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"y##0", ptr %"tmp#3##0" + ret i64 %"#rec##0" } - -define external fastcc {i64, i64} @"alias_type1.position.position<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#result##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#result##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = insertvalue {i64, i64} undef, i64 %1, 0 - %6 = insertvalue {i64, i64} %5, i64 %4, 1 - ret {i64, i64} %6 +define external fastcc {i64, i64} @"alias_type1.position.position<1>"(i64 %"#result##0") { + %"tmp#0##0" = inttoptr i64 %"#result##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + %"tmp#2##0" = add i64 %"#result##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#3##0" + %"tmp#5##0" = insertvalue {i64, i64} undef, i64 %"tmp#1##0", 0 + %"tmp#6##0" = insertvalue {i64, i64} %"tmp#5##0", i64 %"tmp#4##0", 1 + ret {i64, i64} %"tmp#6##0" } - -define external fastcc i64 @"alias_type1.position.x<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#rec##0" to i64* - %1 = load i64, i64* %0 - ret i64 %1 +define external fastcc i64 @"alias_type1.position.x<0>"(i64 %"#rec##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + ret i64 %"tmp#1##0" } - -define external fastcc i64 @"alias_type1.position.x<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = inttoptr i64 %2 to i64* - store i64 %"#field##0", i64* %6 - ret i64 %2 +define external fastcc i64 @"alias_type1.position.x<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"#field##0", ptr %"tmp#3##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"alias_type1.position.y<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = add i64 %"#rec##0", 8 - %1 = inttoptr i64 %0 to i64* - %2 = load i64, i64* %1 - ret i64 %2 +define external fastcc i64 @"alias_type1.position.y<0>"(i64 %"#rec##0") { + %"tmp#0##0" = add i64 %"#rec##0", 8 + %"tmp#1##0" = inttoptr i64 %"tmp#0##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"alias_type1.position.y<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = add i64 %2, 8 - %7 = inttoptr i64 %6 to i64* - store i64 %"#field##0", i64* %7 - ret i64 %2 +define external fastcc i64 @"alias_type1.position.y<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = add i64 %"tmp#2##0", 8 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 %"#field##0", ptr %"tmp#4##0" + ret i64 %"tmp#2##0" } - -define external fastcc i1 @"alias_type1.position.~=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %"#right##0" to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = icmp eq i64 %1, %6 - br i1 %10, label %if.then, label %if.else -if.then: - %11 = icmp eq i64 %4, %9 - %12 = xor i1 %11, 1 - ret i1 %12 -if.else: - %13 = xor i1 0, 1 - ret i1 %13 +define external fastcc i1 @"alias_type1.position.~=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#8##0" = inttoptr i64 %"#left##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#8##0" + %"tmp#9##0" = add i64 %"#left##0", 8 + %"tmp#10##0" = inttoptr i64 %"tmp#9##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#10##0" + %"tmp#11##0" = inttoptr i64 %"#right##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#11##0" + %"tmp#12##0" = add i64 %"#right##0", 8 + %"tmp#13##0" = inttoptr i64 %"tmp#12##0" to ptr + %"tmp#6##0" = load i64, ptr %"tmp#13##0" + %"tmp#7##0" = icmp eq i64 %"tmp#3##0", %"tmp#5##0" + br i1 %"tmp#7##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#0##0" = icmp eq i64 %"tmp#4##0", %"tmp#6##0" + %"tmp#14##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#14##0" +if.else.0: + %"tmp#15##0" = xor i1 0, 1 + ret i1 %"tmp#15##0" } + -------------------------------------------------- Module alias_type1.posrec - representation : address + representation : pointer public submods : public resources: public procs : alias_type1.posrec.=<0> @@ -469,165 +438,141 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'alias_type1.posrec' - - - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i1 @"alias_type1.posrec.=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %"#right##0" to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = icmp eq i64 %1, %6 - br i1 %10, label %if.then, label %if.else -if.then: - %11 = inttoptr i64 %4 to i64* - %12 = load i64, i64* %11 - %13 = add i64 %4, 8 - %14 = inttoptr i64 %13 to i64* - %15 = load i64, i64* %14 - %16 = inttoptr i64 %9 to i64* - %17 = load i64, i64* %16 - %18 = add i64 %9, 8 - %19 = inttoptr i64 %18 to i64* - %20 = load i64, i64* %19 - %21 = icmp eq i64 %17, %12 - br i1 %21, label %if.then1, label %if.else1 -if.else: - ret i1 0 -if.then1: - %22 = icmp eq i64 %15, %20 - ret i1 %22 -if.else1: - ret i1 0 +source_filename = "!ROOT!/final-dump/alias_type1.wybe" +target triple ???? + + +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc i1 @"alias_type1.posrec.=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#14##0" = inttoptr i64 %"#left##0" to ptr + %"#left#a##0" = load i64, ptr %"tmp#14##0" + %"tmp#15##0" = add i64 %"#left##0", 8 + %"tmp#16##0" = inttoptr i64 %"tmp#15##0" to ptr + %"#left#p##0" = load i64, ptr %"tmp#16##0" + %"tmp#17##0" = inttoptr i64 %"#right##0" to ptr + %"#right#a##0" = load i64, ptr %"tmp#17##0" + %"tmp#18##0" = add i64 %"#right##0", 8 + %"tmp#19##0" = inttoptr i64 %"tmp#18##0" to ptr + %"#right#p##0" = load i64, ptr %"tmp#19##0" + %"tmp#1##0" = icmp eq i64 %"#left#a##0", %"#right#a##0" + br i1 %"tmp#1##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#20##0" = inttoptr i64 %"#left#p##0" to ptr + %"tmp#9##0" = load i64, ptr %"tmp#20##0" + %"tmp#21##0" = add i64 %"#left#p##0", 8 + %"tmp#22##0" = inttoptr i64 %"tmp#21##0" to ptr + %"tmp#10##0" = load i64, ptr %"tmp#22##0" + %"tmp#23##0" = inttoptr i64 %"#right#p##0" to ptr + %"tmp#11##0" = load i64, ptr %"tmp#23##0" + %"tmp#24##0" = add i64 %"#right#p##0", 8 + %"tmp#25##0" = inttoptr i64 %"tmp#24##0" to ptr + %"tmp#12##0" = load i64, ptr %"tmp#25##0" + %"tmp#13##0" = icmp eq i64 %"tmp#11##0", %"tmp#9##0" + br i1 %"tmp#13##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#26##0" = icmp eq i64 %"tmp#10##0", %"tmp#12##0" + ret i1 %"tmp#26##0" +if.else.1: + ret i1 0 +if.else.0: + ret i1 0 } - -define external fastcc i64 @"alias_type1.posrec.a<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#rec##0" to i64* - %1 = load i64, i64* %0 - ret i64 %1 +define external fastcc i64 @"alias_type1.posrec.a<0>"(i64 %"#rec##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + ret i64 %"tmp#1##0" } - -define external fastcc i64 @"alias_type1.posrec.a<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = inttoptr i64 %2 to i64* - store i64 %"#field##0", i64* %6 - ret i64 %2 +define external fastcc i64 @"alias_type1.posrec.a<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"#field##0", ptr %"tmp#3##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"alias_type1.posrec.p<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = add i64 %"#rec##0", 8 - %1 = inttoptr i64 %0 to i64* - %2 = load i64, i64* %1 - ret i64 %2 +define external fastcc i64 @"alias_type1.posrec.p<0>"(i64 %"#rec##0") { + %"tmp#0##0" = add i64 %"#rec##0", 8 + %"tmp#1##0" = inttoptr i64 %"tmp#0##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"alias_type1.posrec.p<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = add i64 %2, 8 - %7 = inttoptr i64 %6 to i64* - store i64 %"#field##0", i64* %7 - ret i64 %2 +define external fastcc i64 @"alias_type1.posrec.p<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = add i64 %"tmp#2##0", 8 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 %"#field##0", ptr %"tmp#4##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"alias_type1.posrec.posrec<0>"(i64 %"a##0", i64 %"p##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"a##0", i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"p##0", i64* %5 - ret i64 %2 +define external fastcc i64 @"alias_type1.posrec.posrec<0>"(i64 %"a##0", i64 %"p##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 16) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"a##0", ptr %"tmp#1##0" + %"tmp#2##0" = add i64 %"#rec##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"p##0", ptr %"tmp#3##0" + ret i64 %"#rec##0" } - -define external fastcc {i64, i64} @"alias_type1.posrec.posrec<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#result##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#result##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = insertvalue {i64, i64} undef, i64 %1, 0 - %6 = insertvalue {i64, i64} %5, i64 %4, 1 - ret {i64, i64} %6 +define external fastcc {i64, i64} @"alias_type1.posrec.posrec<1>"(i64 %"#result##0") { + %"tmp#0##0" = inttoptr i64 %"#result##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + %"tmp#2##0" = add i64 %"#result##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#3##0" + %"tmp#5##0" = insertvalue {i64, i64} undef, i64 %"tmp#1##0", 0 + %"tmp#6##0" = insertvalue {i64, i64} %"tmp#5##0", i64 %"tmp#4##0", 1 + ret {i64, i64} %"tmp#6##0" } - -define external fastcc i1 @"alias_type1.posrec.~=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %"#right##0" to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = icmp eq i64 %1, %6 - br i1 %10, label %if.then, label %if.else -if.then: - %11 = inttoptr i64 %4 to i64* - %12 = load i64, i64* %11 - %13 = add i64 %4, 8 - %14 = inttoptr i64 %13 to i64* - %15 = load i64, i64* %14 - %16 = inttoptr i64 %9 to i64* - %17 = load i64, i64* %16 - %18 = add i64 %9, 8 - %19 = inttoptr i64 %18 to i64* - %20 = load i64, i64* %19 - %21 = icmp eq i64 %17, %12 - br i1 %21, label %if.then1, label %if.else1 -if.else: - %25 = xor i1 0, 1 - ret i1 %25 -if.then1: - %22 = icmp eq i64 %20, %15 - %23 = xor i1 %22, 1 - ret i1 %23 -if.else1: - %24 = xor i1 0, 1 - ret i1 %24 +define external fastcc i1 @"alias_type1.posrec.~=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#13##0" = inttoptr i64 %"#left##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#13##0" + %"tmp#14##0" = add i64 %"#left##0", 8 + %"tmp#15##0" = inttoptr i64 %"tmp#14##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#15##0" + %"tmp#16##0" = inttoptr i64 %"#right##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#16##0" + %"tmp#17##0" = add i64 %"#right##0", 8 + %"tmp#18##0" = inttoptr i64 %"tmp#17##0" to ptr + %"tmp#6##0" = load i64, ptr %"tmp#18##0" + %"tmp#7##0" = icmp eq i64 %"tmp#3##0", %"tmp#5##0" + br i1 %"tmp#7##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#19##0" = inttoptr i64 %"tmp#4##0" to ptr + %"tmp#8##0" = load i64, ptr %"tmp#19##0" + %"tmp#20##0" = add i64 %"tmp#4##0", 8 + %"tmp#21##0" = inttoptr i64 %"tmp#20##0" to ptr + %"tmp#9##0" = load i64, ptr %"tmp#21##0" + %"tmp#22##0" = inttoptr i64 %"tmp#6##0" to ptr + %"tmp#10##0" = load i64, ptr %"tmp#22##0" + %"tmp#23##0" = add i64 %"tmp#6##0", 8 + %"tmp#24##0" = inttoptr i64 %"tmp#23##0" to ptr + %"tmp#11##0" = load i64, ptr %"tmp#24##0" + %"tmp#12##0" = icmp eq i64 %"tmp#10##0", %"tmp#8##0" + br i1 %"tmp#12##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#0##0" = icmp eq i64 %"tmp#11##0", %"tmp#9##0" + %"tmp#25##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#25##0" +if.else.1: + %"tmp#26##0" = xor i1 0, 1 + ret i1 %"tmp#26##0" +if.else.0: + %"tmp#27##0" = xor i1 0, 1 + ret i1 %"tmp#27##0" } diff --git a/test-cases/final-dump/alias_type2.exp b/test-cases/final-dump/alias_type2.exp index 0eb013e31..44b5e453b 100644 --- a/test-cases/final-dump/alias_type2.exp +++ b/test-cases/final-dump/alias_type2.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module alias_type2 representation : (not a type) public submods : position -> alias_type2.position @@ -54,76 +57,62 @@ module top-level code > public {semipure} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'alias_type2' - - - - -declare external ccc void @putchar(i8) - - -declare external ccc void @print_int(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"alias_type2.<0>"() { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 100, i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 100, i64* %5 - %6 = trunc i64 16 to i32 - %7 = tail call ccc i8* @wybe_malloc(i32 %6) - %8 = ptrtoint i8* %7 to i64 - %9 = inttoptr i64 %8 to i64* - store i64 %2, i64* %9 - %10 = add i64 %8, 8 - %11 = inttoptr i64 %10 to i64* - store i64 1, i64* %11 - %12 = trunc i64 16 to i32 - %13 = tail call ccc i8* @wybe_malloc(i32 %12) - %14 = ptrtoint i8* %13 to i64 - %15 = inttoptr i64 %14 to i8* - %16 = inttoptr i64 %8 to i8* - %17 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %15, i8* %16, i32 %17, i1 0) - %18 = add i64 %14, 8 - %19 = inttoptr i64 %18 to i64* - store i64 2, i64* %19 - %20 = trunc i64 16 to i32 - %21 = tail call ccc i8* @wybe_malloc(i32 %20) - %22 = ptrtoint i8* %21 to i64 - %23 = inttoptr i64 %22 to i8* - %24 = inttoptr i64 %2 to i8* - %25 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %23, i8* %24, i32 %25, i1 0) - %26 = inttoptr i64 %22 to i64* - store i64 200, i64* %26 - %27 = inttoptr i64 %22 to i64* - %28 = load i64, i64* %27 - tail call ccc void @print_int(i64 %28) - tail call ccc void @putchar(i8 10) - %29 = inttoptr i64 %14 to i64* - %30 = load i64, i64* %29 - %31 = inttoptr i64 %30 to i64* - %32 = load i64, i64* %31 - tail call ccc void @print_int(i64 %32) - tail call ccc void @putchar(i8 10) - ret void +source_filename = "!ROOT!/final-dump/alias_type2.wybe" +target triple ???? + + +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"alias_type2.<0>"() { + %"tmp#30##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#7##0" = ptrtoint ptr %"tmp#30##0" to i64 + %"tmp#31##0" = inttoptr i64 %"tmp#7##0" to ptr + store i64 100, ptr %"tmp#31##0" + %"tmp#32##0" = add i64 %"tmp#7##0", 8 + %"tmp#33##0" = inttoptr i64 %"tmp#32##0" to ptr + store i64 100, ptr %"tmp#33##0" + %"tmp#34##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#12##0" = ptrtoint ptr %"tmp#34##0" to i64 + %"tmp#35##0" = inttoptr i64 %"tmp#12##0" to ptr + store i64 %"tmp#7##0", ptr %"tmp#35##0" + %"tmp#36##0" = add i64 %"tmp#12##0", 8 + %"tmp#37##0" = inttoptr i64 %"tmp#36##0" to ptr + store i64 1, ptr %"tmp#37##0" + %"tmp#38##0" = inttoptr i64 %"tmp#12##0" to ptr + %"tmp#39##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#39##0", ptr %"tmp#38##0", i64 16, i1 0) + %"tmp#40##0" = ptrtoint ptr %"tmp#39##0" to i64 + %"tmp#41##0" = add i64 %"tmp#40##0", 8 + %"tmp#42##0" = inttoptr i64 %"tmp#41##0" to ptr + store i64 2, ptr %"tmp#42##0" + %"tmp#43##0" = inttoptr i64 %"tmp#7##0" to ptr + %"tmp#44##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#44##0", ptr %"tmp#43##0", i64 16, i1 0) + %"tmp#45##0" = ptrtoint ptr %"tmp#44##0" to i64 + %"tmp#46##0" = inttoptr i64 %"tmp#45##0" to ptr + store i64 200, ptr %"tmp#46##0" + %"tmp#47##0" = inttoptr i64 %"tmp#45##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#47##0" + call ccc void @print_int(i64 %"tmp#2##0") + call ccc void @putchar(i8 10) + %"tmp#48##0" = inttoptr i64 %"tmp#40##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#48##0" + %"tmp#49##0" = inttoptr i64 %"tmp#3##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#49##0" + call ccc void @print_int(i64 %"tmp#4##0") + call ccc void @putchar(i8 10) + ret void } + -------------------------------------------------- Module alias_type2.position - representation : address + representation : pointer public submods : public resources: public procs : alias_type2.position.=<0> @@ -225,140 +214,117 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'alias_type2.position' - - - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i1 @"alias_type2.position.=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %"#right##0" to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = icmp eq i64 %1, %6 - br i1 %10, label %if.then, label %if.else -if.then: - %11 = icmp eq i64 %4, %9 - ret i1 %11 -if.else: - ret i1 0 +source_filename = "!ROOT!/final-dump/alias_type2.wybe" +target triple ???? + + +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc i1 @"alias_type2.position.=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#9##0" = inttoptr i64 %"#left##0" to ptr + %"#left#x##0" = load i64, ptr %"tmp#9##0" + %"tmp#10##0" = add i64 %"#left##0", 8 + %"tmp#11##0" = inttoptr i64 %"tmp#10##0" to ptr + %"#left#y##0" = load i64, ptr %"tmp#11##0" + %"tmp#12##0" = inttoptr i64 %"#right##0" to ptr + %"#right#x##0" = load i64, ptr %"tmp#12##0" + %"tmp#13##0" = add i64 %"#right##0", 8 + %"tmp#14##0" = inttoptr i64 %"tmp#13##0" to ptr + %"#right#y##0" = load i64, ptr %"tmp#14##0" + %"tmp#1##0" = icmp eq i64 %"#left#x##0", %"#right#x##0" + br i1 %"tmp#1##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#15##0" = icmp eq i64 %"#left#y##0", %"#right#y##0" + ret i1 %"tmp#15##0" +if.else.0: + ret i1 0 } - -define external fastcc i64 @"alias_type2.position.position<0>"(i64 %"x##0", i64 %"y##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"x##0", i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"y##0", i64* %5 - ret i64 %2 +define external fastcc i64 @"alias_type2.position.position<0>"(i64 %"x##0", i64 %"y##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 16) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"x##0", ptr %"tmp#1##0" + %"tmp#2##0" = add i64 %"#rec##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"y##0", ptr %"tmp#3##0" + ret i64 %"#rec##0" } - -define external fastcc {i64, i64} @"alias_type2.position.position<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#result##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#result##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = insertvalue {i64, i64} undef, i64 %1, 0 - %6 = insertvalue {i64, i64} %5, i64 %4, 1 - ret {i64, i64} %6 +define external fastcc {i64, i64} @"alias_type2.position.position<1>"(i64 %"#result##0") { + %"tmp#0##0" = inttoptr i64 %"#result##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + %"tmp#2##0" = add i64 %"#result##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#3##0" + %"tmp#5##0" = insertvalue {i64, i64} undef, i64 %"tmp#1##0", 0 + %"tmp#6##0" = insertvalue {i64, i64} %"tmp#5##0", i64 %"tmp#4##0", 1 + ret {i64, i64} %"tmp#6##0" } - -define external fastcc i64 @"alias_type2.position.x<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#rec##0" to i64* - %1 = load i64, i64* %0 - ret i64 %1 +define external fastcc i64 @"alias_type2.position.x<0>"(i64 %"#rec##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + ret i64 %"tmp#1##0" } - -define external fastcc i64 @"alias_type2.position.x<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = inttoptr i64 %2 to i64* - store i64 %"#field##0", i64* %6 - ret i64 %2 +define external fastcc i64 @"alias_type2.position.x<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"#field##0", ptr %"tmp#3##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"alias_type2.position.y<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = add i64 %"#rec##0", 8 - %1 = inttoptr i64 %0 to i64* - %2 = load i64, i64* %1 - ret i64 %2 +define external fastcc i64 @"alias_type2.position.y<0>"(i64 %"#rec##0") { + %"tmp#0##0" = add i64 %"#rec##0", 8 + %"tmp#1##0" = inttoptr i64 %"tmp#0##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"alias_type2.position.y<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = add i64 %2, 8 - %7 = inttoptr i64 %6 to i64* - store i64 %"#field##0", i64* %7 - ret i64 %2 +define external fastcc i64 @"alias_type2.position.y<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = add i64 %"tmp#2##0", 8 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 %"#field##0", ptr %"tmp#4##0" + ret i64 %"tmp#2##0" } - -define external fastcc i1 @"alias_type2.position.~=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %"#right##0" to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = icmp eq i64 %1, %6 - br i1 %10, label %if.then, label %if.else -if.then: - %11 = icmp eq i64 %4, %9 - %12 = xor i1 %11, 1 - ret i1 %12 -if.else: - %13 = xor i1 0, 1 - ret i1 %13 +define external fastcc i1 @"alias_type2.position.~=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#8##0" = inttoptr i64 %"#left##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#8##0" + %"tmp#9##0" = add i64 %"#left##0", 8 + %"tmp#10##0" = inttoptr i64 %"tmp#9##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#10##0" + %"tmp#11##0" = inttoptr i64 %"#right##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#11##0" + %"tmp#12##0" = add i64 %"#right##0", 8 + %"tmp#13##0" = inttoptr i64 %"tmp#12##0" to ptr + %"tmp#6##0" = load i64, ptr %"tmp#13##0" + %"tmp#7##0" = icmp eq i64 %"tmp#3##0", %"tmp#5##0" + br i1 %"tmp#7##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#0##0" = icmp eq i64 %"tmp#4##0", %"tmp#6##0" + %"tmp#14##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#14##0" +if.else.0: + %"tmp#15##0" = xor i1 0, 1 + ret i1 %"tmp#15##0" } + -------------------------------------------------- Module alias_type2.posrec - representation : address + representation : pointer public submods : public resources: public procs : alias_type2.posrec.=<0> @@ -483,165 +449,141 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'alias_type2.posrec' - - - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i1 @"alias_type2.posrec.=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %"#right##0" to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = inttoptr i64 %1 to i64* - %11 = load i64, i64* %10 - %12 = add i64 %1, 8 - %13 = inttoptr i64 %12 to i64* - %14 = load i64, i64* %13 - %15 = inttoptr i64 %6 to i64* - %16 = load i64, i64* %15 - %17 = add i64 %6, 8 - %18 = inttoptr i64 %17 to i64* - %19 = load i64, i64* %18 - %20 = icmp eq i64 %11, %16 - br i1 %20, label %if.then, label %if.else -if.then: - %21 = icmp eq i64 %19, %14 - br i1 %21, label %if.then1, label %if.else1 -if.else: - ret i1 0 -if.then1: - %22 = icmp eq i64 %4, %9 - ret i1 %22 -if.else1: - ret i1 0 +source_filename = "!ROOT!/final-dump/alias_type2.wybe" +target triple ???? + + +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc i1 @"alias_type2.posrec.=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#14##0" = inttoptr i64 %"#left##0" to ptr + %"#left#p##0" = load i64, ptr %"tmp#14##0" + %"tmp#15##0" = add i64 %"#left##0", 8 + %"tmp#16##0" = inttoptr i64 %"tmp#15##0" to ptr + %"#left#a##0" = load i64, ptr %"tmp#16##0" + %"tmp#17##0" = inttoptr i64 %"#right##0" to ptr + %"#right#p##0" = load i64, ptr %"tmp#17##0" + %"tmp#18##0" = add i64 %"#right##0", 8 + %"tmp#19##0" = inttoptr i64 %"tmp#18##0" to ptr + %"#right#a##0" = load i64, ptr %"tmp#19##0" + %"tmp#20##0" = inttoptr i64 %"#left#p##0" to ptr + %"tmp#7##0" = load i64, ptr %"tmp#20##0" + %"tmp#21##0" = add i64 %"#left#p##0", 8 + %"tmp#22##0" = inttoptr i64 %"tmp#21##0" to ptr + %"tmp#8##0" = load i64, ptr %"tmp#22##0" + %"tmp#23##0" = inttoptr i64 %"#right#p##0" to ptr + %"tmp#9##0" = load i64, ptr %"tmp#23##0" + %"tmp#24##0" = add i64 %"#right#p##0", 8 + %"tmp#25##0" = inttoptr i64 %"tmp#24##0" to ptr + %"tmp#10##0" = load i64, ptr %"tmp#25##0" + %"tmp#11##0" = icmp eq i64 %"tmp#7##0", %"tmp#9##0" + br i1 %"tmp#11##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = icmp eq i64 %"tmp#10##0", %"tmp#8##0" + br i1 %"tmp#1##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#26##0" = icmp eq i64 %"#left#a##0", %"#right#a##0" + ret i1 %"tmp#26##0" +if.else.1: + ret i1 0 +if.else.0: + ret i1 0 } - -define external fastcc i64 @"alias_type2.posrec.a<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = add i64 %"#rec##0", 8 - %1 = inttoptr i64 %0 to i64* - %2 = load i64, i64* %1 - ret i64 %2 +define external fastcc i64 @"alias_type2.posrec.a<0>"(i64 %"#rec##0") { + %"tmp#0##0" = add i64 %"#rec##0", 8 + %"tmp#1##0" = inttoptr i64 %"tmp#0##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"alias_type2.posrec.a<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = add i64 %2, 8 - %7 = inttoptr i64 %6 to i64* - store i64 %"#field##0", i64* %7 - ret i64 %2 +define external fastcc i64 @"alias_type2.posrec.a<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = add i64 %"tmp#2##0", 8 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 %"#field##0", ptr %"tmp#4##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"alias_type2.posrec.p<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#rec##0" to i64* - %1 = load i64, i64* %0 - ret i64 %1 +define external fastcc i64 @"alias_type2.posrec.p<0>"(i64 %"#rec##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + ret i64 %"tmp#1##0" } - -define external fastcc i64 @"alias_type2.posrec.p<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = inttoptr i64 %2 to i64* - store i64 %"#field##0", i64* %6 - ret i64 %2 +define external fastcc i64 @"alias_type2.posrec.p<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"#field##0", ptr %"tmp#3##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"alias_type2.posrec.posrec<0>"(i64 %"p##0", i64 %"a##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"p##0", i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"a##0", i64* %5 - ret i64 %2 +define external fastcc i64 @"alias_type2.posrec.posrec<0>"(i64 %"p##0", i64 %"a##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 16) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"p##0", ptr %"tmp#1##0" + %"tmp#2##0" = add i64 %"#rec##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"a##0", ptr %"tmp#3##0" + ret i64 %"#rec##0" } - -define external fastcc {i64, i64} @"alias_type2.posrec.posrec<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#result##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#result##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = insertvalue {i64, i64} undef, i64 %1, 0 - %6 = insertvalue {i64, i64} %5, i64 %4, 1 - ret {i64, i64} %6 +define external fastcc {i64, i64} @"alias_type2.posrec.posrec<1>"(i64 %"#result##0") { + %"tmp#0##0" = inttoptr i64 %"#result##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + %"tmp#2##0" = add i64 %"#result##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#3##0" + %"tmp#5##0" = insertvalue {i64, i64} undef, i64 %"tmp#1##0", 0 + %"tmp#6##0" = insertvalue {i64, i64} %"tmp#5##0", i64 %"tmp#4##0", 1 + ret {i64, i64} %"tmp#6##0" } - -define external fastcc i1 @"alias_type2.posrec.~=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %"#right##0" to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = inttoptr i64 %1 to i64* - %11 = load i64, i64* %10 - %12 = add i64 %1, 8 - %13 = inttoptr i64 %12 to i64* - %14 = load i64, i64* %13 - %15 = inttoptr i64 %6 to i64* - %16 = load i64, i64* %15 - %17 = add i64 %6, 8 - %18 = inttoptr i64 %17 to i64* - %19 = load i64, i64* %18 - %20 = icmp eq i64 %11, %16 - br i1 %20, label %if.then, label %if.else -if.then: - %21 = icmp eq i64 %19, %14 - br i1 %21, label %if.then1, label %if.else1 -if.else: - %25 = xor i1 0, 1 - ret i1 %25 -if.then1: - %22 = icmp eq i64 %4, %9 - %23 = xor i1 %22, 1 - ret i1 %23 -if.else1: - %24 = xor i1 0, 1 - ret i1 %24 +define external fastcc i1 @"alias_type2.posrec.~=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#13##0" = inttoptr i64 %"#left##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#13##0" + %"tmp#14##0" = add i64 %"#left##0", 8 + %"tmp#15##0" = inttoptr i64 %"tmp#14##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#15##0" + %"tmp#16##0" = inttoptr i64 %"#right##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#16##0" + %"tmp#17##0" = add i64 %"#right##0", 8 + %"tmp#18##0" = inttoptr i64 %"tmp#17##0" to ptr + %"tmp#6##0" = load i64, ptr %"tmp#18##0" + %"tmp#19##0" = inttoptr i64 %"tmp#3##0" to ptr + %"tmp#7##0" = load i64, ptr %"tmp#19##0" + %"tmp#20##0" = add i64 %"tmp#3##0", 8 + %"tmp#21##0" = inttoptr i64 %"tmp#20##0" to ptr + %"tmp#8##0" = load i64, ptr %"tmp#21##0" + %"tmp#22##0" = inttoptr i64 %"tmp#5##0" to ptr + %"tmp#9##0" = load i64, ptr %"tmp#22##0" + %"tmp#23##0" = add i64 %"tmp#5##0", 8 + %"tmp#24##0" = inttoptr i64 %"tmp#23##0" to ptr + %"tmp#10##0" = load i64, ptr %"tmp#24##0" + %"tmp#11##0" = icmp eq i64 %"tmp#7##0", %"tmp#9##0" + br i1 %"tmp#11##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#12##0" = icmp eq i64 %"tmp#10##0", %"tmp#8##0" + br i1 %"tmp#12##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#0##0" = icmp eq i64 %"tmp#4##0", %"tmp#6##0" + %"tmp#25##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#25##0" +if.else.1: + %"tmp#26##0" = xor i1 0, 1 + ret i1 %"tmp#26##0" +if.else.0: + %"tmp#27##0" = xor i1 0, 1 + ret i1 %"tmp#27##0" } diff --git a/test-cases/final-dump/alias_type3.exp b/test-cases/final-dump/alias_type3.exp index a5f62acb2..06fdcf9cf 100644 --- a/test-cases/final-dump/alias_type3.exp +++ b/test-cases/final-dump/alias_type3.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module alias_type3 representation : (not a type) public submods : position -> alias_type3.position @@ -57,76 +60,64 @@ module top-level code > public {semipure} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'alias_type3' - - - - -declare external ccc void @putchar(i8) - - -declare external ccc void @print_int(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"alias_type3.<0>"() { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 100, i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 100, i64* %5 - %6 = trunc i64 16 to i32 - %7 = tail call ccc i8* @wybe_malloc(i32 %6) - %8 = ptrtoint i8* %7 to i64 - %9 = inttoptr i64 %8 to i64* - store i64 %2, i64* %9 - %10 = add i64 %8, 8 - %11 = inttoptr i64 %10 to i64* - store i64 1, i64* %11 - %12 = trunc i64 16 to i32 - %13 = tail call ccc i8* @wybe_malloc(i32 %12) - %14 = ptrtoint i8* %13 to i64 - %15 = inttoptr i64 %14 to i64* - store i64 2, i64* %15 - %16 = add i64 %14, 8 - %17 = inttoptr i64 %16 to i64* - store i64 2, i64* %17 - %18 = trunc i64 16 to i32 - %19 = tail call ccc i8* @wybe_malloc(i32 %18) - %20 = ptrtoint i8* %19 to i64 - %21 = inttoptr i64 %20 to i8* - %22 = inttoptr i64 %8 to i8* - %23 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %21, i8* %22, i32 %23, i1 0) - %24 = inttoptr i64 %20 to i64* - store i64 %14, i64* %24 - %25 = inttoptr i64 %2 to i64* - store i64 200, i64* %25 - %26 = inttoptr i64 %2 to i64* - %27 = load i64, i64* %26 - tail call ccc void @print_int(i64 %27) - tail call ccc void @putchar(i8 10) - %28 = inttoptr i64 %20 to i64* - %29 = load i64, i64* %28 - %30 = inttoptr i64 %29 to i64* - %31 = load i64, i64* %30 - tail call ccc void @print_int(i64 %31) - tail call ccc void @putchar(i8 10) - ret void +source_filename = "!ROOT!/final-dump/alias_type3.wybe" +target triple ???? + + +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"alias_type3.<0>"() { + %"tmp#36##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#8##0" = ptrtoint ptr %"tmp#36##0" to i64 + %"tmp#37##0" = inttoptr i64 %"tmp#8##0" to ptr + store i64 100, ptr %"tmp#37##0" + %"tmp#38##0" = add i64 %"tmp#8##0", 8 + %"tmp#39##0" = inttoptr i64 %"tmp#38##0" to ptr + store i64 100, ptr %"tmp#39##0" + %"tmp#40##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#13##0" = ptrtoint ptr %"tmp#40##0" to i64 + %"tmp#41##0" = inttoptr i64 %"tmp#13##0" to ptr + store i64 %"tmp#8##0", ptr %"tmp#41##0" + %"tmp#42##0" = add i64 %"tmp#13##0", 8 + %"tmp#43##0" = inttoptr i64 %"tmp#42##0" to ptr + store i64 1, ptr %"tmp#43##0" + %"tmp#44##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#18##0" = ptrtoint ptr %"tmp#44##0" to i64 + %"tmp#45##0" = inttoptr i64 %"tmp#18##0" to ptr + store i64 2, ptr %"tmp#45##0" + %"tmp#46##0" = add i64 %"tmp#18##0", 8 + %"tmp#47##0" = inttoptr i64 %"tmp#46##0" to ptr + store i64 2, ptr %"tmp#47##0" + %"tmp#48##0" = inttoptr i64 %"tmp#13##0" to ptr + %"tmp#49##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#49##0", ptr %"tmp#48##0", i64 16, i1 0) + %"tmp#50##0" = ptrtoint ptr %"tmp#49##0" to i64 + %"tmp#51##0" = inttoptr i64 %"tmp#50##0" to ptr + store i64 %"tmp#18##0", ptr %"tmp#51##0" + %"tmp#52##0" = inttoptr i64 %"tmp#8##0" to ptr + store i64 200, ptr %"tmp#52##0" + %"tmp#53##0" = inttoptr i64 %"tmp#8##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#53##0" + call ccc void @print_int(i64 %"tmp#3##0") + call ccc void @putchar(i8 10) + %"tmp#54##0" = inttoptr i64 %"tmp#50##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#54##0" + %"tmp#55##0" = inttoptr i64 %"tmp#4##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#55##0" + call ccc void @print_int(i64 %"tmp#5##0") + call ccc void @putchar(i8 10) + ret void } + -------------------------------------------------- Module alias_type3.position - representation : address + representation : pointer public submods : public resources: public procs : alias_type3.position.=<0> @@ -228,140 +219,117 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'alias_type3.position' - - - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i1 @"alias_type3.position.=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %"#right##0" to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = icmp eq i64 %1, %6 - br i1 %10, label %if.then, label %if.else -if.then: - %11 = icmp eq i64 %4, %9 - ret i1 %11 -if.else: - ret i1 0 +source_filename = "!ROOT!/final-dump/alias_type3.wybe" +target triple ???? + + +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc i1 @"alias_type3.position.=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#9##0" = inttoptr i64 %"#left##0" to ptr + %"#left#x##0" = load i64, ptr %"tmp#9##0" + %"tmp#10##0" = add i64 %"#left##0", 8 + %"tmp#11##0" = inttoptr i64 %"tmp#10##0" to ptr + %"#left#y##0" = load i64, ptr %"tmp#11##0" + %"tmp#12##0" = inttoptr i64 %"#right##0" to ptr + %"#right#x##0" = load i64, ptr %"tmp#12##0" + %"tmp#13##0" = add i64 %"#right##0", 8 + %"tmp#14##0" = inttoptr i64 %"tmp#13##0" to ptr + %"#right#y##0" = load i64, ptr %"tmp#14##0" + %"tmp#1##0" = icmp eq i64 %"#left#x##0", %"#right#x##0" + br i1 %"tmp#1##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#15##0" = icmp eq i64 %"#left#y##0", %"#right#y##0" + ret i1 %"tmp#15##0" +if.else.0: + ret i1 0 } - -define external fastcc i64 @"alias_type3.position.position<0>"(i64 %"x##0", i64 %"y##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"x##0", i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"y##0", i64* %5 - ret i64 %2 +define external fastcc i64 @"alias_type3.position.position<0>"(i64 %"x##0", i64 %"y##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 16) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"x##0", ptr %"tmp#1##0" + %"tmp#2##0" = add i64 %"#rec##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"y##0", ptr %"tmp#3##0" + ret i64 %"#rec##0" } - -define external fastcc {i64, i64} @"alias_type3.position.position<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#result##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#result##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = insertvalue {i64, i64} undef, i64 %1, 0 - %6 = insertvalue {i64, i64} %5, i64 %4, 1 - ret {i64, i64} %6 +define external fastcc {i64, i64} @"alias_type3.position.position<1>"(i64 %"#result##0") { + %"tmp#0##0" = inttoptr i64 %"#result##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + %"tmp#2##0" = add i64 %"#result##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#3##0" + %"tmp#5##0" = insertvalue {i64, i64} undef, i64 %"tmp#1##0", 0 + %"tmp#6##0" = insertvalue {i64, i64} %"tmp#5##0", i64 %"tmp#4##0", 1 + ret {i64, i64} %"tmp#6##0" } - -define external fastcc i64 @"alias_type3.position.x<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#rec##0" to i64* - %1 = load i64, i64* %0 - ret i64 %1 +define external fastcc i64 @"alias_type3.position.x<0>"(i64 %"#rec##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + ret i64 %"tmp#1##0" } - -define external fastcc i64 @"alias_type3.position.x<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = inttoptr i64 %2 to i64* - store i64 %"#field##0", i64* %6 - ret i64 %2 +define external fastcc i64 @"alias_type3.position.x<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"#field##0", ptr %"tmp#3##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"alias_type3.position.y<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = add i64 %"#rec##0", 8 - %1 = inttoptr i64 %0 to i64* - %2 = load i64, i64* %1 - ret i64 %2 +define external fastcc i64 @"alias_type3.position.y<0>"(i64 %"#rec##0") { + %"tmp#0##0" = add i64 %"#rec##0", 8 + %"tmp#1##0" = inttoptr i64 %"tmp#0##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"alias_type3.position.y<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = add i64 %2, 8 - %7 = inttoptr i64 %6 to i64* - store i64 %"#field##0", i64* %7 - ret i64 %2 +define external fastcc i64 @"alias_type3.position.y<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = add i64 %"tmp#2##0", 8 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 %"#field##0", ptr %"tmp#4##0" + ret i64 %"tmp#2##0" } - -define external fastcc i1 @"alias_type3.position.~=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %"#right##0" to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = icmp eq i64 %1, %6 - br i1 %10, label %if.then, label %if.else -if.then: - %11 = icmp eq i64 %4, %9 - %12 = xor i1 %11, 1 - ret i1 %12 -if.else: - %13 = xor i1 0, 1 - ret i1 %13 +define external fastcc i1 @"alias_type3.position.~=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#8##0" = inttoptr i64 %"#left##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#8##0" + %"tmp#9##0" = add i64 %"#left##0", 8 + %"tmp#10##0" = inttoptr i64 %"tmp#9##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#10##0" + %"tmp#11##0" = inttoptr i64 %"#right##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#11##0" + %"tmp#12##0" = add i64 %"#right##0", 8 + %"tmp#13##0" = inttoptr i64 %"tmp#12##0" to ptr + %"tmp#6##0" = load i64, ptr %"tmp#13##0" + %"tmp#7##0" = icmp eq i64 %"tmp#3##0", %"tmp#5##0" + br i1 %"tmp#7##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#0##0" = icmp eq i64 %"tmp#4##0", %"tmp#6##0" + %"tmp#14##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#14##0" +if.else.0: + %"tmp#15##0" = xor i1 0, 1 + ret i1 %"tmp#15##0" } + -------------------------------------------------- Module alias_type3.posrec - representation : address + representation : pointer public submods : public resources: public procs : alias_type3.posrec.=<0> @@ -486,165 +454,141 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'alias_type3.posrec' - - - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i1 @"alias_type3.posrec.=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %"#right##0" to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = inttoptr i64 %1 to i64* - %11 = load i64, i64* %10 - %12 = add i64 %1, 8 - %13 = inttoptr i64 %12 to i64* - %14 = load i64, i64* %13 - %15 = inttoptr i64 %6 to i64* - %16 = load i64, i64* %15 - %17 = add i64 %6, 8 - %18 = inttoptr i64 %17 to i64* - %19 = load i64, i64* %18 - %20 = icmp eq i64 %11, %16 - br i1 %20, label %if.then, label %if.else -if.then: - %21 = icmp eq i64 %19, %14 - br i1 %21, label %if.then1, label %if.else1 -if.else: - ret i1 0 -if.then1: - %22 = icmp eq i64 %4, %9 - ret i1 %22 -if.else1: - ret i1 0 +source_filename = "!ROOT!/final-dump/alias_type3.wybe" +target triple ???? + + +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc i1 @"alias_type3.posrec.=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#14##0" = inttoptr i64 %"#left##0" to ptr + %"#left#p##0" = load i64, ptr %"tmp#14##0" + %"tmp#15##0" = add i64 %"#left##0", 8 + %"tmp#16##0" = inttoptr i64 %"tmp#15##0" to ptr + %"#left#a##0" = load i64, ptr %"tmp#16##0" + %"tmp#17##0" = inttoptr i64 %"#right##0" to ptr + %"#right#p##0" = load i64, ptr %"tmp#17##0" + %"tmp#18##0" = add i64 %"#right##0", 8 + %"tmp#19##0" = inttoptr i64 %"tmp#18##0" to ptr + %"#right#a##0" = load i64, ptr %"tmp#19##0" + %"tmp#20##0" = inttoptr i64 %"#left#p##0" to ptr + %"tmp#7##0" = load i64, ptr %"tmp#20##0" + %"tmp#21##0" = add i64 %"#left#p##0", 8 + %"tmp#22##0" = inttoptr i64 %"tmp#21##0" to ptr + %"tmp#8##0" = load i64, ptr %"tmp#22##0" + %"tmp#23##0" = inttoptr i64 %"#right#p##0" to ptr + %"tmp#9##0" = load i64, ptr %"tmp#23##0" + %"tmp#24##0" = add i64 %"#right#p##0", 8 + %"tmp#25##0" = inttoptr i64 %"tmp#24##0" to ptr + %"tmp#10##0" = load i64, ptr %"tmp#25##0" + %"tmp#11##0" = icmp eq i64 %"tmp#7##0", %"tmp#9##0" + br i1 %"tmp#11##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = icmp eq i64 %"tmp#10##0", %"tmp#8##0" + br i1 %"tmp#1##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#26##0" = icmp eq i64 %"#left#a##0", %"#right#a##0" + ret i1 %"tmp#26##0" +if.else.1: + ret i1 0 +if.else.0: + ret i1 0 } - -define external fastcc i64 @"alias_type3.posrec.a<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = add i64 %"#rec##0", 8 - %1 = inttoptr i64 %0 to i64* - %2 = load i64, i64* %1 - ret i64 %2 +define external fastcc i64 @"alias_type3.posrec.a<0>"(i64 %"#rec##0") { + %"tmp#0##0" = add i64 %"#rec##0", 8 + %"tmp#1##0" = inttoptr i64 %"tmp#0##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"alias_type3.posrec.a<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = add i64 %2, 8 - %7 = inttoptr i64 %6 to i64* - store i64 %"#field##0", i64* %7 - ret i64 %2 +define external fastcc i64 @"alias_type3.posrec.a<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = add i64 %"tmp#2##0", 8 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 %"#field##0", ptr %"tmp#4##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"alias_type3.posrec.p<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#rec##0" to i64* - %1 = load i64, i64* %0 - ret i64 %1 +define external fastcc i64 @"alias_type3.posrec.p<0>"(i64 %"#rec##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + ret i64 %"tmp#1##0" } - -define external fastcc i64 @"alias_type3.posrec.p<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = inttoptr i64 %2 to i64* - store i64 %"#field##0", i64* %6 - ret i64 %2 +define external fastcc i64 @"alias_type3.posrec.p<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"#field##0", ptr %"tmp#3##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"alias_type3.posrec.posrec<0>"(i64 %"p##0", i64 %"a##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"p##0", i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"a##0", i64* %5 - ret i64 %2 +define external fastcc i64 @"alias_type3.posrec.posrec<0>"(i64 %"p##0", i64 %"a##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 16) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"p##0", ptr %"tmp#1##0" + %"tmp#2##0" = add i64 %"#rec##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"a##0", ptr %"tmp#3##0" + ret i64 %"#rec##0" } - -define external fastcc {i64, i64} @"alias_type3.posrec.posrec<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#result##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#result##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = insertvalue {i64, i64} undef, i64 %1, 0 - %6 = insertvalue {i64, i64} %5, i64 %4, 1 - ret {i64, i64} %6 +define external fastcc {i64, i64} @"alias_type3.posrec.posrec<1>"(i64 %"#result##0") { + %"tmp#0##0" = inttoptr i64 %"#result##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + %"tmp#2##0" = add i64 %"#result##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#3##0" + %"tmp#5##0" = insertvalue {i64, i64} undef, i64 %"tmp#1##0", 0 + %"tmp#6##0" = insertvalue {i64, i64} %"tmp#5##0", i64 %"tmp#4##0", 1 + ret {i64, i64} %"tmp#6##0" } - -define external fastcc i1 @"alias_type3.posrec.~=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %"#right##0" to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = inttoptr i64 %1 to i64* - %11 = load i64, i64* %10 - %12 = add i64 %1, 8 - %13 = inttoptr i64 %12 to i64* - %14 = load i64, i64* %13 - %15 = inttoptr i64 %6 to i64* - %16 = load i64, i64* %15 - %17 = add i64 %6, 8 - %18 = inttoptr i64 %17 to i64* - %19 = load i64, i64* %18 - %20 = icmp eq i64 %11, %16 - br i1 %20, label %if.then, label %if.else -if.then: - %21 = icmp eq i64 %19, %14 - br i1 %21, label %if.then1, label %if.else1 -if.else: - %25 = xor i1 0, 1 - ret i1 %25 -if.then1: - %22 = icmp eq i64 %4, %9 - %23 = xor i1 %22, 1 - ret i1 %23 -if.else1: - %24 = xor i1 0, 1 - ret i1 %24 +define external fastcc i1 @"alias_type3.posrec.~=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#13##0" = inttoptr i64 %"#left##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#13##0" + %"tmp#14##0" = add i64 %"#left##0", 8 + %"tmp#15##0" = inttoptr i64 %"tmp#14##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#15##0" + %"tmp#16##0" = inttoptr i64 %"#right##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#16##0" + %"tmp#17##0" = add i64 %"#right##0", 8 + %"tmp#18##0" = inttoptr i64 %"tmp#17##0" to ptr + %"tmp#6##0" = load i64, ptr %"tmp#18##0" + %"tmp#19##0" = inttoptr i64 %"tmp#3##0" to ptr + %"tmp#7##0" = load i64, ptr %"tmp#19##0" + %"tmp#20##0" = add i64 %"tmp#3##0", 8 + %"tmp#21##0" = inttoptr i64 %"tmp#20##0" to ptr + %"tmp#8##0" = load i64, ptr %"tmp#21##0" + %"tmp#22##0" = inttoptr i64 %"tmp#5##0" to ptr + %"tmp#9##0" = load i64, ptr %"tmp#22##0" + %"tmp#23##0" = add i64 %"tmp#5##0", 8 + %"tmp#24##0" = inttoptr i64 %"tmp#23##0" to ptr + %"tmp#10##0" = load i64, ptr %"tmp#24##0" + %"tmp#11##0" = icmp eq i64 %"tmp#7##0", %"tmp#9##0" + br i1 %"tmp#11##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#12##0" = icmp eq i64 %"tmp#10##0", %"tmp#8##0" + br i1 %"tmp#12##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#0##0" = icmp eq i64 %"tmp#4##0", %"tmp#6##0" + %"tmp#25##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#25##0" +if.else.1: + %"tmp#26##0" = xor i1 0, 1 + ret i1 %"tmp#26##0" +if.else.0: + %"tmp#27##0" = xor i1 0, 1 + ret i1 %"tmp#27##0" } diff --git a/test-cases/final-dump/alias_type4.exp b/test-cases/final-dump/alias_type4.exp index 1d6cbf6ac..65d2aa31c 100644 --- a/test-cases/final-dump/alias_type4.exp +++ b/test-cases/final-dump/alias_type4.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module alias_type4 representation : (not a type) public submods : position -> alias_type4.position @@ -46,7 +49,7 @@ module top-level code > public {semipure} (0 calls) proc foo > public (1 calls) -0: alias_type4.foo<0>[410bae77d3] +0: alias_type4.foo<0> foo(r1##0:alias_type4.posrec)<{<>}; {<>}; {}>: AliasPairs: [] InterestingCallProperties: [InterestingUnaliased 0] @@ -68,83 +71,68 @@ foo(r1##0:alias_type4.posrec)<{<>}; {<>}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'alias_type4' - - - - -declare external ccc void @putchar(i8) - - -declare external ccc void @print_int(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"alias_type4.<0>"() { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 100, i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 100, i64* %5 - %6 = trunc i64 16 to i32 - %7 = tail call ccc i8* @wybe_malloc(i32 %6) - %8 = ptrtoint i8* %7 to i64 - %9 = inttoptr i64 %8 to i64* - store i64 %2, i64* %9 - %10 = add i64 %8, 8 - %11 = inttoptr i64 %10 to i64* - store i64 1, i64* %11 - tail call fastcc void @"alias_type4.foo<0>[410bae77d3]"(i64 %8) - ret void +source_filename = "!ROOT!/final-dump/alias_type4.wybe" +target triple ???? + + +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"alias_type4.<0>"() { + %"tmp#12##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#4##0" = ptrtoint ptr %"tmp#12##0" to i64 + %"tmp#13##0" = inttoptr i64 %"tmp#4##0" to ptr + store i64 100, ptr %"tmp#13##0" + %"tmp#14##0" = add i64 %"tmp#4##0", 8 + %"tmp#15##0" = inttoptr i64 %"tmp#14##0" to ptr + store i64 100, ptr %"tmp#15##0" + %"tmp#16##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#9##0" = ptrtoint ptr %"tmp#16##0" to i64 + %"tmp#17##0" = inttoptr i64 %"tmp#9##0" to ptr + store i64 %"tmp#4##0", ptr %"tmp#17##0" + %"tmp#18##0" = add i64 %"tmp#9##0", 8 + %"tmp#19##0" = inttoptr i64 %"tmp#18##0" to ptr + store i64 1, ptr %"tmp#19##0" + tail call fastcc void @"alias_type4.foo<0>[410bae77d3]"(i64 %"tmp#9##0") + ret void } - -define external fastcc void @"alias_type4.foo<0>"(i64 %"r1##0") { -entry: - %0 = inttoptr i64 %"r1##0" to i64* - %1 = load i64, i64* %0 - %2 = trunc i64 16 to i32 - %3 = tail call ccc i8* @wybe_malloc(i32 %2) - %4 = ptrtoint i8* %3 to i64 - %5 = inttoptr i64 %4 to i8* - %6 = inttoptr i64 %1 to i8* - %7 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %5, i8* %6, i32 %7, i1 0) - %8 = inttoptr i64 %4 to i64* - store i64 1111, i64* %8 - %9 = inttoptr i64 %4 to i64* - %10 = load i64, i64* %9 - tail call ccc void @print_int(i64 %10) - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"alias_type4.foo<0>"(i64 %"r1##0") { + %"tmp#10##0" = inttoptr i64 %"r1##0" to ptr + %"tmp#0##0" = load i64, ptr %"tmp#10##0" + %"tmp#11##0" = inttoptr i64 %"tmp#0##0" to ptr + %"tmp#12##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#12##0", ptr %"tmp#11##0", i64 16, i1 0) + %"tmp#13##0" = ptrtoint ptr %"tmp#12##0" to i64 + %"tmp#14##0" = inttoptr i64 %"tmp#13##0" to ptr + store i64 1111, ptr %"tmp#14##0" + %"tmp#15##0" = inttoptr i64 %"tmp#13##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#15##0" + call ccc void @print_int(i64 %"tmp#1##0") + call ccc void @putchar(i8 10) + ret void } - -define external fastcc void @"alias_type4.foo<0>[410bae77d3]"(i64 %"r1##0") { -entry: - %0 = inttoptr i64 %"r1##0" to i64* - %1 = load i64, i64* %0 - %2 = inttoptr i64 %1 to i64* - store i64 1111, i64* %2 - %3 = inttoptr i64 %1 to i64* - %4 = load i64, i64* %3 - tail call ccc void @print_int(i64 %4) - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"alias_type4.foo<0>[410bae77d3]"(i64 %"r1##0") { + %"tmp#10##0" = inttoptr i64 %"r1##0" to ptr + %"tmp#0##0" = load i64, ptr %"tmp#10##0" + %"tmp#11##0" = inttoptr i64 %"tmp#0##0" to ptr + store i64 1111, ptr %"tmp#11##0" + %"tmp#12##0" = inttoptr i64 %"tmp#0##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#12##0" + call ccc void @print_int(i64 %"tmp#1##0") + call ccc void @putchar(i8 10) + ret void } + -------------------------------------------------- Module alias_type4.position - representation : address + representation : pointer public submods : public resources: public procs : alias_type4.position.=<0> @@ -246,140 +234,117 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'alias_type4.position' - - - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i1 @"alias_type4.position.=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %"#right##0" to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = icmp eq i64 %1, %6 - br i1 %10, label %if.then, label %if.else -if.then: - %11 = icmp eq i64 %4, %9 - ret i1 %11 -if.else: - ret i1 0 +source_filename = "!ROOT!/final-dump/alias_type4.wybe" +target triple ???? + + +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc i1 @"alias_type4.position.=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#9##0" = inttoptr i64 %"#left##0" to ptr + %"#left#x##0" = load i64, ptr %"tmp#9##0" + %"tmp#10##0" = add i64 %"#left##0", 8 + %"tmp#11##0" = inttoptr i64 %"tmp#10##0" to ptr + %"#left#y##0" = load i64, ptr %"tmp#11##0" + %"tmp#12##0" = inttoptr i64 %"#right##0" to ptr + %"#right#x##0" = load i64, ptr %"tmp#12##0" + %"tmp#13##0" = add i64 %"#right##0", 8 + %"tmp#14##0" = inttoptr i64 %"tmp#13##0" to ptr + %"#right#y##0" = load i64, ptr %"tmp#14##0" + %"tmp#1##0" = icmp eq i64 %"#left#x##0", %"#right#x##0" + br i1 %"tmp#1##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#15##0" = icmp eq i64 %"#left#y##0", %"#right#y##0" + ret i1 %"tmp#15##0" +if.else.0: + ret i1 0 } - -define external fastcc i64 @"alias_type4.position.position<0>"(i64 %"x##0", i64 %"y##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"x##0", i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"y##0", i64* %5 - ret i64 %2 +define external fastcc i64 @"alias_type4.position.position<0>"(i64 %"x##0", i64 %"y##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 16) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"x##0", ptr %"tmp#1##0" + %"tmp#2##0" = add i64 %"#rec##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"y##0", ptr %"tmp#3##0" + ret i64 %"#rec##0" } - -define external fastcc {i64, i64} @"alias_type4.position.position<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#result##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#result##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = insertvalue {i64, i64} undef, i64 %1, 0 - %6 = insertvalue {i64, i64} %5, i64 %4, 1 - ret {i64, i64} %6 +define external fastcc {i64, i64} @"alias_type4.position.position<1>"(i64 %"#result##0") { + %"tmp#0##0" = inttoptr i64 %"#result##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + %"tmp#2##0" = add i64 %"#result##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#3##0" + %"tmp#5##0" = insertvalue {i64, i64} undef, i64 %"tmp#1##0", 0 + %"tmp#6##0" = insertvalue {i64, i64} %"tmp#5##0", i64 %"tmp#4##0", 1 + ret {i64, i64} %"tmp#6##0" } - -define external fastcc i64 @"alias_type4.position.x<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#rec##0" to i64* - %1 = load i64, i64* %0 - ret i64 %1 +define external fastcc i64 @"alias_type4.position.x<0>"(i64 %"#rec##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + ret i64 %"tmp#1##0" } - -define external fastcc i64 @"alias_type4.position.x<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = inttoptr i64 %2 to i64* - store i64 %"#field##0", i64* %6 - ret i64 %2 +define external fastcc i64 @"alias_type4.position.x<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"#field##0", ptr %"tmp#3##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"alias_type4.position.y<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = add i64 %"#rec##0", 8 - %1 = inttoptr i64 %0 to i64* - %2 = load i64, i64* %1 - ret i64 %2 +define external fastcc i64 @"alias_type4.position.y<0>"(i64 %"#rec##0") { + %"tmp#0##0" = add i64 %"#rec##0", 8 + %"tmp#1##0" = inttoptr i64 %"tmp#0##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"alias_type4.position.y<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = add i64 %2, 8 - %7 = inttoptr i64 %6 to i64* - store i64 %"#field##0", i64* %7 - ret i64 %2 +define external fastcc i64 @"alias_type4.position.y<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = add i64 %"tmp#2##0", 8 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 %"#field##0", ptr %"tmp#4##0" + ret i64 %"tmp#2##0" } - -define external fastcc i1 @"alias_type4.position.~=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %"#right##0" to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = icmp eq i64 %1, %6 - br i1 %10, label %if.then, label %if.else -if.then: - %11 = icmp eq i64 %4, %9 - %12 = xor i1 %11, 1 - ret i1 %12 -if.else: - %13 = xor i1 0, 1 - ret i1 %13 +define external fastcc i1 @"alias_type4.position.~=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#8##0" = inttoptr i64 %"#left##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#8##0" + %"tmp#9##0" = add i64 %"#left##0", 8 + %"tmp#10##0" = inttoptr i64 %"tmp#9##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#10##0" + %"tmp#11##0" = inttoptr i64 %"#right##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#11##0" + %"tmp#12##0" = add i64 %"#right##0", 8 + %"tmp#13##0" = inttoptr i64 %"tmp#12##0" to ptr + %"tmp#6##0" = load i64, ptr %"tmp#13##0" + %"tmp#7##0" = icmp eq i64 %"tmp#3##0", %"tmp#5##0" + br i1 %"tmp#7##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#0##0" = icmp eq i64 %"tmp#4##0", %"tmp#6##0" + %"tmp#14##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#14##0" +if.else.0: + %"tmp#15##0" = xor i1 0, 1 + ret i1 %"tmp#15##0" } + -------------------------------------------------- Module alias_type4.posrec - representation : address + representation : pointer public submods : public resources: public procs : alias_type4.posrec.=<0> @@ -504,165 +469,141 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'alias_type4.posrec' - - - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i1 @"alias_type4.posrec.=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %"#right##0" to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = inttoptr i64 %1 to i64* - %11 = load i64, i64* %10 - %12 = add i64 %1, 8 - %13 = inttoptr i64 %12 to i64* - %14 = load i64, i64* %13 - %15 = inttoptr i64 %6 to i64* - %16 = load i64, i64* %15 - %17 = add i64 %6, 8 - %18 = inttoptr i64 %17 to i64* - %19 = load i64, i64* %18 - %20 = icmp eq i64 %11, %16 - br i1 %20, label %if.then, label %if.else -if.then: - %21 = icmp eq i64 %19, %14 - br i1 %21, label %if.then1, label %if.else1 -if.else: - ret i1 0 -if.then1: - %22 = icmp eq i64 %4, %9 - ret i1 %22 -if.else1: - ret i1 0 +source_filename = "!ROOT!/final-dump/alias_type4.wybe" +target triple ???? + + +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc i1 @"alias_type4.posrec.=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#14##0" = inttoptr i64 %"#left##0" to ptr + %"#left#p##0" = load i64, ptr %"tmp#14##0" + %"tmp#15##0" = add i64 %"#left##0", 8 + %"tmp#16##0" = inttoptr i64 %"tmp#15##0" to ptr + %"#left#a##0" = load i64, ptr %"tmp#16##0" + %"tmp#17##0" = inttoptr i64 %"#right##0" to ptr + %"#right#p##0" = load i64, ptr %"tmp#17##0" + %"tmp#18##0" = add i64 %"#right##0", 8 + %"tmp#19##0" = inttoptr i64 %"tmp#18##0" to ptr + %"#right#a##0" = load i64, ptr %"tmp#19##0" + %"tmp#20##0" = inttoptr i64 %"#left#p##0" to ptr + %"tmp#7##0" = load i64, ptr %"tmp#20##0" + %"tmp#21##0" = add i64 %"#left#p##0", 8 + %"tmp#22##0" = inttoptr i64 %"tmp#21##0" to ptr + %"tmp#8##0" = load i64, ptr %"tmp#22##0" + %"tmp#23##0" = inttoptr i64 %"#right#p##0" to ptr + %"tmp#9##0" = load i64, ptr %"tmp#23##0" + %"tmp#24##0" = add i64 %"#right#p##0", 8 + %"tmp#25##0" = inttoptr i64 %"tmp#24##0" to ptr + %"tmp#10##0" = load i64, ptr %"tmp#25##0" + %"tmp#11##0" = icmp eq i64 %"tmp#7##0", %"tmp#9##0" + br i1 %"tmp#11##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = icmp eq i64 %"tmp#10##0", %"tmp#8##0" + br i1 %"tmp#1##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#26##0" = icmp eq i64 %"#left#a##0", %"#right#a##0" + ret i1 %"tmp#26##0" +if.else.1: + ret i1 0 +if.else.0: + ret i1 0 } - -define external fastcc i64 @"alias_type4.posrec.a<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = add i64 %"#rec##0", 8 - %1 = inttoptr i64 %0 to i64* - %2 = load i64, i64* %1 - ret i64 %2 +define external fastcc i64 @"alias_type4.posrec.a<0>"(i64 %"#rec##0") { + %"tmp#0##0" = add i64 %"#rec##0", 8 + %"tmp#1##0" = inttoptr i64 %"tmp#0##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"alias_type4.posrec.a<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = add i64 %2, 8 - %7 = inttoptr i64 %6 to i64* - store i64 %"#field##0", i64* %7 - ret i64 %2 +define external fastcc i64 @"alias_type4.posrec.a<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = add i64 %"tmp#2##0", 8 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 %"#field##0", ptr %"tmp#4##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"alias_type4.posrec.p<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#rec##0" to i64* - %1 = load i64, i64* %0 - ret i64 %1 +define external fastcc i64 @"alias_type4.posrec.p<0>"(i64 %"#rec##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + ret i64 %"tmp#1##0" } - -define external fastcc i64 @"alias_type4.posrec.p<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = inttoptr i64 %2 to i64* - store i64 %"#field##0", i64* %6 - ret i64 %2 +define external fastcc i64 @"alias_type4.posrec.p<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"#field##0", ptr %"tmp#3##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"alias_type4.posrec.posrec<0>"(i64 %"p##0", i64 %"a##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"p##0", i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"a##0", i64* %5 - ret i64 %2 +define external fastcc i64 @"alias_type4.posrec.posrec<0>"(i64 %"p##0", i64 %"a##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 16) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"p##0", ptr %"tmp#1##0" + %"tmp#2##0" = add i64 %"#rec##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"a##0", ptr %"tmp#3##0" + ret i64 %"#rec##0" } - -define external fastcc {i64, i64} @"alias_type4.posrec.posrec<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#result##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#result##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = insertvalue {i64, i64} undef, i64 %1, 0 - %6 = insertvalue {i64, i64} %5, i64 %4, 1 - ret {i64, i64} %6 +define external fastcc {i64, i64} @"alias_type4.posrec.posrec<1>"(i64 %"#result##0") { + %"tmp#0##0" = inttoptr i64 %"#result##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + %"tmp#2##0" = add i64 %"#result##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#3##0" + %"tmp#5##0" = insertvalue {i64, i64} undef, i64 %"tmp#1##0", 0 + %"tmp#6##0" = insertvalue {i64, i64} %"tmp#5##0", i64 %"tmp#4##0", 1 + ret {i64, i64} %"tmp#6##0" } - -define external fastcc i1 @"alias_type4.posrec.~=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %"#right##0" to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = inttoptr i64 %1 to i64* - %11 = load i64, i64* %10 - %12 = add i64 %1, 8 - %13 = inttoptr i64 %12 to i64* - %14 = load i64, i64* %13 - %15 = inttoptr i64 %6 to i64* - %16 = load i64, i64* %15 - %17 = add i64 %6, 8 - %18 = inttoptr i64 %17 to i64* - %19 = load i64, i64* %18 - %20 = icmp eq i64 %11, %16 - br i1 %20, label %if.then, label %if.else -if.then: - %21 = icmp eq i64 %19, %14 - br i1 %21, label %if.then1, label %if.else1 -if.else: - %25 = xor i1 0, 1 - ret i1 %25 -if.then1: - %22 = icmp eq i64 %4, %9 - %23 = xor i1 %22, 1 - ret i1 %23 -if.else1: - %24 = xor i1 0, 1 - ret i1 %24 +define external fastcc i1 @"alias_type4.posrec.~=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#13##0" = inttoptr i64 %"#left##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#13##0" + %"tmp#14##0" = add i64 %"#left##0", 8 + %"tmp#15##0" = inttoptr i64 %"tmp#14##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#15##0" + %"tmp#16##0" = inttoptr i64 %"#right##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#16##0" + %"tmp#17##0" = add i64 %"#right##0", 8 + %"tmp#18##0" = inttoptr i64 %"tmp#17##0" to ptr + %"tmp#6##0" = load i64, ptr %"tmp#18##0" + %"tmp#19##0" = inttoptr i64 %"tmp#3##0" to ptr + %"tmp#7##0" = load i64, ptr %"tmp#19##0" + %"tmp#20##0" = add i64 %"tmp#3##0", 8 + %"tmp#21##0" = inttoptr i64 %"tmp#20##0" to ptr + %"tmp#8##0" = load i64, ptr %"tmp#21##0" + %"tmp#22##0" = inttoptr i64 %"tmp#5##0" to ptr + %"tmp#9##0" = load i64, ptr %"tmp#22##0" + %"tmp#23##0" = add i64 %"tmp#5##0", 8 + %"tmp#24##0" = inttoptr i64 %"tmp#23##0" to ptr + %"tmp#10##0" = load i64, ptr %"tmp#24##0" + %"tmp#11##0" = icmp eq i64 %"tmp#7##0", %"tmp#9##0" + br i1 %"tmp#11##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#12##0" = icmp eq i64 %"tmp#10##0", %"tmp#8##0" + br i1 %"tmp#12##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#0##0" = icmp eq i64 %"tmp#4##0", %"tmp#6##0" + %"tmp#25##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#25##0" +if.else.1: + %"tmp#26##0" = xor i1 0, 1 + ret i1 %"tmp#26##0" +if.else.0: + %"tmp#27##0" = xor i1 0, 1 + ret i1 %"tmp#27##0" } diff --git a/test-cases/final-dump/alloc_args.exp b/test-cases/final-dump/alloc_args.exp index 21d83cde9..0589001c3 100644 --- a/test-cases/final-dump/alloc_args.exp +++ b/test-cases/final-dump/alloc_args.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module alloc_args representation : (not a type) public submods : @@ -32,39 +35,30 @@ foo(size##0:wybe.int)<{<>}; {<>}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'alloc_args' +source_filename = "!ROOT!/final-dump/alloc_args.wybe" +target triple ???? - - - -declare external ccc void @putchar(i8) - - -declare external fastcc void @"wybe.string.print<0>[410bae77d3]"(i64) +declare external fastcc void @"wybe.string.print<0>[410bae77d3]"(i64) +declare external ccc void @putchar(i8) +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"alloc_args.<0>"() alwaysinline { -entry: - tail call fastcc void @"alloc_args.foo<0>"(i64 1) - ret void +define external fastcc void @"alloc_args.<0>"() { + tail call fastcc void @"alloc_args.foo<0>"(i64 1) + ret void } - -define external fastcc void @"alloc_args.foo<0>"(i64 %"size##0") noinline { -entry: - %0 = trunc i64 %"size##0" to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 0, i64* %3 - tail call fastcc void @"wybe.string.print<0>[410bae77d3]"(i64 %2) - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"alloc_args.foo<0>"(i64 %"size##0") { + %"tmp#4##0" = trunc i64 %"size##0" to i32 + %"tmp#5##0" = call ccc ptr @wybe_malloc(i32 %"tmp#4##0") + %"str##0" = ptrtoint ptr %"tmp#5##0" to i64 + %"tmp#6##0" = inttoptr i64 %"str##0" to ptr + store i64 0, ptr %"tmp#6##0" + tail call fastcc void @"wybe.string.print<0>[410bae77d3]"(i64 %"str##0") + call ccc void @putchar(i8 10) + ret void } diff --git a/test-cases/final-dump/anon_field.exp b/test-cases/final-dump/anon_field.exp index 1737f0d08..efd19bcec 100644 --- a/test-cases/final-dump/anon_field.exp +++ b/test-cases/final-dump/anon_field.exp @@ -1,7 +1,10 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module anon_field - representation : address + representation : pointer public submods : quux -> anon_field.quux public resources: public procs : anon_field.<0> @@ -351,452 +354,388 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'anon_field' - - - - -@anon_field.5 = constant {i64, i64} { i64 3, i64 ptrtoint ([?? x i8]* @anon_field.4 to i64) } - - -@anon_field.3 = constant {i64, i64} { i64 4, i64 ptrtoint ([?? x i8]* @anon_field.2 to i64) } - - -@anon_field.1 = constant {i64, i64} { i64 5, i64 ptrtoint ([?? x i8]* @anon_field.0 to i64) } - - -@anon_field.7 = constant {i64, i64} { i64 5, i64 ptrtoint ([?? x i8]* @anon_field.6 to i64) } - - -@anon_field.4 = constant [?? x i8] c"bad\00" - - -@anon_field.2 = constant [?? x i8] c"good\00" - - -@anon_field.6 = constant [?? x i8] c"maybe\00" - - -@anon_field.0 = constant [?? x i8] c"uh oh\00" - - -declare external ccc void @putchar(i8) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"anon_field.<0>"() { -entry: - %0 = trunc i64 24 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i1* - store i1 0, i1* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 1, i64* %5 - %6 = add i64 %2, 16 - %7 = inttoptr i64 %6 to i64* - store i64 1, i64* %7 - %8 = trunc i64 8 to i32 - %9 = tail call ccc i8* @wybe_malloc(i32 %8) - %10 = ptrtoint i8* %9 to i64 - %11 = inttoptr i64 %10 to i64* - store i64 1, i64* %11 - %12 = or i64 %10, 1 - %13 = tail call fastcc i1 @"anon_field.=<0>"(i64 %2, i64 %12) - br i1 %13, label %if.then, label %if.else -if.then: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @anon_field.1, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - musttail call fastcc void @"anon_field.#cont#1<0>"() - ret void -if.else: - musttail call fastcc void @"anon_field.#cont#1<0>"() - ret void +source_filename = "!ROOT!/final-dump/anon_field.wybe" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c"bad\00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c"good\00", align 8 +@"cstring#2" = private unnamed_addr constant [ ?? x i8 ] c"maybe\00", align 8 +@"cstring#3" = private unnamed_addr constant [ ?? x i8 ] c"uh oh\00", align 8 +@"string#4" = private unnamed_addr constant {i64, i64} { i64 3, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +@"string#5" = private unnamed_addr constant {i64, i64} { i64 4, i64 ptrtoint( ptr @"cstring#1" to i64 ) }, align 8 +@"string#6" = private unnamed_addr constant {i64, i64} { i64 5, i64 ptrtoint( ptr @"cstring#2" to i64 ) }, align 8 +@"string#7" = private unnamed_addr constant {i64, i64} { i64 5, i64 ptrtoint( ptr @"cstring#3" to i64 ) }, align 8 + +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @putchar(i8) +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"anon_field.<0>"() { + %"tmp#30##0" = call ccc ptr @wybe_malloc(i32 24) + %"tmp#21##0" = ptrtoint ptr %"tmp#30##0" to i64 + %"tmp#31##0" = inttoptr i64 %"tmp#21##0" to ptr + store i1 0, ptr %"tmp#31##0" + %"tmp#32##0" = add i64 %"tmp#21##0", 8 + %"tmp#33##0" = inttoptr i64 %"tmp#32##0" to ptr + store i64 1, ptr %"tmp#33##0" + %"tmp#34##0" = add i64 %"tmp#21##0", 16 + %"tmp#35##0" = inttoptr i64 %"tmp#34##0" to ptr + store i64 1, ptr %"tmp#35##0" + %"tmp#36##0" = call ccc ptr @wybe_malloc(i32 8) + %"tmp#25##0" = ptrtoint ptr %"tmp#36##0" to i64 + %"tmp#37##0" = inttoptr i64 %"tmp#25##0" to ptr + store i64 1, ptr %"tmp#37##0" + %"tmp#2##0" = or i64 %"tmp#25##0", 1 + %"tmp#17##0" = tail call fastcc i1 @"anon_field.=<0>"(i64 %"tmp#21##0", i64 %"tmp#2##0") + br i1 %"tmp#17##0", label %if.then.0, label %if.else.0 +if.then.0: + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#7" to i64 )) + call ccc void @putchar(i8 10) + tail call fastcc void @"anon_field.#cont#1<0>"() + ret void +if.else.0: + tail call fastcc void @"anon_field.#cont#1<0>"() + ret void } - -define external fastcc void @"anon_field.#cont#1<0>"() { -entry: - %0 = trunc i64 24 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i1* - store i1 0, i1* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 1, i64* %5 - %6 = add i64 %2, 16 - %7 = inttoptr i64 %6 to i64* - store i64 1, i64* %7 - %8 = and i64 %2, 3 - %9 = icmp eq i64 %8, 0 - br i1 %9, label %if.then, label %if.else -if.then: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @anon_field.3, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - musttail call fastcc void @"anon_field.#cont#2<0>"() - ret void -if.else: - musttail call fastcc void @"anon_field.#cont#2<0>"() - ret void +define external fastcc void @"anon_field.#cont#1<0>"() { + %"tmp#31##0" = call ccc ptr @wybe_malloc(i32 24) + %"tmp#20##0" = ptrtoint ptr %"tmp#31##0" to i64 + %"tmp#32##0" = inttoptr i64 %"tmp#20##0" to ptr + store i1 0, ptr %"tmp#32##0" + %"tmp#33##0" = add i64 %"tmp#20##0", 8 + %"tmp#34##0" = inttoptr i64 %"tmp#33##0" to ptr + store i64 1, ptr %"tmp#34##0" + %"tmp#35##0" = add i64 %"tmp#20##0", 16 + %"tmp#36##0" = inttoptr i64 %"tmp#35##0" to ptr + store i64 1, ptr %"tmp#36##0" + %"tmp#24##0" = and i64 %"tmp#20##0", 3 + %"tmp#25##0" = icmp eq i64 %"tmp#24##0", 0 + br i1 %"tmp#25##0", label %if.then.0, label %if.else.0 +if.then.0: + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#5" to i64 )) + call ccc void @putchar(i8 10) + tail call fastcc void @"anon_field.#cont#2<0>"() + ret void +if.else.0: + tail call fastcc void @"anon_field.#cont#2<0>"() + ret void } - -define external fastcc void @"anon_field.#cont#2<0>"() { -entry: - %0 = trunc i64 24 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i1* - store i1 0, i1* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 1, i64* %5 - %6 = add i64 %2, 16 - %7 = inttoptr i64 %6 to i64* - store i64 1, i64* %7 - %8 = trunc i64 24 to i32 - %9 = tail call ccc i8* @wybe_malloc(i32 %8) - %10 = ptrtoint i8* %9 to i64 - %11 = inttoptr i64 %10 to i1* - store i1 0, i1* %11 - %12 = add i64 %10, 8 - %13 = inttoptr i64 %12 to i64* - store i64 2, i64* %13 - %14 = add i64 %10, 16 - %15 = inttoptr i64 %14 to i64* - store i64 1, i64* %15 - %16 = tail call fastcc i1 @"anon_field.=<0>"(i64 %2, i64 %10) - br i1 %16, label %if.then, label %if.else -if.then: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @anon_field.5, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - musttail call fastcc void @"anon_field.#cont#3<0>"() - ret void -if.else: - musttail call fastcc void @"anon_field.#cont#3<0>"() - ret void +define external fastcc void @"anon_field.#cont#2<0>"() { + %"tmp#30##0" = call ccc ptr @wybe_malloc(i32 24) + %"tmp#18##0" = ptrtoint ptr %"tmp#30##0" to i64 + %"tmp#31##0" = inttoptr i64 %"tmp#18##0" to ptr + store i1 0, ptr %"tmp#31##0" + %"tmp#32##0" = add i64 %"tmp#18##0", 8 + %"tmp#33##0" = inttoptr i64 %"tmp#32##0" to ptr + store i64 1, ptr %"tmp#33##0" + %"tmp#34##0" = add i64 %"tmp#18##0", 16 + %"tmp#35##0" = inttoptr i64 %"tmp#34##0" to ptr + store i64 1, ptr %"tmp#35##0" + %"tmp#36##0" = call ccc ptr @wybe_malloc(i32 24) + %"tmp#24##0" = ptrtoint ptr %"tmp#36##0" to i64 + %"tmp#37##0" = inttoptr i64 %"tmp#24##0" to ptr + store i1 0, ptr %"tmp#37##0" + %"tmp#38##0" = add i64 %"tmp#24##0", 8 + %"tmp#39##0" = inttoptr i64 %"tmp#38##0" to ptr + store i64 2, ptr %"tmp#39##0" + %"tmp#40##0" = add i64 %"tmp#24##0", 16 + %"tmp#41##0" = inttoptr i64 %"tmp#40##0" to ptr + store i64 1, ptr %"tmp#41##0" + %"tmp#14##0" = tail call fastcc i1 @"anon_field.=<0>"(i64 %"tmp#18##0", i64 %"tmp#24##0") + br i1 %"tmp#14##0", label %if.then.0, label %if.else.0 +if.then.0: + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#4" to i64 )) + call ccc void @putchar(i8 10) + tail call fastcc void @"anon_field.#cont#3<0>"() + ret void +if.else.0: + tail call fastcc void @"anon_field.#cont#3<0>"() + ret void } - -define external fastcc void @"anon_field.#cont#3<0>"() { -entry: - %0 = trunc i64 8 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 1, i64* %3 - %4 = or i64 %2, 2 - %5 = and i64 %4, 3 - %6 = icmp eq i64 %5, 2 - br i1 %6, label %if.then, label %if.else -if.then: - %7 = add i64 %4, -2 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = icmp ne i64 %9, 2 - br i1 %10, label %if.then1, label %if.else1 -if.else: - ret void -if.then1: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @anon_field.7, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - ret void -if.else1: - ret void +define external fastcc void @"anon_field.#cont#3<0>"() { + %"tmp#25##0" = call ccc ptr @wybe_malloc(i32 8) + %"tmp#15##0" = ptrtoint ptr %"tmp#25##0" to i64 + %"tmp#26##0" = inttoptr i64 %"tmp#15##0" to ptr + store i64 1, ptr %"tmp#26##0" + %"tmp#11##0" = or i64 %"tmp#15##0", 2 + %"tmp#18##0" = and i64 %"tmp#11##0", 3 + %"tmp#19##0" = icmp eq i64 %"tmp#18##0", 2 + br i1 %"tmp#19##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#27##0" = add i64 %"tmp#11##0", -2 + %"tmp#28##0" = inttoptr i64 %"tmp#27##0" to ptr + %"tmp#10##0" = load i64, ptr %"tmp#28##0" + %"tmp#13##0" = icmp ne i64 %"tmp#10##0", 2 + br i1 %"tmp#13##0", label %if.then.1, label %if.else.1 +if.then.1: + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#6" to i64 )) + call ccc void @putchar(i8 10) + ret void +if.else.1: + ret void +if.else.0: + ret void } - -define external fastcc i1 @"anon_field.=<0>"(i64 %"#left##0", i64 %"#right##0") { -entry: - %0 = and i64 %"#left##0", 3 - switch i64 %0, label %switch.3.2 [i64 0, label %switch.3.0 i64 1, label %switch.3.1 i64 2, label %switch.3.2] -switch.3.0: - %1 = inttoptr i64 %"#left##0" to i1* - %2 = load i1, i1* %1 - %3 = add i64 %"#left##0", 8 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = add i64 %"#left##0", 16 - %7 = inttoptr i64 %6 to i64* - %8 = load i64, i64* %7 - %9 = and i64 %"#right##0", 3 - %10 = icmp eq i64 %9, 0 - br i1 %10, label %if.then, label %if.else -switch.3.1: - %22 = add i64 %"#left##0", -1 - %23 = inttoptr i64 %22 to i64* - %24 = load i64, i64* %23 - %25 = and i64 %"#right##0", 3 - %26 = icmp eq i64 %25, 1 - br i1 %26, label %if.then3, label %if.else3 -switch.3.2: - %31 = add i64 %"#left##0", -2 - %32 = inttoptr i64 %31 to i64* - %33 = load i64, i64* %32 - %34 = and i64 %"#right##0", 3 - %35 = icmp eq i64 %34, 2 - br i1 %35, label %if.then4, label %if.else4 -if.then: - %11 = inttoptr i64 %"#right##0" to i1* - %12 = load i1, i1* %11 - %13 = add i64 %"#right##0", 8 - %14 = inttoptr i64 %13 to i64* - %15 = load i64, i64* %14 - %16 = add i64 %"#right##0", 16 - %17 = inttoptr i64 %16 to i64* - %18 = load i64, i64* %17 - %19 = icmp eq i64 %5, %15 - br i1 %19, label %if.then1, label %if.else1 -if.else: - ret i1 0 -if.then1: - %20 = icmp eq i1 %2, %12 - br i1 %20, label %if.then2, label %if.else2 -if.else1: - ret i1 0 -if.then2: - %21 = icmp eq i64 %8, %18 - ret i1 %21 -if.else2: - ret i1 0 -if.then3: - %27 = add i64 %"#right##0", -1 - %28 = inttoptr i64 %27 to i64* - %29 = load i64, i64* %28 - %30 = icmp eq i64 %24, %29 - ret i1 %30 -if.else3: - ret i1 0 -if.then4: - %36 = add i64 %"#right##0", -2 - %37 = inttoptr i64 %36 to i64* - %38 = load i64, i64* %37 - %39 = icmp eq i64 %33, %38 - ret i1 %39 -if.else4: - ret i1 0 +define external fastcc i1 @"anon_field.=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#13##0" = and i64 %"#left##0", 3 + switch i64 %"tmp#13##0", label %case.2.switch.0 [ + i64 0, label %case.0.switch.0 + i64 1, label %case.1.switch.0 + i64 2, label %case.2.switch.0 ] +case.0.switch.0: + %"tmp#40##0" = inttoptr i64 %"#left##0" to ptr + %"#left#foo#2##0" = load i1, ptr %"tmp#40##0" + %"tmp#41##0" = add i64 %"#left##0", 8 + %"tmp#42##0" = inttoptr i64 %"tmp#41##0" to ptr + %"#left#foo#1##0" = load i64, ptr %"tmp#42##0" + %"tmp#43##0" = add i64 %"#left##0", 16 + %"tmp#44##0" = inttoptr i64 %"tmp#43##0" to ptr + %"#left#i##0" = load i64, ptr %"tmp#44##0" + %"tmp#32##0" = and i64 %"#right##0", 3 + %"tmp#33##0" = icmp eq i64 %"tmp#32##0", 0 + br i1 %"tmp#33##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#45##0" = inttoptr i64 %"#right##0" to ptr + %"#right#foo#2##0" = load i1, ptr %"tmp#45##0" + %"tmp#46##0" = add i64 %"#right##0", 8 + %"tmp#47##0" = inttoptr i64 %"tmp#46##0" to ptr + %"#right#foo#1##0" = load i64, ptr %"tmp#47##0" + %"tmp#48##0" = add i64 %"#right##0", 16 + %"tmp#49##0" = inttoptr i64 %"tmp#48##0" to ptr + %"#right#i##0" = load i64, ptr %"tmp#49##0" + %"tmp#2##0" = icmp eq i64 %"#left#foo#1##0", %"#right#foo#1##0" + br i1 %"tmp#2##0", label %if.then.2, label %if.else.2 +if.then.2: + %"tmp#3##0" = icmp eq i1 %"#left#foo#2##0", %"#right#foo#2##0" + br i1 %"tmp#3##0", label %if.then.3, label %if.else.3 +if.then.3: + %"tmp#50##0" = icmp eq i64 %"#left#i##0", %"#right#i##0" + ret i1 %"tmp#50##0" +if.else.3: + ret i1 0 +if.else.2: + ret i1 0 +if.else.1: + ret i1 0 +case.1.switch.0: + %"tmp#51##0" = add i64 %"#left##0", -1 + %"tmp#52##0" = inttoptr i64 %"tmp#51##0" to ptr + %"#left#bar#1##0" = load i64, ptr %"tmp#52##0" + %"tmp#27##0" = and i64 %"#right##0", 3 + %"tmp#28##0" = icmp eq i64 %"tmp#27##0", 1 + br i1 %"tmp#28##0", label %if.then.4, label %if.else.4 +if.then.4: + %"tmp#53##0" = add i64 %"#right##0", -1 + %"tmp#54##0" = inttoptr i64 %"tmp#53##0" to ptr + %"#right#bar#1##0" = load i64, ptr %"tmp#54##0" + %"tmp#55##0" = icmp eq i64 %"#left#bar#1##0", %"#right#bar#1##0" + ret i1 %"tmp#55##0" +if.else.4: + ret i1 0 +case.2.switch.0: + %"tmp#56##0" = add i64 %"#left##0", -2 + %"tmp#57##0" = inttoptr i64 %"tmp#56##0" to ptr + %"#left#field##0" = load i64, ptr %"tmp#57##0" + %"tmp#22##0" = and i64 %"#right##0", 3 + %"tmp#23##0" = icmp eq i64 %"tmp#22##0", 2 + br i1 %"tmp#23##0", label %if.then.5, label %if.else.5 +if.then.5: + %"tmp#58##0" = add i64 %"#right##0", -2 + %"tmp#59##0" = inttoptr i64 %"tmp#58##0" to ptr + %"#right#field##0" = load i64, ptr %"tmp#59##0" + %"tmp#60##0" = icmp eq i64 %"#left#field##0", %"#right#field##0" + ret i1 %"tmp#60##0" +if.else.5: + ret i1 0 } - -define external fastcc i64 @"anon_field.bar<0>"(i64 %"bar#1##0") alwaysinline { -entry: - %0 = trunc i64 8 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"bar#1##0", i64* %3 - %4 = or i64 %2, 1 - ret i64 %4 +define external fastcc i64 @"anon_field.bar<0>"(i64 %"bar#1##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 8) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"bar#1##0", ptr %"tmp#1##0" + %"tmp#2##0" = or i64 %"#rec##0", 1 + ret i64 %"tmp#2##0" } - -define external fastcc {i64, i1} @"anon_field.bar<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = and i64 %"#result##0", 3 - %1 = icmp eq i64 %0, 1 - br i1 %1, label %if.then, label %if.else -if.then: - %2 = add i64 %"#result##0", -1 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = insertvalue {i64, i1} undef, i64 %4, 0 - %6 = insertvalue {i64, i1} %5, i1 1, 1 - ret {i64, i1} %6 -if.else: - %7 = insertvalue {i64, i1} undef, i64 undef, 0 - %8 = insertvalue {i64, i1} %7, i1 0, 1 - ret {i64, i1} %8 +define external fastcc {i64, i1} @"anon_field.bar<1>"(i64 %"#result##0") { + %"tmp#1##0" = and i64 %"#result##0", 3 + %"tmp#0##0" = icmp eq i64 %"tmp#1##0", 1 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = add i64 %"#result##0", -1 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#3##0" + %"tmp#5##0" = insertvalue {i64, i1} undef, i64 %"tmp#4##0", 0 + %"tmp#6##0" = insertvalue {i64, i1} %"tmp#5##0", i1 1, 1 + ret {i64, i1} %"tmp#6##0" +if.else.0: + %"tmp#7##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#8##0" = insertvalue {i64, i1} %"tmp#7##0", i1 0, 1 + ret {i64, i1} %"tmp#8##0" } - -define external fastcc i64 @"anon_field.baz<0>"(i64 %"field##0") alwaysinline { -entry: - %0 = trunc i64 8 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"field##0", i64* %3 - %4 = or i64 %2, 2 - ret i64 %4 +define external fastcc i64 @"anon_field.baz<0>"(i64 %"field##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 8) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"field##0", ptr %"tmp#1##0" + %"tmp#2##0" = or i64 %"#rec##0", 2 + ret i64 %"tmp#2##0" } - -define external fastcc {i64, i1} @"anon_field.baz<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = and i64 %"#result##0", 3 - %1 = icmp eq i64 %0, 2 - br i1 %1, label %if.then, label %if.else -if.then: - %2 = add i64 %"#result##0", -2 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = insertvalue {i64, i1} undef, i64 %4, 0 - %6 = insertvalue {i64, i1} %5, i1 1, 1 - ret {i64, i1} %6 -if.else: - %7 = insertvalue {i64, i1} undef, i64 undef, 0 - %8 = insertvalue {i64, i1} %7, i1 0, 1 - ret {i64, i1} %8 +define external fastcc {i64, i1} @"anon_field.baz<1>"(i64 %"#result##0") { + %"tmp#1##0" = and i64 %"#result##0", 3 + %"tmp#0##0" = icmp eq i64 %"tmp#1##0", 2 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = add i64 %"#result##0", -2 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#3##0" + %"tmp#5##0" = insertvalue {i64, i1} undef, i64 %"tmp#4##0", 0 + %"tmp#6##0" = insertvalue {i64, i1} %"tmp#5##0", i1 1, 1 + ret {i64, i1} %"tmp#6##0" +if.else.0: + %"tmp#7##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#8##0" = insertvalue {i64, i1} %"tmp#7##0", i1 0, 1 + ret {i64, i1} %"tmp#8##0" } - -define external fastcc {i64, i1} @"anon_field.field<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = and i64 %"#rec##0", 3 - %1 = icmp eq i64 %0, 2 - br i1 %1, label %if.then, label %if.else -if.then: - %2 = add i64 %"#rec##0", -2 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = insertvalue {i64, i1} undef, i64 %4, 0 - %6 = insertvalue {i64, i1} %5, i1 1, 1 - ret {i64, i1} %6 -if.else: - %7 = insertvalue {i64, i1} undef, i64 undef, 0 - %8 = insertvalue {i64, i1} %7, i1 0, 1 - ret {i64, i1} %8 +define external fastcc {i64, i1} @"anon_field.field<0>"(i64 %"#rec##0") { + %"tmp#1##0" = and i64 %"#rec##0", 3 + %"tmp#0##0" = icmp eq i64 %"tmp#1##0", 2 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = add i64 %"#rec##0", -2 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#3##0" + %"tmp#5##0" = insertvalue {i64, i1} undef, i64 %"tmp#4##0", 0 + %"tmp#6##0" = insertvalue {i64, i1} %"tmp#5##0", i1 1, 1 + ret {i64, i1} %"tmp#6##0" +if.else.0: + %"tmp#7##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#8##0" = insertvalue {i64, i1} %"tmp#7##0", i1 0, 1 + ret {i64, i1} %"tmp#8##0" } - -define external fastcc {i64, i1} @"anon_field.field<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = and i64 %"#rec##0", 3 - %1 = icmp eq i64 %0, 2 - br i1 %1, label %if.then, label %if.else -if.then: - %2 = trunc i64 8 to i32 - %3 = tail call ccc i8* @wybe_malloc(i32 %2) - %4 = ptrtoint i8* %3 to i64 - %5 = add i64 %4, 2 - %6 = sub i64 %"#rec##0", 2 - %7 = inttoptr i64 %4 to i8* - %8 = inttoptr i64 %6 to i8* - %9 = trunc i64 8 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %7, i8* %8, i32 %9, i1 0) - %10 = add i64 %5, -2 - %11 = inttoptr i64 %10 to i64* - store i64 %"#field##0", i64* %11 - %12 = insertvalue {i64, i1} undef, i64 %5, 0 - %13 = insertvalue {i64, i1} %12, i1 1, 1 - ret {i64, i1} %13 -if.else: - %14 = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 - %15 = insertvalue {i64, i1} %14, i1 0, 1 - ret {i64, i1} %15 +define external fastcc {i64, i1} @"anon_field.field<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#1##0" = and i64 %"#rec##0", 3 + %"tmp#0##0" = icmp eq i64 %"tmp#1##0", 2 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = sub i64 %"#rec##0", 2 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = call ccc ptr @wybe_malloc(i32 8) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#4##0", ptr %"tmp#3##0", i64 8, i1 0) + %"tmp#5##0" = ptrtoint ptr %"tmp#4##0" to i64 + %"tmp#6##0" = add i64 %"tmp#5##0", 2 + %"tmp#7##0" = add i64 %"tmp#6##0", -2 + %"tmp#8##0" = inttoptr i64 %"tmp#7##0" to ptr + store i64 %"#field##0", ptr %"tmp#8##0" + %"tmp#9##0" = insertvalue {i64, i1} undef, i64 %"tmp#6##0", 0 + %"tmp#10##0" = insertvalue {i64, i1} %"tmp#9##0", i1 1, 1 + ret {i64, i1} %"tmp#10##0" +if.else.0: + %"tmp#11##0" = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 + %"tmp#12##0" = insertvalue {i64, i1} %"tmp#11##0", i1 0, 1 + ret {i64, i1} %"tmp#12##0" } - -define external fastcc i64 @"anon_field.foo<0>"(i64 %"foo#1##0", i1 %"foo#2##0", i64 %"i##0") alwaysinline { -entry: - %0 = trunc i64 24 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i1* - store i1 %"foo#2##0", i1* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"foo#1##0", i64* %5 - %6 = add i64 %2, 16 - %7 = inttoptr i64 %6 to i64* - store i64 %"i##0", i64* %7 - ret i64 %2 +define external fastcc i64 @"anon_field.foo<0>"(i64 %"foo#1##0", i1 %"foo#2##0", i64 %"i##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 24) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i1 %"foo#2##0", ptr %"tmp#1##0" + %"tmp#2##0" = add i64 %"#rec##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"foo#1##0", ptr %"tmp#3##0" + %"tmp#4##0" = add i64 %"#rec##0", 16 + %"tmp#5##0" = inttoptr i64 %"tmp#4##0" to ptr + store i64 %"i##0", ptr %"tmp#5##0" + ret i64 %"#rec##0" } - -define external fastcc {i64, i1, i64, i1} @"anon_field.foo<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = and i64 %"#result##0", 3 - %1 = icmp eq i64 %0, 0 - br i1 %1, label %if.then, label %if.else -if.then: - %2 = inttoptr i64 %"#result##0" to i1* - %3 = load i1, i1* %2 - %4 = add i64 %"#result##0", 8 - %5 = inttoptr i64 %4 to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#result##0", 16 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = insertvalue {i64, i1, i64, i1} undef, i64 %6, 0 - %11 = insertvalue {i64, i1, i64, i1} %10, i1 %3, 1 - %12 = insertvalue {i64, i1, i64, i1} %11, i64 %9, 2 - %13 = insertvalue {i64, i1, i64, i1} %12, i1 1, 3 - ret {i64, i1, i64, i1} %13 -if.else: - %14 = insertvalue {i64, i1, i64, i1} undef, i64 undef, 0 - %15 = insertvalue {i64, i1, i64, i1} %14, i1 undef, 1 - %16 = insertvalue {i64, i1, i64, i1} %15, i64 undef, 2 - %17 = insertvalue {i64, i1, i64, i1} %16, i1 0, 3 - ret {i64, i1, i64, i1} %17 +define external fastcc {i64, i1, i64, i1} @"anon_field.foo<1>"(i64 %"#result##0") { + %"tmp#1##0" = and i64 %"#result##0", 3 + %"tmp#0##0" = icmp eq i64 %"tmp#1##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = inttoptr i64 %"#result##0" to ptr + %"tmp#3##0" = load i1, ptr %"tmp#2##0" + %"tmp#4##0" = add i64 %"#result##0", 8 + %"tmp#5##0" = inttoptr i64 %"tmp#4##0" to ptr + %"tmp#6##0" = load i64, ptr %"tmp#5##0" + %"tmp#7##0" = add i64 %"#result##0", 16 + %"tmp#8##0" = inttoptr i64 %"tmp#7##0" to ptr + %"tmp#9##0" = load i64, ptr %"tmp#8##0" + %"tmp#10##0" = insertvalue {i64, i1, i64, i1} undef, i64 %"tmp#6##0", 0 + %"tmp#11##0" = insertvalue {i64, i1, i64, i1} %"tmp#10##0", i1 %"tmp#3##0", 1 + %"tmp#12##0" = insertvalue {i64, i1, i64, i1} %"tmp#11##0", i64 %"tmp#9##0", 2 + %"tmp#13##0" = insertvalue {i64, i1, i64, i1} %"tmp#12##0", i1 1, 3 + ret {i64, i1, i64, i1} %"tmp#13##0" +if.else.0: + %"tmp#14##0" = insertvalue {i64, i1, i64, i1} undef, i64 undef, 0 + %"tmp#15##0" = insertvalue {i64, i1, i64, i1} %"tmp#14##0", i1 undef, 1 + %"tmp#16##0" = insertvalue {i64, i1, i64, i1} %"tmp#15##0", i64 undef, 2 + %"tmp#17##0" = insertvalue {i64, i1, i64, i1} %"tmp#16##0", i1 0, 3 + ret {i64, i1, i64, i1} %"tmp#17##0" } - -define external fastcc {i64, i1} @"anon_field.i<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = and i64 %"#rec##0", 3 - %1 = icmp eq i64 %0, 0 - br i1 %1, label %if.then, label %if.else -if.then: - %2 = add i64 %"#rec##0", 16 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = insertvalue {i64, i1} undef, i64 %4, 0 - %6 = insertvalue {i64, i1} %5, i1 1, 1 - ret {i64, i1} %6 -if.else: - %7 = insertvalue {i64, i1} undef, i64 undef, 0 - %8 = insertvalue {i64, i1} %7, i1 0, 1 - ret {i64, i1} %8 +define external fastcc {i64, i1} @"anon_field.i<0>"(i64 %"#rec##0") { + %"tmp#1##0" = and i64 %"#rec##0", 3 + %"tmp#0##0" = icmp eq i64 %"tmp#1##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = add i64 %"#rec##0", 16 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#3##0" + %"tmp#5##0" = insertvalue {i64, i1} undef, i64 %"tmp#4##0", 0 + %"tmp#6##0" = insertvalue {i64, i1} %"tmp#5##0", i1 1, 1 + ret {i64, i1} %"tmp#6##0" +if.else.0: + %"tmp#7##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#8##0" = insertvalue {i64, i1} %"tmp#7##0", i1 0, 1 + ret {i64, i1} %"tmp#8##0" } - -define external fastcc {i64, i1} @"anon_field.i<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = and i64 %"#rec##0", 3 - %1 = icmp eq i64 %0, 0 - br i1 %1, label %if.then, label %if.else -if.then: - %2 = trunc i64 24 to i32 - %3 = tail call ccc i8* @wybe_malloc(i32 %2) - %4 = ptrtoint i8* %3 to i64 - %5 = inttoptr i64 %4 to i8* - %6 = inttoptr i64 %"#rec##0" to i8* - %7 = trunc i64 24 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %5, i8* %6, i32 %7, i1 0) - %8 = add i64 %4, 16 - %9 = inttoptr i64 %8 to i64* - store i64 %"#field##0", i64* %9 - %10 = insertvalue {i64, i1} undef, i64 %4, 0 - %11 = insertvalue {i64, i1} %10, i1 1, 1 - ret {i64, i1} %11 -if.else: - %12 = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 - %13 = insertvalue {i64, i1} %12, i1 0, 1 - ret {i64, i1} %13 +define external fastcc {i64, i1} @"anon_field.i<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#1##0" = and i64 %"#rec##0", 3 + %"tmp#0##0" = icmp eq i64 %"tmp#1##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#3##0" = call ccc ptr @wybe_malloc(i32 24) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#3##0", ptr %"tmp#2##0", i64 24, i1 0) + %"tmp#4##0" = ptrtoint ptr %"tmp#3##0" to i64 + %"tmp#5##0" = add i64 %"tmp#4##0", 16 + %"tmp#6##0" = inttoptr i64 %"tmp#5##0" to ptr + store i64 %"#field##0", ptr %"tmp#6##0" + %"tmp#7##0" = insertvalue {i64, i1} undef, i64 %"tmp#4##0", 0 + %"tmp#8##0" = insertvalue {i64, i1} %"tmp#7##0", i1 1, 1 + ret {i64, i1} %"tmp#8##0" +if.else.0: + %"tmp#9##0" = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 + %"tmp#10##0" = insertvalue {i64, i1} %"tmp#9##0", i1 0, 1 + ret {i64, i1} %"tmp#10##0" } - -define external fastcc i1 @"anon_field.~=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = tail call fastcc i1 @"anon_field.=<0>"(i64 %"#left##0", i64 %"#right##0") - %1 = xor i1 %0, 1 - ret i1 %1 +define external fastcc i1 @"anon_field.~=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#0##0" = tail call fastcc i1 @"anon_field.=<0>"(i64 %"#left##0", i64 %"#right##0") + %"tmp#1##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#1##0" } + -------------------------------------------------- Module anon_field.quux - representation : address + representation : pointer public submods : public resources: public procs : anon_field.quux.=<0> @@ -882,111 +821,94 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'anon_field.quux' - - - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i1 @"anon_field.quux.=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %"#right##0" to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = icmp eq i64 %1, %6 - br i1 %10, label %if.then, label %if.else -if.then: - %11 = icmp eq i64 %4, %9 - ret i1 %11 -if.else: - ret i1 0 +source_filename = "!ROOT!/final-dump/anon_field.wybe" +target triple ???? + + +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc i1 @"anon_field.quux.=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#9##0" = inttoptr i64 %"#left##0" to ptr + %"#left#quuz#1##0" = load i64, ptr %"tmp#9##0" + %"tmp#10##0" = add i64 %"#left##0", 8 + %"tmp#11##0" = inttoptr i64 %"tmp#10##0" to ptr + %"#left#j##0" = load i64, ptr %"tmp#11##0" + %"tmp#12##0" = inttoptr i64 %"#right##0" to ptr + %"#right#quuz#1##0" = load i64, ptr %"tmp#12##0" + %"tmp#13##0" = add i64 %"#right##0", 8 + %"tmp#14##0" = inttoptr i64 %"tmp#13##0" to ptr + %"#right#j##0" = load i64, ptr %"tmp#14##0" + %"tmp#1##0" = icmp eq i64 %"#left#quuz#1##0", %"#right#quuz#1##0" + br i1 %"tmp#1##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#15##0" = icmp eq i64 %"#left#j##0", %"#right#j##0" + ret i1 %"tmp#15##0" +if.else.0: + ret i1 0 } - -define external fastcc i64 @"anon_field.quux.j<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = add i64 %"#rec##0", 8 - %1 = inttoptr i64 %0 to i64* - %2 = load i64, i64* %1 - ret i64 %2 +define external fastcc i64 @"anon_field.quux.j<0>"(i64 %"#rec##0") { + %"tmp#0##0" = add i64 %"#rec##0", 8 + %"tmp#1##0" = inttoptr i64 %"tmp#0##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"anon_field.quux.j<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = add i64 %2, 8 - %7 = inttoptr i64 %6 to i64* - store i64 %"#field##0", i64* %7 - ret i64 %2 +define external fastcc i64 @"anon_field.quux.j<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = add i64 %"tmp#2##0", 8 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 %"#field##0", ptr %"tmp#4##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"anon_field.quux.quuz<0>"(i64 %"quuz#1##0", i64 %"j##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"quuz#1##0", i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"j##0", i64* %5 - ret i64 %2 +define external fastcc i64 @"anon_field.quux.quuz<0>"(i64 %"quuz#1##0", i64 %"j##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 16) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"quuz#1##0", ptr %"tmp#1##0" + %"tmp#2##0" = add i64 %"#rec##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"j##0", ptr %"tmp#3##0" + ret i64 %"#rec##0" } - -define external fastcc {i64, i64} @"anon_field.quux.quuz<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#result##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#result##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = insertvalue {i64, i64} undef, i64 %1, 0 - %6 = insertvalue {i64, i64} %5, i64 %4, 1 - ret {i64, i64} %6 +define external fastcc {i64, i64} @"anon_field.quux.quuz<1>"(i64 %"#result##0") { + %"tmp#0##0" = inttoptr i64 %"#result##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + %"tmp#2##0" = add i64 %"#result##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#3##0" + %"tmp#5##0" = insertvalue {i64, i64} undef, i64 %"tmp#1##0", 0 + %"tmp#6##0" = insertvalue {i64, i64} %"tmp#5##0", i64 %"tmp#4##0", 1 + ret {i64, i64} %"tmp#6##0" } - -define external fastcc i1 @"anon_field.quux.~=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %"#right##0" to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = icmp eq i64 %1, %6 - br i1 %10, label %if.then, label %if.else -if.then: - %11 = icmp eq i64 %4, %9 - %12 = xor i1 %11, 1 - ret i1 %12 -if.else: - %13 = xor i1 0, 1 - ret i1 %13 +define external fastcc i1 @"anon_field.quux.~=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#8##0" = inttoptr i64 %"#left##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#8##0" + %"tmp#9##0" = add i64 %"#left##0", 8 + %"tmp#10##0" = inttoptr i64 %"tmp#9##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#10##0" + %"tmp#11##0" = inttoptr i64 %"#right##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#11##0" + %"tmp#12##0" = add i64 %"#right##0", 8 + %"tmp#13##0" = inttoptr i64 %"tmp#12##0" to ptr + %"tmp#6##0" = load i64, ptr %"tmp#13##0" + %"tmp#7##0" = icmp eq i64 %"tmp#3##0", %"tmp#5##0" + br i1 %"tmp#7##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#0##0" = icmp eq i64 %"tmp#4##0", %"tmp#6##0" + %"tmp#14##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#14##0" +if.else.0: + %"tmp#15##0" = xor i1 0, 1 + ret i1 %"tmp#15##0" } diff --git a/test-cases/final-dump/anon_field_variable.exp b/test-cases/final-dump/anon_field_variable.exp index 70cdb376b..2941d07b2 100644 --- a/test-cases/final-dump/anon_field_variable.exp +++ b/test-cases/final-dump/anon_field_variable.exp @@ -1,7 +1,10 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module anon_field_variable(T) - representation : address + representation : pointer public submods : public resources: public procs : anon_field_variable.<0> @@ -121,167 +124,138 @@ foo(?foo#1##0:T <{}; {}; {1}>, #result##0:anon_field_variable(T) <{}; {}; {1}>, LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'anon_field_variable' - - - - -@anon_field_variable.1 = constant {i64, i64} { i64 3, i64 ptrtoint ([?? x i8]* @anon_field_variable.0 to i64) } - - -@anon_field_variable.0 = constant [?? x i8] c"foo\00" - - -declare external ccc void @putchar(i8) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"anon_field_variable.<0>"() { -entry: - %0 = trunc i64 8 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 0, i64* %3 - %4 = and i64 %2, 1 - %5 = icmp eq i64 %4, 0 - br i1 %5, label %if.then, label %if.else -if.then: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @anon_field_variable.1, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - ret void -if.else: - ret void +source_filename = "!ROOT!/final-dump/anon_field_variable.wybe" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c"foo\00", align 8 +@"string#1" = private unnamed_addr constant {i64, i64} { i64 3, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 + +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @putchar(i8) +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"anon_field_variable.<0>"() { + %"tmp#12##0" = call ccc ptr @wybe_malloc(i32 8) + %"tmp#5##0" = ptrtoint ptr %"tmp#12##0" to i64 + %"tmp#13##0" = inttoptr i64 %"tmp#5##0" to ptr + store i64 0, ptr %"tmp#13##0" + %"tmp#7##0" = and i64 %"tmp#5##0", 1 + %"tmp#8##0" = icmp eq i64 %"tmp#7##0", 0 + br i1 %"tmp#8##0", label %if.then.0, label %if.else.0 +if.then.0: + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#1" to i64 )) + call ccc void @putchar(i8 10) + ret void +if.else.0: + ret void } - -define external fastcc i64 @"anon_field_variable.bar<0>"(i64 %"bar#1##0", i64 %"field##0", i64 %"bar#3##0") alwaysinline { -entry: - %0 = trunc i64 24 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"bar#1##0", i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"field##0", i64* %5 - %6 = add i64 %2, 16 - %7 = inttoptr i64 %6 to i64* - store i64 %"bar#3##0", i64* %7 - %8 = or i64 %2, 1 - ret i64 %8 +define external fastcc i64 @"anon_field_variable.bar<0>"(i64 %"bar#1##0", i64 %"field##0", i64 %"bar#3##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 24) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"bar#1##0", ptr %"tmp#1##0" + %"tmp#2##0" = add i64 %"#rec##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"field##0", ptr %"tmp#3##0" + %"tmp#4##0" = add i64 %"#rec##0", 16 + %"tmp#5##0" = inttoptr i64 %"tmp#4##0" to ptr + store i64 %"bar#3##0", ptr %"tmp#5##0" + %"tmp#6##0" = or i64 %"#rec##0", 1 + ret i64 %"tmp#6##0" } - -define external fastcc {i64, i64, i64, i1} @"anon_field_variable.bar<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = and i64 %"#result##0", 1 - %1 = icmp eq i64 %0, 1 - br i1 %1, label %if.then, label %if.else -if.then: - %2 = add i64 %"#result##0", -1 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = add i64 %"#result##0", 7 - %6 = inttoptr i64 %5 to i64* - %7 = load i64, i64* %6 - %8 = add i64 %"#result##0", 15 - %9 = inttoptr i64 %8 to i64* - %10 = load i64, i64* %9 - %11 = insertvalue {i64, i64, i64, i1} undef, i64 %4, 0 - %12 = insertvalue {i64, i64, i64, i1} %11, i64 %7, 1 - %13 = insertvalue {i64, i64, i64, i1} %12, i64 %10, 2 - %14 = insertvalue {i64, i64, i64, i1} %13, i1 1, 3 - ret {i64, i64, i64, i1} %14 -if.else: - %15 = insertvalue {i64, i64, i64, i1} undef, i64 undef, 0 - %16 = insertvalue {i64, i64, i64, i1} %15, i64 undef, 1 - %17 = insertvalue {i64, i64, i64, i1} %16, i64 undef, 2 - %18 = insertvalue {i64, i64, i64, i1} %17, i1 0, 3 - ret {i64, i64, i64, i1} %18 +define external fastcc {i64, i64, i64, i1} @"anon_field_variable.bar<1>"(i64 %"#result##0") { + %"tmp#1##0" = and i64 %"#result##0", 1 + %"tmp#0##0" = icmp eq i64 %"tmp#1##0", 1 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = add i64 %"#result##0", -1 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#3##0" + %"tmp#5##0" = add i64 %"#result##0", 7 + %"tmp#6##0" = inttoptr i64 %"tmp#5##0" to ptr + %"tmp#7##0" = load i64, ptr %"tmp#6##0" + %"tmp#8##0" = add i64 %"#result##0", 15 + %"tmp#9##0" = inttoptr i64 %"tmp#8##0" to ptr + %"tmp#10##0" = load i64, ptr %"tmp#9##0" + %"tmp#11##0" = insertvalue {i64, i64, i64, i1} undef, i64 %"tmp#4##0", 0 + %"tmp#12##0" = insertvalue {i64, i64, i64, i1} %"tmp#11##0", i64 %"tmp#7##0", 1 + %"tmp#13##0" = insertvalue {i64, i64, i64, i1} %"tmp#12##0", i64 %"tmp#10##0", 2 + %"tmp#14##0" = insertvalue {i64, i64, i64, i1} %"tmp#13##0", i1 1, 3 + ret {i64, i64, i64, i1} %"tmp#14##0" +if.else.0: + %"tmp#15##0" = insertvalue {i64, i64, i64, i1} undef, i64 undef, 0 + %"tmp#16##0" = insertvalue {i64, i64, i64, i1} %"tmp#15##0", i64 undef, 1 + %"tmp#17##0" = insertvalue {i64, i64, i64, i1} %"tmp#16##0", i64 undef, 2 + %"tmp#18##0" = insertvalue {i64, i64, i64, i1} %"tmp#17##0", i1 0, 3 + ret {i64, i64, i64, i1} %"tmp#18##0" } - -define external fastcc {i64, i1} @"anon_field_variable.field<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = and i64 %"#rec##0", 1 - %1 = icmp eq i64 %0, 1 - br i1 %1, label %if.then, label %if.else -if.then: - %2 = add i64 %"#rec##0", 7 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = insertvalue {i64, i1} undef, i64 %4, 0 - %6 = insertvalue {i64, i1} %5, i1 1, 1 - ret {i64, i1} %6 -if.else: - %7 = insertvalue {i64, i1} undef, i64 undef, 0 - %8 = insertvalue {i64, i1} %7, i1 0, 1 - ret {i64, i1} %8 +define external fastcc {i64, i1} @"anon_field_variable.field<0>"(i64 %"#rec##0") { + %"tmp#1##0" = and i64 %"#rec##0", 1 + %"tmp#0##0" = icmp eq i64 %"tmp#1##0", 1 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = add i64 %"#rec##0", 7 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#3##0" + %"tmp#5##0" = insertvalue {i64, i1} undef, i64 %"tmp#4##0", 0 + %"tmp#6##0" = insertvalue {i64, i1} %"tmp#5##0", i1 1, 1 + ret {i64, i1} %"tmp#6##0" +if.else.0: + %"tmp#7##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#8##0" = insertvalue {i64, i1} %"tmp#7##0", i1 0, 1 + ret {i64, i1} %"tmp#8##0" } - -define external fastcc {i64, i1} @"anon_field_variable.field<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = and i64 %"#rec##0", 1 - %1 = icmp eq i64 %0, 1 - br i1 %1, label %if.then, label %if.else -if.then: - %2 = trunc i64 24 to i32 - %3 = tail call ccc i8* @wybe_malloc(i32 %2) - %4 = ptrtoint i8* %3 to i64 - %5 = add i64 %4, 1 - %6 = sub i64 %"#rec##0", 1 - %7 = inttoptr i64 %4 to i8* - %8 = inttoptr i64 %6 to i8* - %9 = trunc i64 24 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %7, i8* %8, i32 %9, i1 0) - %10 = add i64 %5, 7 - %11 = inttoptr i64 %10 to i64* - store i64 %"#field##0", i64* %11 - %12 = insertvalue {i64, i1} undef, i64 %5, 0 - %13 = insertvalue {i64, i1} %12, i1 1, 1 - ret {i64, i1} %13 -if.else: - %14 = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 - %15 = insertvalue {i64, i1} %14, i1 0, 1 - ret {i64, i1} %15 +define external fastcc {i64, i1} @"anon_field_variable.field<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#1##0" = and i64 %"#rec##0", 1 + %"tmp#0##0" = icmp eq i64 %"tmp#1##0", 1 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = sub i64 %"#rec##0", 1 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = call ccc ptr @wybe_malloc(i32 24) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#4##0", ptr %"tmp#3##0", i64 24, i1 0) + %"tmp#5##0" = ptrtoint ptr %"tmp#4##0" to i64 + %"tmp#6##0" = add i64 %"tmp#5##0", 1 + %"tmp#7##0" = add i64 %"tmp#6##0", 7 + %"tmp#8##0" = inttoptr i64 %"tmp#7##0" to ptr + store i64 %"#field##0", ptr %"tmp#8##0" + %"tmp#9##0" = insertvalue {i64, i1} undef, i64 %"tmp#6##0", 0 + %"tmp#10##0" = insertvalue {i64, i1} %"tmp#9##0", i1 1, 1 + ret {i64, i1} %"tmp#10##0" +if.else.0: + %"tmp#11##0" = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 + %"tmp#12##0" = insertvalue {i64, i1} %"tmp#11##0", i1 0, 1 + ret {i64, i1} %"tmp#12##0" } - -define external fastcc i64 @"anon_field_variable.foo<0>"(i64 %"foo#1##0") alwaysinline { -entry: - %0 = trunc i64 8 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"foo#1##0", i64* %3 - ret i64 %2 +define external fastcc i64 @"anon_field_variable.foo<0>"(i64 %"foo#1##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 8) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"foo#1##0", ptr %"tmp#1##0" + ret i64 %"#rec##0" } - -define external fastcc {i64, i1} @"anon_field_variable.foo<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = and i64 %"#result##0", 1 - %1 = icmp eq i64 %0, 0 - br i1 %1, label %if.then, label %if.else -if.then: - %2 = inttoptr i64 %"#result##0" to i64* - %3 = load i64, i64* %2 - %4 = insertvalue {i64, i1} undef, i64 %3, 0 - %5 = insertvalue {i64, i1} %4, i1 1, 1 - ret {i64, i1} %5 -if.else: - %6 = insertvalue {i64, i1} undef, i64 undef, 0 - %7 = insertvalue {i64, i1} %6, i1 0, 1 - ret {i64, i1} %7 +define external fastcc {i64, i1} @"anon_field_variable.foo<1>"(i64 %"#result##0") { + %"tmp#1##0" = and i64 %"#result##0", 1 + %"tmp#0##0" = icmp eq i64 %"tmp#1##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = inttoptr i64 %"#result##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#2##0" + %"tmp#4##0" = insertvalue {i64, i1} undef, i64 %"tmp#3##0", 0 + %"tmp#5##0" = insertvalue {i64, i1} %"tmp#4##0", i1 1, 1 + ret {i64, i1} %"tmp#5##0" +if.else.0: + %"tmp#6##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#7##0" = insertvalue {i64, i1} %"tmp#6##0", i1 0, 1 + ret {i64, i1} %"tmp#7##0" } diff --git a/test-cases/final-dump/assert_error.exp b/test-cases/final-dump/assert_error.exp index 7557503e7..7d5640636 100644 --- a/test-cases/final-dump/assert_error.exp +++ b/test-cases/final-dump/assert_error.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module assert_error representation : (not a type) public submods : @@ -19,36 +22,22 @@ module top-level code > public {semipure} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'assert_error' +source_filename = "!ROOT!/final-dump/assert_error.wybe" +target triple ???? - - - -@assert_error.0 = constant [?? x i8] c"assert_error:3:2\00" - - -@assert_error.1 = constant [?? x i8] c"assert_error:5:2\00" - - -@assert_error.2 = constant [?? x i8] c"we should never get here\00" - - -declare external ccc void @error_exit(i64, i64) - - -declare external fastcc void @"wybe.control.assert<0>"(i1, i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c"assert_error:3:2\00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c"assert_error:5:2\00", align 8 +@"cstring#2" = private unnamed_addr constant [ ?? x i8 ] c"we should never get here\00", align 8 +declare external fastcc void @"wybe.control.assert<0>"(i1, i64) +declare external ccc void @error_exit(i64, i64) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -define external fastcc void @"assert_error.<0>"() { -entry: - tail call fastcc void @"wybe.control.assert<0>"(i1 0, i64 ptrtoint (i8* getelementptr inbounds ([?? x i8], [?? x i8]* @assert_error.0, i32 0, i32 0) to i64)) - tail call ccc void @error_exit(i64 ptrtoint (i8* getelementptr inbounds ([?? x i8], [?? x i8]* @assert_error.1, i32 0, i32 0) to i64), i64 ptrtoint (i8* getelementptr inbounds ([?? x i8], [?? x i8]* @assert_error.2, i32 0, i32 0) to i64)) - ret void +define external fastcc void @"assert_error.<0>"() { + tail call fastcc void @"wybe.control.assert<0>"(i1 0, i64 ptrtoint( ptr @"cstring#0" to i64 )) + call ccc void @error_exit(i64 ptrtoint( ptr @"cstring#1" to i64 ), i64 ptrtoint( ptr @"cstring#2" to i64 )) + ret void } diff --git a/test-cases/final-dump/backquote_OK.exp b/test-cases/final-dump/backquote_OK.exp index b04659702..584729ea6 100644 --- a/test-cases/final-dump/backquote_OK.exp +++ b/test-cases/final-dump/backquote_OK.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module backquote_OK representation : (not a type) public submods : @@ -18,19 +21,15 @@ OK backquote use!(?#result##0:wybe.int)<{}; {}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'backquote_OK' +source_filename = "!ROOT!/final-dump/backquote_OK.wybe" +target triple ???? - - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -define external fastcc i64 @"backquote_OK.OK backquote use!<0>"() alwaysinline { -entry: - ret i64 1 +define external fastcc i64 @"backquote_OK.OK backquote use!<0>"() { + ret i64 1 } diff --git a/test-cases/final-dump/backwards_assign.exp b/test-cases/final-dump/backwards_assign.exp index d1184a762..2437c412b 100644 --- a/test-cases/final-dump/backwards_assign.exp +++ b/test-cases/final-dump/backwards_assign.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module backwards_assign representation : (not a type) public submods : @@ -45,48 +48,36 @@ backwards_assign(?output##0:wybe.int, input##0:wybe.int)<{}; {}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'backwards_assign' +source_filename = "!ROOT!/final-dump/backwards_assign.wybe" +target triple ???? - - - -declare external ccc void @putchar(i8) - - -declare external ccc void @print_int(i64) +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"backwards_assign.<0>"() alwaysinline { -entry: - tail call fastcc void @"backwards_assign.#cont#1<0>"(i64 0) - ret void +define external fastcc void @"backwards_assign.<0>"() { + tail call fastcc void @"backwards_assign.#cont#1<0>"(i64 0) + ret void } - -define external fastcc void @"backwards_assign.#cont#1<0>"(i64 %"i##0") { -entry: - tail call ccc void @print_int(i64 %"i##0") - tail call ccc void @putchar(i8 10) - %0 = add i64 %"i##0", 1 - %1 = icmp slt i64 %0, 10 - br i1 %1, label %if.then, label %if.else -if.then: - musttail call fastcc void @"backwards_assign.#cont#1<0>"(i64 %0) - ret void -if.else: - ret void +define external fastcc void @"backwards_assign.#cont#1<0>"(i64 %"i##0") { + call ccc void @print_int(i64 %"i##0") + call ccc void @putchar(i8 10) + %"i##1" = add i64 %"i##0", 1 + %"tmp#0##0" = icmp slt i64 %"i##1", 10 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + tail call fastcc void @"backwards_assign.#cont#1<0>"(i64 %"i##1") + ret void +if.else.0: + ret void } - -define external fastcc i64 @"backwards_assign.backwards_assign<0>"(i64 %"input##0") alwaysinline { -entry: - %0 = add i64 %"input##0", 1 - ret i64 %0 +define external fastcc i64 @"backwards_assign.backwards_assign<0>"(i64 %"input##0") { + %"tmp#3##0" = add i64 %"input##0", 1 + ret i64 %"tmp#3##0" } diff --git a/test-cases/final-dump/bar.exp b/test-cases/final-dump/bar.exp index cdbbffef1..ab681df1e 100644 --- a/test-cases/final-dump/bar.exp +++ b/test-cases/final-dump/bar.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module bar representation : (not a type) public submods : @@ -25,39 +28,28 @@ module top-level code > public {semipure} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'bar' +source_filename = "!ROOT!/final-dump/bar.wybe" +target triple ???? - - - -declare external ccc void @putchar(i8) - - -declare external ccc void @print_float(double) - - -declare external ccc void @print_int(i64) - - -declare external fastcc i64 @"numbers.factorial<0>"(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) +declare external fastcc i64 @"numbers.factorial<0>"(i64) +declare external ccc void @print_float(double) +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -define external fastcc void @"bar.<0>"() { -entry: - %0 = tail call fastcc i64 @"numbers.factorial<0>"(i64 4) - tail call ccc void @print_int(i64 %0) - tail call ccc void @putchar(i8 10) - tail call ccc void @print_float(double 3.500000e1) - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"bar.<0>"() { + %"tmp#0##0" = tail call fastcc i64 @"numbers.factorial<0>"(i64 4) + call ccc void @print_int(i64 %"tmp#0##0") + call ccc void @putchar(i8 10) + call ccc void @print_float(double 35.0) + call ccc void @putchar(i8 10) + ret void } + -------------------------------------------------- Module numbers representation : (not a type) @@ -108,55 +100,39 @@ toCelsius(f##0:wybe.float, ?#result##0:wybe.float)<{}; {}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'numbers' +source_filename = "!ROOT!/final-dump/numbers.wybe" +target triple ???? - - - -@numbers.1 = constant {i64, i64} { i64 29, i64 ptrtoint ([?? x i8]* @numbers.0 to i64) } - - -@numbers.0 = constant [?? x i8] c"Numbers has been initialised.\00" - - -declare external ccc void @putchar(i8) - +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c"Numbers has been initialised.\00", align 8 +@"string#1" = private unnamed_addr constant {i64, i64} { i64 29, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 -declare external fastcc void @"wybe.string.print<0>"(i64) +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"numbers.<0>"() alwaysinline { -entry: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @numbers.1, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"numbers.<0>"() { + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#1" to i64 )) + call ccc void @putchar(i8 10) + ret void } - -define external fastcc i64 @"numbers.factorial<0>"(i64 %"n##0") { -entry: - %0 = icmp sle i64 %"n##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - ret i64 1 -if.else: - %1 = sub i64 %"n##0", 1 - %2 = tail call fastcc i64 @"numbers.factorial<0>"(i64 %1) - %3 = mul i64 %"n##0", %2 - ret i64 %3 +define external fastcc i64 @"numbers.factorial<0>"(i64 %"n##0") { + %"tmp#4##0" = icmp sle i64 %"n##0", 0 + br i1 %"tmp#4##0", label %if.then.0, label %if.else.0 +if.then.0: + ret i64 1 +if.else.0: + %"tmp#3##0" = sub i64 %"n##0", 1 + %"tmp#2##0" = tail call fastcc i64 @"numbers.factorial<0>"(i64 %"tmp#3##0") + %"tmp#11##0" = mul i64 %"n##0", %"tmp#2##0" + ret i64 %"tmp#11##0" } - -define external fastcc double @"numbers.toCelsius<0>"(double %"f##0") alwaysinline { -entry: - %0 = fsub double %"f##0", 3.200000e1 - %1 = fdiv double %0, 1.800000e0 - ret double %1 +define external fastcc double @"numbers.toCelsius<0>"(double %"f##0") { + %"tmp#1##0" = fsub double %"f##0", 32.0 + %"tmp#6##0" = fdiv double %"tmp#1##0", 1.8 + ret double %"tmp#6##0" } diff --git a/test-cases/final-dump/bbb.exp b/test-cases/final-dump/bbb.exp index cf091f1a8..f80854553 100644 --- a/test-cases/final-dump/bbb.exp +++ b/test-cases/final-dump/bbb.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module bbb representation : (not a type) public submods : @@ -22,36 +25,25 @@ module top-level code > public {inline,semipure} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'bbb' +source_filename = "!ROOT!/final-dump/bbb.wybe" +target triple ???? - - - -@bbb.1 = constant {i64, i64} { i64 9, i64 ptrtoint ([?? x i8]* @bbb.0 to i64) } - - -@bbb.0 = constant [?? x i8] c"BBB: Init\00" - - -declare external ccc void @putchar(i8) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc i8* @wybe_malloc(i32) - +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c"BBB: Init\00", align 8 +@"string#1" = private unnamed_addr constant {i64, i64} { i64 9, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) - -define external fastcc void @"bbb.<0>"() alwaysinline { -entry: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @bbb.1, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"bbb.<0>"() { + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#1" to i64 )) + call ccc void @putchar(i8 10) + ret void } + -------------------------------------------------- Module ddd representation : (not a type) @@ -74,33 +66,21 @@ module top-level code > public {inline,semipure} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'ddd' +source_filename = "!ROOT!/final-dump/ddd.wybe" +target triple ???? - - - -@ddd.1 = constant {i64, i64} { i64 9, i64 ptrtoint ([?? x i8]* @ddd.0 to i64) } - - -@ddd.0 = constant [?? x i8] c"DDD: Init\00" - - -declare external ccc void @putchar(i8) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c"DDD: Init\00", align 8 +@"string#1" = private unnamed_addr constant {i64, i64} { i64 9, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -define external fastcc void @"ddd.<0>"() alwaysinline { -entry: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @ddd.1, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"ddd.<0>"() { + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#1" to i64 )) + call ccc void @putchar(i8 10) + ret void } diff --git a/test-cases/final-dump/benchmark_fib.exp b/test-cases/final-dump/benchmark_fib.exp index d4acb1771..4bb386e98 100644 --- a/test-cases/final-dump/benchmark_fib.exp +++ b/test-cases/final-dump/benchmark_fib.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module benchmark representation : (not a type) public submods : @@ -39,48 +42,36 @@ time_execution(proc##0:{semipure}(), ?time##0:wybe.float, %call_source_location# LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'benchmark' - - - - -declare external ccc double @benchmark_end(i64) - - -declare external ccc void @benchmark_start(i64) +source_filename = "!ROOT!/../wybelibs/benchmark.o" +target triple ???? -declare external ccc i8* @wybe_malloc(i32) +declare external ccc double @benchmark_end(i64) +declare external ccc void @benchmark_start(i64) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc double @"benchmark.end<0>"(i64 %"call_source_location##0") alwaysinline { -entry: - %0 = tail call ccc double @benchmark_end(i64 %"call_source_location##0") - ret double %0 +define external fastcc double @"benchmark.end<0>"(i64 %"call_source_location##0") { + %"tmp#0##0" = call ccc double @benchmark_end(i64 %"call_source_location##0") + ret double %"tmp#0##0" } - -define external fastcc void @"benchmark.start<0>"(i64 %"call_source_location##0") alwaysinline { -entry: - tail call ccc void @benchmark_start(i64 %"call_source_location##0") - ret void +define external fastcc void @"benchmark.start<0>"(i64 %"call_source_location##0") { + call ccc void @benchmark_start(i64 %"call_source_location##0") + ret void } - -define external fastcc double @"benchmark.time_execution<0>"(i64 %"proc##0", i64 %"call_source_location##0") alwaysinline { -entry: - tail call ccc void @benchmark_start(i64 %"call_source_location##0") - %0 = inttoptr i64 %"proc##0" to i64* - %1 = load i64, i64* %0 - %2 = inttoptr i64 %1 to void (i64)* - tail call fastcc void %2(i64 %"proc##0") - %3 = tail call ccc double @benchmark_end(i64 %"call_source_location##0") - ret double %3 +define external fastcc double @"benchmark.time_execution<0>"(i64 %"proc##0", i64 %"call_source_location##0") { + call ccc void @benchmark_start(i64 %"call_source_location##0") + %"tmp#1##0" = inttoptr i64 %"proc##0" to ptr + %"tmp#0##0" = load ptr, ptr %"tmp#1##0" + tail call fastcc void %"tmp#0##0"(i64 %"proc##0") + %"tmp#2##0" = call ccc double @benchmark_end(i64 %"call_source_location##0") + ret double %"tmp#2##0" } + -------------------------------------------------- Module benchmark_fib representation : (not a type) @@ -228,172 +219,124 @@ naive_fib1(n##0:wybe.int, ?#result##0:wybe.int)<{}; {}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'benchmark_fib' - - - - -@benchmark_fib.3 = constant {i64, i64} { i64 19, i64 ptrtoint ([?? x i8]* @benchmark_fib.2 to i64) } - - -@benchmark_fib.2 = constant [?? x i8] c"Elapsed time (s): \00" - - -@benchmark_fib.7 = constant [?? x i8] c"benchmark_fib:18:21\00" - - -@benchmark_fib.0 = constant [?? x i8] c"benchmark_fib:30:2\00" - - -@benchmark_fib.1 = constant [?? x i8] c"benchmark_fib:32:2\00" - - -@benchmark_fib.4 = constant [?? x i8] c"benchmark_fib:35:2\00" - - -@benchmark_fib.5 = constant [?? x i8] c"benchmark_fib:37:2\00" - - -@benchmark_fib.6 = constant [?? x i8] c"benchmark_fib:40:2\00" - - -@benchmark_fib.9 = constant [?? x i8] c"benchmark_fib:5:21\00" - - -@benchmark_fib.8 = constant [?? x i8] c"n should be strictly positive\00" - - -declare external ccc void @error_exit(i64, i64) - - -declare external ccc void @putchar(i8) - - -declare external ccc void @print_float(double) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc double @benchmark_end(i64) - - -declare external ccc void @benchmark_start(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"benchmark_fib.<0>"() { -entry: - tail call ccc void @benchmark_start(i64 ptrtoint (i8* getelementptr inbounds ([?? x i8], [?? x i8]* @benchmark_fib.0, i32 0, i32 0) to i64)) - %0 = tail call fastcc i64 @"benchmark_fib.naive_fib<0>"(i64 42) - %1 = tail call ccc double @benchmark_end(i64 ptrtoint (i8* getelementptr inbounds ([?? x i8], [?? x i8]* @benchmark_fib.1, i32 0, i32 0) to i64)) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @benchmark_fib.3, i32 0, i32 0) to i64)) - tail call ccc void @print_float(double %1) - tail call ccc void @putchar(i8 10) - tail call ccc void @benchmark_start(i64 ptrtoint (i8* getelementptr inbounds ([?? x i8], [?? x i8]* @benchmark_fib.4, i32 0, i32 0) to i64)) - %2 = tail call fastcc i64 @"benchmark_fib.fib<0>"(i64 42) - %3 = tail call ccc double @benchmark_end(i64 ptrtoint (i8* getelementptr inbounds ([?? x i8], [?? x i8]* @benchmark_fib.5, i32 0, i32 0) to i64)) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @benchmark_fib.3, i32 0, i32 0) to i64)) - tail call ccc void @print_float(double %3) - tail call ccc void @putchar(i8 10) - tail call ccc void @benchmark_start(i64 ptrtoint (i8* getelementptr inbounds ([?? x i8], [?? x i8]* @benchmark_fib.6, i32 0, i32 0) to i64)) - tail call fastcc void @"benchmark_fib.#anon#1<0>"() - %4 = tail call ccc double @benchmark_end(i64 ptrtoint (i8* getelementptr inbounds ([?? x i8], [?? x i8]* @benchmark_fib.6, i32 0, i32 0) to i64)) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @benchmark_fib.3, i32 0, i32 0) to i64)) - tail call ccc void @print_float(double %4) - tail call ccc void @putchar(i8 10) - ret void +source_filename = "!ROOT!/final-dump/benchmark_fib.wybe" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c"Elapsed time (s): \00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c"benchmark_fib:18:21\00", align 8 +@"cstring#2" = private unnamed_addr constant [ ?? x i8 ] c"benchmark_fib:30:2\00", align 8 +@"cstring#3" = private unnamed_addr constant [ ?? x i8 ] c"benchmark_fib:32:2\00", align 8 +@"cstring#4" = private unnamed_addr constant [ ?? x i8 ] c"benchmark_fib:35:2\00", align 8 +@"cstring#5" = private unnamed_addr constant [ ?? x i8 ] c"benchmark_fib:37:2\00", align 8 +@"cstring#6" = private unnamed_addr constant [ ?? x i8 ] c"benchmark_fib:40:2\00", align 8 +@"cstring#7" = private unnamed_addr constant [ ?? x i8 ] c"benchmark_fib:5:21\00", align 8 +@"cstring#8" = private unnamed_addr constant [ ?? x i8 ] c"n should be strictly positive\00", align 8 +@"string#9" = private unnamed_addr constant {i64, i64} { i64 19, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 + +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc double @benchmark_end(i64) +declare external ccc void @benchmark_start(i64) +declare external ccc void @error_exit(i64, i64) +declare external ccc void @print_float(double) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"benchmark_fib.<0>"() { + call ccc void @benchmark_start(i64 ptrtoint( ptr @"cstring#2" to i64 )) + %"res##0" = tail call fastcc i64 @"benchmark_fib.naive_fib<0>"(i64 42) + %"time##0" = call ccc double @benchmark_end(i64 ptrtoint( ptr @"cstring#3" to i64 )) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#9" to i64 )) + call ccc void @print_float(double %"time##0") + call ccc void @putchar(i8 10) + call ccc void @benchmark_start(i64 ptrtoint( ptr @"cstring#4" to i64 )) + %"res##1" = tail call fastcc i64 @"benchmark_fib.fib<0>"(i64 42) + %"time##1" = call ccc double @benchmark_end(i64 ptrtoint( ptr @"cstring#5" to i64 )) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#9" to i64 )) + call ccc void @print_float(double %"time##1") + call ccc void @putchar(i8 10) + call ccc void @benchmark_start(i64 ptrtoint( ptr @"cstring#6" to i64 )) + tail call fastcc void @"benchmark_fib.#anon#1<0>"() + %"time##2" = call ccc double @benchmark_end(i64 ptrtoint( ptr @"cstring#6" to i64 )) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#9" to i64 )) + call ccc void @print_float(double %"time##2") + call ccc void @putchar(i8 10) + ret void } - -define external fastcc void @"benchmark_fib.#anon#1<0>"() alwaysinline { -entry: - %0 = tail call fastcc i64 @"benchmark_fib.naive_fib<0>"(i64 42) - ret void +define external fastcc void @"benchmark_fib.#anon#1<0>"() { + %"res##0" = tail call fastcc i64 @"benchmark_fib.naive_fib<0>"(i64 42) + ret void } - -define external fastcc void @"benchmark_fib.#anon#1<1>"(i64 %"#env##0") alwaysinline { -entry: - %0 = tail call fastcc i64 @"benchmark_fib.naive_fib<0>"(i64 42) - ret void +define external fastcc void @"benchmark_fib.#anon#1<1>"(i64 %"#env##0") { + %"tmp#0##0" = tail call fastcc i64 @"benchmark_fib.naive_fib<0>"(i64 42) + ret void } - -define external fastcc i64 @"benchmark_fib.fib<0>"(i64 %"n##0") { -entry: - %0 = icmp sle i64 %"n##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - tail call ccc void @error_exit(i64 ptrtoint (i8* getelementptr inbounds ([?? x i8], [?? x i8]* @benchmark_fib.7, i32 0, i32 0) to i64), i64 ptrtoint (i8* getelementptr inbounds ([?? x i8], [?? x i8]* @benchmark_fib.8, i32 0, i32 0) to i64)) - ret i64 undef -if.else: - %1 = icmp eq i64 %"n##0", 1 - br i1 %1, label %if.then1, label %if.else1 -if.then1: - ret i64 1 -if.else1: - %2 = icmp eq i64 %"n##0", 2 - br i1 %2, label %if.then2, label %if.else2 -if.then2: - ret i64 1 -if.else2: - %3 = sub i64 %"n##0", 3 - %4 = tail call fastcc i64 @"benchmark_fib.fib1<0>"(i64 1, i64 1, i64 %3) - ret i64 %4 +define external fastcc i64 @"benchmark_fib.fib<0>"(i64 %"n##0") { + %"tmp#4##0" = icmp sle i64 %"n##0", 0 + br i1 %"tmp#4##0", label %if.then.0, label %if.else.0 +if.then.0: + call ccc void @error_exit(i64 ptrtoint( ptr @"cstring#1" to i64 ), i64 ptrtoint( ptr @"cstring#8" to i64 )) + ret i64 undef +if.else.0: + %"tmp#3##0" = icmp eq i64 %"n##0", 1 + br i1 %"tmp#3##0", label %if.then.1, label %if.else.1 +if.then.1: + ret i64 1 +if.else.1: + %"tmp#2##0" = icmp eq i64 %"n##0", 2 + br i1 %"tmp#2##0", label %if.then.2, label %if.else.2 +if.then.2: + ret i64 1 +if.else.2: + %"tmp#1##0" = sub i64 %"n##0", 3 + %"tmp#15##0" = tail call fastcc i64 @"benchmark_fib.fib1<0>"(i64 1, i64 1, i64 %"tmp#1##0") + ret i64 %"tmp#15##0" } - -define external fastcc i64 @"benchmark_fib.fib1<0>"(i64 %"pprev##0", i64 %"prev##0", i64 %"n##0") { -entry: - %0 = icmp eq i64 %"n##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = add i64 %"pprev##0", %"prev##0" - ret i64 %1 -if.else: - %2 = add i64 %"pprev##0", %"prev##0" - %3 = sub i64 %"n##0", 1 - %4 = musttail call fastcc i64 @"benchmark_fib.fib1<0>"(i64 %"prev##0", i64 %2, i64 %3) - ret i64 %4 +define external fastcc i64 @"benchmark_fib.fib1<0>"(i64 %"pprev##0", i64 %"prev##0", i64 %"n##0") { + %"tmp#5##0" = icmp eq i64 %"n##0", 0 + br i1 %"tmp#5##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#14##0" = add i64 %"pprev##0", %"prev##0" + ret i64 %"tmp#14##0" +if.else.0: + %"tmp#3##0" = add i64 %"pprev##0", %"prev##0" + %"tmp#4##0" = sub i64 %"n##0", 1 + %"tmp#15##0" = tail call fastcc i64 @"benchmark_fib.fib1<0>"(i64 %"prev##0", i64 %"tmp#3##0", i64 %"tmp#4##0") + ret i64 %"tmp#15##0" } - -define external fastcc i64 @"benchmark_fib.naive_fib<0>"(i64 %"n##0") { -entry: - %0 = icmp sle i64 %"n##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - tail call ccc void @error_exit(i64 ptrtoint (i8* getelementptr inbounds ([?? x i8], [?? x i8]* @benchmark_fib.9, i32 0, i32 0) to i64), i64 ptrtoint (i8* getelementptr inbounds ([?? x i8], [?? x i8]* @benchmark_fib.8, i32 0, i32 0) to i64)) - ret i64 undef -if.else: - %1 = musttail call fastcc i64 @"benchmark_fib.naive_fib1<0>"(i64 %"n##0") - ret i64 %1 +define external fastcc i64 @"benchmark_fib.naive_fib<0>"(i64 %"n##0") { + %"tmp#1##0" = icmp sle i64 %"n##0", 0 + br i1 %"tmp#1##0", label %if.then.0, label %if.else.0 +if.then.0: + call ccc void @error_exit(i64 ptrtoint( ptr @"cstring#7" to i64 ), i64 ptrtoint( ptr @"cstring#8" to i64 )) + ret i64 undef +if.else.0: + %"tmp#6##0" = tail call fastcc i64 @"benchmark_fib.naive_fib1<0>"(i64 %"n##0") + ret i64 %"tmp#6##0" } - -define external fastcc i64 @"benchmark_fib.naive_fib1<0>"(i64 %"n##0") { -entry: - %0 = icmp eq i64 %"n##0", 1 - br i1 %0, label %if.then, label %if.else -if.then: - ret i64 1 -if.else: - %1 = icmp eq i64 %"n##0", 2 - br i1 %1, label %if.then1, label %if.else1 -if.then1: - ret i64 1 -if.else1: - %2 = sub i64 %"n##0", 1 - %3 = tail call fastcc i64 @"benchmark_fib.naive_fib1<0>"(i64 %2) - %4 = sub i64 %"n##0", 2 - %5 = tail call fastcc i64 @"benchmark_fib.naive_fib1<0>"(i64 %4) - %6 = add i64 %3, %5 - ret i64 %6 +define external fastcc i64 @"benchmark_fib.naive_fib1<0>"(i64 %"n##0") { + %"tmp#7##0" = icmp eq i64 %"n##0", 1 + br i1 %"tmp#7##0", label %if.then.0, label %if.else.0 +if.then.0: + ret i64 1 +if.else.0: + %"tmp#6##0" = icmp eq i64 %"n##0", 2 + br i1 %"tmp#6##0", label %if.then.1, label %if.else.1 +if.then.1: + ret i64 1 +if.else.1: + %"tmp#3##0" = sub i64 %"n##0", 1 + %"tmp#2##0" = tail call fastcc i64 @"benchmark_fib.naive_fib1<0>"(i64 %"tmp#3##0") + %"tmp#5##0" = sub i64 %"n##0", 2 + %"tmp#4##0" = tail call fastcc i64 @"benchmark_fib.naive_fib1<0>"(i64 %"tmp#5##0") + %"tmp#18##0" = add i64 %"tmp#2##0", %"tmp#4##0" + ret i64 %"tmp#18##0" } diff --git a/test-cases/final-dump/block_comment.exp b/test-cases/final-dump/block_comment.exp index a95392d60..0aa76d343 100644 --- a/test-cases/final-dump/block_comment.exp +++ b/test-cases/final-dump/block_comment.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module block_comment representation : (not a type) public submods : @@ -31,50 +34,32 @@ module top-level code > public {semipure} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'block_comment' - - - - -@block_comment.1 = constant {i64, i64} { i64 41, i64 ptrtoint ([?? x i8]* @block_comment.0 to i64) } - - -@block_comment.3 = constant {i64, i64} { i64 45, i64 ptrtoint ([?? x i8]* @block_comment.2 to i64) } - - -@block_comment.0 = constant [?? x i8] c"print(x:string) creates a newline already\00" - - -@block_comment.2 = constant [?? x i8] c"println(x:string) generates an extra newline?\00" - - -declare external ccc void @print_int(i64) - - -declare external ccc void @putchar(i8) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"block_comment.<0>"() { -entry: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @block_comment.1, i32 0, i32 0) to i64)) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @block_comment.3, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @block_comment.3, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - tail call ccc void @putchar(i8 99) - tail call ccc void @putchar(i8 10) - tail call ccc void @print_int(i64 1) - tail call ccc void @putchar(i8 10) - tail call ccc void @print_int(i64 1) - ret void +source_filename = "!ROOT!/final-dump/block_comment.wybe" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c"print(x:string) creates a newline already\00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c"println(x:string) generates an extra newline?\00", align 8 +@"string#2" = private unnamed_addr constant {i64, i64} { i64 41, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +@"string#3" = private unnamed_addr constant {i64, i64} { i64 45, i64 ptrtoint( ptr @"cstring#1" to i64 ) }, align 8 + +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"block_comment.<0>"() { + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#2" to i64 )) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#3" to i64 )) + call ccc void @putchar(i8 10) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#3" to i64 )) + call ccc void @putchar(i8 10) + call ccc void @putchar(i8 99) + call ccc void @putchar(i8 10) + call ccc void @print_int(i64 1) + call ccc void @putchar(i8 10) + call ccc void @print_int(i64 1) + ret void } diff --git a/test-cases/final-dump/break_in_loop_in_do.exp b/test-cases/final-dump/break_in_loop_in_do.exp index f7b1966ce..c66fa142c 100644 --- a/test-cases/final-dump/break_in_loop_in_do.exp +++ b/test-cases/final-dump/break_in_loop_in_do.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module break_in_loop_in_do representation : (not a type) public submods : @@ -46,49 +49,35 @@ proc #cont#2 > {inline,semipure} (1 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'break_in_loop_in_do' - - - - -@"resource#break_in_loop_in_do.counter" = global i64 undef - - -declare external ccc void @putchar(i8) +source_filename = "!ROOT!/final-dump/break_in_loop_in_do.wybe" +target triple ???? -declare external ccc void @print_int(i64) +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) +@"resource#break_in_loop_in_do.counter" = global i64 undef - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"break_in_loop_in_do.<0>"() alwaysinline { -entry: - %0 = load i64, i64* @"resource#break_in_loop_in_do.counter" - tail call ccc void @print_int(i64 %0) - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"break_in_loop_in_do.<0>"() { + %"tmp#3##0" = load i64, ptr @"resource#break_in_loop_in_do.counter" + call ccc void @print_int(i64 %"tmp#3##0") + call ccc void @putchar(i8 10) + ret void } - -define external fastcc void @"break_in_loop_in_do.#cont#1<0>"() alwaysinline { -entry: - %0 = load i64, i64* @"resource#break_in_loop_in_do.counter" - tail call ccc void @print_int(i64 %0) - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"break_in_loop_in_do.#cont#1<0>"() { + %"tmp#1##0" = load i64, ptr @"resource#break_in_loop_in_do.counter" + call ccc void @print_int(i64 %"tmp#1##0") + call ccc void @putchar(i8 10) + ret void } - -define external fastcc void @"break_in_loop_in_do.#cont#2<0>"(i64 %"tmp#1##0") alwaysinline { -entry: - store i64 %"tmp#1##0", i64* @"resource#break_in_loop_in_do.counter" - tail call ccc void @print_int(i64 %"tmp#1##0") - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"break_in_loop_in_do.#cont#2<0>"(i64 %"tmp#1##0") { + store i64 %"tmp#1##0", ptr @"resource#break_in_loop_in_do.counter" + call ccc void @print_int(i64 %"tmp#1##0") + call ccc void @putchar(i8 10) + ret void } diff --git a/test-cases/final-dump/bug214.exp b/test-cases/final-dump/bug214.exp index 16db636a8..59940943c 100644 --- a/test-cases/final-dump/bug214.exp +++ b/test-cases/final-dump/bug214.exp @@ -1,7 +1,10 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module bug214 - representation : address + representation : pointer public submods : public resources: public procs : bug214.<0> @@ -57,7 +60,7 @@ proc #cont#1 > {inline,semipure} (0 calls) proc #cont#2 > {semipure} (3 calls) -0: bug214.#cont#2<0>[7477e50a09] +0: bug214.#cont#2<0> #cont#2(pos##0:bug214.position, sub##0:bug214)<{<>}; {<>}; {}>: AliasPairs: [] InterestingCallProperties: [InterestingUnaliased 0,InterestingUnaliased 1] @@ -161,7 +164,7 @@ aim(#rec##0:bug214, ?#rec##1:bug214, #field##0:wybe.int)<{}; {}; {}>: proc move > (1 calls) -0: bug214.move<0>[410bae77d3] +0: bug214.move<0> move(pos##0:bug214.position, ?pos##1:bug214.position, dir##0:bug214.direction, units##0:wybe.int)<{}; {}; {}>: AliasPairs: [] InterestingCallProperties: [InterestingUnaliased 0] @@ -199,7 +202,7 @@ move(pos##0:bug214.position, ?pos##1:bug214.position, dir##0:bug214.direction, u foreign lpvm {noalias} mutate(~pos##0:bug214.position, ?pos##1:bug214.position, 8:wybe.int, 1:wybe.int, 16:wybe.int, 0:wybe.int, ~tmp#7##0:wybe.int) @bug214:nn:nn proc move > (1 calls) -1: bug214.move<1>[410bae77d3] +1: bug214.move<1> move(sub##0:bug214, ?sub##2:bug214, dir##0:bug214.direction, units##0:wybe.int)<{}; {}; {}>: AliasPairs: [(sub##0,sub##2)] InterestingCallProperties: [InterestingUnaliased 0] @@ -319,535 +322,453 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'bug214' - - - - -@bug214.1 = constant {i64, i64} { i64 8, i64 ptrtoint ([?? x i8]* @bug214.0 to i64) } - - -@bug214.3 = constant {i64, i64} { i64 8, i64 ptrtoint ([?? x i8]* @bug214.2 to i64) } - - -@bug214.0 = constant [?? x i8] c"Part 1: \00" - - -@bug214.2 = constant [?? x i8] c"Part 2: \00" - - -declare external fastcc i1 @"wybe.int.=<0>"(i64, i64) - - -declare external ccc i64 @read_line() - - -declare external ccc i64 @read_int() - - -declare external fastcc i64 @"wybe.string.string<0>"(i64) - - -declare external ccc void @putchar(i8) - - -declare external ccc void @print_int(i64) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"bug214.<0>"() { -entry: - %0 = tail call fastcc i64 @"bug214.position.origin<0>"() - %1 = tail call fastcc i64 @"bug214.position.origin<0>"() - %2 = trunc i64 16 to i32 - %3 = tail call ccc i8* @wybe_malloc(i32 %2) - %4 = ptrtoint i8* %3 to i64 - %5 = inttoptr i64 %4 to i64* - store i64 %1, i64* %5 - %6 = add i64 %4, 8 - %7 = inttoptr i64 %6 to i64* - store i64 0, i64* %7 - tail call fastcc void @"bug214.#cont#2<0>[7477e50a09]"(i64 %0, i64 %4) - ret void +source_filename = "!ROOT!/final-dump/bug214.wybe" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c"Part 1: \00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c"Part 2: \00", align 8 +@"string#2" = private unnamed_addr constant {i64, i64} { i64 8, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +@"string#3" = private unnamed_addr constant {i64, i64} { i64 8, i64 ptrtoint( ptr @"cstring#1" to i64 ) }, align 8 + +declare external fastcc i1 @"wybe.int.=<0>"(i64, i64) +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external fastcc i64 @"wybe.string.string<0>"(i64) +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc i64 @read_int() +declare external ccc i64 @read_line() +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"bug214.<0>"() { + %"tmp#0##0" = tail call fastcc i64 @"bug214.position.origin<0>"() + %"tmp#2##0" = tail call fastcc i64 @"bug214.position.origin<0>"() + %"tmp#19##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#17##0" = ptrtoint ptr %"tmp#19##0" to i64 + %"tmp#20##0" = inttoptr i64 %"tmp#17##0" to ptr + store i64 %"tmp#2##0", ptr %"tmp#20##0" + %"tmp#21##0" = add i64 %"tmp#17##0", 8 + %"tmp#22##0" = inttoptr i64 %"tmp#21##0" to ptr + store i64 0, ptr %"tmp#22##0" + tail call fastcc void @"bug214.#cont#2<0>[7477e50a09]"(i64 %"tmp#0##0", i64 %"tmp#17##0") + ret void } - -define external fastcc void @"bug214.#cont#1<0>"(i64 %"pos##0", i64 %"sub##0") alwaysinline { -entry: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @bug214.1, i32 0, i32 0) to i64)) - tail call fastcc void @"bug214.position.print<0>"(i64 %"pos##0") - tail call ccc void @putchar(i8 32) - %0 = inttoptr i64 %"pos##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"pos##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = mul i64 %1, %4 - tail call ccc void @print_int(i64 %5) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @bug214.3, i32 0, i32 0) to i64)) - %6 = inttoptr i64 %"sub##0" to i64* - %7 = load i64, i64* %6 - tail call fastcc void @"bug214.position.print<0>"(i64 %7) - tail call ccc void @putchar(i8 32) - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = add i64 %7, 8 - %11 = inttoptr i64 %10 to i64* - %12 = load i64, i64* %11 - %13 = mul i64 %9, %12 - tail call ccc void @print_int(i64 %13) - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"bug214.#cont#1<0>"(i64 %"pos##0", i64 %"sub##0") { + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#2" to i64 )) + tail call fastcc void @"bug214.position.print<0>"(i64 %"pos##0") + call ccc void @putchar(i8 32) + %"tmp#39##0" = inttoptr i64 %"pos##0" to ptr + %"tmp#6##0" = load i64, ptr %"tmp#39##0" + %"tmp#40##0" = add i64 %"pos##0", 8 + %"tmp#41##0" = inttoptr i64 %"tmp#40##0" to ptr + %"tmp#7##0" = load i64, ptr %"tmp#41##0" + %"tmp#5##0" = mul i64 %"tmp#6##0", %"tmp#7##0" + call ccc void @print_int(i64 %"tmp#5##0") + call ccc void @putchar(i8 10) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#3" to i64 )) + %"tmp#42##0" = inttoptr i64 %"sub##0" to ptr + %"tmp#8##0" = load i64, ptr %"tmp#42##0" + tail call fastcc void @"bug214.position.print<0>"(i64 %"tmp#8##0") + call ccc void @putchar(i8 32) + %"tmp#43##0" = inttoptr i64 %"tmp#8##0" to ptr + %"tmp#10##0" = load i64, ptr %"tmp#43##0" + %"tmp#44##0" = add i64 %"tmp#8##0", 8 + %"tmp#45##0" = inttoptr i64 %"tmp#44##0" to ptr + %"tmp#12##0" = load i64, ptr %"tmp#45##0" + %"tmp#9##0" = mul i64 %"tmp#10##0", %"tmp#12##0" + call ccc void @print_int(i64 %"tmp#9##0") + call ccc void @putchar(i8 10) + ret void } - -define external fastcc void @"bug214.#cont#2<0>"(i64 %"pos##0", i64 %"sub##0") { -entry: - %0 = tail call ccc i64 @read_line() - %1 = tail call fastcc i64 @"wybe.string.string<0>"(i64 %0) - %2 = tail call fastcc {i2, i1} @"bug214.direction.parse_direction<0>"(i64 %1) - %3 = extractvalue {i2, i1} %2, 0 - %4 = extractvalue {i2, i1} %2, 1 - br i1 %4, label %if.then, label %if.else -if.then: - %5 = tail call ccc i64 @read_int() - %6 = tail call ccc i64 @read_line() - %7 = tail call fastcc i64 @"bug214.move<0>"(i64 %"pos##0", i2 %3, i64 %5) - %8 = tail call fastcc i64 @"bug214.move<1>"(i64 %"sub##0", i2 %3, i64 %5) - musttail call fastcc void @"bug214.#cont#2<0>[410bae77d3]"(i64 %7, i64 %8) - ret void -if.else: - musttail call fastcc void @"bug214.#cont#2<0>"(i64 %"pos##0", i64 %"sub##0") - ret void +define external fastcc void @"bug214.#cont#2<0>"(i64 %"pos##0", i64 %"sub##0") { + %"tmp#16##0" = call ccc i64 @read_line() + %"dir_str##0" = tail call fastcc i64 @"wybe.string.string<0>"(i64 %"tmp#16##0") + %"tmp#23##0" = tail call fastcc {i2, i1} @"bug214.direction.parse_direction<0>"(i64 %"dir_str##0") + %"tmp#3##0" = extractvalue {i2, i1}%"tmp#23##0", 0 + %"tmp#14##0" = extractvalue {i2, i1}%"tmp#23##0", 1 + br i1 %"tmp#14##0", label %if.then.0, label %if.else.0 +if.then.0: + %"units##0" = call ccc i64 @read_int() + %"tmp#21##0" = call ccc i64 @read_line() + %"pos##1" = tail call fastcc i64 @"bug214.move<0>"(i64 %"pos##0", i2 %"tmp#3##0", i64 %"units##0") + %"sub##1" = tail call fastcc i64 @"bug214.move<1>"(i64 %"sub##0", i2 %"tmp#3##0", i64 %"units##0") + tail call fastcc void @"bug214.#cont#2<0>[410bae77d3]"(i64 %"pos##1", i64 %"sub##1") + ret void +if.else.0: + tail call fastcc void @"bug214.#cont#2<0>"(i64 %"pos##0", i64 %"sub##0") + ret void } - -define external fastcc void @"bug214.#cont#2<0>[410bae77d3]"(i64 %"pos##0", i64 %"sub##0") { -entry: - %0 = tail call ccc i64 @read_line() - %1 = tail call fastcc i64 @"wybe.string.string<0>"(i64 %0) - %2 = tail call fastcc {i2, i1} @"bug214.direction.parse_direction<0>"(i64 %1) - %3 = extractvalue {i2, i1} %2, 0 - %4 = extractvalue {i2, i1} %2, 1 - br i1 %4, label %if.then, label %if.else -if.then: - %5 = tail call ccc i64 @read_int() - %6 = tail call ccc i64 @read_line() - %7 = tail call fastcc i64 @"bug214.move<0>[410bae77d3]"(i64 %"pos##0", i2 %3, i64 %5) - %8 = tail call fastcc i64 @"bug214.move<1>"(i64 %"sub##0", i2 %3, i64 %5) - musttail call fastcc void @"bug214.#cont#2<0>[410bae77d3]"(i64 %7, i64 %8) - ret void -if.else: - musttail call fastcc void @"bug214.#cont#2<0>[410bae77d3]"(i64 %"pos##0", i64 %"sub##0") - ret void +define external fastcc void @"bug214.#cont#2<0>[410bae77d3]"(i64 %"pos##0", i64 %"sub##0") { + %"tmp#16##0" = call ccc i64 @read_line() + %"dir_str##0" = tail call fastcc i64 @"wybe.string.string<0>"(i64 %"tmp#16##0") + %"tmp#23##0" = tail call fastcc {i2, i1} @"bug214.direction.parse_direction<0>"(i64 %"dir_str##0") + %"tmp#3##0" = extractvalue {i2, i1}%"tmp#23##0", 0 + %"tmp#14##0" = extractvalue {i2, i1}%"tmp#23##0", 1 + br i1 %"tmp#14##0", label %if.then.0, label %if.else.0 +if.then.0: + %"units##0" = call ccc i64 @read_int() + %"tmp#21##0" = call ccc i64 @read_line() + %"pos##1" = tail call fastcc i64 @"bug214.move<0>[410bae77d3]"(i64 %"pos##0", i2 %"tmp#3##0", i64 %"units##0") + %"sub##1" = tail call fastcc i64 @"bug214.move<1>"(i64 %"sub##0", i2 %"tmp#3##0", i64 %"units##0") + tail call fastcc void @"bug214.#cont#2<0>[410bae77d3]"(i64 %"pos##1", i64 %"sub##1") + ret void +if.else.0: + tail call fastcc void @"bug214.#cont#2<0>[410bae77d3]"(i64 %"pos##0", i64 %"sub##0") + ret void } - -define external fastcc void @"bug214.#cont#2<0>[7477e50a09]"(i64 %"pos##0", i64 %"sub##0") { -entry: - %0 = tail call ccc i64 @read_line() - %1 = tail call fastcc i64 @"wybe.string.string<0>"(i64 %0) - %2 = tail call fastcc {i2, i1} @"bug214.direction.parse_direction<0>"(i64 %1) - %3 = extractvalue {i2, i1} %2, 0 - %4 = extractvalue {i2, i1} %2, 1 - br i1 %4, label %if.then, label %if.else -if.then: - %5 = tail call ccc i64 @read_int() - %6 = tail call ccc i64 @read_line() - %7 = tail call fastcc i64 @"bug214.move<0>[410bae77d3]"(i64 %"pos##0", i2 %3, i64 %5) - %8 = tail call fastcc i64 @"bug214.move<1>[410bae77d3]"(i64 %"sub##0", i2 %3, i64 %5) - musttail call fastcc void @"bug214.#cont#2<0>[7477e50a09]"(i64 %7, i64 %8) - ret void -if.else: - musttail call fastcc void @"bug214.#cont#2<0>[7477e50a09]"(i64 %"pos##0", i64 %"sub##0") - ret void +define external fastcc void @"bug214.#cont#2<0>[7477e50a09]"(i64 %"pos##0", i64 %"sub##0") { + %"tmp#16##0" = call ccc i64 @read_line() + %"dir_str##0" = tail call fastcc i64 @"wybe.string.string<0>"(i64 %"tmp#16##0") + %"tmp#23##0" = tail call fastcc {i2, i1} @"bug214.direction.parse_direction<0>"(i64 %"dir_str##0") + %"tmp#3##0" = extractvalue {i2, i1}%"tmp#23##0", 0 + %"tmp#14##0" = extractvalue {i2, i1}%"tmp#23##0", 1 + br i1 %"tmp#14##0", label %if.then.0, label %if.else.0 +if.then.0: + %"units##0" = call ccc i64 @read_int() + %"tmp#21##0" = call ccc i64 @read_line() + %"pos##1" = tail call fastcc i64 @"bug214.move<0>[410bae77d3]"(i64 %"pos##0", i2 %"tmp#3##0", i64 %"units##0") + %"sub##1" = tail call fastcc i64 @"bug214.move<1>[410bae77d3]"(i64 %"sub##0", i2 %"tmp#3##0", i64 %"units##0") + tail call fastcc void @"bug214.#cont#2<0>[7477e50a09]"(i64 %"pos##1", i64 %"sub##1") + ret void +if.else.0: + tail call fastcc void @"bug214.#cont#2<0>[7477e50a09]"(i64 %"pos##0", i64 %"sub##0") + ret void } - -define external fastcc i1 @"bug214.=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %"#right##0" to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = tail call fastcc {i64, i64} @"bug214.position.position<1>"(i64 %1) - %11 = extractvalue {i64, i64} %10, 0 - %12 = extractvalue {i64, i64} %10, 1 - %13 = tail call fastcc {i64, i64} @"bug214.position.position<1>"(i64 %6) - %14 = extractvalue {i64, i64} %13, 0 - %15 = extractvalue {i64, i64} %13, 1 - %16 = tail call fastcc i1 @"wybe.int.=<0>"(i64 %11, i64 %14) - br i1 %16, label %if.then, label %if.else -if.then: - %17 = tail call fastcc i1 @"wybe.int.=<0>"(i64 %12, i64 %15) - br i1 %17, label %if.then1, label %if.else1 -if.else: - ret i1 0 -if.then1: - %18 = icmp eq i64 %4, %9 - ret i1 %18 -if.else1: - ret i1 0 +define external fastcc i1 @"bug214.=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#16##0" = inttoptr i64 %"#left##0" to ptr + %"#left#sub_pos##0" = load i64, ptr %"tmp#16##0" + %"tmp#17##0" = add i64 %"#left##0", 8 + %"tmp#18##0" = inttoptr i64 %"tmp#17##0" to ptr + %"#left#aim##0" = load i64, ptr %"tmp#18##0" + %"tmp#19##0" = inttoptr i64 %"#right##0" to ptr + %"#right#sub_pos##0" = load i64, ptr %"tmp#19##0" + %"tmp#20##0" = add i64 %"#right##0", 8 + %"tmp#21##0" = inttoptr i64 %"tmp#20##0" to ptr + %"#right#aim##0" = load i64, ptr %"tmp#21##0" + %"tmp#22##0" = tail call fastcc {i64, i64} @"bug214.position.position<1>"(i64 %"#left#sub_pos##0") + %"tmp#8##0" = extractvalue {i64, i64}%"tmp#22##0", 0 + %"tmp#9##0" = extractvalue {i64, i64}%"tmp#22##0", 1 + %"tmp#23##0" = tail call fastcc {i64, i64} @"bug214.position.position<1>"(i64 %"#right#sub_pos##0") + %"tmp#10##0" = extractvalue {i64, i64}%"tmp#23##0", 0 + %"tmp#11##0" = extractvalue {i64, i64}%"tmp#23##0", 1 + %"tmp#12##0" = tail call fastcc i1 @"wybe.int.=<0>"(i64 %"tmp#8##0", i64 %"tmp#10##0") + br i1 %"tmp#12##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = tail call fastcc i1 @"wybe.int.=<0>"(i64 %"tmp#9##0", i64 %"tmp#11##0") + br i1 %"tmp#1##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#24##0" = icmp eq i64 %"#left#aim##0", %"#right#aim##0" + ret i1 %"tmp#24##0" +if.else.1: + ret i1 0 +if.else.0: + ret i1 0 } - -define external fastcc i64 @"bug214.aim<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = add i64 %"#rec##0", 8 - %1 = inttoptr i64 %0 to i64* - %2 = load i64, i64* %1 - ret i64 %2 +define external fastcc i64 @"bug214.aim<0>"(i64 %"#rec##0") { + %"tmp#0##0" = add i64 %"#rec##0", 8 + %"tmp#1##0" = inttoptr i64 %"tmp#0##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"bug214.aim<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = add i64 %2, 8 - %7 = inttoptr i64 %6 to i64* - store i64 %"#field##0", i64* %7 - ret i64 %2 +define external fastcc i64 @"bug214.aim<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = add i64 %"tmp#2##0", 8 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 %"#field##0", ptr %"tmp#4##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"bug214.move<0>"(i64 %"pos##0", i2 %"dir##0", i64 %"units##0") { -entry: - switch i2 %"dir##0", label %switch.3.2 [i2 0, label %switch.3.0 i2 1, label %switch.3.1 i2 2, label %switch.3.2] -switch.3.0: - %0 = inttoptr i64 %"pos##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %1, %"units##0" - %3 = trunc i64 16 to i32 - %4 = tail call ccc i8* @wybe_malloc(i32 %3) - %5 = ptrtoint i8* %4 to i64 - %6 = inttoptr i64 %5 to i8* - %7 = inttoptr i64 %"pos##0" to i8* - %8 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %6, i8* %7, i32 %8, i1 0) - %9 = inttoptr i64 %5 to i64* - store i64 %2, i64* %9 - ret i64 %5 -switch.3.1: - %10 = add i64 %"pos##0", 8 - %11 = inttoptr i64 %10 to i64* - %12 = load i64, i64* %11 - %13 = add i64 %12, %"units##0" - %14 = trunc i64 16 to i32 - %15 = tail call ccc i8* @wybe_malloc(i32 %14) - %16 = ptrtoint i8* %15 to i64 - %17 = inttoptr i64 %16 to i8* - %18 = inttoptr i64 %"pos##0" to i8* - %19 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %17, i8* %18, i32 %19, i1 0) - %20 = add i64 %16, 8 - %21 = inttoptr i64 %20 to i64* - store i64 %13, i64* %21 - ret i64 %16 -switch.3.2: - %22 = add i64 %"pos##0", 8 - %23 = inttoptr i64 %22 to i64* - %24 = load i64, i64* %23 - %25 = sub i64 %24, %"units##0" - %26 = trunc i64 16 to i32 - %27 = tail call ccc i8* @wybe_malloc(i32 %26) - %28 = ptrtoint i8* %27 to i64 - %29 = inttoptr i64 %28 to i8* - %30 = inttoptr i64 %"pos##0" to i8* - %31 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %29, i8* %30, i32 %31, i1 0) - %32 = add i64 %28, 8 - %33 = inttoptr i64 %32 to i64* - store i64 %25, i64* %33 - ret i64 %28 +define external fastcc i64 @"bug214.move<0>"(i64 %"pos##0", i2 %"dir##0", i64 %"units##0") { + switch i2 %"dir##0", label %case.2.switch.0 [ + i2 0, label %case.0.switch.0 + i2 1, label %case.1.switch.0 + i2 2, label %case.2.switch.0 ] +case.0.switch.0: + %"tmp#36##0" = inttoptr i64 %"pos##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#36##0" + %"tmp#1##0" = add i64 %"tmp#2##0", %"units##0" + %"tmp#37##0" = inttoptr i64 %"pos##0" to ptr + %"tmp#38##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#38##0", ptr %"tmp#37##0", i64 16, i1 0) + %"tmp#39##0" = ptrtoint ptr %"tmp#38##0" to i64 + %"tmp#40##0" = inttoptr i64 %"tmp#39##0" to ptr + store i64 %"tmp#1##0", ptr %"tmp#40##0" + ret i64 %"tmp#39##0" +case.1.switch.0: + %"tmp#41##0" = add i64 %"pos##0", 8 + %"tmp#42##0" = inttoptr i64 %"tmp#41##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#42##0" + %"tmp#4##0" = add i64 %"tmp#5##0", %"units##0" + %"tmp#43##0" = inttoptr i64 %"pos##0" to ptr + %"tmp#44##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#44##0", ptr %"tmp#43##0", i64 16, i1 0) + %"tmp#45##0" = ptrtoint ptr %"tmp#44##0" to i64 + %"tmp#46##0" = add i64 %"tmp#45##0", 8 + %"tmp#47##0" = inttoptr i64 %"tmp#46##0" to ptr + store i64 %"tmp#4##0", ptr %"tmp#47##0" + ret i64 %"tmp#45##0" +case.2.switch.0: + %"tmp#48##0" = add i64 %"pos##0", 8 + %"tmp#49##0" = inttoptr i64 %"tmp#48##0" to ptr + %"tmp#8##0" = load i64, ptr %"tmp#49##0" + %"tmp#7##0" = sub i64 %"tmp#8##0", %"units##0" + %"tmp#50##0" = inttoptr i64 %"pos##0" to ptr + %"tmp#51##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#51##0", ptr %"tmp#50##0", i64 16, i1 0) + %"tmp#52##0" = ptrtoint ptr %"tmp#51##0" to i64 + %"tmp#53##0" = add i64 %"tmp#52##0", 8 + %"tmp#54##0" = inttoptr i64 %"tmp#53##0" to ptr + store i64 %"tmp#7##0", ptr %"tmp#54##0" + ret i64 %"tmp#52##0" } - -define external fastcc i64 @"bug214.move<0>[410bae77d3]"(i64 %"pos##0", i2 %"dir##0", i64 %"units##0") { -entry: - switch i2 %"dir##0", label %switch.3.2 [i2 0, label %switch.3.0 i2 1, label %switch.3.1 i2 2, label %switch.3.2] -switch.3.0: - %0 = inttoptr i64 %"pos##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %1, %"units##0" - %3 = inttoptr i64 %"pos##0" to i64* - store i64 %2, i64* %3 - ret i64 %"pos##0" -switch.3.1: - %4 = add i64 %"pos##0", 8 - %5 = inttoptr i64 %4 to i64* - %6 = load i64, i64* %5 - %7 = add i64 %6, %"units##0" - %8 = add i64 %"pos##0", 8 - %9 = inttoptr i64 %8 to i64* - store i64 %7, i64* %9 - ret i64 %"pos##0" -switch.3.2: - %10 = add i64 %"pos##0", 8 - %11 = inttoptr i64 %10 to i64* - %12 = load i64, i64* %11 - %13 = sub i64 %12, %"units##0" - %14 = add i64 %"pos##0", 8 - %15 = inttoptr i64 %14 to i64* - store i64 %13, i64* %15 - ret i64 %"pos##0" +define external fastcc i64 @"bug214.move<0>[410bae77d3]"(i64 %"pos##0", i2 %"dir##0", i64 %"units##0") { + switch i2 %"dir##0", label %case.2.switch.0 [ + i2 0, label %case.0.switch.0 + i2 1, label %case.1.switch.0 + i2 2, label %case.2.switch.0 ] +case.0.switch.0: + %"tmp#36##0" = inttoptr i64 %"pos##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#36##0" + %"tmp#1##0" = add i64 %"tmp#2##0", %"units##0" + %"tmp#37##0" = inttoptr i64 %"pos##0" to ptr + store i64 %"tmp#1##0", ptr %"tmp#37##0" + ret i64 %"pos##0" +case.1.switch.0: + %"tmp#38##0" = add i64 %"pos##0", 8 + %"tmp#39##0" = inttoptr i64 %"tmp#38##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#39##0" + %"tmp#4##0" = add i64 %"tmp#5##0", %"units##0" + %"tmp#40##0" = add i64 %"pos##0", 8 + %"tmp#41##0" = inttoptr i64 %"tmp#40##0" to ptr + store i64 %"tmp#4##0", ptr %"tmp#41##0" + ret i64 %"pos##0" +case.2.switch.0: + %"tmp#42##0" = add i64 %"pos##0", 8 + %"tmp#43##0" = inttoptr i64 %"tmp#42##0" to ptr + %"tmp#8##0" = load i64, ptr %"tmp#43##0" + %"tmp#7##0" = sub i64 %"tmp#8##0", %"units##0" + %"tmp#44##0" = add i64 %"pos##0", 8 + %"tmp#45##0" = inttoptr i64 %"tmp#44##0" to ptr + store i64 %"tmp#7##0", ptr %"tmp#45##0" + ret i64 %"pos##0" } - -define external fastcc i64 @"bug214.move<1>"(i64 %"sub##0", i2 %"dir##0", i64 %"units##0") { -entry: - switch i2 %"dir##0", label %switch.3.2 [i2 0, label %switch.3.0 i2 1, label %switch.3.1 i2 2, label %switch.3.2] -switch.3.0: - %0 = inttoptr i64 %"sub##0" to i64* - %1 = load i64, i64* %0 - %2 = inttoptr i64 %1 to i64* - %3 = load i64, i64* %2 - %4 = add i64 %3, %"units##0" - %5 = trunc i64 16 to i32 - %6 = tail call ccc i8* @wybe_malloc(i32 %5) - %7 = ptrtoint i8* %6 to i64 - %8 = inttoptr i64 %7 to i8* - %9 = inttoptr i64 %1 to i8* - %10 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %8, i8* %9, i32 %10, i1 0) - %11 = inttoptr i64 %7 to i64* - store i64 %4, i64* %11 - %12 = trunc i64 16 to i32 - %13 = tail call ccc i8* @wybe_malloc(i32 %12) - %14 = ptrtoint i8* %13 to i64 - %15 = inttoptr i64 %14 to i8* - %16 = inttoptr i64 %"sub##0" to i8* - %17 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %15, i8* %16, i32 %17, i1 0) - %18 = inttoptr i64 %14 to i64* - store i64 %7, i64* %18 - %19 = inttoptr i64 %14 to i64* - %20 = load i64, i64* %19 - %21 = add i64 %20, 8 - %22 = inttoptr i64 %21 to i64* - %23 = load i64, i64* %22 - %24 = add i64 %14, 8 - %25 = inttoptr i64 %24 to i64* - %26 = load i64, i64* %25 - %27 = mul i64 %26, %"units##0" - %28 = add i64 %23, %27 - %29 = trunc i64 16 to i32 - %30 = tail call ccc i8* @wybe_malloc(i32 %29) - %31 = ptrtoint i8* %30 to i64 - %32 = inttoptr i64 %31 to i8* - %33 = inttoptr i64 %20 to i8* - %34 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %32, i8* %33, i32 %34, i1 0) - %35 = add i64 %31, 8 - %36 = inttoptr i64 %35 to i64* - store i64 %28, i64* %36 - %37 = inttoptr i64 %14 to i64* - store i64 %31, i64* %37 - ret i64 %14 -switch.3.1: - %38 = add i64 %"sub##0", 8 - %39 = inttoptr i64 %38 to i64* - %40 = load i64, i64* %39 - %41 = add i64 %40, %"units##0" - %42 = trunc i64 16 to i32 - %43 = tail call ccc i8* @wybe_malloc(i32 %42) - %44 = ptrtoint i8* %43 to i64 - %45 = inttoptr i64 %44 to i8* - %46 = inttoptr i64 %"sub##0" to i8* - %47 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %45, i8* %46, i32 %47, i1 0) - %48 = add i64 %44, 8 - %49 = inttoptr i64 %48 to i64* - store i64 %41, i64* %49 - ret i64 %44 -switch.3.2: - %50 = add i64 %"sub##0", 8 - %51 = inttoptr i64 %50 to i64* - %52 = load i64, i64* %51 - %53 = sub i64 %52, %"units##0" - %54 = trunc i64 16 to i32 - %55 = tail call ccc i8* @wybe_malloc(i32 %54) - %56 = ptrtoint i8* %55 to i64 - %57 = inttoptr i64 %56 to i8* - %58 = inttoptr i64 %"sub##0" to i8* - %59 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %57, i8* %58, i32 %59, i1 0) - %60 = add i64 %56, 8 - %61 = inttoptr i64 %60 to i64* - store i64 %53, i64* %61 - ret i64 %56 +define external fastcc i64 @"bug214.move<1>"(i64 %"sub##0", i2 %"dir##0", i64 %"units##0") { + switch i2 %"dir##0", label %case.2.switch.0 [ + i2 0, label %case.0.switch.0 + i2 1, label %case.1.switch.0 + i2 2, label %case.2.switch.0 ] +case.0.switch.0: + %"tmp#60##0" = inttoptr i64 %"sub##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#60##0" + %"tmp#61##0" = inttoptr i64 %"tmp#1##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#61##0" + %"tmp#2##0" = add i64 %"tmp#3##0", %"units##0" + %"tmp#62##0" = inttoptr i64 %"tmp#1##0" to ptr + %"tmp#63##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#63##0", ptr %"tmp#62##0", i64 16, i1 0) + %"tmp#64##0" = ptrtoint ptr %"tmp#63##0" to i64 + %"tmp#65##0" = inttoptr i64 %"tmp#64##0" to ptr + store i64 %"tmp#2##0", ptr %"tmp#65##0" + %"tmp#66##0" = inttoptr i64 %"sub##0" to ptr + %"tmp#67##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#67##0", ptr %"tmp#66##0", i64 16, i1 0) + %"tmp#68##0" = ptrtoint ptr %"tmp#67##0" to i64 + %"tmp#69##0" = inttoptr i64 %"tmp#68##0" to ptr + store i64 %"tmp#64##0", ptr %"tmp#69##0" + %"tmp#70##0" = inttoptr i64 %"tmp#68##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#70##0" + %"tmp#71##0" = add i64 %"tmp#5##0", 8 + %"tmp#72##0" = inttoptr i64 %"tmp#71##0" to ptr + %"tmp#7##0" = load i64, ptr %"tmp#72##0" + %"tmp#73##0" = add i64 %"tmp#68##0", 8 + %"tmp#74##0" = inttoptr i64 %"tmp#73##0" to ptr + %"tmp#10##0" = load i64, ptr %"tmp#74##0" + %"tmp#9##0" = mul i64 %"tmp#10##0", %"units##0" + %"tmp#6##0" = add i64 %"tmp#7##0", %"tmp#9##0" + %"tmp#75##0" = inttoptr i64 %"tmp#5##0" to ptr + %"tmp#76##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#76##0", ptr %"tmp#75##0", i64 16, i1 0) + %"tmp#77##0" = ptrtoint ptr %"tmp#76##0" to i64 + %"tmp#78##0" = add i64 %"tmp#77##0", 8 + %"tmp#79##0" = inttoptr i64 %"tmp#78##0" to ptr + store i64 %"tmp#6##0", ptr %"tmp#79##0" + %"tmp#80##0" = inttoptr i64 %"tmp#68##0" to ptr + store i64 %"tmp#77##0", ptr %"tmp#80##0" + ret i64 %"tmp#68##0" +case.1.switch.0: + %"tmp#81##0" = add i64 %"sub##0", 8 + %"tmp#82##0" = inttoptr i64 %"tmp#81##0" to ptr + %"tmp#13##0" = load i64, ptr %"tmp#82##0" + %"tmp#12##0" = add i64 %"tmp#13##0", %"units##0" + %"tmp#83##0" = inttoptr i64 %"sub##0" to ptr + %"tmp#84##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#84##0", ptr %"tmp#83##0", i64 16, i1 0) + %"tmp#85##0" = ptrtoint ptr %"tmp#84##0" to i64 + %"tmp#86##0" = add i64 %"tmp#85##0", 8 + %"tmp#87##0" = inttoptr i64 %"tmp#86##0" to ptr + store i64 %"tmp#12##0", ptr %"tmp#87##0" + ret i64 %"tmp#85##0" +case.2.switch.0: + %"tmp#88##0" = add i64 %"sub##0", 8 + %"tmp#89##0" = inttoptr i64 %"tmp#88##0" to ptr + %"tmp#16##0" = load i64, ptr %"tmp#89##0" + %"tmp#15##0" = sub i64 %"tmp#16##0", %"units##0" + %"tmp#90##0" = inttoptr i64 %"sub##0" to ptr + %"tmp#91##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#91##0", ptr %"tmp#90##0", i64 16, i1 0) + %"tmp#92##0" = ptrtoint ptr %"tmp#91##0" to i64 + %"tmp#93##0" = add i64 %"tmp#92##0", 8 + %"tmp#94##0" = inttoptr i64 %"tmp#93##0" to ptr + store i64 %"tmp#15##0", ptr %"tmp#94##0" + ret i64 %"tmp#92##0" } - -define external fastcc i64 @"bug214.move<1>[410bae77d3]"(i64 %"sub##0", i2 %"dir##0", i64 %"units##0") { -entry: - switch i2 %"dir##0", label %switch.3.2 [i2 0, label %switch.3.0 i2 1, label %switch.3.1 i2 2, label %switch.3.2] -switch.3.0: - %0 = inttoptr i64 %"sub##0" to i64* - %1 = load i64, i64* %0 - %2 = inttoptr i64 %1 to i64* - %3 = load i64, i64* %2 - %4 = add i64 %3, %"units##0" - %5 = trunc i64 16 to i32 - %6 = tail call ccc i8* @wybe_malloc(i32 %5) - %7 = ptrtoint i8* %6 to i64 - %8 = inttoptr i64 %7 to i8* - %9 = inttoptr i64 %1 to i8* - %10 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %8, i8* %9, i32 %10, i1 0) - %11 = inttoptr i64 %7 to i64* - store i64 %4, i64* %11 - %12 = inttoptr i64 %"sub##0" to i64* - store i64 %7, i64* %12 - %13 = inttoptr i64 %"sub##0" to i64* - %14 = load i64, i64* %13 - %15 = add i64 %14, 8 - %16 = inttoptr i64 %15 to i64* - %17 = load i64, i64* %16 - %18 = add i64 %"sub##0", 8 - %19 = inttoptr i64 %18 to i64* - %20 = load i64, i64* %19 - %21 = mul i64 %20, %"units##0" - %22 = add i64 %17, %21 - %23 = trunc i64 16 to i32 - %24 = tail call ccc i8* @wybe_malloc(i32 %23) - %25 = ptrtoint i8* %24 to i64 - %26 = inttoptr i64 %25 to i8* - %27 = inttoptr i64 %14 to i8* - %28 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %26, i8* %27, i32 %28, i1 0) - %29 = add i64 %25, 8 - %30 = inttoptr i64 %29 to i64* - store i64 %22, i64* %30 - %31 = inttoptr i64 %"sub##0" to i64* - store i64 %25, i64* %31 - ret i64 %"sub##0" -switch.3.1: - %32 = add i64 %"sub##0", 8 - %33 = inttoptr i64 %32 to i64* - %34 = load i64, i64* %33 - %35 = add i64 %34, %"units##0" - %36 = add i64 %"sub##0", 8 - %37 = inttoptr i64 %36 to i64* - store i64 %35, i64* %37 - ret i64 %"sub##0" -switch.3.2: - %38 = add i64 %"sub##0", 8 - %39 = inttoptr i64 %38 to i64* - %40 = load i64, i64* %39 - %41 = sub i64 %40, %"units##0" - %42 = add i64 %"sub##0", 8 - %43 = inttoptr i64 %42 to i64* - store i64 %41, i64* %43 - ret i64 %"sub##0" +define external fastcc i64 @"bug214.move<1>[410bae77d3]"(i64 %"sub##0", i2 %"dir##0", i64 %"units##0") { + switch i2 %"dir##0", label %case.2.switch.0 [ + i2 0, label %case.0.switch.0 + i2 1, label %case.1.switch.0 + i2 2, label %case.2.switch.0 ] +case.0.switch.0: + %"tmp#60##0" = inttoptr i64 %"sub##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#60##0" + %"tmp#61##0" = inttoptr i64 %"tmp#1##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#61##0" + %"tmp#2##0" = add i64 %"tmp#3##0", %"units##0" + %"tmp#62##0" = inttoptr i64 %"tmp#1##0" to ptr + %"tmp#63##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#63##0", ptr %"tmp#62##0", i64 16, i1 0) + %"tmp#64##0" = ptrtoint ptr %"tmp#63##0" to i64 + %"tmp#65##0" = inttoptr i64 %"tmp#64##0" to ptr + store i64 %"tmp#2##0", ptr %"tmp#65##0" + %"tmp#66##0" = inttoptr i64 %"sub##0" to ptr + store i64 %"tmp#64##0", ptr %"tmp#66##0" + %"tmp#67##0" = inttoptr i64 %"sub##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#67##0" + %"tmp#68##0" = add i64 %"tmp#5##0", 8 + %"tmp#69##0" = inttoptr i64 %"tmp#68##0" to ptr + %"tmp#7##0" = load i64, ptr %"tmp#69##0" + %"tmp#70##0" = add i64 %"sub##0", 8 + %"tmp#71##0" = inttoptr i64 %"tmp#70##0" to ptr + %"tmp#10##0" = load i64, ptr %"tmp#71##0" + %"tmp#9##0" = mul i64 %"tmp#10##0", %"units##0" + %"tmp#6##0" = add i64 %"tmp#7##0", %"tmp#9##0" + %"tmp#72##0" = inttoptr i64 %"tmp#5##0" to ptr + %"tmp#73##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#73##0", ptr %"tmp#72##0", i64 16, i1 0) + %"tmp#74##0" = ptrtoint ptr %"tmp#73##0" to i64 + %"tmp#75##0" = add i64 %"tmp#74##0", 8 + %"tmp#76##0" = inttoptr i64 %"tmp#75##0" to ptr + store i64 %"tmp#6##0", ptr %"tmp#76##0" + %"tmp#77##0" = inttoptr i64 %"sub##0" to ptr + store i64 %"tmp#74##0", ptr %"tmp#77##0" + ret i64 %"sub##0" +case.1.switch.0: + %"tmp#78##0" = add i64 %"sub##0", 8 + %"tmp#79##0" = inttoptr i64 %"tmp#78##0" to ptr + %"tmp#13##0" = load i64, ptr %"tmp#79##0" + %"tmp#12##0" = add i64 %"tmp#13##0", %"units##0" + %"tmp#80##0" = add i64 %"sub##0", 8 + %"tmp#81##0" = inttoptr i64 %"tmp#80##0" to ptr + store i64 %"tmp#12##0", ptr %"tmp#81##0" + ret i64 %"sub##0" +case.2.switch.0: + %"tmp#82##0" = add i64 %"sub##0", 8 + %"tmp#83##0" = inttoptr i64 %"tmp#82##0" to ptr + %"tmp#16##0" = load i64, ptr %"tmp#83##0" + %"tmp#15##0" = sub i64 %"tmp#16##0", %"units##0" + %"tmp#84##0" = add i64 %"sub##0", 8 + %"tmp#85##0" = inttoptr i64 %"tmp#84##0" to ptr + store i64 %"tmp#15##0", ptr %"tmp#85##0" + ret i64 %"sub##0" } - -define external fastcc i64 @"bug214.sub_pos<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#rec##0" to i64* - %1 = load i64, i64* %0 - ret i64 %1 +define external fastcc i64 @"bug214.sub_pos<0>"(i64 %"#rec##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + ret i64 %"tmp#1##0" } - -define external fastcc i64 @"bug214.sub_pos<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = inttoptr i64 %2 to i64* - store i64 %"#field##0", i64* %6 - ret i64 %2 +define external fastcc i64 @"bug214.sub_pos<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"#field##0", ptr %"tmp#3##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"bug214.submarine<0>"(i64 %"sub_pos##0", i64 %"aim##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"sub_pos##0", i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"aim##0", i64* %5 - ret i64 %2 +define external fastcc i64 @"bug214.submarine<0>"(i64 %"sub_pos##0", i64 %"aim##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 16) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"sub_pos##0", ptr %"tmp#1##0" + %"tmp#2##0" = add i64 %"#rec##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"aim##0", ptr %"tmp#3##0" + ret i64 %"#rec##0" } - -define external fastcc {i64, i64} @"bug214.submarine<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#result##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#result##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = insertvalue {i64, i64} undef, i64 %1, 0 - %6 = insertvalue {i64, i64} %5, i64 %4, 1 - ret {i64, i64} %6 +define external fastcc {i64, i64} @"bug214.submarine<1>"(i64 %"#result##0") { + %"tmp#0##0" = inttoptr i64 %"#result##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + %"tmp#2##0" = add i64 %"#result##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#3##0" + %"tmp#5##0" = insertvalue {i64, i64} undef, i64 %"tmp#1##0", 0 + %"tmp#6##0" = insertvalue {i64, i64} %"tmp#5##0", i64 %"tmp#4##0", 1 + ret {i64, i64} %"tmp#6##0" } - -define external fastcc i1 @"bug214.~=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %"#right##0" to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = tail call fastcc {i64, i64} @"bug214.position.position<1>"(i64 %1) - %11 = extractvalue {i64, i64} %10, 0 - %12 = extractvalue {i64, i64} %10, 1 - %13 = tail call fastcc {i64, i64} @"bug214.position.position<1>"(i64 %6) - %14 = extractvalue {i64, i64} %13, 0 - %15 = extractvalue {i64, i64} %13, 1 - %16 = tail call fastcc i1 @"wybe.int.=<0>"(i64 %11, i64 %14) - br i1 %16, label %if.then, label %if.else -if.then: - %17 = tail call fastcc i1 @"wybe.int.=<0>"(i64 %12, i64 %15) - br i1 %17, label %if.then1, label %if.else1 -if.else: - %21 = xor i1 0, 1 - ret i1 %21 -if.then1: - %18 = icmp eq i64 %4, %9 - %19 = xor i1 %18, 1 - ret i1 %19 -if.else1: - %20 = xor i1 0, 1 - ret i1 %20 +define external fastcc i1 @"bug214.~=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#13##0" = inttoptr i64 %"#left##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#13##0" + %"tmp#14##0" = add i64 %"#left##0", 8 + %"tmp#15##0" = inttoptr i64 %"tmp#14##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#15##0" + %"tmp#16##0" = inttoptr i64 %"#right##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#16##0" + %"tmp#17##0" = add i64 %"#right##0", 8 + %"tmp#18##0" = inttoptr i64 %"tmp#17##0" to ptr + %"tmp#6##0" = load i64, ptr %"tmp#18##0" + %"tmp#19##0" = tail call fastcc {i64, i64} @"bug214.position.position<1>"(i64 %"tmp#3##0") + %"tmp#7##0" = extractvalue {i64, i64}%"tmp#19##0", 0 + %"tmp#8##0" = extractvalue {i64, i64}%"tmp#19##0", 1 + %"tmp#20##0" = tail call fastcc {i64, i64} @"bug214.position.position<1>"(i64 %"tmp#5##0") + %"tmp#9##0" = extractvalue {i64, i64}%"tmp#20##0", 0 + %"tmp#10##0" = extractvalue {i64, i64}%"tmp#20##0", 1 + %"tmp#11##0" = tail call fastcc i1 @"wybe.int.=<0>"(i64 %"tmp#7##0", i64 %"tmp#9##0") + br i1 %"tmp#11##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#12##0" = tail call fastcc i1 @"wybe.int.=<0>"(i64 %"tmp#8##0", i64 %"tmp#10##0") + br i1 %"tmp#12##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#0##0" = icmp eq i64 %"tmp#4##0", %"tmp#6##0" + %"tmp#21##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#21##0" +if.else.1: + %"tmp#22##0" = xor i1 0, 1 + ret i1 %"tmp#22##0" +if.else.0: + %"tmp#23##0" = xor i1 0, 1 + ret i1 %"tmp#23##0" } + -------------------------------------------------- Module bug214.direction representation : 2 bit unsigned @@ -942,105 +863,78 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'bug214.direction' +source_filename = "!ROOT!/final-dump/bug214.wybe" +target triple ???? - - - -@bug214.direction.5 = constant {i64, i64} { i64 2, i64 ptrtoint ([?? x i8]* @bug214.direction.4 to i64) } - - -@bug214.direction.3 = constant {i64, i64} { i64 4, i64 ptrtoint ([?? x i8]* @bug214.direction.2 to i64) } +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c"down\00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c"forward\00", align 8 +@"cstring#2" = private unnamed_addr constant [ ?? x i8 ] c"up\00", align 8 +@"string#3" = private unnamed_addr constant {i64, i64} { i64 4, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +@"string#4" = private unnamed_addr constant {i64, i64} { i64 7, i64 ptrtoint( ptr @"cstring#1" to i64 ) }, align 8 +@"string#5" = private unnamed_addr constant {i64, i64} { i64 2, i64 ptrtoint( ptr @"cstring#2" to i64 ) }, align 8 +declare external fastcc i2 @"wybe.string.<=>#cont#2<0>"(i2, i64, i64, i64, i64) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -@bug214.direction.1 = constant {i64, i64} { i64 7, i64 ptrtoint ([?? x i8]* @bug214.direction.0 to i64) } - - -@bug214.direction.2 = constant [?? x i8] c"down\00" - - -@bug214.direction.0 = constant [?? x i8] c"forward\00" - - -@bug214.direction.4 = constant [?? x i8] c"up\00" - - -declare external fastcc i2 @"wybe.string.<=>#cont#2<0>"(i2, i64, i64, i64, i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i1 @"bug214.direction.=<0>"(i2 %"#left##0", i2 %"#right##0") alwaysinline { -entry: - %0 = icmp eq i2 %"#left##0", %"#right##0" - ret i1 %0 +define external fastcc i1 @"bug214.direction.=<0>"(i2 %"#left##0", i2 %"#right##0") { + %"tmp#1##0" = icmp eq i2 %"#left##0", %"#right##0" + ret i1 %"tmp#1##0" } - -define external fastcc i2 @"bug214.direction.down<0>"() alwaysinline { -entry: - ret i2 1 +define external fastcc i2 @"bug214.direction.down<0>"() { + ret i2 1 } - -define external fastcc i2 @"bug214.direction.fwd<0>"() alwaysinline { -entry: - ret i2 0 +define external fastcc i2 @"bug214.direction.fwd<0>"() { + ret i2 0 } - -define external fastcc {i2, i1} @"bug214.direction.parse_direction<0>"(i64 %"str##0") { -entry: - %0 = tail call fastcc i2 @"wybe.string.<=>#cont#2<0>"(i2 1, i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @bug214.direction.1, i32 0, i32 0) to i64), i64 %"str##0", i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @bug214.direction.1, i32 0, i32 0) to i64), i64 %"str##0") - %1 = icmp eq i2 %0, 1 - br i1 %1, label %if.then, label %if.else -if.then: - %2 = insertvalue {i2, i1} undef, i2 0, 0 - %3 = insertvalue {i2, i1} %2, i1 1, 1 - ret {i2, i1} %3 -if.else: - %4 = tail call fastcc i2 @"wybe.string.<=>#cont#2<0>"(i2 1, i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @bug214.direction.3, i32 0, i32 0) to i64), i64 %"str##0", i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @bug214.direction.3, i32 0, i32 0) to i64), i64 %"str##0") - %5 = icmp eq i2 %4, 1 - br i1 %5, label %if.then1, label %if.else1 -if.then1: - %6 = insertvalue {i2, i1} undef, i2 1, 0 - %7 = insertvalue {i2, i1} %6, i1 1, 1 - ret {i2, i1} %7 -if.else1: - %8 = tail call fastcc i2 @"wybe.string.<=>#cont#2<0>"(i2 1, i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @bug214.direction.5, i32 0, i32 0) to i64), i64 %"str##0", i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @bug214.direction.5, i32 0, i32 0) to i64), i64 %"str##0") - %9 = icmp eq i2 %8, 1 - br i1 %9, label %if.then2, label %if.else2 -if.then2: - %10 = insertvalue {i2, i1} undef, i2 2, 0 - %11 = insertvalue {i2, i1} %10, i1 1, 1 - ret {i2, i1} %11 -if.else2: - %12 = insertvalue {i2, i1} undef, i2 undef, 0 - %13 = insertvalue {i2, i1} %12, i1 0, 1 - ret {i2, i1} %13 +define external fastcc {i2, i1} @"bug214.direction.parse_direction<0>"(i64 %"str##0") { + %"tmp#8##0" = tail call fastcc i2 @"wybe.string.<=>#cont#2<0>"(i2 1, i64 ptrtoint( ptr @"string#4" to i64 ), i64 %"str##0", i64 ptrtoint( ptr @"string#4" to i64 ), i64 %"str##0") + %"tmp#5##0" = icmp eq i2 %"tmp#8##0", 1 + br i1 %"tmp#5##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#15##0" = insertvalue {i2, i1} undef, i2 0, 0 + %"tmp#16##0" = insertvalue {i2, i1} %"tmp#15##0", i1 1, 1 + ret {i2, i1} %"tmp#16##0" +if.else.0: + %"tmp#11##0" = tail call fastcc i2 @"wybe.string.<=>#cont#2<0>"(i2 1, i64 ptrtoint( ptr @"string#3" to i64 ), i64 %"str##0", i64 ptrtoint( ptr @"string#3" to i64 ), i64 %"str##0") + %"tmp#4##0" = icmp eq i2 %"tmp#11##0", 1 + br i1 %"tmp#4##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#17##0" = insertvalue {i2, i1} undef, i2 1, 0 + %"tmp#18##0" = insertvalue {i2, i1} %"tmp#17##0", i1 1, 1 + ret {i2, i1} %"tmp#18##0" +if.else.1: + %"tmp#14##0" = tail call fastcc i2 @"wybe.string.<=>#cont#2<0>"(i2 1, i64 ptrtoint( ptr @"string#5" to i64 ), i64 %"str##0", i64 ptrtoint( ptr @"string#5" to i64 ), i64 %"str##0") + %"tmp#3##0" = icmp eq i2 %"tmp#14##0", 1 + br i1 %"tmp#3##0", label %if.then.2, label %if.else.2 +if.then.2: + %"tmp#19##0" = insertvalue {i2, i1} undef, i2 2, 0 + %"tmp#20##0" = insertvalue {i2, i1} %"tmp#19##0", i1 1, 1 + ret {i2, i1} %"tmp#20##0" +if.else.2: + %"tmp#21##0" = insertvalue {i2, i1} undef, i2 undef, 0 + %"tmp#22##0" = insertvalue {i2, i1} %"tmp#21##0", i1 0, 1 + ret {i2, i1} %"tmp#22##0" } - -define external fastcc i2 @"bug214.direction.up<0>"() alwaysinline { -entry: - ret i2 2 +define external fastcc i2 @"bug214.direction.up<0>"() { + ret i2 2 } - -define external fastcc i1 @"bug214.direction.~=<0>"(i2 %"#left##0", i2 %"#right##0") alwaysinline { -entry: - %0 = icmp eq i2 %"#left##0", %"#right##0" - %1 = xor i1 %0, 1 - ret i1 %1 +define external fastcc i1 @"bug214.direction.~=<0>"(i2 %"#left##0", i2 %"#right##0") { + %"tmp#0##0" = icmp eq i2 %"#left##0", %"#right##0" + %"tmp#3##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#3##0" } + -------------------------------------------------- Module bug214.position - representation : address + representation : pointer public submods : public resources: public procs : bug214.position.=<0> @@ -1172,188 +1066,143 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'bug214.position' - - - - -@bug214.position.1 = constant {i64, i64} { i64 1, i64 ptrtoint ([?? x i8]* @bug214.position.0 to i64) } - - -@bug214.position.3 = constant {i64, i64} { i64 1, i64 ptrtoint ([?? x i8]* @bug214.position.2 to i64) } - - -@bug214.position.5 = constant {i64, i64} { i64 1, i64 ptrtoint ([?? x i8]* @bug214.position.4 to i64) } - - -@bug214.position.0 = constant [?? x i8] c"(\00" - - -@bug214.position.4 = constant [?? x i8] c")\00" - - -@bug214.position.2 = constant [?? x i8] c",\00" - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc void @print_int(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i1 @"bug214.position.=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %"#right##0" to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = icmp eq i64 %1, %6 - br i1 %10, label %if.then, label %if.else -if.then: - %11 = icmp eq i64 %4, %9 - ret i1 %11 -if.else: - ret i1 0 +source_filename = "!ROOT!/final-dump/bug214.wybe" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c"(\00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c")\00", align 8 +@"cstring#2" = private unnamed_addr constant [ ?? x i8 ] c",\00", align 8 +@"string#3" = private unnamed_addr constant {i64, i64} { i64 1, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +@"string#4" = private unnamed_addr constant {i64, i64} { i64 1, i64 ptrtoint( ptr @"cstring#1" to i64 ) }, align 8 +@"string#5" = private unnamed_addr constant {i64, i64} { i64 1, i64 ptrtoint( ptr @"cstring#2" to i64 ) }, align 8 + +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @print_int(i64) +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc i1 @"bug214.position.=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#9##0" = inttoptr i64 %"#left##0" to ptr + %"#left#x##0" = load i64, ptr %"tmp#9##0" + %"tmp#10##0" = add i64 %"#left##0", 8 + %"tmp#11##0" = inttoptr i64 %"tmp#10##0" to ptr + %"#left#y##0" = load i64, ptr %"tmp#11##0" + %"tmp#12##0" = inttoptr i64 %"#right##0" to ptr + %"#right#x##0" = load i64, ptr %"tmp#12##0" + %"tmp#13##0" = add i64 %"#right##0", 8 + %"tmp#14##0" = inttoptr i64 %"tmp#13##0" to ptr + %"#right#y##0" = load i64, ptr %"tmp#14##0" + %"tmp#1##0" = icmp eq i64 %"#left#x##0", %"#right#x##0" + br i1 %"tmp#1##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#15##0" = icmp eq i64 %"#left#y##0", %"#right#y##0" + ret i1 %"tmp#15##0" +if.else.0: + ret i1 0 } - -define external fastcc i64 @"bug214.position.origin<0>"() { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 0, i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 0, i64* %5 - ret i64 %2 +define external fastcc i64 @"bug214.position.origin<0>"() { + %"tmp#5##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#3##0" = ptrtoint ptr %"tmp#5##0" to i64 + %"tmp#6##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 0, ptr %"tmp#6##0" + %"tmp#7##0" = add i64 %"tmp#3##0", 8 + %"tmp#8##0" = inttoptr i64 %"tmp#7##0" to ptr + store i64 0, ptr %"tmp#8##0" + ret i64 %"tmp#3##0" } - -define external fastcc i64 @"bug214.position.position<0>"(i64 %"x##0", i64 %"y##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"x##0", i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"y##0", i64* %5 - ret i64 %2 +define external fastcc i64 @"bug214.position.position<0>"(i64 %"x##0", i64 %"y##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 16) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"x##0", ptr %"tmp#1##0" + %"tmp#2##0" = add i64 %"#rec##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"y##0", ptr %"tmp#3##0" + ret i64 %"#rec##0" } - -define external fastcc {i64, i64} @"bug214.position.position<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#result##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#result##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = insertvalue {i64, i64} undef, i64 %1, 0 - %6 = insertvalue {i64, i64} %5, i64 %4, 1 - ret {i64, i64} %6 +define external fastcc {i64, i64} @"bug214.position.position<1>"(i64 %"#result##0") { + %"tmp#0##0" = inttoptr i64 %"#result##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + %"tmp#2##0" = add i64 %"#result##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#3##0" + %"tmp#5##0" = insertvalue {i64, i64} undef, i64 %"tmp#1##0", 0 + %"tmp#6##0" = insertvalue {i64, i64} %"tmp#5##0", i64 %"tmp#4##0", 1 + ret {i64, i64} %"tmp#6##0" } - -define external fastcc void @"bug214.position.print<0>"(i64 %"pos##0") { -entry: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @bug214.position.1, i32 0, i32 0) to i64)) - %0 = inttoptr i64 %"pos##0" to i64* - %1 = load i64, i64* %0 - tail call ccc void @print_int(i64 %1) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @bug214.position.3, i32 0, i32 0) to i64)) - %2 = add i64 %"pos##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - tail call ccc void @print_int(i64 %4) - musttail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @bug214.position.5, i32 0, i32 0) to i64)) - ret void +define external fastcc void @"bug214.position.print<0>"(i64 %"pos##0") { + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#3" to i64 )) + %"tmp#10##0" = inttoptr i64 %"pos##0" to ptr + %"tmp#0##0" = load i64, ptr %"tmp#10##0" + call ccc void @print_int(i64 %"tmp#0##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#5" to i64 )) + %"tmp#11##0" = add i64 %"pos##0", 8 + %"tmp#12##0" = inttoptr i64 %"tmp#11##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#12##0" + call ccc void @print_int(i64 %"tmp#1##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#4" to i64 )) + ret void } - -define external fastcc i64 @"bug214.position.x<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#rec##0" to i64* - %1 = load i64, i64* %0 - ret i64 %1 +define external fastcc i64 @"bug214.position.x<0>"(i64 %"#rec##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + ret i64 %"tmp#1##0" } - -define external fastcc i64 @"bug214.position.x<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = inttoptr i64 %2 to i64* - store i64 %"#field##0", i64* %6 - ret i64 %2 +define external fastcc i64 @"bug214.position.x<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"#field##0", ptr %"tmp#3##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"bug214.position.y<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = add i64 %"#rec##0", 8 - %1 = inttoptr i64 %0 to i64* - %2 = load i64, i64* %1 - ret i64 %2 +define external fastcc i64 @"bug214.position.y<0>"(i64 %"#rec##0") { + %"tmp#0##0" = add i64 %"#rec##0", 8 + %"tmp#1##0" = inttoptr i64 %"tmp#0##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"bug214.position.y<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = add i64 %2, 8 - %7 = inttoptr i64 %6 to i64* - store i64 %"#field##0", i64* %7 - ret i64 %2 +define external fastcc i64 @"bug214.position.y<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = add i64 %"tmp#2##0", 8 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 %"#field##0", ptr %"tmp#4##0" + ret i64 %"tmp#2##0" } - -define external fastcc i1 @"bug214.position.~=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %"#right##0" to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = icmp eq i64 %1, %6 - br i1 %10, label %if.then, label %if.else -if.then: - %11 = icmp eq i64 %4, %9 - %12 = xor i1 %11, 1 - ret i1 %12 -if.else: - %13 = xor i1 0, 1 - ret i1 %13 +define external fastcc i1 @"bug214.position.~=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#8##0" = inttoptr i64 %"#left##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#8##0" + %"tmp#9##0" = add i64 %"#left##0", 8 + %"tmp#10##0" = inttoptr i64 %"tmp#9##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#10##0" + %"tmp#11##0" = inttoptr i64 %"#right##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#11##0" + %"tmp#12##0" = add i64 %"#right##0", 8 + %"tmp#13##0" = inttoptr i64 %"tmp#12##0" to ptr + %"tmp#6##0" = load i64, ptr %"tmp#13##0" + %"tmp#7##0" = icmp eq i64 %"tmp#3##0", %"tmp#5##0" + br i1 %"tmp#7##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#0##0" = icmp eq i64 %"tmp#4##0", %"tmp#6##0" + %"tmp#14##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#14##0" +if.else.0: + %"tmp#15##0" = xor i1 0, 1 + ret i1 %"tmp#15##0" } diff --git a/test-cases/final-dump/bug217.exp b/test-cases/final-dump/bug217.exp index 69546929b..55eea6330 100644 --- a/test-cases/final-dump/bug217.exp +++ b/test-cases/final-dump/bug217.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module bug217 representation : (not a type) public submods : @@ -14,16 +17,15 @@ AFTER EVERYTHING: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'bug217' +source_filename = "!ROOT!/final-dump/bug217.wybe" +target triple ???? - - - -declare external ccc i8* @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) -------------------------------------------------- Module bug217.foo representation : 0 bit unsigned @@ -63,34 +65,27 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'bug217.foo' +source_filename = "!ROOT!/final-dump/bug217.wybe" +target triple ???? - - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -define external fastcc i1 @"bug217.foo.=<0>"() alwaysinline { -entry: - ret i1 1 +define external fastcc i1 @"bug217.foo.=<0>"() { + ret i1 1 } - -define external fastcc void @"bug217.foo.foo<0>"() alwaysinline { -entry: - ret void +define external fastcc void @"bug217.foo.foo<0>"() { + ret void } - -define external fastcc i1 @"bug217.foo.~=<0>"() alwaysinline { -entry: - ret i1 0 +define external fastcc i1 @"bug217.foo.~=<0>"() { + ret i1 0 } + -------------------------------------------------- Module bug217.foo.bar representation : 0 bit unsigned @@ -128,31 +123,23 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'bug217.foo.bar' +source_filename = "!ROOT!/final-dump/bug217.wybe" +target triple ???? - - - -declare external ccc i8* @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i1 @"bug217.foo.bar.=<0>"() alwaysinline { -entry: - ret i1 1 +define external fastcc i1 @"bug217.foo.bar.=<0>"() { + ret i1 1 } - -define external fastcc void @"bug217.foo.bar.bar<0>"() alwaysinline { -entry: - ret void +define external fastcc void @"bug217.foo.bar.bar<0>"() { + ret void } - -define external fastcc i1 @"bug217.foo.bar.~=<0>"() alwaysinline { -entry: - ret i1 0 +define external fastcc i1 @"bug217.foo.bar.~=<0>"() { + ret i1 0 } diff --git a/test-cases/final-dump/bug228-okay.exp b/test-cases/final-dump/bug228-okay.exp index 40a6bbd01..047f2a218 100644 --- a/test-cases/final-dump/bug228-okay.exp +++ b/test-cases/final-dump/bug228-okay.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module bug228-okay representation : (not a type) public submods : @@ -42,49 +45,35 @@ init_res()<{}; {<>}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'bug228-okay' - - - - -@"resource#bug228-okay.res" = global i64 undef - - -declare external ccc void @putchar(i8) +source_filename = "!ROOT!/final-dump/bug228-okay.wybe" +target triple ???? -declare external ccc void @print_int(i64) +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) +@"resource#bug228-okay.res" = global i64 undef - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"bug228-okay.<0>"() { -entry: - tail call ccc void @print_int(i64 1) - tail call ccc void @putchar(i8 10) - tail call ccc void @print_int(i64 2) - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"bug228-okay.<0>"() { + call ccc void @print_int(i64 1) + call ccc void @putchar(i8 10) + call ccc void @print_int(i64 2) + call ccc void @putchar(i8 10) + ret void } - -define external fastcc {i64, i64} @"bug228-okay.bar<0>"() alwaysinline { -entry: - %0 = load i64, i64* @"resource#bug228-okay.res" - store i64 %0, i64* @"resource#bug228-okay.res" - %1 = insertvalue {i64, i64} undef, i64 1, 0 - %2 = insertvalue {i64, i64} %1, i64 2, 1 - ret {i64, i64} %2 +define external fastcc {i64, i64} @"bug228-okay.bar<0>"() { + %"tmp#1##0" = load i64, ptr @"resource#bug228-okay.res" + store i64 %"tmp#1##0", ptr @"resource#bug228-okay.res" + %"tmp#2##0" = insertvalue {i64, i64} undef, i64 1, 0 + %"tmp#3##0" = insertvalue {i64, i64} %"tmp#2##0", i64 2, 1 + ret {i64, i64} %"tmp#3##0" } - -define external fastcc void @"bug228-okay.init_res<0>"() alwaysinline { -entry: - store i64 2, i64* @"resource#bug228-okay.res" - ret void +define external fastcc void @"bug228-okay.init_res<0>"() { + store i64 2, ptr @"resource#bug228-okay.res" + ret void } diff --git a/test-cases/final-dump/bug_var_def.exp b/test-cases/final-dump/bug_var_def.exp index 61a8591c0..6174082dc 100644 --- a/test-cases/final-dump/bug_var_def.exp +++ b/test-cases/final-dump/bug_var_def.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module bug_var_def representation : (not a type) public submods : @@ -17,19 +20,15 @@ module top-level code > public {inline,semipure} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'bug_var_def' +source_filename = "!ROOT!/final-dump/bug_var_def.wybe" +target triple ???? - - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -define external fastcc void @"bug_var_def.<0>"() alwaysinline { -entry: - ret void +define external fastcc void @"bug_var_def.<0>"() { + ret void } diff --git a/test-cases/final-dump/call_site_id.exp b/test-cases/final-dump/call_site_id.exp index 2a072c59b..2e8cf9657 100644 --- a/test-cases/final-dump/call_site_id.exp +++ b/test-cases/final-dump/call_site_id.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module call_site_id representation : (not a type) public submods : @@ -78,87 +81,67 @@ foo(x##0:wybe.int)<{<>}; {<>}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'call_site_id' - - - - -@call_site_id.1 = constant {i64, i64} { i64 1, i64 ptrtoint ([?? x i8]* @call_site_id.0 to i64) } - - -@call_site_id.0 = constant [?? x i8] c" \00" - - -declare external ccc void @putchar(i8) - - -declare external ccc void @print_int(i64) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc i64 @read_int() - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"call_site_id.<0>"() { -entry: - %0 = tail call ccc i64 @read_int() - %1 = tail call ccc i64 @read_int() - %2 = icmp sgt i64 %0, 0 - br i1 %2, label %if.then, label %if.else -if.then: - tail call fastcc void @"call_site_id.foo<0>"(i64 %0) - %3 = icmp sgt i64 %1, 0 - br i1 %3, label %if.then1, label %if.else1 -if.else: - %5 = sub i64 0, %0 - tail call fastcc void @"call_site_id.foo<0>"(i64 %5) - %6 = icmp sgt i64 %1, 0 - br i1 %6, label %if.then2, label %if.else2 -if.then1: - tail call fastcc void @"call_site_id.foo<0>"(i64 %1) - ret void -if.else1: - %4 = sub i64 0, %1 - tail call fastcc void @"call_site_id.foo<0>"(i64 %4) - ret void -if.then2: - tail call fastcc void @"call_site_id.foo<0>"(i64 %1) - ret void -if.else2: - %7 = sub i64 0, %1 - tail call fastcc void @"call_site_id.foo<0>"(i64 %7) - ret void +source_filename = "!ROOT!/final-dump/call_site_id.wybe" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c" \00", align 8 +@"string#1" = private unnamed_addr constant {i64, i64} { i64 1, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 + +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc i64 @read_int() +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"call_site_id.<0>"() { + %"x##0" = call ccc i64 @read_int() + %"y##0" = call ccc i64 @read_int() + %"tmp#5##0" = icmp sgt i64 %"x##0", 0 + br i1 %"tmp#5##0", label %if.then.0, label %if.else.0 +if.then.0: + tail call fastcc void @"call_site_id.foo<0>"(i64 %"x##0") + %"tmp#3##0" = icmp sgt i64 %"y##0", 0 + br i1 %"tmp#3##0", label %if.then.1, label %if.else.1 +if.then.1: + tail call fastcc void @"call_site_id.foo<0>"(i64 %"y##0") + ret void +if.else.1: + %"tmp#0##0" = sub i64 0, %"y##0" + tail call fastcc void @"call_site_id.foo<0>"(i64 %"tmp#0##0") + ret void +if.else.0: + %"tmp#1##0" = sub i64 0, %"x##0" + tail call fastcc void @"call_site_id.foo<0>"(i64 %"tmp#1##0") + %"tmp#4##0" = icmp sgt i64 %"y##0", 0 + br i1 %"tmp#4##0", label %if.then.2, label %if.else.2 +if.then.2: + tail call fastcc void @"call_site_id.foo<0>"(i64 %"y##0") + ret void +if.else.2: + %"tmp#2##0" = sub i64 0, %"y##0" + tail call fastcc void @"call_site_id.foo<0>"(i64 %"tmp#2##0") + ret void } - -define external fastcc void @"call_site_id.bar<0>"(i64 %"x##0") alwaysinline { -entry: - musttail call fastcc void @"call_site_id.foo<0>"(i64 %"x##0") - ret void +define external fastcc void @"call_site_id.bar<0>"(i64 %"x##0") { + tail call fastcc void @"call_site_id.foo<0>"(i64 %"x##0") + ret void } - -define external fastcc void @"call_site_id.foo<0>"(i64 %"x##0") { -entry: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @call_site_id.1, i32 0, i32 0) to i64)) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @call_site_id.1, i32 0, i32 0) to i64)) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @call_site_id.1, i32 0, i32 0) to i64)) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @call_site_id.1, i32 0, i32 0) to i64)) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @call_site_id.1, i32 0, i32 0) to i64)) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @call_site_id.1, i32 0, i32 0) to i64)) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @call_site_id.1, i32 0, i32 0) to i64)) - %0 = mul i64 %"x##0", 5 - %1 = add i64 %0, 10 - tail call ccc void @print_int(i64 %1) - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"call_site_id.foo<0>"(i64 %"x##0") { + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#1" to i64 )) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#1" to i64 )) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#1" to i64 )) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#1" to i64 )) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#1" to i64 )) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#1" to i64 )) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#1" to i64 )) + %"tmp#1##0" = mul i64 %"x##0", 5 + %"tmp#0##0" = add i64 %"tmp#1##0", 10 + call ccc void @print_int(i64 %"tmp#0##0") + call ccc void @putchar(i8 10) + ret void } diff --git a/test-cases/final-dump/card.exp b/test-cases/final-dump/card.exp index 76c895644..4e9abf67d 100644 --- a/test-cases/final-dump/card.exp +++ b/test-cases/final-dump/card.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module card representation : 6 bit unsigned public submods : rank -> card.rank @@ -88,12 +91,14 @@ proc #cont#2 > {semipure} (2 calls) 1: foreign lpvm access(tmp#2##0:wybe.list(T), 0:wybe.int, 16:wybe.int, 0:wybe.int, ?r##0:card.rank) @card:nn:nn foreign lpvm access(~tmp#2##0:wybe.list(T), 8:wybe.int, 16:wybe.int, 0:wybe.int, ?tmp#2##1:wybe.list(card.rank)) @card:nn:nn - foreign llvm shl(~r##0:card, 2:card, ?tmp#12##0:card) @card:nn:nn - foreign llvm or(s##0:card, ~tmp#12##0:card, ?tmp#4##0:card) @card:nn:nn + foreign lpvm cast(~r##0:card.rank, ?tmp#12##0:card) @card:nn:nn + foreign llvm shl(~tmp#12##0:card, 2:card, ?tmp#13##0:card) @card:nn:nn + foreign lpvm cast(s##0:card.suit, ?tmp#14##0:card) @card:nn:nn + foreign llvm or(~tmp#13##0:card, ~tmp#14##0:card, ?tmp#4##0:card) @card:nn:nn card.print<0>(~tmp#4##0:card)<{<>}; {<>}; {}> #2 @card:nn:nn - foreign lpvm load(<>:wybe.phantom, ?%tmp#13##0:wybe.phantom) @card:nn:nn - foreign c putchar('\n':wybe.char, ~tmp#13##0:wybe.phantom, ?tmp#14##0:wybe.phantom) @card:nn:nn - foreign lpvm store(~%tmp#14##0:wybe.phantom, <>:wybe.phantom) @card:nn:nn + foreign lpvm load(<>:wybe.phantom, ?%tmp#15##0:wybe.phantom) @card:nn:nn + foreign c putchar('\n':wybe.char, ~tmp#15##0:wybe.phantom, ?tmp#16##0:wybe.phantom) @card:nn:nn + foreign lpvm store(~%tmp#16##0:wybe.phantom, <>:wybe.phantom) @card:nn:nn card.#cont#2<0>(~s##0:card.suit, ~tmp#0##0:wybe.list(card.suit), ~tmp#2##1:wybe.list(card.rank))<{<>}; {<>}; {}> #4 @card:nn:nn @@ -111,8 +116,10 @@ proc card > public {inline} (1 calls) card(rank##0:card.rank, suit##0:card.suit, ?#result##3:card)<{}; {}; {}>: AliasPairs: [] InterestingCallProperties: [] - foreign llvm shl(~rank##0:card, 2:card, ?#temp##0:card) @card:nn:nn - foreign llvm or(~#temp##0:card, ~suit##0:card, ?#result##3:card) @card:nn:nn + foreign lpvm cast(~rank##0:card.rank, ?#temp##0:card) @card:nn:nn + foreign llvm shl(~#temp##0:card, 2:card, ?#temp##1:card) @card:nn:nn + foreign lpvm cast(~suit##0:card.suit, ?#temp##2:card) @card:nn:nn + foreign llvm or(~#temp##1:card, ~#temp##2:card, ?#result##3:card) @card:nn:nn proc card > public {inline} (0 calls) 1: card.card<1> card(?rank##0:card.rank, ?suit##0:card.suit, #result##0:card)<{}; {}; {}>: @@ -153,8 +160,9 @@ rank(#rec##0:card, ?#rec##2:card, #field##0:card.rank)<{}; {}; {}>: AliasPairs: [] InterestingCallProperties: [] foreign llvm and(~#rec##0:card, -61:card, ?#rec##1:card) @card:nn:nn - foreign llvm shl(~#field##0:card, 2:card, ?#temp##0:card) @card:nn:nn - foreign llvm or(~#rec##1:card, ~#temp##0:card, ?#rec##2:card) @card:nn:nn + foreign lpvm cast(~#field##0:card.rank, ?#temp##0:card) @card:nn:nn + foreign llvm shl(~#temp##0:card, 2:card, ?#temp##1:card) @card:nn:nn + foreign llvm or(~#rec##1:card, ~#temp##1:card, ?#rec##2:card) @card:nn:nn proc suit > public {inline} (1 calls) @@ -170,7 +178,8 @@ suit(#rec##0:card, ?#rec##2:card, #field##0:card.suit)<{}; {}; {}>: AliasPairs: [] InterestingCallProperties: [] foreign llvm and(~#rec##0:card, -4:card, ?#rec##1:card) @card:nn:nn - foreign llvm or(~#field##0:card, ~#rec##1:card, ?#rec##2:card) @card:nn:nn + foreign lpvm cast(~#field##0:card.suit, ?#temp##0:card) @card:nn:nn + foreign llvm or(~#rec##1:card, ~#temp##0:card, ?#rec##2:card) @card:nn:nn proc ~= > public {inline} (0 calls) @@ -183,156 +192,129 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'card' - - - - -declare external ccc void @putchar(i8) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"card.<0>"() alwaysinline { -entry: - %0 = tail call fastcc i64 @"card.suit.suits<0>"() - tail call fastcc void @"card.#cont#1<0>"(i64 %0) - ret void -} - - -define external fastcc void @"card.#cont#1<0>"(i64 %"tmp#0##0") { -entry: - %0 = icmp ne i64 %"tmp#0##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"tmp#0##0" to i2* - %2 = load i2, i2* %1 - %3 = add i64 %"tmp#0##0", 8 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = tail call fastcc i64 @"card.rank.ranks<0>"() - tail call fastcc void @"card.#cont#2<0>"(i2 %2, i64 %5, i64 %6) - ret void -if.else: - ret void -} - - -define external fastcc void @"card.#cont#2<0>"(i2 %"s##0", i64 %"tmp#0##0", i64 %"tmp#2##0") { -entry: - %0 = icmp ne i64 %"tmp#2##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"tmp#2##0" to i4* - %2 = load i4, i4* %1 - %3 = add i64 %"tmp#2##0", 8 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = zext i4 %2 to i6 - %7 = shl i6 %6, 2 - %8 = zext i2 %"s##0" to i6 - %9 = or i6 %8, %7 - tail call fastcc void @"card.print<0>"(i6 %9) - tail call ccc void @putchar(i8 10) - musttail call fastcc void @"card.#cont#2<0>"(i2 %"s##0", i64 %"tmp#0##0", i64 %5) - ret void -if.else: - tail call fastcc void @"card.#cont#1<0>"(i64 %"tmp#0##0") - ret void -} - - -define external fastcc i1 @"card.=<0>"(i6 %"#left##0", i6 %"#right##0") alwaysinline { -entry: - %0 = icmp eq i6 %"#left##0", %"#right##0" - ret i1 %0 -} - - -define external fastcc i6 @"card.card<0>"(i4 %"rank##0", i2 %"suit##0") alwaysinline { -entry: - %0 = zext i4 %"rank##0" to i6 - %1 = shl i6 %0, 2 - %2 = zext i2 %"suit##0" to i6 - %3 = or i6 %1, %2 - ret i6 %3 -} - - -define external fastcc {i4, i2} @"card.card<1>"(i6 %"#result##0") alwaysinline { -entry: - %0 = lshr i6 %"#result##0", 2 - %1 = and i6 %0, 15 - %2 = trunc i6 %1 to i4 - %3 = and i6 %"#result##0", 3 - %4 = trunc i6 %3 to i2 - %5 = insertvalue {i4, i2} undef, i4 %2, 0 - %6 = insertvalue {i4, i2} %5, i2 %4, 1 - ret {i4, i2} %6 -} - - -define external fastcc void @"card.print<0>"(i6 %"c##0") { -entry: - %0 = lshr i6 %"c##0", 2 - %1 = and i6 %0, 15 - %2 = trunc i6 %1 to i4 - tail call fastcc void @"card.rank.print<0>"(i4 %2) - %3 = and i6 %"c##0", 3 - %4 = trunc i6 %3 to i2 - tail call fastcc void @"card.suit.print<0>"(i2 %4) - ret void -} - - -define external fastcc i4 @"card.rank<0>"(i6 %"#rec##0") alwaysinline { -entry: - %0 = lshr i6 %"#rec##0", 2 - %1 = and i6 %0, 15 - %2 = trunc i6 %1 to i4 - ret i4 %2 -} - - -define external fastcc i6 @"card.rank<1>"(i6 %"#rec##0", i4 %"#field##0") alwaysinline { -entry: - %0 = and i6 %"#rec##0", -61 - %1 = zext i4 %"#field##0" to i6 - %2 = shl i6 %1, 2 - %3 = or i6 %0, %2 - ret i6 %3 +source_filename = "!ROOT!/final-dump/card.wybe" +target triple ???? + + +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"card.<0>"() { + %"tmp#1##0" = tail call fastcc i64 @"card.suit.suits<0>"() + tail call fastcc void @"card.#cont#1<0>"(i64 %"tmp#1##0") + ret void +} + +define external fastcc void @"card.#cont#1<0>"(i64 %"tmp#0##0") { + %"tmp#10##0" = icmp ne i64 %"tmp#0##0", 0 + br i1 %"tmp#10##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#11##0" = inttoptr i64 %"tmp#0##0" to ptr + %"s##0" = load i2, ptr %"tmp#11##0" + %"tmp#12##0" = add i64 %"tmp#0##0", 8 + %"tmp#13##0" = inttoptr i64 %"tmp#12##0" to ptr + %"tmp#0##1" = load i64, ptr %"tmp#13##0" + %"tmp#3##0" = tail call fastcc i64 @"card.rank.ranks<0>"() + tail call fastcc void @"card.#cont#2<0>"(i2 %"s##0", i64 %"tmp#0##1", i64 %"tmp#3##0") + ret void +if.else.0: + ret void +} + +define external fastcc void @"card.#cont#2<0>"(i2 %"s##0", i64 %"tmp#0##0", i64 %"tmp#2##0") { + %"tmp#9##0" = icmp ne i64 %"tmp#2##0", 0 + br i1 %"tmp#9##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#17##0" = inttoptr i64 %"tmp#2##0" to ptr + %"r##0" = load i4, ptr %"tmp#17##0" + %"tmp#18##0" = add i64 %"tmp#2##0", 8 + %"tmp#19##0" = inttoptr i64 %"tmp#18##0" to ptr + %"tmp#2##1" = load i64, ptr %"tmp#19##0" + %"tmp#12##0" = zext i4 %"r##0" to i6 + %"tmp#13##0" = shl i6 %"tmp#12##0", 2 + %"tmp#14##0" = zext i2 %"s##0" to i6 + %"tmp#4##0" = or i6 %"tmp#13##0", %"tmp#14##0" + tail call fastcc void @"card.print<0>"(i6 %"tmp#4##0") + call ccc void @putchar(i8 10) + tail call fastcc void @"card.#cont#2<0>"(i2 %"s##0", i64 %"tmp#0##0", i64 %"tmp#2##1") + ret void +if.else.0: + tail call fastcc void @"card.#cont#1<0>"(i64 %"tmp#0##0") + ret void +} + +define external fastcc i1 @"card.=<0>"(i6 %"#left##0", i6 %"#right##0") { + %"tmp#1##0" = icmp eq i6 %"#left##0", %"#right##0" + ret i1 %"tmp#1##0" +} + +define external fastcc i6 @"card.card<0>"(i4 %"rank##0", i2 %"suit##0") { + %"#temp##0" = zext i4 %"rank##0" to i6 + %"#temp##1" = shl i6 %"#temp##0", 2 + %"#temp##2" = zext i2 %"suit##0" to i6 + %"tmp#0##0" = or i6 %"#temp##1", %"#temp##2" + ret i6 %"tmp#0##0" +} + +define external fastcc {i4, i2} @"card.card<1>"(i6 %"#result##0") { + %"#temp##0" = lshr i6 %"#result##0", 2 + %"#temp2##0" = and i6 %"#temp##0", 15 + %"tmp#0##0" = trunc i6 %"#temp2##0" to i4 + %"#temp2##1" = and i6 %"#result##0", 3 + %"tmp#1##0" = trunc i6 %"#temp2##1" to i2 + %"tmp#2##0" = insertvalue {i4, i2} undef, i4 %"tmp#0##0", 0 + %"tmp#3##0" = insertvalue {i4, i2} %"tmp#2##0", i2 %"tmp#1##0", 1 + ret {i4, i2} %"tmp#3##0" +} + +define external fastcc void @"card.print<0>"(i6 %"c##0") { + %"tmp#3##0" = lshr i6 %"c##0", 2 + %"tmp#4##0" = and i6 %"tmp#3##0", 15 + %"tmp#0##0" = trunc i6 %"tmp#4##0" to i4 + tail call fastcc void @"card.rank.print<0>"(i4 %"tmp#0##0") + %"tmp#6##0" = and i6 %"c##0", 3 + %"tmp#1##0" = trunc i6 %"tmp#6##0" to i2 + tail call fastcc void @"card.suit.print<0>"(i2 %"tmp#1##0") + ret void +} + +define external fastcc i4 @"card.rank<0>"(i6 %"#rec##0") { + %"#rec##1" = lshr i6 %"#rec##0", 2 + %"#field##0" = and i6 %"#rec##1", 15 + %"tmp#0##0" = trunc i6 %"#field##0" to i4 + ret i4 %"tmp#0##0" +} + +define external fastcc i6 @"card.rank<1>"(i6 %"#rec##0", i4 %"#field##0") { + %"#rec##1" = and i6 %"#rec##0", -61 + %"#temp##0" = zext i4 %"#field##0" to i6 + %"#temp##1" = shl i6 %"#temp##0", 2 + %"tmp#0##0" = or i6 %"#rec##1", %"#temp##1" + ret i6 %"tmp#0##0" +} + +define external fastcc i2 @"card.suit<0>"(i6 %"#rec##0") { + %"#field##0" = and i6 %"#rec##0", 3 + %"tmp#0##0" = trunc i6 %"#field##0" to i2 + ret i2 %"tmp#0##0" +} + +define external fastcc i6 @"card.suit<1>"(i6 %"#rec##0", i2 %"#field##0") { + %"#rec##1" = and i6 %"#rec##0", -4 + %"#temp##0" = zext i2 %"#field##0" to i6 + %"tmp#0##0" = or i6 %"#rec##1", %"#temp##0" + ret i6 %"tmp#0##0" +} + +define external fastcc i1 @"card.~=<0>"(i6 %"#left##0", i6 %"#right##0") { + %"tmp#0##0" = icmp eq i6 %"#left##0", %"#right##0" + %"tmp#3##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#3##0" } - -define external fastcc i2 @"card.suit<0>"(i6 %"#rec##0") alwaysinline { -entry: - %0 = and i6 %"#rec##0", 3 - %1 = trunc i6 %0 to i2 - ret i2 %1 -} - - -define external fastcc i6 @"card.suit<1>"(i6 %"#rec##0", i2 %"#field##0") alwaysinline { -entry: - %0 = and i6 %"#rec##0", -4 - %1 = zext i2 %"#field##0" to i6 - %2 = or i6 %1, %0 - ret i6 %2 -} - - -define external fastcc i1 @"card.~=<0>"(i6 %"#left##0", i6 %"#right##0") alwaysinline { -entry: - %0 = icmp eq i6 %"#left##0", %"#right##0" - %1 = xor i1 %0, 1 - ret i1 %1 -} -------------------------------------------------- Module card.rank representation : 4 bit unsigned @@ -587,262 +569,224 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'card.rank' +source_filename = "!ROOT!/final-dump/card.wybe" +target triple ???? - - - -declare external ccc void @putchar(i8) - - -declare external ccc i8* @wybe_malloc(i32) +declare external ccc void @putchar(i8) +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i1 @"card.rank.=<0>"(i4 %"#left##0", i4 %"#right##0") alwaysinline { -entry: - %0 = icmp eq i4 %"#left##0", %"#right##0" - ret i1 %0 -} - - -define external fastcc i4 @"card.rank.ace<0>"() alwaysinline { -entry: - ret i4 12 -} - - -define external fastcc i8 @"card.rank.char<0>"(i4 %"r##0") { -entry: - switch i4 %"r##0", label %switch.13.12 [i4 0, label %switch.13.0 i4 1, label %switch.13.1 i4 2, label %switch.13.2 i4 3, label %switch.13.3 i4 4, label %switch.13.4 i4 5, label %switch.13.5 i4 6, label %switch.13.6 i4 7, label %switch.13.7 i4 8, label %switch.13.8 i4 9, label %switch.13.9 i4 10, label %switch.13.10 i4 11, label %switch.13.11 i4 12, label %switch.13.12] -switch.13.0: - ret i8 50 -switch.13.1: - ret i8 51 -switch.13.2: - ret i8 52 -switch.13.3: - ret i8 53 -switch.13.4: - ret i8 54 -switch.13.5: - ret i8 55 -switch.13.6: - ret i8 56 -switch.13.7: - ret i8 57 -switch.13.8: - ret i8 84 -switch.13.9: - ret i8 74 -switch.13.10: - ret i8 81 -switch.13.11: - ret i8 75 -switch.13.12: - ret i8 65 +define external fastcc i1 @"card.rank.=<0>"(i4 %"#left##0", i4 %"#right##0") { + %"tmp#1##0" = icmp eq i4 %"#left##0", %"#right##0" + ret i1 %"tmp#1##0" } - -define external fastcc i4 @"card.rank.jack<0>"() alwaysinline { -entry: - ret i4 9 -} - - -define external fastcc i4 @"card.rank.king<0>"() alwaysinline { -entry: - ret i4 11 +define external fastcc i4 @"card.rank.ace<0>"() { + ret i4 12 } - -define external fastcc void @"card.rank.print<0>"(i4 %"r##0") alwaysinline { -entry: - %0 = tail call fastcc i8 @"card.rank.char<0>"(i4 %"r##0") - tail call ccc void @putchar(i8 %0) - ret void -} - - -define external fastcc i4 @"card.rank.queen<0>"() alwaysinline { -entry: - ret i4 10 +define external fastcc i8 @"card.rank.char<0>"(i4 %"r##0") { + switch i4 %"r##0", label %case.12.switch.0 [ + i4 0, label %case.0.switch.0 + i4 1, label %case.1.switch.0 + i4 2, label %case.2.switch.0 + i4 3, label %case.3.switch.0 + i4 4, label %case.4.switch.0 + i4 5, label %case.5.switch.0 + i4 6, label %case.6.switch.0 + i4 7, label %case.7.switch.0 + i4 8, label %case.8.switch.0 + i4 9, label %case.9.switch.0 + i4 10, label %case.10.switch.0 + i4 11, label %case.11.switch.0 + i4 12, label %case.12.switch.0 ] +case.0.switch.0: + ret i8 50 +case.1.switch.0: + ret i8 51 +case.2.switch.0: + ret i8 52 +case.3.switch.0: + ret i8 53 +case.4.switch.0: + ret i8 54 +case.5.switch.0: + ret i8 55 +case.6.switch.0: + ret i8 56 +case.7.switch.0: + ret i8 57 +case.8.switch.0: + ret i8 84 +case.9.switch.0: + ret i8 74 +case.10.switch.0: + ret i8 81 +case.11.switch.0: + ret i8 75 +case.12.switch.0: + ret i8 65 +} + +define external fastcc i4 @"card.rank.jack<0>"() { + ret i4 9 +} + +define external fastcc i4 @"card.rank.king<0>"() { + ret i4 11 +} + +define external fastcc void @"card.rank.print<0>"(i4 %"r##0") { + %"tmp#0##0" = tail call fastcc i8 @"card.rank.char<0>"(i4 %"r##0") + call ccc void @putchar(i8 %"tmp#0##0") + ret void +} + +define external fastcc i4 @"card.rank.queen<0>"() { + ret i4 10 +} + +define external fastcc i4 @"card.rank.r10<0>"() { + ret i4 8 +} + +define external fastcc i4 @"card.rank.r2<0>"() { + ret i4 0 +} + +define external fastcc i4 @"card.rank.r3<0>"() { + ret i4 1 +} + +define external fastcc i4 @"card.rank.r4<0>"() { + ret i4 2 +} + +define external fastcc i4 @"card.rank.r5<0>"() { + ret i4 3 +} + +define external fastcc i4 @"card.rank.r6<0>"() { + ret i4 4 +} + +define external fastcc i4 @"card.rank.r7<0>"() { + ret i4 5 +} + +define external fastcc i4 @"card.rank.r8<0>"() { + ret i4 6 +} + +define external fastcc i4 @"card.rank.r9<0>"() { + ret i4 7 +} + +define external fastcc i64 @"card.rank.ranks<0>"() { + %"tmp#79##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#29##0" = ptrtoint ptr %"tmp#79##0" to i64 + %"tmp#80##0" = inttoptr i64 %"tmp#29##0" to ptr + store i64 12, ptr %"tmp#80##0" + %"tmp#81##0" = add i64 %"tmp#29##0", 8 + %"tmp#82##0" = inttoptr i64 %"tmp#81##0" to ptr + store i64 0, ptr %"tmp#82##0" + %"tmp#83##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#33##0" = ptrtoint ptr %"tmp#83##0" to i64 + %"tmp#84##0" = inttoptr i64 %"tmp#33##0" to ptr + store i64 11, ptr %"tmp#84##0" + %"tmp#85##0" = add i64 %"tmp#33##0", 8 + %"tmp#86##0" = inttoptr i64 %"tmp#85##0" to ptr + store i64 %"tmp#29##0", ptr %"tmp#86##0" + %"tmp#87##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#37##0" = ptrtoint ptr %"tmp#87##0" to i64 + %"tmp#88##0" = inttoptr i64 %"tmp#37##0" to ptr + store i64 10, ptr %"tmp#88##0" + %"tmp#89##0" = add i64 %"tmp#37##0", 8 + %"tmp#90##0" = inttoptr i64 %"tmp#89##0" to ptr + store i64 %"tmp#33##0", ptr %"tmp#90##0" + %"tmp#91##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#41##0" = ptrtoint ptr %"tmp#91##0" to i64 + %"tmp#92##0" = inttoptr i64 %"tmp#41##0" to ptr + store i64 9, ptr %"tmp#92##0" + %"tmp#93##0" = add i64 %"tmp#41##0", 8 + %"tmp#94##0" = inttoptr i64 %"tmp#93##0" to ptr + store i64 %"tmp#37##0", ptr %"tmp#94##0" + %"tmp#95##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#45##0" = ptrtoint ptr %"tmp#95##0" to i64 + %"tmp#96##0" = inttoptr i64 %"tmp#45##0" to ptr + store i64 8, ptr %"tmp#96##0" + %"tmp#97##0" = add i64 %"tmp#45##0", 8 + %"tmp#98##0" = inttoptr i64 %"tmp#97##0" to ptr + store i64 %"tmp#41##0", ptr %"tmp#98##0" + %"tmp#99##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#49##0" = ptrtoint ptr %"tmp#99##0" to i64 + %"tmp#100##0" = inttoptr i64 %"tmp#49##0" to ptr + store i64 7, ptr %"tmp#100##0" + %"tmp#101##0" = add i64 %"tmp#49##0", 8 + %"tmp#102##0" = inttoptr i64 %"tmp#101##0" to ptr + store i64 %"tmp#45##0", ptr %"tmp#102##0" + %"tmp#103##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#53##0" = ptrtoint ptr %"tmp#103##0" to i64 + %"tmp#104##0" = inttoptr i64 %"tmp#53##0" to ptr + store i64 6, ptr %"tmp#104##0" + %"tmp#105##0" = add i64 %"tmp#53##0", 8 + %"tmp#106##0" = inttoptr i64 %"tmp#105##0" to ptr + store i64 %"tmp#49##0", ptr %"tmp#106##0" + %"tmp#107##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#57##0" = ptrtoint ptr %"tmp#107##0" to i64 + %"tmp#108##0" = inttoptr i64 %"tmp#57##0" to ptr + store i64 5, ptr %"tmp#108##0" + %"tmp#109##0" = add i64 %"tmp#57##0", 8 + %"tmp#110##0" = inttoptr i64 %"tmp#109##0" to ptr + store i64 %"tmp#53##0", ptr %"tmp#110##0" + %"tmp#111##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#61##0" = ptrtoint ptr %"tmp#111##0" to i64 + %"tmp#112##0" = inttoptr i64 %"tmp#61##0" to ptr + store i64 4, ptr %"tmp#112##0" + %"tmp#113##0" = add i64 %"tmp#61##0", 8 + %"tmp#114##0" = inttoptr i64 %"tmp#113##0" to ptr + store i64 %"tmp#57##0", ptr %"tmp#114##0" + %"tmp#115##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#65##0" = ptrtoint ptr %"tmp#115##0" to i64 + %"tmp#116##0" = inttoptr i64 %"tmp#65##0" to ptr + store i64 3, ptr %"tmp#116##0" + %"tmp#117##0" = add i64 %"tmp#65##0", 8 + %"tmp#118##0" = inttoptr i64 %"tmp#117##0" to ptr + store i64 %"tmp#61##0", ptr %"tmp#118##0" + %"tmp#119##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#69##0" = ptrtoint ptr %"tmp#119##0" to i64 + %"tmp#120##0" = inttoptr i64 %"tmp#69##0" to ptr + store i64 2, ptr %"tmp#120##0" + %"tmp#121##0" = add i64 %"tmp#69##0", 8 + %"tmp#122##0" = inttoptr i64 %"tmp#121##0" to ptr + store i64 %"tmp#65##0", ptr %"tmp#122##0" + %"tmp#123##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#73##0" = ptrtoint ptr %"tmp#123##0" to i64 + %"tmp#124##0" = inttoptr i64 %"tmp#73##0" to ptr + store i64 1, ptr %"tmp#124##0" + %"tmp#125##0" = add i64 %"tmp#73##0", 8 + %"tmp#126##0" = inttoptr i64 %"tmp#125##0" to ptr + store i64 %"tmp#69##0", ptr %"tmp#126##0" + %"tmp#127##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#77##0" = ptrtoint ptr %"tmp#127##0" to i64 + %"tmp#128##0" = inttoptr i64 %"tmp#77##0" to ptr + store i64 0, ptr %"tmp#128##0" + %"tmp#129##0" = add i64 %"tmp#77##0", 8 + %"tmp#130##0" = inttoptr i64 %"tmp#129##0" to ptr + store i64 %"tmp#73##0", ptr %"tmp#130##0" + ret i64 %"tmp#77##0" +} + +define external fastcc i1 @"card.rank.~=<0>"(i4 %"#left##0", i4 %"#right##0") { + %"tmp#0##0" = icmp eq i4 %"#left##0", %"#right##0" + %"tmp#3##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#3##0" } - -define external fastcc i4 @"card.rank.r10<0>"() alwaysinline { -entry: - ret i4 8 -} - - -define external fastcc i4 @"card.rank.r2<0>"() alwaysinline { -entry: - ret i4 0 -} - - -define external fastcc i4 @"card.rank.r3<0>"() alwaysinline { -entry: - ret i4 1 -} - - -define external fastcc i4 @"card.rank.r4<0>"() alwaysinline { -entry: - ret i4 2 -} - - -define external fastcc i4 @"card.rank.r5<0>"() alwaysinline { -entry: - ret i4 3 -} - - -define external fastcc i4 @"card.rank.r6<0>"() alwaysinline { -entry: - ret i4 4 -} - - -define external fastcc i4 @"card.rank.r7<0>"() alwaysinline { -entry: - ret i4 5 -} - - -define external fastcc i4 @"card.rank.r8<0>"() alwaysinline { -entry: - ret i4 6 -} - - -define external fastcc i4 @"card.rank.r9<0>"() alwaysinline { -entry: - ret i4 7 -} - - -define external fastcc i64 @"card.rank.ranks<0>"() { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 12, i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 0, i64* %5 - %6 = trunc i64 16 to i32 - %7 = tail call ccc i8* @wybe_malloc(i32 %6) - %8 = ptrtoint i8* %7 to i64 - %9 = inttoptr i64 %8 to i64* - store i64 11, i64* %9 - %10 = add i64 %8, 8 - %11 = inttoptr i64 %10 to i64* - store i64 %2, i64* %11 - %12 = trunc i64 16 to i32 - %13 = tail call ccc i8* @wybe_malloc(i32 %12) - %14 = ptrtoint i8* %13 to i64 - %15 = inttoptr i64 %14 to i64* - store i64 10, i64* %15 - %16 = add i64 %14, 8 - %17 = inttoptr i64 %16 to i64* - store i64 %8, i64* %17 - %18 = trunc i64 16 to i32 - %19 = tail call ccc i8* @wybe_malloc(i32 %18) - %20 = ptrtoint i8* %19 to i64 - %21 = inttoptr i64 %20 to i64* - store i64 9, i64* %21 - %22 = add i64 %20, 8 - %23 = inttoptr i64 %22 to i64* - store i64 %14, i64* %23 - %24 = trunc i64 16 to i32 - %25 = tail call ccc i8* @wybe_malloc(i32 %24) - %26 = ptrtoint i8* %25 to i64 - %27 = inttoptr i64 %26 to i64* - store i64 8, i64* %27 - %28 = add i64 %26, 8 - %29 = inttoptr i64 %28 to i64* - store i64 %20, i64* %29 - %30 = trunc i64 16 to i32 - %31 = tail call ccc i8* @wybe_malloc(i32 %30) - %32 = ptrtoint i8* %31 to i64 - %33 = inttoptr i64 %32 to i64* - store i64 7, i64* %33 - %34 = add i64 %32, 8 - %35 = inttoptr i64 %34 to i64* - store i64 %26, i64* %35 - %36 = trunc i64 16 to i32 - %37 = tail call ccc i8* @wybe_malloc(i32 %36) - %38 = ptrtoint i8* %37 to i64 - %39 = inttoptr i64 %38 to i64* - store i64 6, i64* %39 - %40 = add i64 %38, 8 - %41 = inttoptr i64 %40 to i64* - store i64 %32, i64* %41 - %42 = trunc i64 16 to i32 - %43 = tail call ccc i8* @wybe_malloc(i32 %42) - %44 = ptrtoint i8* %43 to i64 - %45 = inttoptr i64 %44 to i64* - store i64 5, i64* %45 - %46 = add i64 %44, 8 - %47 = inttoptr i64 %46 to i64* - store i64 %38, i64* %47 - %48 = trunc i64 16 to i32 - %49 = tail call ccc i8* @wybe_malloc(i32 %48) - %50 = ptrtoint i8* %49 to i64 - %51 = inttoptr i64 %50 to i64* - store i64 4, i64* %51 - %52 = add i64 %50, 8 - %53 = inttoptr i64 %52 to i64* - store i64 %44, i64* %53 - %54 = trunc i64 16 to i32 - %55 = tail call ccc i8* @wybe_malloc(i32 %54) - %56 = ptrtoint i8* %55 to i64 - %57 = inttoptr i64 %56 to i64* - store i64 3, i64* %57 - %58 = add i64 %56, 8 - %59 = inttoptr i64 %58 to i64* - store i64 %50, i64* %59 - %60 = trunc i64 16 to i32 - %61 = tail call ccc i8* @wybe_malloc(i32 %60) - %62 = ptrtoint i8* %61 to i64 - %63 = inttoptr i64 %62 to i64* - store i64 2, i64* %63 - %64 = add i64 %62, 8 - %65 = inttoptr i64 %64 to i64* - store i64 %56, i64* %65 - %66 = trunc i64 16 to i32 - %67 = tail call ccc i8* @wybe_malloc(i32 %66) - %68 = ptrtoint i8* %67 to i64 - %69 = inttoptr i64 %68 to i64* - store i64 1, i64* %69 - %70 = add i64 %68, 8 - %71 = inttoptr i64 %70 to i64* - store i64 %62, i64* %71 - %72 = trunc i64 16 to i32 - %73 = tail call ccc i8* @wybe_malloc(i32 %72) - %74 = ptrtoint i8* %73 to i64 - %75 = inttoptr i64 %74 to i64* - store i64 0, i64* %75 - %76 = add i64 %74, 8 - %77 = inttoptr i64 %76 to i64* - store i64 %68, i64* %77 - ret i64 %74 -} - - -define external fastcc i1 @"card.rank.~=<0>"(i4 %"#left##0", i4 %"#right##0") alwaysinline { -entry: - %0 = icmp eq i4 %"#left##0", %"#right##0" - %1 = xor i1 %0, 1 - ret i1 %1 -} -------------------------------------------------- Module card.suit representation : 2 bit unsigned @@ -962,115 +906,94 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'card.suit' - - - - -declare external ccc void @putchar(i8) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i1 @"card.suit.=<0>"(i2 %"#left##0", i2 %"#right##0") alwaysinline { -entry: - %0 = icmp eq i2 %"#left##0", %"#right##0" - ret i1 %0 -} - - -define external fastcc i8 @"card.suit.char<0>"(i2 %"s##0") { -entry: - switch i2 %"s##0", label %switch.4.3 [i2 0, label %switch.4.0 i2 1, label %switch.4.1 i2 2, label %switch.4.2 i2 3, label %switch.4.3] -switch.4.0: - ret i8 67 -switch.4.1: - ret i8 68 -switch.4.2: - ret i8 72 -switch.4.3: - ret i8 83 -} - - -define external fastcc i2 @"card.suit.clubs<0>"() alwaysinline { -entry: - ret i2 0 -} - - -define external fastcc i2 @"card.suit.diamonds<0>"() alwaysinline { -entry: - ret i2 1 -} - - -define external fastcc i2 @"card.suit.hearts<0>"() alwaysinline { -entry: - ret i2 2 -} - - -define external fastcc void @"card.suit.print<0>"(i2 %"r##0") alwaysinline { -entry: - %0 = tail call fastcc i8 @"card.suit.char<0>"(i2 %"r##0") - tail call ccc void @putchar(i8 %0) - ret void -} - - -define external fastcc i2 @"card.suit.spades<0>"() alwaysinline { -entry: - ret i2 3 -} - - -define external fastcc i64 @"card.suit.suits<0>"() { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 3, i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 0, i64* %5 - %6 = trunc i64 16 to i32 - %7 = tail call ccc i8* @wybe_malloc(i32 %6) - %8 = ptrtoint i8* %7 to i64 - %9 = inttoptr i64 %8 to i64* - store i64 2, i64* %9 - %10 = add i64 %8, 8 - %11 = inttoptr i64 %10 to i64* - store i64 %2, i64* %11 - %12 = trunc i64 16 to i32 - %13 = tail call ccc i8* @wybe_malloc(i32 %12) - %14 = ptrtoint i8* %13 to i64 - %15 = inttoptr i64 %14 to i64* - store i64 1, i64* %15 - %16 = add i64 %14, 8 - %17 = inttoptr i64 %16 to i64* - store i64 %8, i64* %17 - %18 = trunc i64 16 to i32 - %19 = tail call ccc i8* @wybe_malloc(i32 %18) - %20 = ptrtoint i8* %19 to i64 - %21 = inttoptr i64 %20 to i64* - store i64 0, i64* %21 - %22 = add i64 %20, 8 - %23 = inttoptr i64 %22 to i64* - store i64 %14, i64* %23 - ret i64 %20 -} - - -define external fastcc i1 @"card.suit.~=<0>"(i2 %"#left##0", i2 %"#right##0") alwaysinline { -entry: - %0 = icmp eq i2 %"#left##0", %"#right##0" - %1 = xor i1 %0, 1 - ret i1 %1 +source_filename = "!ROOT!/final-dump/card.wybe" +target triple ???? + + +declare external ccc void @putchar(i8) +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc i1 @"card.suit.=<0>"(i2 %"#left##0", i2 %"#right##0") { + %"tmp#1##0" = icmp eq i2 %"#left##0", %"#right##0" + ret i1 %"tmp#1##0" +} + +define external fastcc i8 @"card.suit.char<0>"(i2 %"s##0") { + switch i2 %"s##0", label %case.3.switch.0 [ + i2 0, label %case.0.switch.0 + i2 1, label %case.1.switch.0 + i2 2, label %case.2.switch.0 + i2 3, label %case.3.switch.0 ] +case.0.switch.0: + ret i8 67 +case.1.switch.0: + ret i8 68 +case.2.switch.0: + ret i8 72 +case.3.switch.0: + ret i8 83 +} + +define external fastcc i2 @"card.suit.clubs<0>"() { + ret i2 0 +} + +define external fastcc i2 @"card.suit.diamonds<0>"() { + ret i2 1 +} + +define external fastcc i2 @"card.suit.hearts<0>"() { + ret i2 2 +} + +define external fastcc void @"card.suit.print<0>"(i2 %"r##0") { + %"tmp#0##0" = tail call fastcc i8 @"card.suit.char<0>"(i2 %"r##0") + call ccc void @putchar(i8 %"tmp#0##0") + ret void +} + +define external fastcc i2 @"card.suit.spades<0>"() { + ret i2 3 +} + +define external fastcc i64 @"card.suit.suits<0>"() { + %"tmp#25##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#11##0" = ptrtoint ptr %"tmp#25##0" to i64 + %"tmp#26##0" = inttoptr i64 %"tmp#11##0" to ptr + store i64 3, ptr %"tmp#26##0" + %"tmp#27##0" = add i64 %"tmp#11##0", 8 + %"tmp#28##0" = inttoptr i64 %"tmp#27##0" to ptr + store i64 0, ptr %"tmp#28##0" + %"tmp#29##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#15##0" = ptrtoint ptr %"tmp#29##0" to i64 + %"tmp#30##0" = inttoptr i64 %"tmp#15##0" to ptr + store i64 2, ptr %"tmp#30##0" + %"tmp#31##0" = add i64 %"tmp#15##0", 8 + %"tmp#32##0" = inttoptr i64 %"tmp#31##0" to ptr + store i64 %"tmp#11##0", ptr %"tmp#32##0" + %"tmp#33##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#19##0" = ptrtoint ptr %"tmp#33##0" to i64 + %"tmp#34##0" = inttoptr i64 %"tmp#19##0" to ptr + store i64 1, ptr %"tmp#34##0" + %"tmp#35##0" = add i64 %"tmp#19##0", 8 + %"tmp#36##0" = inttoptr i64 %"tmp#35##0" to ptr + store i64 %"tmp#15##0", ptr %"tmp#36##0" + %"tmp#37##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#23##0" = ptrtoint ptr %"tmp#37##0" to i64 + %"tmp#38##0" = inttoptr i64 %"tmp#23##0" to ptr + store i64 0, ptr %"tmp#38##0" + %"tmp#39##0" = add i64 %"tmp#23##0", 8 + %"tmp#40##0" = inttoptr i64 %"tmp#39##0" to ptr + store i64 %"tmp#19##0", ptr %"tmp#40##0" + ret i64 %"tmp#23##0" +} + +define external fastcc i1 @"card.suit.~=<0>"(i2 %"#left##0", i2 %"#right##0") { + %"tmp#0##0" = icmp eq i2 %"#left##0", %"#right##0" + %"tmp#3##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#3##0" } diff --git a/test-cases/final-dump/caret.exp b/test-cases/final-dump/caret.exp index aed84c626..76498ddd9 100644 --- a/test-cases/final-dump/caret.exp +++ b/test-cases/final-dump/caret.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module caret representation : (not a type) public submods : @@ -38,7 +41,7 @@ module top-level code > public {semipure} (0 calls) proc #cont#1 > {semipure} (2 calls) -0: caret.#cont#1<0>[410bae77d3] +0: caret.#cont#1<0> #cont#1(reg##0:caret.region)<{<>}; {<>}; {}>: AliasPairs: [] InterestingCallProperties: [InterestingUnaliased 0] @@ -93,233 +96,177 @@ expand_region(reg##0:caret.region, ?reg##4:caret.region, point##0:position.posit LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'caret' - - - - -@caret.1 = constant {i64, i64} { i64 6, i64 ptrtoint ([?? x i8]* @caret.0 to i64) } - - -@caret.3 = constant {i64, i64} { i64 10, i64 ptrtoint ([?? x i8]* @caret.2 to i64) } - - -@caret.2 = constant [?? x i8] c"now ten = \00" - - -@caret.0 = constant [?? x i8] c"ten = \00" - - -declare external fastcc i64 @"wybe.int.max<0>"(i64, i64) - - -declare external fastcc i64 @"wybe.int.min<0>"(i64, i64) - - -declare external ccc void @putchar(i8) - - -declare external ccc void @print_int(i64) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"caret.<0>"() { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 0, i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 1, i64* %5 - %6 = trunc i64 16 to i32 - %7 = tail call ccc i8* @wybe_malloc(i32 %6) - %8 = ptrtoint i8* %7 to i64 - %9 = inttoptr i64 %8 to i64* - store i64 10, i64* %9 - %10 = add i64 %8, 8 - %11 = inttoptr i64 %10 to i64* - store i64 12, i64* %11 - %12 = trunc i64 16 to i32 - %13 = tail call ccc i8* @wybe_malloc(i32 %12) - %14 = ptrtoint i8* %13 to i64 - %15 = inttoptr i64 %14 to i64* - store i64 %2, i64* %15 - %16 = add i64 %14, 8 - %17 = inttoptr i64 %16 to i64* - store i64 %8, i64* %17 - %18 = inttoptr i64 %8 to i64* - %19 = load i64, i64* %18 - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @caret.1, i32 0, i32 0) to i64)) - tail call ccc void @print_int(i64 %19) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"caret.#cont#1<0>[410bae77d3]"(i64 %14) - ret void +source_filename = "!ROOT!/final-dump/caret.wybe" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c"now ten = \00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c"ten = \00", align 8 +@"string#2" = private unnamed_addr constant {i64, i64} { i64 10, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +@"string#3" = private unnamed_addr constant {i64, i64} { i64 6, i64 ptrtoint( ptr @"cstring#1" to i64 ) }, align 8 + +declare external fastcc i64 @"wybe.int.max<0>"(i64, i64) +declare external fastcc i64 @"wybe.int.min<0>"(i64, i64) +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"caret.<0>"() { + %"tmp#34##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#15##0" = ptrtoint ptr %"tmp#34##0" to i64 + %"tmp#35##0" = inttoptr i64 %"tmp#15##0" to ptr + store i64 0, ptr %"tmp#35##0" + %"tmp#36##0" = add i64 %"tmp#15##0", 8 + %"tmp#37##0" = inttoptr i64 %"tmp#36##0" to ptr + store i64 1, ptr %"tmp#37##0" + %"tmp#38##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#19##0" = ptrtoint ptr %"tmp#38##0" to i64 + %"tmp#39##0" = inttoptr i64 %"tmp#19##0" to ptr + store i64 10, ptr %"tmp#39##0" + %"tmp#40##0" = add i64 %"tmp#19##0", 8 + %"tmp#41##0" = inttoptr i64 %"tmp#40##0" to ptr + store i64 12, ptr %"tmp#41##0" + %"tmp#42##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#23##0" = ptrtoint ptr %"tmp#42##0" to i64 + %"tmp#43##0" = inttoptr i64 %"tmp#23##0" to ptr + store i64 %"tmp#15##0", ptr %"tmp#43##0" + %"tmp#44##0" = add i64 %"tmp#23##0", 8 + %"tmp#45##0" = inttoptr i64 %"tmp#44##0" to ptr + store i64 %"tmp#19##0", ptr %"tmp#45##0" + %"tmp#46##0" = inttoptr i64 %"tmp#19##0" to ptr + %"ten##0" = load i64, ptr %"tmp#46##0" + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#3" to i64 )) + call ccc void @print_int(i64 %"ten##0") + call ccc void @putchar(i8 10) + tail call fastcc void @"caret.#cont#1<0>[410bae77d3]"(i64 %"tmp#23##0") + ret void } - -define external fastcc void @"caret.#cont#1<0>"(i64 %"reg##0") { -entry: - %0 = add i64 %"reg##0", 8 - %1 = inttoptr i64 %0 to i64* - %2 = load i64, i64* %1 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = add i64 %4, 1 - %6 = trunc i64 16 to i32 - %7 = tail call ccc i8* @wybe_malloc(i32 %6) - %8 = ptrtoint i8* %7 to i64 - %9 = inttoptr i64 %8 to i8* - %10 = inttoptr i64 %2 to i8* - %11 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %9, i8* %10, i32 %11, i1 0) - %12 = inttoptr i64 %8 to i64* - store i64 %5, i64* %12 - %13 = inttoptr i64 %8 to i64* - %14 = load i64, i64* %13 - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @caret.3, i32 0, i32 0) to i64)) - tail call ccc void @print_int(i64 %14) - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"caret.#cont#1<0>"(i64 %"reg##0") { + %"tmp#25##0" = add i64 %"reg##0", 8 + %"tmp#26##0" = inttoptr i64 %"tmp#25##0" to ptr + %"tmp#6##0" = load i64, ptr %"tmp#26##0" + %"tmp#27##0" = inttoptr i64 %"tmp#6##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#27##0" + %"tmp#5##1" = add i64 %"tmp#5##0", 1 + %"tmp#28##0" = inttoptr i64 %"tmp#6##0" to ptr + %"tmp#29##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#29##0", ptr %"tmp#28##0", i64 16, i1 0) + %"tmp#30##0" = ptrtoint ptr %"tmp#29##0" to i64 + %"tmp#31##0" = inttoptr i64 %"tmp#30##0" to ptr + store i64 %"tmp#5##1", ptr %"tmp#31##0" + %"tmp#32##0" = inttoptr i64 %"tmp#30##0" to ptr + %"ten##0" = load i64, ptr %"tmp#32##0" + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#2" to i64 )) + call ccc void @print_int(i64 %"ten##0") + call ccc void @putchar(i8 10) + ret void } - -define external fastcc void @"caret.#cont#1<0>[410bae77d3]"(i64 %"reg##0") { -entry: - %0 = add i64 %"reg##0", 8 - %1 = inttoptr i64 %0 to i64* - %2 = load i64, i64* %1 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = add i64 %4, 1 - %6 = inttoptr i64 %2 to i64* - store i64 %5, i64* %6 - %7 = inttoptr i64 %2 to i64* - %8 = load i64, i64* %7 - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @caret.3, i32 0, i32 0) to i64)) - tail call ccc void @print_int(i64 %8) - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"caret.#cont#1<0>[410bae77d3]"(i64 %"reg##0") { + %"tmp#25##0" = add i64 %"reg##0", 8 + %"tmp#26##0" = inttoptr i64 %"tmp#25##0" to ptr + %"tmp#6##0" = load i64, ptr %"tmp#26##0" + %"tmp#27##0" = inttoptr i64 %"tmp#6##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#27##0" + %"tmp#5##1" = add i64 %"tmp#5##0", 1 + %"tmp#28##0" = inttoptr i64 %"tmp#6##0" to ptr + store i64 %"tmp#5##1", ptr %"tmp#28##0" + %"tmp#29##0" = inttoptr i64 %"tmp#6##0" to ptr + %"ten##0" = load i64, ptr %"tmp#29##0" + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#2" to i64 )) + call ccc void @print_int(i64 %"ten##0") + call ccc void @putchar(i8 10) + ret void } - -define external fastcc i64 @"caret.expand_region<0>"(i64 %"reg##0", i64 %"point##0") { -entry: - %0 = inttoptr i64 %"reg##0" to i64* - %1 = load i64, i64* %0 - %2 = inttoptr i64 %1 to i64* - %3 = load i64, i64* %2 - %4 = inttoptr i64 %"point##0" to i64* - %5 = load i64, i64* %4 - %6 = tail call fastcc i64 @"wybe.int.min<0>"(i64 %3, i64 %5) - %7 = trunc i64 16 to i32 - %8 = tail call ccc i8* @wybe_malloc(i32 %7) - %9 = ptrtoint i8* %8 to i64 - %10 = inttoptr i64 %9 to i8* - %11 = inttoptr i64 %1 to i8* - %12 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %10, i8* %11, i32 %12, i1 0) - %13 = inttoptr i64 %9 to i64* - store i64 %6, i64* %13 - %14 = trunc i64 16 to i32 - %15 = tail call ccc i8* @wybe_malloc(i32 %14) - %16 = ptrtoint i8* %15 to i64 - %17 = inttoptr i64 %16 to i8* - %18 = inttoptr i64 %"reg##0" to i8* - %19 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %17, i8* %18, i32 %19, i1 0) - %20 = inttoptr i64 %16 to i64* - store i64 %9, i64* %20 - %21 = add i64 %9, 8 - %22 = inttoptr i64 %21 to i64* - %23 = load i64, i64* %22 - %24 = add i64 %"point##0", 8 - %25 = inttoptr i64 %24 to i64* - %26 = load i64, i64* %25 - %27 = tail call fastcc i64 @"wybe.int.min<0>"(i64 %23, i64 %26) - %28 = trunc i64 16 to i32 - %29 = tail call ccc i8* @wybe_malloc(i32 %28) - %30 = ptrtoint i8* %29 to i64 - %31 = inttoptr i64 %30 to i8* - %32 = inttoptr i64 %9 to i8* - %33 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %31, i8* %32, i32 %33, i1 0) - %34 = add i64 %30, 8 - %35 = inttoptr i64 %34 to i64* - store i64 %27, i64* %35 - %36 = trunc i64 16 to i32 - %37 = tail call ccc i8* @wybe_malloc(i32 %36) - %38 = ptrtoint i8* %37 to i64 - %39 = inttoptr i64 %38 to i8* - %40 = inttoptr i64 %16 to i8* - %41 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %39, i8* %40, i32 %41, i1 0) - %42 = inttoptr i64 %38 to i64* - store i64 %30, i64* %42 - %43 = add i64 %38, 8 - %44 = inttoptr i64 %43 to i64* - %45 = load i64, i64* %44 - %46 = inttoptr i64 %45 to i64* - %47 = load i64, i64* %46 - %48 = tail call fastcc i64 @"wybe.int.max<0>"(i64 %47, i64 %5) - %49 = trunc i64 16 to i32 - %50 = tail call ccc i8* @wybe_malloc(i32 %49) - %51 = ptrtoint i8* %50 to i64 - %52 = inttoptr i64 %51 to i8* - %53 = inttoptr i64 %45 to i8* - %54 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %52, i8* %53, i32 %54, i1 0) - %55 = inttoptr i64 %51 to i64* - store i64 %48, i64* %55 - %56 = trunc i64 16 to i32 - %57 = tail call ccc i8* @wybe_malloc(i32 %56) - %58 = ptrtoint i8* %57 to i64 - %59 = inttoptr i64 %58 to i8* - %60 = inttoptr i64 %38 to i8* - %61 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %59, i8* %60, i32 %61, i1 0) - %62 = add i64 %58, 8 - %63 = inttoptr i64 %62 to i64* - store i64 %51, i64* %63 - %64 = add i64 %51, 8 - %65 = inttoptr i64 %64 to i64* - %66 = load i64, i64* %65 - %67 = tail call fastcc i64 @"wybe.int.max<0>"(i64 %66, i64 %26) - %68 = trunc i64 16 to i32 - %69 = tail call ccc i8* @wybe_malloc(i32 %68) - %70 = ptrtoint i8* %69 to i64 - %71 = inttoptr i64 %70 to i8* - %72 = inttoptr i64 %51 to i8* - %73 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %71, i8* %72, i32 %73, i1 0) - %74 = add i64 %70, 8 - %75 = inttoptr i64 %74 to i64* - store i64 %67, i64* %75 - %76 = trunc i64 16 to i32 - %77 = tail call ccc i8* @wybe_malloc(i32 %76) - %78 = ptrtoint i8* %77 to i64 - %79 = inttoptr i64 %78 to i8* - %80 = inttoptr i64 %58 to i8* - %81 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %79, i8* %80, i32 %81, i1 0) - %82 = add i64 %78, 8 - %83 = inttoptr i64 %82 to i64* - store i64 %70, i64* %83 - ret i64 %78 +define external fastcc i64 @"caret.expand_region<0>"(i64 %"reg##0", i64 %"point##0") { + %"tmp#52##0" = inttoptr i64 %"reg##0" to ptr + %"tmp#0##0" = load i64, ptr %"tmp#52##0" + %"tmp#53##0" = inttoptr i64 %"tmp#0##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#53##0" + %"tmp#54##0" = inttoptr i64 %"point##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#54##0" + %"tmp#1##0" = tail call fastcc i64 @"wybe.int.min<0>"(i64 %"tmp#2##0", i64 %"tmp#4##0") + %"tmp#55##0" = inttoptr i64 %"tmp#0##0" to ptr + %"tmp#56##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#56##0", ptr %"tmp#55##0", i64 16, i1 0) + %"tmp#57##0" = ptrtoint ptr %"tmp#56##0" to i64 + %"tmp#58##0" = inttoptr i64 %"tmp#57##0" to ptr + store i64 %"tmp#1##0", ptr %"tmp#58##0" + %"tmp#59##0" = inttoptr i64 %"reg##0" to ptr + %"tmp#60##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#60##0", ptr %"tmp#59##0", i64 16, i1 0) + %"tmp#61##0" = ptrtoint ptr %"tmp#60##0" to i64 + %"tmp#62##0" = inttoptr i64 %"tmp#61##0" to ptr + store i64 %"tmp#57##0", ptr %"tmp#62##0" + %"tmp#63##0" = add i64 %"tmp#57##0", 8 + %"tmp#64##0" = inttoptr i64 %"tmp#63##0" to ptr + %"tmp#7##0" = load i64, ptr %"tmp#64##0" + %"tmp#65##0" = add i64 %"point##0", 8 + %"tmp#66##0" = inttoptr i64 %"tmp#65##0" to ptr + %"tmp#9##0" = load i64, ptr %"tmp#66##0" + %"tmp#6##0" = tail call fastcc i64 @"wybe.int.min<0>"(i64 %"tmp#7##0", i64 %"tmp#9##0") + %"tmp#67##0" = inttoptr i64 %"tmp#57##0" to ptr + %"tmp#68##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#68##0", ptr %"tmp#67##0", i64 16, i1 0) + %"tmp#69##0" = ptrtoint ptr %"tmp#68##0" to i64 + %"tmp#70##0" = add i64 %"tmp#69##0", 8 + %"tmp#71##0" = inttoptr i64 %"tmp#70##0" to ptr + store i64 %"tmp#6##0", ptr %"tmp#71##0" + %"tmp#72##0" = inttoptr i64 %"tmp#61##0" to ptr + %"tmp#73##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#73##0", ptr %"tmp#72##0", i64 16, i1 0) + %"tmp#74##0" = ptrtoint ptr %"tmp#73##0" to i64 + %"tmp#75##0" = inttoptr i64 %"tmp#74##0" to ptr + store i64 %"tmp#69##0", ptr %"tmp#75##0" + %"tmp#76##0" = add i64 %"tmp#74##0", 8 + %"tmp#77##0" = inttoptr i64 %"tmp#76##0" to ptr + %"tmp#10##0" = load i64, ptr %"tmp#77##0" + %"tmp#78##0" = inttoptr i64 %"tmp#10##0" to ptr + %"tmp#12##0" = load i64, ptr %"tmp#78##0" + %"tmp#11##0" = tail call fastcc i64 @"wybe.int.max<0>"(i64 %"tmp#12##0", i64 %"tmp#4##0") + %"tmp#79##0" = inttoptr i64 %"tmp#10##0" to ptr + %"tmp#80##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#80##0", ptr %"tmp#79##0", i64 16, i1 0) + %"tmp#81##0" = ptrtoint ptr %"tmp#80##0" to i64 + %"tmp#82##0" = inttoptr i64 %"tmp#81##0" to ptr + store i64 %"tmp#11##0", ptr %"tmp#82##0" + %"tmp#83##0" = inttoptr i64 %"tmp#74##0" to ptr + %"tmp#84##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#84##0", ptr %"tmp#83##0", i64 16, i1 0) + %"tmp#85##0" = ptrtoint ptr %"tmp#84##0" to i64 + %"tmp#86##0" = add i64 %"tmp#85##0", 8 + %"tmp#87##0" = inttoptr i64 %"tmp#86##0" to ptr + store i64 %"tmp#81##0", ptr %"tmp#87##0" + %"tmp#88##0" = add i64 %"tmp#81##0", 8 + %"tmp#89##0" = inttoptr i64 %"tmp#88##0" to ptr + %"tmp#17##0" = load i64, ptr %"tmp#89##0" + %"tmp#16##0" = tail call fastcc i64 @"wybe.int.max<0>"(i64 %"tmp#17##0", i64 %"tmp#9##0") + %"tmp#90##0" = inttoptr i64 %"tmp#81##0" to ptr + %"tmp#91##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#91##0", ptr %"tmp#90##0", i64 16, i1 0) + %"tmp#92##0" = ptrtoint ptr %"tmp#91##0" to i64 + %"tmp#93##0" = add i64 %"tmp#92##0", 8 + %"tmp#94##0" = inttoptr i64 %"tmp#93##0" to ptr + store i64 %"tmp#16##0", ptr %"tmp#94##0" + %"tmp#95##0" = inttoptr i64 %"tmp#85##0" to ptr + %"tmp#96##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#96##0", ptr %"tmp#95##0", i64 16, i1 0) + %"tmp#97##0" = ptrtoint ptr %"tmp#96##0" to i64 + %"tmp#98##0" = add i64 %"tmp#97##0", 8 + %"tmp#99##0" = inttoptr i64 %"tmp#98##0" to ptr + store i64 %"tmp#92##0", ptr %"tmp#99##0" + ret i64 %"tmp#97##0" } + -------------------------------------------------- Module caret.region - representation : address + representation : pointer public submods : public resources: public procs : caret.region.=<0> @@ -467,199 +414,176 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'caret.region' - - - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i1 @"caret.region.=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %"#right##0" to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = inttoptr i64 %1 to i64* - %11 = load i64, i64* %10 - %12 = add i64 %1, 8 - %13 = inttoptr i64 %12 to i64* - %14 = load i64, i64* %13 - %15 = inttoptr i64 %6 to i64* - %16 = load i64, i64* %15 - %17 = add i64 %6, 8 - %18 = inttoptr i64 %17 to i64* - %19 = load i64, i64* %18 - %20 = icmp eq i64 %11, %16 - br i1 %20, label %if.then, label %if.else -if.then: - %21 = icmp eq i64 %19, %14 - br i1 %21, label %if.then1, label %if.else1 -if.else: - ret i1 0 -if.then1: - %22 = inttoptr i64 %4 to i64* - %23 = load i64, i64* %22 - %24 = add i64 %4, 8 - %25 = inttoptr i64 %24 to i64* - %26 = load i64, i64* %25 - %27 = inttoptr i64 %9 to i64* - %28 = load i64, i64* %27 - %29 = add i64 %9, 8 - %30 = inttoptr i64 %29 to i64* - %31 = load i64, i64* %30 - %32 = icmp eq i64 %23, %28 - br i1 %32, label %if.then2, label %if.else2 -if.else1: - ret i1 0 -if.then2: - %33 = icmp eq i64 %26, %31 - ret i1 %33 -if.else2: - ret i1 0 +source_filename = "!ROOT!/final-dump/caret.wybe" +target triple ???? + + +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc i1 @"caret.region.=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#19##0" = inttoptr i64 %"#left##0" to ptr + %"#left#lower_left##0" = load i64, ptr %"tmp#19##0" + %"tmp#20##0" = add i64 %"#left##0", 8 + %"tmp#21##0" = inttoptr i64 %"tmp#20##0" to ptr + %"#left#upper_right##0" = load i64, ptr %"tmp#21##0" + %"tmp#22##0" = inttoptr i64 %"#right##0" to ptr + %"#right#lower_left##0" = load i64, ptr %"tmp#22##0" + %"tmp#23##0" = add i64 %"#right##0", 8 + %"tmp#24##0" = inttoptr i64 %"tmp#23##0" to ptr + %"#right#upper_right##0" = load i64, ptr %"tmp#24##0" + %"tmp#25##0" = inttoptr i64 %"#left#lower_left##0" to ptr + %"tmp#7##0" = load i64, ptr %"tmp#25##0" + %"tmp#26##0" = add i64 %"#left#lower_left##0", 8 + %"tmp#27##0" = inttoptr i64 %"tmp#26##0" to ptr + %"tmp#8##0" = load i64, ptr %"tmp#27##0" + %"tmp#28##0" = inttoptr i64 %"#right#lower_left##0" to ptr + %"tmp#9##0" = load i64, ptr %"tmp#28##0" + %"tmp#29##0" = add i64 %"#right#lower_left##0", 8 + %"tmp#30##0" = inttoptr i64 %"tmp#29##0" to ptr + %"tmp#10##0" = load i64, ptr %"tmp#30##0" + %"tmp#11##0" = icmp eq i64 %"tmp#7##0", %"tmp#9##0" + br i1 %"tmp#11##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = icmp eq i64 %"tmp#10##0", %"tmp#8##0" + br i1 %"tmp#1##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#31##0" = inttoptr i64 %"#left#upper_right##0" to ptr + %"tmp#14##0" = load i64, ptr %"tmp#31##0" + %"tmp#32##0" = add i64 %"#left#upper_right##0", 8 + %"tmp#33##0" = inttoptr i64 %"tmp#32##0" to ptr + %"tmp#15##0" = load i64, ptr %"tmp#33##0" + %"tmp#34##0" = inttoptr i64 %"#right#upper_right##0" to ptr + %"tmp#16##0" = load i64, ptr %"tmp#34##0" + %"tmp#35##0" = add i64 %"#right#upper_right##0", 8 + %"tmp#36##0" = inttoptr i64 %"tmp#35##0" to ptr + %"tmp#17##0" = load i64, ptr %"tmp#36##0" + %"tmp#18##0" = icmp eq i64 %"tmp#14##0", %"tmp#16##0" + br i1 %"tmp#18##0", label %if.then.2, label %if.else.2 +if.then.2: + %"tmp#37##0" = icmp eq i64 %"tmp#15##0", %"tmp#17##0" + ret i1 %"tmp#37##0" +if.else.2: + ret i1 0 +if.else.1: + ret i1 0 +if.else.0: + ret i1 0 } - -define external fastcc i64 @"caret.region.lower_left<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#rec##0" to i64* - %1 = load i64, i64* %0 - ret i64 %1 +define external fastcc i64 @"caret.region.lower_left<0>"(i64 %"#rec##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + ret i64 %"tmp#1##0" } - -define external fastcc i64 @"caret.region.lower_left<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = inttoptr i64 %2 to i64* - store i64 %"#field##0", i64* %6 - ret i64 %2 +define external fastcc i64 @"caret.region.lower_left<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"#field##0", ptr %"tmp#3##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"caret.region.region<0>"(i64 %"lower_left##0", i64 %"upper_right##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"lower_left##0", i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"upper_right##0", i64* %5 - ret i64 %2 +define external fastcc i64 @"caret.region.region<0>"(i64 %"lower_left##0", i64 %"upper_right##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 16) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"lower_left##0", ptr %"tmp#1##0" + %"tmp#2##0" = add i64 %"#rec##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"upper_right##0", ptr %"tmp#3##0" + ret i64 %"#rec##0" } - -define external fastcc {i64, i64} @"caret.region.region<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#result##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#result##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = insertvalue {i64, i64} undef, i64 %1, 0 - %6 = insertvalue {i64, i64} %5, i64 %4, 1 - ret {i64, i64} %6 +define external fastcc {i64, i64} @"caret.region.region<1>"(i64 %"#result##0") { + %"tmp#0##0" = inttoptr i64 %"#result##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + %"tmp#2##0" = add i64 %"#result##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#3##0" + %"tmp#5##0" = insertvalue {i64, i64} undef, i64 %"tmp#1##0", 0 + %"tmp#6##0" = insertvalue {i64, i64} %"tmp#5##0", i64 %"tmp#4##0", 1 + ret {i64, i64} %"tmp#6##0" } - -define external fastcc i64 @"caret.region.upper_right<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = add i64 %"#rec##0", 8 - %1 = inttoptr i64 %0 to i64* - %2 = load i64, i64* %1 - ret i64 %2 +define external fastcc i64 @"caret.region.upper_right<0>"(i64 %"#rec##0") { + %"tmp#0##0" = add i64 %"#rec##0", 8 + %"tmp#1##0" = inttoptr i64 %"tmp#0##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"caret.region.upper_right<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = add i64 %2, 8 - %7 = inttoptr i64 %6 to i64* - store i64 %"#field##0", i64* %7 - ret i64 %2 +define external fastcc i64 @"caret.region.upper_right<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = add i64 %"tmp#2##0", 8 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 %"#field##0", ptr %"tmp#4##0" + ret i64 %"tmp#2##0" } - -define external fastcc i1 @"caret.region.~=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %"#right##0" to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = inttoptr i64 %1 to i64* - %11 = load i64, i64* %10 - %12 = add i64 %1, 8 - %13 = inttoptr i64 %12 to i64* - %14 = load i64, i64* %13 - %15 = inttoptr i64 %6 to i64* - %16 = load i64, i64* %15 - %17 = add i64 %6, 8 - %18 = inttoptr i64 %17 to i64* - %19 = load i64, i64* %18 - %20 = icmp eq i64 %11, %16 - br i1 %20, label %if.then, label %if.else -if.then: - %21 = icmp eq i64 %19, %14 - br i1 %21, label %if.then1, label %if.else1 -if.else: - %37 = xor i1 0, 1 - ret i1 %37 -if.then1: - %22 = inttoptr i64 %4 to i64* - %23 = load i64, i64* %22 - %24 = add i64 %4, 8 - %25 = inttoptr i64 %24 to i64* - %26 = load i64, i64* %25 - %27 = inttoptr i64 %9 to i64* - %28 = load i64, i64* %27 - %29 = add i64 %9, 8 - %30 = inttoptr i64 %29 to i64* - %31 = load i64, i64* %30 - %32 = icmp eq i64 %23, %28 - br i1 %32, label %if.then2, label %if.else2 -if.else1: - %36 = xor i1 0, 1 - ret i1 %36 -if.then2: - %33 = icmp eq i64 %26, %31 - %34 = xor i1 %33, 1 - ret i1 %34 -if.else2: - %35 = xor i1 0, 1 - ret i1 %35 +define external fastcc i1 @"caret.region.~=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#18##0" = inttoptr i64 %"#left##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#18##0" + %"tmp#19##0" = add i64 %"#left##0", 8 + %"tmp#20##0" = inttoptr i64 %"tmp#19##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#20##0" + %"tmp#21##0" = inttoptr i64 %"#right##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#21##0" + %"tmp#22##0" = add i64 %"#right##0", 8 + %"tmp#23##0" = inttoptr i64 %"tmp#22##0" to ptr + %"tmp#6##0" = load i64, ptr %"tmp#23##0" + %"tmp#24##0" = inttoptr i64 %"tmp#3##0" to ptr + %"tmp#7##0" = load i64, ptr %"tmp#24##0" + %"tmp#25##0" = add i64 %"tmp#3##0", 8 + %"tmp#26##0" = inttoptr i64 %"tmp#25##0" to ptr + %"tmp#8##0" = load i64, ptr %"tmp#26##0" + %"tmp#27##0" = inttoptr i64 %"tmp#5##0" to ptr + %"tmp#9##0" = load i64, ptr %"tmp#27##0" + %"tmp#28##0" = add i64 %"tmp#5##0", 8 + %"tmp#29##0" = inttoptr i64 %"tmp#28##0" to ptr + %"tmp#10##0" = load i64, ptr %"tmp#29##0" + %"tmp#11##0" = icmp eq i64 %"tmp#7##0", %"tmp#9##0" + br i1 %"tmp#11##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#12##0" = icmp eq i64 %"tmp#10##0", %"tmp#8##0" + br i1 %"tmp#12##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#30##0" = inttoptr i64 %"tmp#4##0" to ptr + %"tmp#13##0" = load i64, ptr %"tmp#30##0" + %"tmp#31##0" = add i64 %"tmp#4##0", 8 + %"tmp#32##0" = inttoptr i64 %"tmp#31##0" to ptr + %"tmp#14##0" = load i64, ptr %"tmp#32##0" + %"tmp#33##0" = inttoptr i64 %"tmp#6##0" to ptr + %"tmp#15##0" = load i64, ptr %"tmp#33##0" + %"tmp#34##0" = add i64 %"tmp#6##0", 8 + %"tmp#35##0" = inttoptr i64 %"tmp#34##0" to ptr + %"tmp#16##0" = load i64, ptr %"tmp#35##0" + %"tmp#17##0" = icmp eq i64 %"tmp#13##0", %"tmp#15##0" + br i1 %"tmp#17##0", label %if.then.2, label %if.else.2 +if.then.2: + %"tmp#0##0" = icmp eq i64 %"tmp#14##0", %"tmp#16##0" + %"tmp#36##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#36##0" +if.else.2: + %"tmp#37##0" = xor i1 0, 1 + ret i1 %"tmp#37##0" +if.else.1: + %"tmp#38##0" = xor i1 0, 1 + ret i1 %"tmp#38##0" +if.else.0: + %"tmp#39##0" = xor i1 0, 1 + ret i1 %"tmp#39##0" } + -------------------------------------------------- Module position representation : (not a type) @@ -702,63 +626,42 @@ printPosition(pos##0:position.position)<{<>}; {<>}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'position' - - - - -@position.3 = constant {i64, i64} { i64 1, i64 ptrtoint ([?? x i8]* @position.2 to i64) } - - -@position.5 = constant {i64, i64} { i64 1, i64 ptrtoint ([?? x i8]* @position.4 to i64) } - - -@position.1 = constant {i64, i64} { i64 2, i64 ptrtoint ([?? x i8]* @position.0 to i64) } - - -@position.0 = constant [?? x i8] c" (\00" - - -@position.4 = constant [?? x i8] c")\00" - - -@position.2 = constant [?? x i8] c",\00" - - -declare external ccc void @putchar(i8) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc void @print_int(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"position.printPosition<0>"(i64 %"pos##0") { -entry: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @position.1, i32 0, i32 0) to i64)) - %0 = inttoptr i64 %"pos##0" to i64* - %1 = load i64, i64* %0 - tail call ccc void @print_int(i64 %1) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @position.3, i32 0, i32 0) to i64)) - %2 = add i64 %"pos##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - tail call ccc void @print_int(i64 %4) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @position.5, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - ret void +source_filename = "!ROOT!/final-dump/position.wybe" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c" (\00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c")\00", align 8 +@"cstring#2" = private unnamed_addr constant [ ?? x i8 ] c",\00", align 8 +@"string#3" = private unnamed_addr constant {i64, i64} { i64 2, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +@"string#4" = private unnamed_addr constant {i64, i64} { i64 1, i64 ptrtoint( ptr @"cstring#1" to i64 ) }, align 8 +@"string#5" = private unnamed_addr constant {i64, i64} { i64 1, i64 ptrtoint( ptr @"cstring#2" to i64 ) }, align 8 + +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"position.printPosition<0>"(i64 %"pos##0") { + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#3" to i64 )) + %"tmp#13##0" = inttoptr i64 %"pos##0" to ptr + %"tmp#0##0" = load i64, ptr %"tmp#13##0" + call ccc void @print_int(i64 %"tmp#0##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#5" to i64 )) + %"tmp#14##0" = add i64 %"pos##0", 8 + %"tmp#15##0" = inttoptr i64 %"tmp#14##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#15##0" + call ccc void @print_int(i64 %"tmp#1##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#4" to i64 )) + call ccc void @putchar(i8 10) + ret void } + -------------------------------------------------- Module position.position - representation : address + representation : pointer public submods : public resources: public procs : position.position.=<0> @@ -860,134 +763,110 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'position.position' - - - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i1 @"position.position.=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %"#right##0" to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = icmp eq i64 %1, %6 - br i1 %10, label %if.then, label %if.else -if.then: - %11 = icmp eq i64 %4, %9 - ret i1 %11 -if.else: - ret i1 0 +source_filename = "!ROOT!/final-dump/position.wybe" +target triple ???? + + +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc i1 @"position.position.=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#9##0" = inttoptr i64 %"#left##0" to ptr + %"#left#x##0" = load i64, ptr %"tmp#9##0" + %"tmp#10##0" = add i64 %"#left##0", 8 + %"tmp#11##0" = inttoptr i64 %"tmp#10##0" to ptr + %"#left#y##0" = load i64, ptr %"tmp#11##0" + %"tmp#12##0" = inttoptr i64 %"#right##0" to ptr + %"#right#x##0" = load i64, ptr %"tmp#12##0" + %"tmp#13##0" = add i64 %"#right##0", 8 + %"tmp#14##0" = inttoptr i64 %"tmp#13##0" to ptr + %"#right#y##0" = load i64, ptr %"tmp#14##0" + %"tmp#1##0" = icmp eq i64 %"#left#x##0", %"#right#x##0" + br i1 %"tmp#1##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#15##0" = icmp eq i64 %"#left#y##0", %"#right#y##0" + ret i1 %"tmp#15##0" +if.else.0: + ret i1 0 } - -define external fastcc i64 @"position.position.position<0>"(i64 %"x##0", i64 %"y##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"x##0", i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"y##0", i64* %5 - ret i64 %2 +define external fastcc i64 @"position.position.position<0>"(i64 %"x##0", i64 %"y##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 16) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"x##0", ptr %"tmp#1##0" + %"tmp#2##0" = add i64 %"#rec##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"y##0", ptr %"tmp#3##0" + ret i64 %"#rec##0" } - -define external fastcc {i64, i64} @"position.position.position<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#result##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#result##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = insertvalue {i64, i64} undef, i64 %1, 0 - %6 = insertvalue {i64, i64} %5, i64 %4, 1 - ret {i64, i64} %6 +define external fastcc {i64, i64} @"position.position.position<1>"(i64 %"#result##0") { + %"tmp#0##0" = inttoptr i64 %"#result##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + %"tmp#2##0" = add i64 %"#result##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#3##0" + %"tmp#5##0" = insertvalue {i64, i64} undef, i64 %"tmp#1##0", 0 + %"tmp#6##0" = insertvalue {i64, i64} %"tmp#5##0", i64 %"tmp#4##0", 1 + ret {i64, i64} %"tmp#6##0" } - -define external fastcc i64 @"position.position.x<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#rec##0" to i64* - %1 = load i64, i64* %0 - ret i64 %1 +define external fastcc i64 @"position.position.x<0>"(i64 %"#rec##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + ret i64 %"tmp#1##0" } - -define external fastcc i64 @"position.position.x<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = inttoptr i64 %2 to i64* - store i64 %"#field##0", i64* %6 - ret i64 %2 +define external fastcc i64 @"position.position.x<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"#field##0", ptr %"tmp#3##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"position.position.y<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = add i64 %"#rec##0", 8 - %1 = inttoptr i64 %0 to i64* - %2 = load i64, i64* %1 - ret i64 %2 +define external fastcc i64 @"position.position.y<0>"(i64 %"#rec##0") { + %"tmp#0##0" = add i64 %"#rec##0", 8 + %"tmp#1##0" = inttoptr i64 %"tmp#0##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"position.position.y<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = add i64 %2, 8 - %7 = inttoptr i64 %6 to i64* - store i64 %"#field##0", i64* %7 - ret i64 %2 +define external fastcc i64 @"position.position.y<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = add i64 %"tmp#2##0", 8 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 %"#field##0", ptr %"tmp#4##0" + ret i64 %"tmp#2##0" } - -define external fastcc i1 @"position.position.~=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %"#right##0" to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = icmp eq i64 %1, %6 - br i1 %10, label %if.then, label %if.else -if.then: - %11 = icmp eq i64 %4, %9 - %12 = xor i1 %11, 1 - ret i1 %12 -if.else: - %13 = xor i1 0, 1 - ret i1 %13 +define external fastcc i1 @"position.position.~=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#8##0" = inttoptr i64 %"#left##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#8##0" + %"tmp#9##0" = add i64 %"#left##0", 8 + %"tmp#10##0" = inttoptr i64 %"tmp#9##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#10##0" + %"tmp#11##0" = inttoptr i64 %"#right##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#11##0" + %"tmp#12##0" = add i64 %"#right##0", 8 + %"tmp#13##0" = inttoptr i64 %"tmp#12##0" to ptr + %"tmp#6##0" = load i64, ptr %"tmp#13##0" + %"tmp#7##0" = icmp eq i64 %"tmp#3##0", %"tmp#5##0" + br i1 %"tmp#7##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#0##0" = icmp eq i64 %"tmp#4##0", %"tmp#6##0" + %"tmp#14##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#14##0" +if.else.0: + %"tmp#15##0" = xor i1 0, 1 + ret i1 %"tmp#15##0" } diff --git a/test-cases/final-dump/cases.exp b/test-cases/final-dump/cases.exp index 8fe7e4f89..1d40707e0 100644 --- a/test-cases/final-dump/cases.exp +++ b/test-cases/final-dump/cases.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module cases representation : (not a type) public submods : @@ -44,45 +47,39 @@ len2(lst##0:wybe.list(T) <{}; {}; {0}>, ?#result##0:wybe.int)<{}; {}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'cases' +source_filename = "!ROOT!/final-dump/cases.wybe" +target triple ???? - - - -declare external ccc i8* @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i64 @"cases.len<0>"(i64 %"lst##0") { -entry: - %0 = icmp ne i64 %"lst##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = add i64 %"lst##0", 8 - %2 = inttoptr i64 %1 to i64* - %3 = load i64, i64* %2 - %4 = tail call fastcc i64 @"cases.len<0>"(i64 %3) - %5 = add i64 %4, 1 - ret i64 %5 -if.else: - ret i64 0 +define external fastcc i64 @"cases.len<0>"(i64 %"lst##0") { + %"tmp#5##0" = icmp ne i64 %"lst##0", 0 + br i1 %"tmp#5##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#8##0" = add i64 %"lst##0", 8 + %"tmp#9##0" = inttoptr i64 %"tmp#8##0" to ptr + %"t##0" = load i64, ptr %"tmp#9##0" + %"tmp#2##0" = tail call fastcc i64 @"cases.len<0>"(i64 %"t##0") + %"tmp#10##0" = add i64 %"tmp#2##0", 1 + ret i64 %"tmp#10##0" +if.else.0: + ret i64 0 } - -define external fastcc i64 @"cases.len2<0>"(i64 %"lst##0") { -entry: - %0 = icmp ne i64 %"lst##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = add i64 %"lst##0", 8 - %2 = inttoptr i64 %1 to i64* - %3 = load i64, i64* %2 - %4 = tail call fastcc i64 @"cases.len2<0>"(i64 %3) - %5 = add i64 %4, 1 - ret i64 %5 -if.else: - ret i64 0 +define external fastcc i64 @"cases.len2<0>"(i64 %"lst##0") { + %"tmp#6##0" = icmp ne i64 %"lst##0", 0 + br i1 %"tmp#6##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#9##0" = add i64 %"lst##0", 8 + %"tmp#10##0" = inttoptr i64 %"tmp#9##0" to ptr + %"t##0" = load i64, ptr %"tmp#10##0" + %"tmp#3##0" = tail call fastcc i64 @"cases.len2<0>"(i64 %"t##0") + %"tmp#11##0" = add i64 %"tmp#3##0", 1 + ret i64 %"tmp#11##0" +if.else.0: + ret i64 0 } diff --git a/test-cases/final-dump/ccc.exp b/test-cases/final-dump/ccc.exp index 34e56d423..a480c4f34 100644 --- a/test-cases/final-dump/ccc.exp +++ b/test-cases/final-dump/ccc.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module ccc representation : (not a type) public submods : @@ -22,36 +25,25 @@ module top-level code > public {inline,semipure} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'ccc' +source_filename = "!ROOT!/final-dump/ccc.wybe" +target triple ???? - - - -@ccc.1 = constant {i64, i64} { i64 9, i64 ptrtoint ([?? x i8]* @ccc.0 to i64) } - - -@ccc.0 = constant [?? x i8] c"CCC: Init\00" - - -declare external ccc void @putchar(i8) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc i8* @wybe_malloc(i32) - +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c"CCC: Init\00", align 8 +@"string#1" = private unnamed_addr constant {i64, i64} { i64 9, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) - -define external fastcc void @"ccc.<0>"() alwaysinline { -entry: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @ccc.1, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"ccc.<0>"() { + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#1" to i64 )) + call ccc void @putchar(i8 10) + ret void } + -------------------------------------------------- Module ddd representation : (not a type) @@ -74,33 +66,21 @@ module top-level code > public {inline,semipure} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'ddd' +source_filename = "!ROOT!/final-dump/ddd.wybe" +target triple ???? - - - -@ddd.1 = constant {i64, i64} { i64 9, i64 ptrtoint ([?? x i8]* @ddd.0 to i64) } - - -@ddd.0 = constant [?? x i8] c"DDD: Init\00" - - -declare external ccc void @putchar(i8) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c"DDD: Init\00", align 8 +@"string#1" = private unnamed_addr constant {i64, i64} { i64 9, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -define external fastcc void @"ddd.<0>"() alwaysinline { -entry: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @ddd.1, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"ddd.<0>"() { + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#1" to i64 )) + call ccc void @putchar(i8 10) + ret void } diff --git a/test-cases/final-dump/chain_assign.exp b/test-cases/final-dump/chain_assign.exp index b80ed44ee..a87683153 100644 --- a/test-cases/final-dump/chain_assign.exp +++ b/test-cases/final-dump/chain_assign.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module chain_assign representation : (not a type) public submods : @@ -18,19 +21,15 @@ chain(?z##0:wybe.int)<{}; {}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'chain_assign' +source_filename = "!ROOT!/final-dump/chain_assign.wybe" +target triple ???? - - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -define external fastcc i64 @"chain_assign.chain<0>"() alwaysinline { -entry: - ret i64 1 +define external fastcc i64 @"chain_assign.chain<0>"() { + ret i64 1 } diff --git a/test-cases/final-dump/char-escape.exp b/test-cases/final-dump/char-escape.exp index e8c9befe2..cf589fcac 100644 --- a/test-cases/final-dump/char-escape.exp +++ b/test-cases/final-dump/char-escape.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module char-escape representation : (not a type) public submods : @@ -53,132 +56,70 @@ test(ch##0:wybe.char, code##0:wybe.int, name##0:wybe.string)<{<>}; { LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'char-escape' - - - - -@char-escape.19 = constant {i64, i64} { i64 3, i64 ptrtoint ([?? x i8]* @char-escape.18 to i64) } - - -@char-escape.1 = constant {i64, i64} { i64 4, i64 ptrtoint ([?? x i8]* @char-escape.0 to i64) } - - -@char-escape.3 = constant {i64, i64} { i64 4, i64 ptrtoint ([?? x i8]* @char-escape.2 to i64) } - - -@char-escape.7 = constant {i64, i64} { i64 6, i64 ptrtoint ([?? x i8]* @char-escape.6 to i64) } - - -@char-escape.11 = constant {i64, i64} { i64 7, i64 ptrtoint ([?? x i8]* @char-escape.10 to i64) } - - -@char-escape.9 = constant {i64, i64} { i64 8, i64 ptrtoint ([?? x i8]* @char-escape.8 to i64) } - - -@char-escape.5 = constant {i64, i64} { i64 9, i64 ptrtoint ([?? x i8]* @char-escape.4 to i64) } - - -@char-escape.17 = constant {i64, i64} { i64 12, i64 ptrtoint ([?? x i8]* @char-escape.16 to i64) } - - -@char-escape.15 = constant {i64, i64} { i64 14, i64 ptrtoint ([?? x i8]* @char-escape.14 to i64) } - - -@char-escape.13 = constant {i64, i64} { i64 15, i64 ptrtoint ([?? x i8]* @char-escape.12 to i64) } - - -@char-escape.23 = constant {i64, i64} { i64 18, i64 ptrtoint ([?? x i8]* @char-escape.22 to i64) } - - -@char-escape.25 = constant {i64, i64} { i64 24, i64 ptrtoint ([?? x i8]* @char-escape.24 to i64) } - - -@char-escape.21 = constant {i64, i64} { i64 36, i64 ptrtoint ([?? x i8]* @char-escape.20 to i64) } - - -@char-escape.20 = constant [?? x i8] c"\07string with hex character escapes!\0a\00" - - -@char-escape.24 = constant [?? x i8] c" char escapes don't work\00" - - -@char-escape.22 = constant [?? x i8] c" char escapes work\00" - - -@char-escape.4 = constant [?? x i8] c"backspace\00" - - -@char-escape.2 = constant [?? x i8] c"bell\00" - - -@char-escape.12 = constant [?? x i8] c"carriage return\00" - - -@char-escape.6 = constant [?? x i8] c"escape\00" - - -@char-escape.8 = constant [?? x i8] c"formfeed\00" - - -@char-escape.18 = constant [?? x i8] c"hex\00" - - -@char-escape.14 = constant [?? x i8] c"horizontal tab\00" - - -@char-escape.10 = constant [?? x i8] c"newline\00" - - -@char-escape.0 = constant [?? x i8] c"null\00" - - -@char-escape.16 = constant [?? x i8] c"vertical tab\00" - - -declare external ccc void @putchar(i8) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"char-escape.<0>"() { -entry: - tail call fastcc void @"char-escape.test<0>"(i8 0, i64 0, i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @char-escape.1, i32 0, i32 0) to i64)) - tail call fastcc void @"char-escape.test<0>"(i8 7, i64 7, i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @char-escape.3, i32 0, i32 0) to i64)) - tail call fastcc void @"char-escape.test<0>"(i8 8, i64 8, i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @char-escape.5, i32 0, i32 0) to i64)) - tail call fastcc void @"char-escape.test<0>"(i8 27, i64 27, i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @char-escape.7, i32 0, i32 0) to i64)) - tail call fastcc void @"char-escape.test<0>"(i8 12, i64 12, i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @char-escape.9, i32 0, i32 0) to i64)) - tail call fastcc void @"char-escape.test<0>"(i8 10, i64 10, i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @char-escape.11, i32 0, i32 0) to i64)) - tail call fastcc void @"char-escape.test<0>"(i8 13, i64 13, i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @char-escape.13, i32 0, i32 0) to i64)) - tail call fastcc void @"char-escape.test<0>"(i8 9, i64 9, i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @char-escape.15, i32 0, i32 0) to i64)) - tail call fastcc void @"char-escape.test<0>"(i8 11, i64 11, i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @char-escape.17, i32 0, i32 0) to i64)) - tail call fastcc void @"char-escape.test<0>"(i8 32, i64 32, i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @char-escape.19, i32 0, i32 0) to i64)) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @char-escape.21, i32 0, i32 0) to i64)) - ret void +source_filename = "!ROOT!/final-dump/char-escape.wybe" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c"\07string with hex character escapes!\0A\00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c" char escapes don't work\00", align 8 +@"cstring#2" = private unnamed_addr constant [ ?? x i8 ] c" char escapes work\00", align 8 +@"cstring#3" = private unnamed_addr constant [ ?? x i8 ] c"backspace\00", align 8 +@"cstring#4" = private unnamed_addr constant [ ?? x i8 ] c"bell\00", align 8 +@"cstring#5" = private unnamed_addr constant [ ?? x i8 ] c"carriage return\00", align 8 +@"cstring#6" = private unnamed_addr constant [ ?? x i8 ] c"escape\00", align 8 +@"cstring#7" = private unnamed_addr constant [ ?? x i8 ] c"formfeed\00", align 8 +@"cstring#8" = private unnamed_addr constant [ ?? x i8 ] c"hex\00", align 8 +@"cstring#9" = private unnamed_addr constant [ ?? x i8 ] c"horizontal tab\00", align 8 +@"cstring#10" = private unnamed_addr constant [ ?? x i8 ] c"newline\00", align 8 +@"cstring#11" = private unnamed_addr constant [ ?? x i8 ] c"null\00", align 8 +@"cstring#12" = private unnamed_addr constant [ ?? x i8 ] c"vertical tab\00", align 8 +@"string#13" = private unnamed_addr constant {i64, i64} { i64 36, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +@"string#14" = private unnamed_addr constant {i64, i64} { i64 24, i64 ptrtoint( ptr @"cstring#1" to i64 ) }, align 8 +@"string#15" = private unnamed_addr constant {i64, i64} { i64 18, i64 ptrtoint( ptr @"cstring#2" to i64 ) }, align 8 +@"string#16" = private unnamed_addr constant {i64, i64} { i64 9, i64 ptrtoint( ptr @"cstring#3" to i64 ) }, align 8 +@"string#17" = private unnamed_addr constant {i64, i64} { i64 4, i64 ptrtoint( ptr @"cstring#4" to i64 ) }, align 8 +@"string#18" = private unnamed_addr constant {i64, i64} { i64 15, i64 ptrtoint( ptr @"cstring#5" to i64 ) }, align 8 +@"string#19" = private unnamed_addr constant {i64, i64} { i64 6, i64 ptrtoint( ptr @"cstring#6" to i64 ) }, align 8 +@"string#20" = private unnamed_addr constant {i64, i64} { i64 8, i64 ptrtoint( ptr @"cstring#7" to i64 ) }, align 8 +@"string#21" = private unnamed_addr constant {i64, i64} { i64 3, i64 ptrtoint( ptr @"cstring#8" to i64 ) }, align 8 +@"string#22" = private unnamed_addr constant {i64, i64} { i64 14, i64 ptrtoint( ptr @"cstring#9" to i64 ) }, align 8 +@"string#23" = private unnamed_addr constant {i64, i64} { i64 7, i64 ptrtoint( ptr @"cstring#10" to i64 ) }, align 8 +@"string#24" = private unnamed_addr constant {i64, i64} { i64 4, i64 ptrtoint( ptr @"cstring#11" to i64 ) }, align 8 +@"string#25" = private unnamed_addr constant {i64, i64} { i64 12, i64 ptrtoint( ptr @"cstring#12" to i64 ) }, align 8 + +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"char-escape.<0>"() { + tail call fastcc void @"char-escape.test<0>"(i8 0, i64 0, i64 ptrtoint( ptr @"string#24" to i64 )) + tail call fastcc void @"char-escape.test<0>"(i8 7, i64 7, i64 ptrtoint( ptr @"string#17" to i64 )) + tail call fastcc void @"char-escape.test<0>"(i8 8, i64 8, i64 ptrtoint( ptr @"string#16" to i64 )) + tail call fastcc void @"char-escape.test<0>"(i8 27, i64 27, i64 ptrtoint( ptr @"string#19" to i64 )) + tail call fastcc void @"char-escape.test<0>"(i8 12, i64 12, i64 ptrtoint( ptr @"string#20" to i64 )) + tail call fastcc void @"char-escape.test<0>"(i8 10, i64 10, i64 ptrtoint( ptr @"string#23" to i64 )) + tail call fastcc void @"char-escape.test<0>"(i8 13, i64 13, i64 ptrtoint( ptr @"string#18" to i64 )) + tail call fastcc void @"char-escape.test<0>"(i8 9, i64 9, i64 ptrtoint( ptr @"string#22" to i64 )) + tail call fastcc void @"char-escape.test<0>"(i8 11, i64 11, i64 ptrtoint( ptr @"string#25" to i64 )) + tail call fastcc void @"char-escape.test<0>"(i8 32, i64 32, i64 ptrtoint( ptr @"string#21" to i64 )) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#13" to i64 )) + ret void } - -define external fastcc void @"char-escape.test<0>"(i8 %"ch##0", i64 %"code##0", i64 %"name##0") { -entry: - %0 = zext i8 %"ch##0" to i64 - %1 = icmp eq i64 %"code##0", %0 - br i1 %1, label %if.then, label %if.else -if.then: - tail call fastcc void @"wybe.string.print<0>"(i64 %"name##0") - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @char-escape.23, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - ret void -if.else: - tail call fastcc void @"wybe.string.print<0>"(i64 %"name##0") - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @char-escape.25, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"char-escape.test<0>"(i8 %"ch##0", i64 %"code##0", i64 %"name##0") { + %"tmp#0##0" = sext i8 %"ch##0" to i64 + %"tmp#1##0" = icmp eq i64 %"code##0", %"tmp#0##0" + br i1 %"tmp#1##0", label %if.then.0, label %if.else.0 +if.then.0: + tail call fastcc void @"wybe.string.print<0>"(i64 %"name##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#15" to i64 )) + call ccc void @putchar(i8 10) + ret void +if.else.0: + tail call fastcc void @"wybe.string.print<0>"(i64 %"name##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#14" to i64 )) + call ccc void @putchar(i8 10) + ret void } diff --git a/test-cases/final-dump/common_fields.exp b/test-cases/final-dump/common_fields.exp index 7a2b9277c..e3f9f2bea 100644 --- a/test-cases/final-dump/common_fields.exp +++ b/test-cases/final-dump/common_fields.exp @@ -1,7 +1,10 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module common_fields - representation : address + representation : pointer public submods : public resources: public procs : common_fields.<0> @@ -475,7 +478,7 @@ id(#rec##0:common_fields, ?#result##0:wybe.int)<{}; {}; {}>: foreign lpvm access(~#rec##0:common_fields, 22:wybe.int, 32:wybe.int, 2:wybe.int, ?#result##0:wybe.int) @common_fields:nn:nn proc id > public (7 calls) -1: common_fields.id<1>[410bae77d3] +1: common_fields.id<1> id(#rec##0:common_fields, ?#rec##1:common_fields, #field##0:wybe.int)<{}; {}; {}>: AliasPairs: [(#rec##0,#rec##1)] InterestingCallProperties: [InterestingUnaliased 0] @@ -609,864 +612,769 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'common_fields' - - - - -@common_fields.1 = constant {i64, i64} { i64 1, i64 ptrtoint ([?? x i8]* @common_fields.0 to i64) } - - -@common_fields.3 = constant {i64, i64} { i64 1, i64 ptrtoint ([?? x i8]* @common_fields.2 to i64) } - - -@common_fields.5 = constant {i64, i64} { i64 1, i64 ptrtoint ([?? x i8]* @common_fields.4 to i64) } - - -@common_fields.7 = constant {i64, i64} { i64 1, i64 ptrtoint ([?? x i8]* @common_fields.6 to i64) } - - -@common_fields.0 = constant [?? x i8] c"a\00" - - -@common_fields.2 = constant [?? x i8] c"b\00" - - -@common_fields.4 = constant [?? x i8] c"c\00" - - -@common_fields.6 = constant [?? x i8] c"g\00" - - -declare external fastcc i2 @"wybe.string.<=>#cont#2<0>"(i2, i64, i64, i64, i64) - - -declare external ccc void @putchar(i8) - - -declare external fastcc void @"wybe.string.print<0>[410bae77d3]"(i64) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc void @print_int(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"common_fields.<0>"() { -entry: - %0 = trunc i64 32 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @common_fields.1, i32 0, i32 0) to i64), i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @common_fields.3, i32 0, i32 0) to i64), i64* %5 - %6 = add i64 %2, 16 - %7 = inttoptr i64 %6 to i64* - store i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @common_fields.5, i32 0, i32 0) to i64), i64* %7 - %8 = add i64 %2, 24 - %9 = inttoptr i64 %8 to i64* - store i64 0, i64* %9 - %10 = trunc i64 24 to i32 - %11 = tail call ccc i8* @wybe_malloc(i32 %10) - %12 = ptrtoint i8* %11 to i64 - %13 = inttoptr i64 %12 to i64* - store i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @common_fields.3, i32 0, i32 0) to i64), i64* %13 - %14 = add i64 %12, 8 - %15 = inttoptr i64 %14 to i64* - store i64 0, i64* %15 - %16 = add i64 %12, 16 - %17 = inttoptr i64 %16 to i64* - store i64 1, i64* %17 - %18 = or i64 %12, 1 - %19 = tail call fastcc i64 @"common_fields.title<0>"(i64 %2) - tail call fastcc void @"wybe.string.print<0>"(i64 %19) - tail call ccc void @putchar(i8 10) - %20 = tail call fastcc i64 @"common_fields.id<0>"(i64 %18) - tail call ccc void @print_int(i64 %20) - tail call ccc void @putchar(i8 10) - %21 = tail call fastcc i64 @"common_fields.id<1>[410bae77d3]"(i64 %18, i64 10) - %22 = tail call fastcc i64 @"common_fields.id<0>"(i64 %21) - tail call ccc void @print_int(i64 %22) - tail call ccc void @putchar(i8 10) - %23 = tail call fastcc {i64, i1} @"common_fields.genre<0>"(i64 %2) - %24 = extractvalue {i64, i1} %23, 0 - %25 = extractvalue {i64, i1} %23, 1 - br i1 %25, label %if.then, label %if.else -if.then: - %26 = tail call fastcc {i64, i1} @"common_fields.genre<1>"(i64 %2, i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @common_fields.7, i32 0, i32 0) to i64)) - %27 = extractvalue {i64, i1} %26, 0 - %28 = extractvalue {i64, i1} %26, 1 - br i1 %28, label %if.then1, label %if.else1 -if.else: - ret void -if.then1: - tail call fastcc void @"wybe.string.print<0>"(i64 %24) - tail call ccc void @putchar(i8 10) - %29 = tail call fastcc {i64, i1} @"common_fields.genre<0>"(i64 %27) - %30 = extractvalue {i64, i1} %29, 0 - %31 = extractvalue {i64, i1} %29, 1 - br i1 %31, label %if.then2, label %if.else2 -if.else1: - ret void -if.then2: - tail call fastcc void @"wybe.string.print<0>[410bae77d3]"(i64 %30) - tail call ccc void @putchar(i8 10) - ret void -if.else2: - ret void +source_filename = "!ROOT!/final-dump/common_fields.wybe" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c"a\00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c"b\00", align 8 +@"cstring#2" = private unnamed_addr constant [ ?? x i8 ] c"c\00", align 8 +@"cstring#3" = private unnamed_addr constant [ ?? x i8 ] c"g\00", align 8 +@"string#4" = private unnamed_addr constant {i64, i64} { i64 1, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +@"string#5" = private unnamed_addr constant {i64, i64} { i64 1, i64 ptrtoint( ptr @"cstring#1" to i64 ) }, align 8 +@"string#6" = private unnamed_addr constant {i64, i64} { i64 1, i64 ptrtoint( ptr @"cstring#2" to i64 ) }, align 8 +@"string#7" = private unnamed_addr constant {i64, i64} { i64 1, i64 ptrtoint( ptr @"cstring#3" to i64 ) }, align 8 + +declare external fastcc i2 @"wybe.string.<=>#cont#2<0>"(i2, i64, i64, i64, i64) +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external fastcc void @"wybe.string.print<0>[410bae77d3]"(i64) +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"common_fields.<0>"() { + %"tmp#43##0" = call ccc ptr @wybe_malloc(i32 32) + %"tmp#15##0" = ptrtoint ptr %"tmp#43##0" to i64 + %"tmp#44##0" = inttoptr i64 %"tmp#15##0" to ptr + store i64 ptrtoint( ptr @"string#4" to i64 ), ptr %"tmp#44##0" + %"tmp#45##0" = add i64 %"tmp#15##0", 8 + %"tmp#46##0" = inttoptr i64 %"tmp#45##0" to ptr + store i64 ptrtoint( ptr @"string#5" to i64 ), ptr %"tmp#46##0" + %"tmp#47##0" = add i64 %"tmp#15##0", 16 + %"tmp#48##0" = inttoptr i64 %"tmp#47##0" to ptr + store i64 ptrtoint( ptr @"string#6" to i64 ), ptr %"tmp#48##0" + %"tmp#49##0" = add i64 %"tmp#15##0", 24 + %"tmp#50##0" = inttoptr i64 %"tmp#49##0" to ptr + store i64 0, ptr %"tmp#50##0" + %"tmp#51##0" = call ccc ptr @wybe_malloc(i32 24) + %"tmp#22##0" = ptrtoint ptr %"tmp#51##0" to i64 + %"tmp#52##0" = inttoptr i64 %"tmp#22##0" to ptr + store i64 ptrtoint( ptr @"string#5" to i64 ), ptr %"tmp#52##0" + %"tmp#53##0" = add i64 %"tmp#22##0", 8 + %"tmp#54##0" = inttoptr i64 %"tmp#53##0" to ptr + store i64 0, ptr %"tmp#54##0" + %"tmp#55##0" = add i64 %"tmp#22##0", 16 + %"tmp#56##0" = inttoptr i64 %"tmp#55##0" to ptr + store i64 1, ptr %"tmp#56##0" + %"tmp#1##0" = or i64 %"tmp#22##0", 1 + %"tmp#2##0" = tail call fastcc i64 @"common_fields.title<0>"(i64 %"tmp#15##0") + tail call fastcc void @"wybe.string.print<0>"(i64 %"tmp#2##0") + call ccc void @putchar(i8 10) + %"tmp#3##0" = tail call fastcc i64 @"common_fields.id<0>"(i64 %"tmp#1##0") + call ccc void @print_int(i64 %"tmp#3##0") + call ccc void @putchar(i8 10) + %"c##1" = tail call fastcc i64 @"common_fields.id<1>[410bae77d3]"(i64 %"tmp#1##0", i64 10) + %"tmp#4##0" = tail call fastcc i64 @"common_fields.id<0>"(i64 %"c##1") + call ccc void @print_int(i64 %"tmp#4##0") + call ccc void @putchar(i8 10) + %"tmp#57##0" = tail call fastcc {i64, i1} @"common_fields.genre<0>"(i64 %"tmp#15##0") + %"tmp#5##0" = extractvalue {i64, i1}%"tmp#57##0", 0 + %"tmp#9##0" = extractvalue {i64, i1}%"tmp#57##0", 1 + br i1 %"tmp#9##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#58##0" = tail call fastcc {i64, i1} @"common_fields.genre<1>"(i64 %"tmp#15##0", i64 ptrtoint( ptr @"string#7" to i64 )) + %"b##1" = extractvalue {i64, i1}%"tmp#58##0", 0 + %"tmp#10##0" = extractvalue {i64, i1}%"tmp#58##0", 1 + br i1 %"tmp#10##0", label %if.then.1, label %if.else.1 +if.then.1: + tail call fastcc void @"wybe.string.print<0>"(i64 %"tmp#5##0") + call ccc void @putchar(i8 10) + %"tmp#59##0" = tail call fastcc {i64, i1} @"common_fields.genre<0>"(i64 %"b##1") + %"tmp#6##0" = extractvalue {i64, i1}%"tmp#59##0", 0 + %"tmp#8##0" = extractvalue {i64, i1}%"tmp#59##0", 1 + br i1 %"tmp#8##0", label %if.then.2, label %if.else.2 +if.then.2: + tail call fastcc void @"wybe.string.print<0>[410bae77d3]"(i64 %"tmp#6##0") + call ccc void @putchar(i8 10) + ret void +if.else.2: + ret void +if.else.1: + ret void +if.else.0: + ret void } - -define external fastcc i1 @"common_fields.=<0>"(i64 %"#left##0", i64 %"#right##0") { -entry: - %0 = and i64 %"#left##0", 3 - switch i64 %0, label %switch.4.3 [i64 0, label %switch.4.0 i64 1, label %switch.4.1 i64 2, label %switch.4.2 i64 3, label %switch.4.3] -switch.4.0: - %1 = inttoptr i64 %"#left##0" to i64* - %2 = load i64, i64* %1 - %3 = add i64 %"#left##0", 8 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = add i64 %"#left##0", 16 - %7 = inttoptr i64 %6 to i64* - %8 = load i64, i64* %7 - %9 = add i64 %"#left##0", 24 - %10 = inttoptr i64 %9 to i64* - %11 = load i64, i64* %10 - %12 = and i64 %"#right##0", 3 - %13 = icmp eq i64 %12, 0 - br i1 %13, label %if.then, label %if.else -switch.4.1: - %32 = add i64 %"#left##0", -1 - %33 = inttoptr i64 %32 to i64* - %34 = load i64, i64* %33 - %35 = add i64 %"#left##0", 7 - %36 = inttoptr i64 %35 to i64* - %37 = load i64, i64* %36 - %38 = add i64 %"#left##0", 15 - %39 = inttoptr i64 %38 to i64* - %40 = load i64, i64* %39 - %41 = and i64 %"#right##0", 3 - %42 = icmp eq i64 %41, 1 - br i1 %42, label %if.then4, label %if.else4 -switch.4.2: - %56 = add i64 %"#left##0", -2 - %57 = inttoptr i64 %56 to i64* - %58 = load i64, i64* %57 - %59 = add i64 %"#left##0", 6 - %60 = inttoptr i64 %59 to i64* - %61 = load i64, i64* %60 - %62 = add i64 %"#left##0", 14 - %63 = inttoptr i64 %62 to i64* - %64 = load i64, i64* %63 - %65 = add i64 %"#left##0", 22 - %66 = inttoptr i64 %65 to i64* - %67 = load i64, i64* %66 - %68 = and i64 %"#right##0", 3 - %69 = icmp eq i64 %68, 2 - br i1 %69, label %if.then7, label %if.else7 -switch.4.3: - %89 = add i64 %"#left##0", -3 - %90 = inttoptr i64 %89 to i64* - %91 = load i64, i64* %90 - %92 = add i64 %"#left##0", 5 - %93 = inttoptr i64 %92 to i64* - %94 = load i64, i64* %93 - %95 = and i64 %"#right##0", 3 - %96 = icmp eq i64 %95, 3 - br i1 %96, label %if.then11, label %if.else11 -if.then: - %14 = inttoptr i64 %"#right##0" to i64* - %15 = load i64, i64* %14 - %16 = add i64 %"#right##0", 8 - %17 = inttoptr i64 %16 to i64* - %18 = load i64, i64* %17 - %19 = add i64 %"#right##0", 16 - %20 = inttoptr i64 %19 to i64* - %21 = load i64, i64* %20 - %22 = add i64 %"#right##0", 24 - %23 = inttoptr i64 %22 to i64* - %24 = load i64, i64* %23 - %25 = tail call fastcc i2 @"wybe.string.<=>#cont#2<0>"(i2 1, i64 %2, i64 %15, i64 %2, i64 %15) - %26 = icmp eq i2 %25, 1 - br i1 %26, label %if.then1, label %if.else1 -if.else: - ret i1 0 -if.then1: - %27 = tail call fastcc i2 @"wybe.string.<=>#cont#2<0>"(i2 1, i64 %5, i64 %18, i64 %5, i64 %18) - %28 = icmp eq i2 %27, 1 - br i1 %28, label %if.then2, label %if.else2 -if.else1: - ret i1 0 -if.then2: - %29 = tail call fastcc i2 @"wybe.string.<=>#cont#2<0>"(i2 1, i64 %8, i64 %21, i64 %8, i64 %21) - %30 = icmp eq i2 %29, 1 - br i1 %30, label %if.then3, label %if.else3 -if.else2: - ret i1 0 -if.then3: - %31 = icmp eq i64 %11, %24 - ret i1 %31 -if.else3: - ret i1 0 -if.then4: - %43 = add i64 %"#right##0", -1 - %44 = inttoptr i64 %43 to i64* - %45 = load i64, i64* %44 - %46 = add i64 %"#right##0", 7 - %47 = inttoptr i64 %46 to i64* - %48 = load i64, i64* %47 - %49 = add i64 %"#right##0", 15 - %50 = inttoptr i64 %49 to i64* - %51 = load i64, i64* %50 - %52 = tail call fastcc i2 @"wybe.string.<=>#cont#2<0>"(i2 1, i64 %34, i64 %45, i64 %34, i64 %45) - %53 = icmp eq i2 %52, 1 - br i1 %53, label %if.then5, label %if.else5 -if.else4: - ret i1 0 -if.then5: - %54 = icmp eq i64 %37, %48 - br i1 %54, label %if.then6, label %if.else6 -if.else5: - ret i1 0 -if.then6: - %55 = icmp eq i64 %40, %51 - ret i1 %55 -if.else6: - ret i1 0 -if.then7: - %70 = add i64 %"#right##0", -2 - %71 = inttoptr i64 %70 to i64* - %72 = load i64, i64* %71 - %73 = add i64 %"#right##0", 6 - %74 = inttoptr i64 %73 to i64* - %75 = load i64, i64* %74 - %76 = add i64 %"#right##0", 14 - %77 = inttoptr i64 %76 to i64* - %78 = load i64, i64* %77 - %79 = add i64 %"#right##0", 22 - %80 = inttoptr i64 %79 to i64* - %81 = load i64, i64* %80 - %82 = tail call fastcc i2 @"wybe.string.<=>#cont#2<0>"(i2 1, i64 %58, i64 %72, i64 %58, i64 %72) - %83 = icmp eq i2 %82, 1 - br i1 %83, label %if.then8, label %if.else8 -if.else7: - ret i1 0 -if.then8: - %84 = tail call fastcc i2 @"wybe.string.<=>#cont#2<0>"(i2 1, i64 %61, i64 %75, i64 %61, i64 %75) - %85 = icmp eq i2 %84, 1 - br i1 %85, label %if.then9, label %if.else9 -if.else8: - ret i1 0 -if.then9: - %86 = tail call fastcc i2 @"wybe.string.<=>#cont#2<0>"(i2 1, i64 %64, i64 %78, i64 %64, i64 %78) - %87 = icmp eq i2 %86, 1 - br i1 %87, label %if.then10, label %if.else10 -if.else9: - ret i1 0 -if.then10: - %88 = icmp eq i64 %67, %81 - ret i1 %88 -if.else10: - ret i1 0 -if.then11: - %97 = add i64 %"#right##0", -3 - %98 = inttoptr i64 %97 to i64* - %99 = load i64, i64* %98 - %100 = add i64 %"#right##0", 5 - %101 = inttoptr i64 %100 to i64* - %102 = load i64, i64* %101 - %103 = tail call fastcc i2 @"wybe.string.<=>#cont#2<0>"(i2 1, i64 %91, i64 %99, i64 %91, i64 %99) - %104 = icmp eq i2 %103, 1 - br i1 %104, label %if.then12, label %if.else12 -if.else11: - ret i1 0 -if.then12: - %105 = icmp eq i64 %94, %102 - ret i1 %105 -if.else12: - ret i1 0 +define external fastcc i1 @"common_fields.=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#23##0" = and i64 %"#left##0", 3 + switch i64 %"tmp#23##0", label %case.3.switch.0 [ + i64 0, label %case.0.switch.0 + i64 1, label %case.1.switch.0 + i64 2, label %case.2.switch.0 + i64 3, label %case.3.switch.0 ] +case.0.switch.0: + %"tmp#80##0" = inttoptr i64 %"#left##0" to ptr + %"#left#title##0" = load i64, ptr %"tmp#80##0" + %"tmp#81##0" = add i64 %"#left##0", 8 + %"tmp#82##0" = inttoptr i64 %"tmp#81##0" to ptr + %"#left#author##0" = load i64, ptr %"tmp#82##0" + %"tmp#83##0" = add i64 %"#left##0", 16 + %"tmp#84##0" = inttoptr i64 %"tmp#83##0" to ptr + %"#left#genre##0" = load i64, ptr %"tmp#84##0" + %"tmp#85##0" = add i64 %"#left##0", 24 + %"tmp#86##0" = inttoptr i64 %"tmp#85##0" to ptr + %"#left#id##0" = load i64, ptr %"tmp#86##0" + %"tmp#67##0" = and i64 %"#right##0", 3 + %"tmp#68##0" = icmp eq i64 %"tmp#67##0", 0 + br i1 %"tmp#68##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#87##0" = inttoptr i64 %"#right##0" to ptr + %"#right#title##0" = load i64, ptr %"tmp#87##0" + %"tmp#88##0" = add i64 %"#right##0", 8 + %"tmp#89##0" = inttoptr i64 %"tmp#88##0" to ptr + %"#right#author##0" = load i64, ptr %"tmp#89##0" + %"tmp#90##0" = add i64 %"#right##0", 16 + %"tmp#91##0" = inttoptr i64 %"tmp#90##0" to ptr + %"#right#genre##0" = load i64, ptr %"tmp#91##0" + %"tmp#92##0" = add i64 %"#right##0", 24 + %"tmp#93##0" = inttoptr i64 %"tmp#92##0" to ptr + %"#right#id##0" = load i64, ptr %"tmp#93##0" + %"tmp#71##0" = tail call fastcc i2 @"wybe.string.<=>#cont#2<0>"(i2 1, i64 %"#left#title##0", i64 %"#right#title##0", i64 %"#left#title##0", i64 %"#right#title##0") + %"tmp#2##0" = icmp eq i2 %"tmp#71##0", 1 + br i1 %"tmp#2##0", label %if.then.2, label %if.else.2 +if.then.2: + %"tmp#74##0" = tail call fastcc i2 @"wybe.string.<=>#cont#2<0>"(i2 1, i64 %"#left#author##0", i64 %"#right#author##0", i64 %"#left#author##0", i64 %"#right#author##0") + %"tmp#3##0" = icmp eq i2 %"tmp#74##0", 1 + br i1 %"tmp#3##0", label %if.then.3, label %if.else.3 +if.then.3: + %"tmp#77##0" = tail call fastcc i2 @"wybe.string.<=>#cont#2<0>"(i2 1, i64 %"#left#genre##0", i64 %"#right#genre##0", i64 %"#left#genre##0", i64 %"#right#genre##0") + %"tmp#4##0" = icmp eq i2 %"tmp#77##0", 1 + br i1 %"tmp#4##0", label %if.then.4, label %if.else.4 +if.then.4: + %"tmp#94##0" = icmp eq i64 %"#left#id##0", %"#right#id##0" + ret i1 %"tmp#94##0" +if.else.4: + ret i1 0 +if.else.3: + ret i1 0 +if.else.2: + ret i1 0 +if.else.1: + ret i1 0 +case.1.switch.0: + %"tmp#95##0" = add i64 %"#left##0", -1 + %"tmp#96##0" = inttoptr i64 %"tmp#95##0" to ptr + %"#left#title##1" = load i64, ptr %"tmp#96##0" + %"tmp#97##0" = add i64 %"#left##0", 7 + %"tmp#98##0" = inttoptr i64 %"tmp#97##0" to ptr + %"#left#frequency##0" = load i64, ptr %"tmp#98##0" + %"tmp#99##0" = add i64 %"#left##0", 15 + %"tmp#100##0" = inttoptr i64 %"tmp#99##0" to ptr + %"#left#id##1" = load i64, ptr %"tmp#100##0" + %"tmp#57##0" = and i64 %"#right##0", 3 + %"tmp#58##0" = icmp eq i64 %"tmp#57##0", 1 + br i1 %"tmp#58##0", label %if.then.5, label %if.else.5 +if.then.5: + %"tmp#101##0" = add i64 %"#right##0", -1 + %"tmp#102##0" = inttoptr i64 %"tmp#101##0" to ptr + %"tmp#103##0" = load i64, ptr %"tmp#102##0" + %"tmp#104##0" = add i64 %"#right##0", 7 + %"tmp#105##0" = inttoptr i64 %"tmp#104##0" to ptr + %"#right#frequency##0" = load i64, ptr %"tmp#105##0" + %"tmp#106##0" = add i64 %"#right##0", 15 + %"tmp#107##0" = inttoptr i64 %"tmp#106##0" to ptr + %"tmp#108##0" = load i64, ptr %"tmp#107##0" + %"tmp#61##0" = tail call fastcc i2 @"wybe.string.<=>#cont#2<0>"(i2 1, i64 %"#left#title##1", i64 %"tmp#103##0", i64 %"#left#title##1", i64 %"tmp#103##0") + %"tmp#7##0" = icmp eq i2 %"tmp#61##0", 1 + br i1 %"tmp#7##0", label %if.then.6, label %if.else.6 +if.then.6: + %"tmp#8##0" = icmp eq i64 %"#left#frequency##0", %"#right#frequency##0" + br i1 %"tmp#8##0", label %if.then.7, label %if.else.7 +if.then.7: + %"tmp#109##0" = icmp eq i64 %"#left#id##1", %"tmp#108##0" + ret i1 %"tmp#109##0" +if.else.7: + ret i1 0 +if.else.6: + ret i1 0 +if.else.5: + ret i1 0 +case.2.switch.0: + %"tmp#110##0" = add i64 %"#left##0", -2 + %"tmp#111##0" = inttoptr i64 %"tmp#110##0" to ptr + %"#left#title##2" = load i64, ptr %"tmp#111##0" + %"tmp#112##0" = add i64 %"#left##0", 6 + %"tmp#113##0" = inttoptr i64 %"tmp#112##0" to ptr + %"#left#director##0" = load i64, ptr %"tmp#113##0" + %"tmp#114##0" = add i64 %"#left##0", 14 + %"tmp#115##0" = inttoptr i64 %"tmp#114##0" to ptr + %"#left#genre##1" = load i64, ptr %"tmp#115##0" + %"tmp#116##0" = add i64 %"#left##0", 22 + %"tmp#117##0" = inttoptr i64 %"tmp#116##0" to ptr + %"#left#id##2" = load i64, ptr %"tmp#117##0" + %"tmp#43##0" = and i64 %"#right##0", 3 + %"tmp#44##0" = icmp eq i64 %"tmp#43##0", 2 + br i1 %"tmp#44##0", label %if.then.8, label %if.else.8 +if.then.8: + %"tmp#118##0" = add i64 %"#right##0", -2 + %"tmp#119##0" = inttoptr i64 %"tmp#118##0" to ptr + %"tmp#120##0" = load i64, ptr %"tmp#119##0" + %"tmp#121##0" = add i64 %"#right##0", 6 + %"tmp#122##0" = inttoptr i64 %"tmp#121##0" to ptr + %"#right#director##0" = load i64, ptr %"tmp#122##0" + %"tmp#123##0" = add i64 %"#right##0", 14 + %"tmp#124##0" = inttoptr i64 %"tmp#123##0" to ptr + %"tmp#125##0" = load i64, ptr %"tmp#124##0" + %"tmp#126##0" = add i64 %"#right##0", 22 + %"tmp#127##0" = inttoptr i64 %"tmp#126##0" to ptr + %"tmp#128##0" = load i64, ptr %"tmp#127##0" + %"tmp#47##0" = tail call fastcc i2 @"wybe.string.<=>#cont#2<0>"(i2 1, i64 %"#left#title##2", i64 %"tmp#120##0", i64 %"#left#title##2", i64 %"tmp#120##0") + %"tmp#11##0" = icmp eq i2 %"tmp#47##0", 1 + br i1 %"tmp#11##0", label %if.then.9, label %if.else.9 +if.then.9: + %"tmp#50##0" = tail call fastcc i2 @"wybe.string.<=>#cont#2<0>"(i2 1, i64 %"#left#director##0", i64 %"#right#director##0", i64 %"#left#director##0", i64 %"#right#director##0") + %"tmp#12##0" = icmp eq i2 %"tmp#50##0", 1 + br i1 %"tmp#12##0", label %if.then.10, label %if.else.10 +if.then.10: + %"tmp#53##0" = tail call fastcc i2 @"wybe.string.<=>#cont#2<0>"(i2 1, i64 %"#left#genre##1", i64 %"tmp#125##0", i64 %"#left#genre##1", i64 %"tmp#125##0") + %"tmp#13##0" = icmp eq i2 %"tmp#53##0", 1 + br i1 %"tmp#13##0", label %if.then.11, label %if.else.11 +if.then.11: + %"tmp#129##0" = icmp eq i64 %"#left#id##2", %"tmp#128##0" + ret i1 %"tmp#129##0" +if.else.11: + ret i1 0 +if.else.10: + ret i1 0 +if.else.9: + ret i1 0 +if.else.8: + ret i1 0 +case.3.switch.0: + %"tmp#130##0" = add i64 %"#left##0", -3 + %"tmp#131##0" = inttoptr i64 %"tmp#130##0" to ptr + %"#left#title##3" = load i64, ptr %"tmp#131##0" + %"tmp#132##0" = add i64 %"#left##0", 5 + %"tmp#133##0" = inttoptr i64 %"tmp#132##0" to ptr + %"#left#id##3" = load i64, ptr %"tmp#133##0" + %"tmp#35##0" = and i64 %"#right##0", 3 + %"tmp#36##0" = icmp eq i64 %"tmp#35##0", 3 + br i1 %"tmp#36##0", label %if.then.12, label %if.else.12 +if.then.12: + %"tmp#134##0" = add i64 %"#right##0", -3 + %"tmp#135##0" = inttoptr i64 %"tmp#134##0" to ptr + %"tmp#136##0" = load i64, ptr %"tmp#135##0" + %"tmp#137##0" = add i64 %"#right##0", 5 + %"tmp#138##0" = inttoptr i64 %"tmp#137##0" to ptr + %"tmp#139##0" = load i64, ptr %"tmp#138##0" + %"tmp#39##0" = tail call fastcc i2 @"wybe.string.<=>#cont#2<0>"(i2 1, i64 %"#left#title##3", i64 %"tmp#136##0", i64 %"#left#title##3", i64 %"tmp#136##0") + %"tmp#16##0" = icmp eq i2 %"tmp#39##0", 1 + br i1 %"tmp#16##0", label %if.then.13, label %if.else.13 +if.then.13: + %"tmp#140##0" = icmp eq i64 %"#left#id##3", %"tmp#139##0" + ret i1 %"tmp#140##0" +if.else.13: + ret i1 0 +if.else.12: + ret i1 0 } - -define external fastcc i64 @"common_fields.DVD<0>"(i64 %"title##0", i64 %"director##0", i64 %"genre##0", i64 %"id##0") alwaysinline { -entry: - %0 = trunc i64 32 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"title##0", i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"director##0", i64* %5 - %6 = add i64 %2, 16 - %7 = inttoptr i64 %6 to i64* - store i64 %"genre##0", i64* %7 - %8 = add i64 %2, 24 - %9 = inttoptr i64 %8 to i64* - store i64 %"id##0", i64* %9 - %10 = or i64 %2, 2 - ret i64 %10 +define external fastcc i64 @"common_fields.DVD<0>"(i64 %"title##0", i64 %"director##0", i64 %"genre##0", i64 %"id##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 32) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"title##0", ptr %"tmp#1##0" + %"tmp#2##0" = add i64 %"#rec##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"director##0", ptr %"tmp#3##0" + %"tmp#4##0" = add i64 %"#rec##0", 16 + %"tmp#5##0" = inttoptr i64 %"tmp#4##0" to ptr + store i64 %"genre##0", ptr %"tmp#5##0" + %"tmp#6##0" = add i64 %"#rec##0", 24 + %"tmp#7##0" = inttoptr i64 %"tmp#6##0" to ptr + store i64 %"id##0", ptr %"tmp#7##0" + %"tmp#8##0" = or i64 %"#rec##0", 2 + ret i64 %"tmp#8##0" } - -define external fastcc {i64, i64, i64, i64, i1} @"common_fields.DVD<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = and i64 %"#result##0", 3 - %1 = icmp eq i64 %0, 2 - br i1 %1, label %if.then, label %if.else -if.then: - %2 = add i64 %"#result##0", -2 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = add i64 %"#result##0", 6 - %6 = inttoptr i64 %5 to i64* - %7 = load i64, i64* %6 - %8 = add i64 %"#result##0", 14 - %9 = inttoptr i64 %8 to i64* - %10 = load i64, i64* %9 - %11 = add i64 %"#result##0", 22 - %12 = inttoptr i64 %11 to i64* - %13 = load i64, i64* %12 - %14 = insertvalue {i64, i64, i64, i64, i1} undef, i64 %4, 0 - %15 = insertvalue {i64, i64, i64, i64, i1} %14, i64 %7, 1 - %16 = insertvalue {i64, i64, i64, i64, i1} %15, i64 %10, 2 - %17 = insertvalue {i64, i64, i64, i64, i1} %16, i64 %13, 3 - %18 = insertvalue {i64, i64, i64, i64, i1} %17, i1 1, 4 - ret {i64, i64, i64, i64, i1} %18 -if.else: - %19 = insertvalue {i64, i64, i64, i64, i1} undef, i64 undef, 0 - %20 = insertvalue {i64, i64, i64, i64, i1} %19, i64 undef, 1 - %21 = insertvalue {i64, i64, i64, i64, i1} %20, i64 undef, 2 - %22 = insertvalue {i64, i64, i64, i64, i1} %21, i64 undef, 3 - %23 = insertvalue {i64, i64, i64, i64, i1} %22, i1 0, 4 - ret {i64, i64, i64, i64, i1} %23 +define external fastcc {i64, i64, i64, i64, i1} @"common_fields.DVD<1>"(i64 %"#result##0") { + %"tmp#1##0" = and i64 %"#result##0", 3 + %"tmp#0##0" = icmp eq i64 %"tmp#1##0", 2 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = add i64 %"#result##0", -2 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#3##0" + %"tmp#5##0" = add i64 %"#result##0", 6 + %"tmp#6##0" = inttoptr i64 %"tmp#5##0" to ptr + %"tmp#7##0" = load i64, ptr %"tmp#6##0" + %"tmp#8##0" = add i64 %"#result##0", 14 + %"tmp#9##0" = inttoptr i64 %"tmp#8##0" to ptr + %"tmp#10##0" = load i64, ptr %"tmp#9##0" + %"tmp#11##0" = add i64 %"#result##0", 22 + %"tmp#12##0" = inttoptr i64 %"tmp#11##0" to ptr + %"tmp#13##0" = load i64, ptr %"tmp#12##0" + %"tmp#14##0" = insertvalue {i64, i64, i64, i64, i1} undef, i64 %"tmp#4##0", 0 + %"tmp#15##0" = insertvalue {i64, i64, i64, i64, i1} %"tmp#14##0", i64 %"tmp#7##0", 1 + %"tmp#16##0" = insertvalue {i64, i64, i64, i64, i1} %"tmp#15##0", i64 %"tmp#10##0", 2 + %"tmp#17##0" = insertvalue {i64, i64, i64, i64, i1} %"tmp#16##0", i64 %"tmp#13##0", 3 + %"tmp#18##0" = insertvalue {i64, i64, i64, i64, i1} %"tmp#17##0", i1 1, 4 + ret {i64, i64, i64, i64, i1} %"tmp#18##0" +if.else.0: + %"tmp#19##0" = insertvalue {i64, i64, i64, i64, i1} undef, i64 undef, 0 + %"tmp#20##0" = insertvalue {i64, i64, i64, i64, i1} %"tmp#19##0", i64 undef, 1 + %"tmp#21##0" = insertvalue {i64, i64, i64, i64, i1} %"tmp#20##0", i64 undef, 2 + %"tmp#22##0" = insertvalue {i64, i64, i64, i64, i1} %"tmp#21##0", i64 undef, 3 + %"tmp#23##0" = insertvalue {i64, i64, i64, i64, i1} %"tmp#22##0", i1 0, 4 + ret {i64, i64, i64, i64, i1} %"tmp#23##0" } - -define external fastcc {i64, i1} @"common_fields.author<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = and i64 %"#rec##0", 3 - %1 = icmp eq i64 %0, 0 - br i1 %1, label %if.then, label %if.else -if.then: - %2 = add i64 %"#rec##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = insertvalue {i64, i1} undef, i64 %4, 0 - %6 = insertvalue {i64, i1} %5, i1 1, 1 - ret {i64, i1} %6 -if.else: - %7 = insertvalue {i64, i1} undef, i64 undef, 0 - %8 = insertvalue {i64, i1} %7, i1 0, 1 - ret {i64, i1} %8 +define external fastcc {i64, i1} @"common_fields.author<0>"(i64 %"#rec##0") { + %"tmp#1##0" = and i64 %"#rec##0", 3 + %"tmp#0##0" = icmp eq i64 %"tmp#1##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = add i64 %"#rec##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#3##0" + %"tmp#5##0" = insertvalue {i64, i1} undef, i64 %"tmp#4##0", 0 + %"tmp#6##0" = insertvalue {i64, i1} %"tmp#5##0", i1 1, 1 + ret {i64, i1} %"tmp#6##0" +if.else.0: + %"tmp#7##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#8##0" = insertvalue {i64, i1} %"tmp#7##0", i1 0, 1 + ret {i64, i1} %"tmp#8##0" } - -define external fastcc {i64, i1} @"common_fields.author<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = and i64 %"#rec##0", 3 - %1 = icmp eq i64 %0, 0 - br i1 %1, label %if.then, label %if.else -if.then: - %2 = trunc i64 32 to i32 - %3 = tail call ccc i8* @wybe_malloc(i32 %2) - %4 = ptrtoint i8* %3 to i64 - %5 = inttoptr i64 %4 to i8* - %6 = inttoptr i64 %"#rec##0" to i8* - %7 = trunc i64 32 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %5, i8* %6, i32 %7, i1 0) - %8 = add i64 %4, 8 - %9 = inttoptr i64 %8 to i64* - store i64 %"#field##0", i64* %9 - %10 = insertvalue {i64, i1} undef, i64 %4, 0 - %11 = insertvalue {i64, i1} %10, i1 1, 1 - ret {i64, i1} %11 -if.else: - %12 = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 - %13 = insertvalue {i64, i1} %12, i1 0, 1 - ret {i64, i1} %13 +define external fastcc {i64, i1} @"common_fields.author<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#1##0" = and i64 %"#rec##0", 3 + %"tmp#0##0" = icmp eq i64 %"tmp#1##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#3##0" = call ccc ptr @wybe_malloc(i32 32) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#3##0", ptr %"tmp#2##0", i64 32, i1 0) + %"tmp#4##0" = ptrtoint ptr %"tmp#3##0" to i64 + %"tmp#5##0" = add i64 %"tmp#4##0", 8 + %"tmp#6##0" = inttoptr i64 %"tmp#5##0" to ptr + store i64 %"#field##0", ptr %"tmp#6##0" + %"tmp#7##0" = insertvalue {i64, i1} undef, i64 %"tmp#4##0", 0 + %"tmp#8##0" = insertvalue {i64, i1} %"tmp#7##0", i1 1, 1 + ret {i64, i1} %"tmp#8##0" +if.else.0: + %"tmp#9##0" = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 + %"tmp#10##0" = insertvalue {i64, i1} %"tmp#9##0", i1 0, 1 + ret {i64, i1} %"tmp#10##0" } - -define external fastcc i64 @"common_fields.book<0>"(i64 %"title##0", i64 %"author##0", i64 %"genre##0", i64 %"id##0") alwaysinline { -entry: - %0 = trunc i64 32 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"title##0", i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"author##0", i64* %5 - %6 = add i64 %2, 16 - %7 = inttoptr i64 %6 to i64* - store i64 %"genre##0", i64* %7 - %8 = add i64 %2, 24 - %9 = inttoptr i64 %8 to i64* - store i64 %"id##0", i64* %9 - ret i64 %2 +define external fastcc i64 @"common_fields.book<0>"(i64 %"title##0", i64 %"author##0", i64 %"genre##0", i64 %"id##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 32) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"title##0", ptr %"tmp#1##0" + %"tmp#2##0" = add i64 %"#rec##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"author##0", ptr %"tmp#3##0" + %"tmp#4##0" = add i64 %"#rec##0", 16 + %"tmp#5##0" = inttoptr i64 %"tmp#4##0" to ptr + store i64 %"genre##0", ptr %"tmp#5##0" + %"tmp#6##0" = add i64 %"#rec##0", 24 + %"tmp#7##0" = inttoptr i64 %"tmp#6##0" to ptr + store i64 %"id##0", ptr %"tmp#7##0" + ret i64 %"#rec##0" } - -define external fastcc {i64, i64, i64, i64, i1} @"common_fields.book<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = and i64 %"#result##0", 3 - %1 = icmp eq i64 %0, 0 - br i1 %1, label %if.then, label %if.else -if.then: - %2 = inttoptr i64 %"#result##0" to i64* - %3 = load i64, i64* %2 - %4 = add i64 %"#result##0", 8 - %5 = inttoptr i64 %4 to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#result##0", 16 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = add i64 %"#result##0", 24 - %11 = inttoptr i64 %10 to i64* - %12 = load i64, i64* %11 - %13 = insertvalue {i64, i64, i64, i64, i1} undef, i64 %3, 0 - %14 = insertvalue {i64, i64, i64, i64, i1} %13, i64 %6, 1 - %15 = insertvalue {i64, i64, i64, i64, i1} %14, i64 %9, 2 - %16 = insertvalue {i64, i64, i64, i64, i1} %15, i64 %12, 3 - %17 = insertvalue {i64, i64, i64, i64, i1} %16, i1 1, 4 - ret {i64, i64, i64, i64, i1} %17 -if.else: - %18 = insertvalue {i64, i64, i64, i64, i1} undef, i64 undef, 0 - %19 = insertvalue {i64, i64, i64, i64, i1} %18, i64 undef, 1 - %20 = insertvalue {i64, i64, i64, i64, i1} %19, i64 undef, 2 - %21 = insertvalue {i64, i64, i64, i64, i1} %20, i64 undef, 3 - %22 = insertvalue {i64, i64, i64, i64, i1} %21, i1 0, 4 - ret {i64, i64, i64, i64, i1} %22 +define external fastcc {i64, i64, i64, i64, i1} @"common_fields.book<1>"(i64 %"#result##0") { + %"tmp#1##0" = and i64 %"#result##0", 3 + %"tmp#0##0" = icmp eq i64 %"tmp#1##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = inttoptr i64 %"#result##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#2##0" + %"tmp#4##0" = add i64 %"#result##0", 8 + %"tmp#5##0" = inttoptr i64 %"tmp#4##0" to ptr + %"tmp#6##0" = load i64, ptr %"tmp#5##0" + %"tmp#7##0" = add i64 %"#result##0", 16 + %"tmp#8##0" = inttoptr i64 %"tmp#7##0" to ptr + %"tmp#9##0" = load i64, ptr %"tmp#8##0" + %"tmp#10##0" = add i64 %"#result##0", 24 + %"tmp#11##0" = inttoptr i64 %"tmp#10##0" to ptr + %"tmp#12##0" = load i64, ptr %"tmp#11##0" + %"tmp#13##0" = insertvalue {i64, i64, i64, i64, i1} undef, i64 %"tmp#3##0", 0 + %"tmp#14##0" = insertvalue {i64, i64, i64, i64, i1} %"tmp#13##0", i64 %"tmp#6##0", 1 + %"tmp#15##0" = insertvalue {i64, i64, i64, i64, i1} %"tmp#14##0", i64 %"tmp#9##0", 2 + %"tmp#16##0" = insertvalue {i64, i64, i64, i64, i1} %"tmp#15##0", i64 %"tmp#12##0", 3 + %"tmp#17##0" = insertvalue {i64, i64, i64, i64, i1} %"tmp#16##0", i1 1, 4 + ret {i64, i64, i64, i64, i1} %"tmp#17##0" +if.else.0: + %"tmp#18##0" = insertvalue {i64, i64, i64, i64, i1} undef, i64 undef, 0 + %"tmp#19##0" = insertvalue {i64, i64, i64, i64, i1} %"tmp#18##0", i64 undef, 1 + %"tmp#20##0" = insertvalue {i64, i64, i64, i64, i1} %"tmp#19##0", i64 undef, 2 + %"tmp#21##0" = insertvalue {i64, i64, i64, i64, i1} %"tmp#20##0", i64 undef, 3 + %"tmp#22##0" = insertvalue {i64, i64, i64, i64, i1} %"tmp#21##0", i1 0, 4 + ret {i64, i64, i64, i64, i1} %"tmp#22##0" } - -define external fastcc {i64, i1} @"common_fields.director<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = and i64 %"#rec##0", 3 - %1 = icmp eq i64 %0, 2 - br i1 %1, label %if.then, label %if.else -if.then: - %2 = add i64 %"#rec##0", 6 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = insertvalue {i64, i1} undef, i64 %4, 0 - %6 = insertvalue {i64, i1} %5, i1 1, 1 - ret {i64, i1} %6 -if.else: - %7 = insertvalue {i64, i1} undef, i64 undef, 0 - %8 = insertvalue {i64, i1} %7, i1 0, 1 - ret {i64, i1} %8 +define external fastcc {i64, i1} @"common_fields.director<0>"(i64 %"#rec##0") { + %"tmp#1##0" = and i64 %"#rec##0", 3 + %"tmp#0##0" = icmp eq i64 %"tmp#1##0", 2 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = add i64 %"#rec##0", 6 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#3##0" + %"tmp#5##0" = insertvalue {i64, i1} undef, i64 %"tmp#4##0", 0 + %"tmp#6##0" = insertvalue {i64, i1} %"tmp#5##0", i1 1, 1 + ret {i64, i1} %"tmp#6##0" +if.else.0: + %"tmp#7##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#8##0" = insertvalue {i64, i1} %"tmp#7##0", i1 0, 1 + ret {i64, i1} %"tmp#8##0" } - -define external fastcc {i64, i1} @"common_fields.director<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = and i64 %"#rec##0", 3 - %1 = icmp eq i64 %0, 2 - br i1 %1, label %if.then, label %if.else -if.then: - %2 = trunc i64 32 to i32 - %3 = tail call ccc i8* @wybe_malloc(i32 %2) - %4 = ptrtoint i8* %3 to i64 - %5 = add i64 %4, 2 - %6 = sub i64 %"#rec##0", 2 - %7 = inttoptr i64 %4 to i8* - %8 = inttoptr i64 %6 to i8* - %9 = trunc i64 32 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %7, i8* %8, i32 %9, i1 0) - %10 = add i64 %5, 6 - %11 = inttoptr i64 %10 to i64* - store i64 %"#field##0", i64* %11 - %12 = insertvalue {i64, i1} undef, i64 %5, 0 - %13 = insertvalue {i64, i1} %12, i1 1, 1 - ret {i64, i1} %13 -if.else: - %14 = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 - %15 = insertvalue {i64, i1} %14, i1 0, 1 - ret {i64, i1} %15 +define external fastcc {i64, i1} @"common_fields.director<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#1##0" = and i64 %"#rec##0", 3 + %"tmp#0##0" = icmp eq i64 %"tmp#1##0", 2 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = sub i64 %"#rec##0", 2 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = call ccc ptr @wybe_malloc(i32 32) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#4##0", ptr %"tmp#3##0", i64 32, i1 0) + %"tmp#5##0" = ptrtoint ptr %"tmp#4##0" to i64 + %"tmp#6##0" = add i64 %"tmp#5##0", 2 + %"tmp#7##0" = add i64 %"tmp#6##0", 6 + %"tmp#8##0" = inttoptr i64 %"tmp#7##0" to ptr + store i64 %"#field##0", ptr %"tmp#8##0" + %"tmp#9##0" = insertvalue {i64, i1} undef, i64 %"tmp#6##0", 0 + %"tmp#10##0" = insertvalue {i64, i1} %"tmp#9##0", i1 1, 1 + ret {i64, i1} %"tmp#10##0" +if.else.0: + %"tmp#11##0" = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 + %"tmp#12##0" = insertvalue {i64, i1} %"tmp#11##0", i1 0, 1 + ret {i64, i1} %"tmp#12##0" } - -define external fastcc {i64, i1} @"common_fields.frequency<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = and i64 %"#rec##0", 3 - %1 = icmp eq i64 %0, 1 - br i1 %1, label %if.then, label %if.else -if.then: - %2 = add i64 %"#rec##0", 7 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = insertvalue {i64, i1} undef, i64 %4, 0 - %6 = insertvalue {i64, i1} %5, i1 1, 1 - ret {i64, i1} %6 -if.else: - %7 = insertvalue {i64, i1} undef, i64 undef, 0 - %8 = insertvalue {i64, i1} %7, i1 0, 1 - ret {i64, i1} %8 +define external fastcc {i64, i1} @"common_fields.frequency<0>"(i64 %"#rec##0") { + %"tmp#1##0" = and i64 %"#rec##0", 3 + %"tmp#0##0" = icmp eq i64 %"tmp#1##0", 1 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = add i64 %"#rec##0", 7 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#3##0" + %"tmp#5##0" = insertvalue {i64, i1} undef, i64 %"tmp#4##0", 0 + %"tmp#6##0" = insertvalue {i64, i1} %"tmp#5##0", i1 1, 1 + ret {i64, i1} %"tmp#6##0" +if.else.0: + %"tmp#7##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#8##0" = insertvalue {i64, i1} %"tmp#7##0", i1 0, 1 + ret {i64, i1} %"tmp#8##0" } - -define external fastcc {i64, i1} @"common_fields.frequency<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = and i64 %"#rec##0", 3 - %1 = icmp eq i64 %0, 1 - br i1 %1, label %if.then, label %if.else -if.then: - %2 = trunc i64 24 to i32 - %3 = tail call ccc i8* @wybe_malloc(i32 %2) - %4 = ptrtoint i8* %3 to i64 - %5 = add i64 %4, 1 - %6 = sub i64 %"#rec##0", 1 - %7 = inttoptr i64 %4 to i8* - %8 = inttoptr i64 %6 to i8* - %9 = trunc i64 24 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %7, i8* %8, i32 %9, i1 0) - %10 = add i64 %5, 7 - %11 = inttoptr i64 %10 to i64* - store i64 %"#field##0", i64* %11 - %12 = insertvalue {i64, i1} undef, i64 %5, 0 - %13 = insertvalue {i64, i1} %12, i1 1, 1 - ret {i64, i1} %13 -if.else: - %14 = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 - %15 = insertvalue {i64, i1} %14, i1 0, 1 - ret {i64, i1} %15 +define external fastcc {i64, i1} @"common_fields.frequency<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#1##0" = and i64 %"#rec##0", 3 + %"tmp#0##0" = icmp eq i64 %"tmp#1##0", 1 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = sub i64 %"#rec##0", 1 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = call ccc ptr @wybe_malloc(i32 24) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#4##0", ptr %"tmp#3##0", i64 24, i1 0) + %"tmp#5##0" = ptrtoint ptr %"tmp#4##0" to i64 + %"tmp#6##0" = add i64 %"tmp#5##0", 1 + %"tmp#7##0" = add i64 %"tmp#6##0", 7 + %"tmp#8##0" = inttoptr i64 %"tmp#7##0" to ptr + store i64 %"#field##0", ptr %"tmp#8##0" + %"tmp#9##0" = insertvalue {i64, i1} undef, i64 %"tmp#6##0", 0 + %"tmp#10##0" = insertvalue {i64, i1} %"tmp#9##0", i1 1, 1 + ret {i64, i1} %"tmp#10##0" +if.else.0: + %"tmp#11##0" = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 + %"tmp#12##0" = insertvalue {i64, i1} %"tmp#11##0", i1 0, 1 + ret {i64, i1} %"tmp#12##0" } - -define external fastcc {i64, i1} @"common_fields.genre<0>"(i64 %"#rec##0") { -entry: - %0 = and i64 %"#rec##0", 3 - %1 = icmp eq i64 %0, 0 - br i1 %1, label %if.then, label %if.else -if.then: - %2 = add i64 %"#rec##0", 16 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = insertvalue {i64, i1} undef, i64 %4, 0 - %6 = insertvalue {i64, i1} %5, i1 1, 1 - ret {i64, i1} %6 -if.else: - %7 = icmp eq i64 %0, 2 - br i1 %7, label %if.then1, label %if.else1 -if.then1: - %8 = add i64 %"#rec##0", 14 - %9 = inttoptr i64 %8 to i64* - %10 = load i64, i64* %9 - %11 = insertvalue {i64, i1} undef, i64 %10, 0 - %12 = insertvalue {i64, i1} %11, i1 1, 1 - ret {i64, i1} %12 -if.else1: - %13 = insertvalue {i64, i1} undef, i64 undef, 0 - %14 = insertvalue {i64, i1} %13, i1 0, 1 - ret {i64, i1} %14 +define external fastcc {i64, i1} @"common_fields.genre<0>"(i64 %"#rec##0") { + %"tmp#1##0" = and i64 %"#rec##0", 3 + %"tmp#0##0" = icmp eq i64 %"tmp#1##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#4##0" = add i64 %"#rec##0", 16 + %"tmp#5##0" = inttoptr i64 %"tmp#4##0" to ptr + %"tmp#6##0" = load i64, ptr %"tmp#5##0" + %"tmp#7##0" = insertvalue {i64, i1} undef, i64 %"tmp#6##0", 0 + %"tmp#8##0" = insertvalue {i64, i1} %"tmp#7##0", i1 1, 1 + ret {i64, i1} %"tmp#8##0" +if.else.0: + %"tmp#2##0" = icmp eq i64 %"tmp#1##0", 2 + br i1 %"tmp#2##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#9##0" = add i64 %"#rec##0", 14 + %"tmp#10##0" = inttoptr i64 %"tmp#9##0" to ptr + %"tmp#11##0" = load i64, ptr %"tmp#10##0" + %"tmp#12##0" = insertvalue {i64, i1} undef, i64 %"tmp#11##0", 0 + %"tmp#13##0" = insertvalue {i64, i1} %"tmp#12##0", i1 1, 1 + ret {i64, i1} %"tmp#13##0" +if.else.1: + %"tmp#14##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#15##0" = insertvalue {i64, i1} %"tmp#14##0", i1 0, 1 + ret {i64, i1} %"tmp#15##0" } - -define external fastcc {i64, i1} @"common_fields.genre<1>"(i64 %"#rec##0", i64 %"#field##0") { -entry: - %0 = and i64 %"#rec##0", 3 - %1 = icmp eq i64 %0, 0 - br i1 %1, label %if.then, label %if.else -if.then: - %2 = trunc i64 32 to i32 - %3 = tail call ccc i8* @wybe_malloc(i32 %2) - %4 = ptrtoint i8* %3 to i64 - %5 = inttoptr i64 %4 to i8* - %6 = inttoptr i64 %"#rec##0" to i8* - %7 = trunc i64 32 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %5, i8* %6, i32 %7, i1 0) - %8 = add i64 %4, 16 - %9 = inttoptr i64 %8 to i64* - store i64 %"#field##0", i64* %9 - %10 = insertvalue {i64, i1} undef, i64 %4, 0 - %11 = insertvalue {i64, i1} %10, i1 1, 1 - ret {i64, i1} %11 -if.else: - %12 = icmp eq i64 %0, 2 - br i1 %12, label %if.then1, label %if.else1 -if.then1: - %13 = trunc i64 32 to i32 - %14 = tail call ccc i8* @wybe_malloc(i32 %13) - %15 = ptrtoint i8* %14 to i64 - %16 = add i64 %15, 2 - %17 = sub i64 %"#rec##0", 2 - %18 = inttoptr i64 %15 to i8* - %19 = inttoptr i64 %17 to i8* - %20 = trunc i64 32 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %18, i8* %19, i32 %20, i1 0) - %21 = add i64 %16, 14 - %22 = inttoptr i64 %21 to i64* - store i64 %"#field##0", i64* %22 - %23 = insertvalue {i64, i1} undef, i64 %16, 0 - %24 = insertvalue {i64, i1} %23, i1 1, 1 - ret {i64, i1} %24 -if.else1: - %25 = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 - %26 = insertvalue {i64, i1} %25, i1 0, 1 - ret {i64, i1} %26 +define external fastcc {i64, i1} @"common_fields.genre<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#1##0" = and i64 %"#rec##0", 3 + %"tmp#0##0" = icmp eq i64 %"tmp#1##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#4##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#5##0" = call ccc ptr @wybe_malloc(i32 32) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#5##0", ptr %"tmp#4##0", i64 32, i1 0) + %"tmp#6##0" = ptrtoint ptr %"tmp#5##0" to i64 + %"tmp#7##0" = add i64 %"tmp#6##0", 16 + %"tmp#8##0" = inttoptr i64 %"tmp#7##0" to ptr + store i64 %"#field##0", ptr %"tmp#8##0" + %"tmp#9##0" = insertvalue {i64, i1} undef, i64 %"tmp#6##0", 0 + %"tmp#10##0" = insertvalue {i64, i1} %"tmp#9##0", i1 1, 1 + ret {i64, i1} %"tmp#10##0" +if.else.0: + %"tmp#2##0" = icmp eq i64 %"tmp#1##0", 2 + br i1 %"tmp#2##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#11##0" = sub i64 %"#rec##0", 2 + %"tmp#12##0" = inttoptr i64 %"tmp#11##0" to ptr + %"tmp#13##0" = call ccc ptr @wybe_malloc(i32 32) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#13##0", ptr %"tmp#12##0", i64 32, i1 0) + %"tmp#14##0" = ptrtoint ptr %"tmp#13##0" to i64 + %"tmp#15##0" = add i64 %"tmp#14##0", 2 + %"tmp#16##0" = add i64 %"tmp#15##0", 14 + %"tmp#17##0" = inttoptr i64 %"tmp#16##0" to ptr + store i64 %"#field##0", ptr %"tmp#17##0" + %"tmp#18##0" = insertvalue {i64, i1} undef, i64 %"tmp#15##0", 0 + %"tmp#19##0" = insertvalue {i64, i1} %"tmp#18##0", i1 1, 1 + ret {i64, i1} %"tmp#19##0" +if.else.1: + %"tmp#20##0" = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 + %"tmp#21##0" = insertvalue {i64, i1} %"tmp#20##0", i1 0, 1 + ret {i64, i1} %"tmp#21##0" } - -define external fastcc i64 @"common_fields.id<0>"(i64 %"#rec##0") { -entry: - %0 = and i64 %"#rec##0", 3 - switch i64 %0, label %switch.3.2 [i64 0, label %switch.3.0 i64 1, label %switch.3.1 i64 2, label %switch.3.2] -switch.3.0: - %1 = add i64 %"#rec##0", 24 - %2 = inttoptr i64 %1 to i64* - %3 = load i64, i64* %2 - ret i64 %3 -switch.3.1: - %4 = add i64 %"#rec##0", 15 - %5 = inttoptr i64 %4 to i64* - %6 = load i64, i64* %5 - ret i64 %6 -switch.3.2: - %7 = add i64 %"#rec##0", 22 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - ret i64 %9 +define external fastcc i64 @"common_fields.id<0>"(i64 %"#rec##0") { + %"tmp#1##0" = and i64 %"#rec##0", 3 + switch i64 %"tmp#1##0", label %case.2.switch.0 [ + i64 0, label %case.0.switch.0 + i64 1, label %case.1.switch.0 + i64 2, label %case.2.switch.0 ] +case.0.switch.0: + %"tmp#6##0" = add i64 %"#rec##0", 24 + %"tmp#7##0" = inttoptr i64 %"tmp#6##0" to ptr + %"tmp#8##0" = load i64, ptr %"tmp#7##0" + ret i64 %"tmp#8##0" +case.1.switch.0: + %"tmp#9##0" = add i64 %"#rec##0", 15 + %"tmp#10##0" = inttoptr i64 %"tmp#9##0" to ptr + %"tmp#11##0" = load i64, ptr %"tmp#10##0" + ret i64 %"tmp#11##0" +case.2.switch.0: + %"tmp#12##0" = add i64 %"#rec##0", 22 + %"tmp#13##0" = inttoptr i64 %"tmp#12##0" to ptr + %"tmp#14##0" = load i64, ptr %"tmp#13##0" + ret i64 %"tmp#14##0" } - -define external fastcc i64 @"common_fields.id<1>"(i64 %"#rec##0", i64 %"#field##0") { -entry: - %0 = and i64 %"#rec##0", 3 - switch i64 %0, label %switch.3.2 [i64 0, label %switch.3.0 i64 1, label %switch.3.1 i64 2, label %switch.3.2] -switch.3.0: - %1 = trunc i64 32 to i32 - %2 = tail call ccc i8* @wybe_malloc(i32 %1) - %3 = ptrtoint i8* %2 to i64 - %4 = inttoptr i64 %3 to i8* - %5 = inttoptr i64 %"#rec##0" to i8* - %6 = trunc i64 32 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %4, i8* %5, i32 %6, i1 0) - %7 = add i64 %3, 24 - %8 = inttoptr i64 %7 to i64* - store i64 %"#field##0", i64* %8 - ret i64 %3 -switch.3.1: - %9 = trunc i64 24 to i32 - %10 = tail call ccc i8* @wybe_malloc(i32 %9) - %11 = ptrtoint i8* %10 to i64 - %12 = add i64 %11, 1 - %13 = sub i64 %"#rec##0", 1 - %14 = inttoptr i64 %11 to i8* - %15 = inttoptr i64 %13 to i8* - %16 = trunc i64 24 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %14, i8* %15, i32 %16, i1 0) - %17 = add i64 %12, 15 - %18 = inttoptr i64 %17 to i64* - store i64 %"#field##0", i64* %18 - ret i64 %12 -switch.3.2: - %19 = trunc i64 32 to i32 - %20 = tail call ccc i8* @wybe_malloc(i32 %19) - %21 = ptrtoint i8* %20 to i64 - %22 = add i64 %21, 2 - %23 = sub i64 %"#rec##0", 2 - %24 = inttoptr i64 %21 to i8* - %25 = inttoptr i64 %23 to i8* - %26 = trunc i64 32 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %24, i8* %25, i32 %26, i1 0) - %27 = add i64 %22, 22 - %28 = inttoptr i64 %27 to i64* - store i64 %"#field##0", i64* %28 - ret i64 %22 +define external fastcc i64 @"common_fields.id<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#1##0" = and i64 %"#rec##0", 3 + switch i64 %"tmp#1##0", label %case.2.switch.0 [ + i64 0, label %case.0.switch.0 + i64 1, label %case.1.switch.0 + i64 2, label %case.2.switch.0 ] +case.0.switch.0: + %"tmp#6##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#7##0" = call ccc ptr @wybe_malloc(i32 32) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#7##0", ptr %"tmp#6##0", i64 32, i1 0) + %"tmp#8##0" = ptrtoint ptr %"tmp#7##0" to i64 + %"tmp#9##0" = add i64 %"tmp#8##0", 24 + %"tmp#10##0" = inttoptr i64 %"tmp#9##0" to ptr + store i64 %"#field##0", ptr %"tmp#10##0" + ret i64 %"tmp#8##0" +case.1.switch.0: + %"tmp#11##0" = sub i64 %"#rec##0", 1 + %"tmp#12##0" = inttoptr i64 %"tmp#11##0" to ptr + %"tmp#13##0" = call ccc ptr @wybe_malloc(i32 24) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#13##0", ptr %"tmp#12##0", i64 24, i1 0) + %"tmp#14##0" = ptrtoint ptr %"tmp#13##0" to i64 + %"tmp#15##0" = add i64 %"tmp#14##0", 1 + %"tmp#16##0" = add i64 %"tmp#15##0", 15 + %"tmp#17##0" = inttoptr i64 %"tmp#16##0" to ptr + store i64 %"#field##0", ptr %"tmp#17##0" + ret i64 %"tmp#15##0" +case.2.switch.0: + %"tmp#18##0" = sub i64 %"#rec##0", 2 + %"tmp#19##0" = inttoptr i64 %"tmp#18##0" to ptr + %"tmp#20##0" = call ccc ptr @wybe_malloc(i32 32) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#20##0", ptr %"tmp#19##0", i64 32, i1 0) + %"tmp#21##0" = ptrtoint ptr %"tmp#20##0" to i64 + %"tmp#22##0" = add i64 %"tmp#21##0", 2 + %"tmp#23##0" = add i64 %"tmp#22##0", 22 + %"tmp#24##0" = inttoptr i64 %"tmp#23##0" to ptr + store i64 %"#field##0", ptr %"tmp#24##0" + ret i64 %"tmp#22##0" } - -define external fastcc i64 @"common_fields.id<1>[410bae77d3]"(i64 %"#rec##0", i64 %"#field##0") { -entry: - %0 = and i64 %"#rec##0", 3 - switch i64 %0, label %switch.3.2 [i64 0, label %switch.3.0 i64 1, label %switch.3.1 i64 2, label %switch.3.2] -switch.3.0: - %1 = add i64 %"#rec##0", 24 - %2 = inttoptr i64 %1 to i64* - store i64 %"#field##0", i64* %2 - ret i64 %"#rec##0" -switch.3.1: - %3 = add i64 %"#rec##0", 15 - %4 = inttoptr i64 %3 to i64* - store i64 %"#field##0", i64* %4 - ret i64 %"#rec##0" -switch.3.2: - %5 = add i64 %"#rec##0", 22 - %6 = inttoptr i64 %5 to i64* - store i64 %"#field##0", i64* %6 - ret i64 %"#rec##0" +define external fastcc i64 @"common_fields.id<1>[410bae77d3]"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#1##0" = and i64 %"#rec##0", 3 + switch i64 %"tmp#1##0", label %case.2.switch.0 [ + i64 0, label %case.0.switch.0 + i64 1, label %case.1.switch.0 + i64 2, label %case.2.switch.0 ] +case.0.switch.0: + %"tmp#6##0" = add i64 %"#rec##0", 24 + %"tmp#7##0" = inttoptr i64 %"tmp#6##0" to ptr + store i64 %"#field##0", ptr %"tmp#7##0" + ret i64 %"#rec##0" +case.1.switch.0: + %"tmp#8##0" = add i64 %"#rec##0", 15 + %"tmp#9##0" = inttoptr i64 %"tmp#8##0" to ptr + store i64 %"#field##0", ptr %"tmp#9##0" + ret i64 %"#rec##0" +case.2.switch.0: + %"tmp#10##0" = add i64 %"#rec##0", 22 + %"tmp#11##0" = inttoptr i64 %"tmp#10##0" to ptr + store i64 %"#field##0", ptr %"tmp#11##0" + ret i64 %"#rec##0" } - -define external fastcc i64 @"common_fields.magazine<0>"(i64 %"title##0", i64 %"frequency##0", i64 %"id##0") alwaysinline { -entry: - %0 = trunc i64 24 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"title##0", i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"frequency##0", i64* %5 - %6 = add i64 %2, 16 - %7 = inttoptr i64 %6 to i64* - store i64 %"id##0", i64* %7 - %8 = or i64 %2, 1 - ret i64 %8 +define external fastcc i64 @"common_fields.magazine<0>"(i64 %"title##0", i64 %"frequency##0", i64 %"id##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 24) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"title##0", ptr %"tmp#1##0" + %"tmp#2##0" = add i64 %"#rec##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"frequency##0", ptr %"tmp#3##0" + %"tmp#4##0" = add i64 %"#rec##0", 16 + %"tmp#5##0" = inttoptr i64 %"tmp#4##0" to ptr + store i64 %"id##0", ptr %"tmp#5##0" + %"tmp#6##0" = or i64 %"#rec##0", 1 + ret i64 %"tmp#6##0" } - -define external fastcc {i64, i64, i64, i1} @"common_fields.magazine<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = and i64 %"#result##0", 3 - %1 = icmp eq i64 %0, 1 - br i1 %1, label %if.then, label %if.else -if.then: - %2 = add i64 %"#result##0", -1 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = add i64 %"#result##0", 7 - %6 = inttoptr i64 %5 to i64* - %7 = load i64, i64* %6 - %8 = add i64 %"#result##0", 15 - %9 = inttoptr i64 %8 to i64* - %10 = load i64, i64* %9 - %11 = insertvalue {i64, i64, i64, i1} undef, i64 %4, 0 - %12 = insertvalue {i64, i64, i64, i1} %11, i64 %7, 1 - %13 = insertvalue {i64, i64, i64, i1} %12, i64 %10, 2 - %14 = insertvalue {i64, i64, i64, i1} %13, i1 1, 3 - ret {i64, i64, i64, i1} %14 -if.else: - %15 = insertvalue {i64, i64, i64, i1} undef, i64 undef, 0 - %16 = insertvalue {i64, i64, i64, i1} %15, i64 undef, 1 - %17 = insertvalue {i64, i64, i64, i1} %16, i64 undef, 2 - %18 = insertvalue {i64, i64, i64, i1} %17, i1 0, 3 - ret {i64, i64, i64, i1} %18 +define external fastcc {i64, i64, i64, i1} @"common_fields.magazine<1>"(i64 %"#result##0") { + %"tmp#1##0" = and i64 %"#result##0", 3 + %"tmp#0##0" = icmp eq i64 %"tmp#1##0", 1 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = add i64 %"#result##0", -1 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#3##0" + %"tmp#5##0" = add i64 %"#result##0", 7 + %"tmp#6##0" = inttoptr i64 %"tmp#5##0" to ptr + %"tmp#7##0" = load i64, ptr %"tmp#6##0" + %"tmp#8##0" = add i64 %"#result##0", 15 + %"tmp#9##0" = inttoptr i64 %"tmp#8##0" to ptr + %"tmp#10##0" = load i64, ptr %"tmp#9##0" + %"tmp#11##0" = insertvalue {i64, i64, i64, i1} undef, i64 %"tmp#4##0", 0 + %"tmp#12##0" = insertvalue {i64, i64, i64, i1} %"tmp#11##0", i64 %"tmp#7##0", 1 + %"tmp#13##0" = insertvalue {i64, i64, i64, i1} %"tmp#12##0", i64 %"tmp#10##0", 2 + %"tmp#14##0" = insertvalue {i64, i64, i64, i1} %"tmp#13##0", i1 1, 3 + ret {i64, i64, i64, i1} %"tmp#14##0" +if.else.0: + %"tmp#15##0" = insertvalue {i64, i64, i64, i1} undef, i64 undef, 0 + %"tmp#16##0" = insertvalue {i64, i64, i64, i1} %"tmp#15##0", i64 undef, 1 + %"tmp#17##0" = insertvalue {i64, i64, i64, i1} %"tmp#16##0", i64 undef, 2 + %"tmp#18##0" = insertvalue {i64, i64, i64, i1} %"tmp#17##0", i1 0, 3 + ret {i64, i64, i64, i1} %"tmp#18##0" } - -define external fastcc i64 @"common_fields.other<0>"(i64 %"title##0", i64 %"id##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"title##0", i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"id##0", i64* %5 - %6 = or i64 %2, 3 - ret i64 %6 +define external fastcc i64 @"common_fields.other<0>"(i64 %"title##0", i64 %"id##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 16) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"title##0", ptr %"tmp#1##0" + %"tmp#2##0" = add i64 %"#rec##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"id##0", ptr %"tmp#3##0" + %"tmp#4##0" = or i64 %"#rec##0", 3 + ret i64 %"tmp#4##0" } - -define external fastcc {i64, i64, i1} @"common_fields.other<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = and i64 %"#result##0", 3 - %1 = icmp eq i64 %0, 3 - br i1 %1, label %if.then, label %if.else -if.then: - %2 = add i64 %"#result##0", -3 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = add i64 %"#result##0", 5 - %6 = inttoptr i64 %5 to i64* - %7 = load i64, i64* %6 - %8 = insertvalue {i64, i64, i1} undef, i64 %4, 0 - %9 = insertvalue {i64, i64, i1} %8, i64 %7, 1 - %10 = insertvalue {i64, i64, i1} %9, i1 1, 2 - ret {i64, i64, i1} %10 -if.else: - %11 = insertvalue {i64, i64, i1} undef, i64 undef, 0 - %12 = insertvalue {i64, i64, i1} %11, i64 undef, 1 - %13 = insertvalue {i64, i64, i1} %12, i1 0, 2 - ret {i64, i64, i1} %13 +define external fastcc {i64, i64, i1} @"common_fields.other<1>"(i64 %"#result##0") { + %"tmp#1##0" = and i64 %"#result##0", 3 + %"tmp#0##0" = icmp eq i64 %"tmp#1##0", 3 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = add i64 %"#result##0", -3 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#3##0" + %"tmp#5##0" = add i64 %"#result##0", 5 + %"tmp#6##0" = inttoptr i64 %"tmp#5##0" to ptr + %"tmp#7##0" = load i64, ptr %"tmp#6##0" + %"tmp#8##0" = insertvalue {i64, i64, i1} undef, i64 %"tmp#4##0", 0 + %"tmp#9##0" = insertvalue {i64, i64, i1} %"tmp#8##0", i64 %"tmp#7##0", 1 + %"tmp#10##0" = insertvalue {i64, i64, i1} %"tmp#9##0", i1 1, 2 + ret {i64, i64, i1} %"tmp#10##0" +if.else.0: + %"tmp#11##0" = insertvalue {i64, i64, i1} undef, i64 undef, 0 + %"tmp#12##0" = insertvalue {i64, i64, i1} %"tmp#11##0", i64 undef, 1 + %"tmp#13##0" = insertvalue {i64, i64, i1} %"tmp#12##0", i1 0, 2 + ret {i64, i64, i1} %"tmp#13##0" } - -define external fastcc i64 @"common_fields.title<0>"(i64 %"#rec##0") { -entry: - %0 = and i64 %"#rec##0", 3 - switch i64 %0, label %switch.3.2 [i64 0, label %switch.3.0 i64 1, label %switch.3.1 i64 2, label %switch.3.2] -switch.3.0: - %1 = inttoptr i64 %"#rec##0" to i64* - %2 = load i64, i64* %1 - ret i64 %2 -switch.3.1: - %3 = add i64 %"#rec##0", -1 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - ret i64 %5 -switch.3.2: - %6 = add i64 %"#rec##0", -2 - %7 = inttoptr i64 %6 to i64* - %8 = load i64, i64* %7 - ret i64 %8 +define external fastcc i64 @"common_fields.title<0>"(i64 %"#rec##0") { + %"tmp#1##0" = and i64 %"#rec##0", 3 + switch i64 %"tmp#1##0", label %case.2.switch.0 [ + i64 0, label %case.0.switch.0 + i64 1, label %case.1.switch.0 + i64 2, label %case.2.switch.0 ] +case.0.switch.0: + %"tmp#6##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#7##0" = load i64, ptr %"tmp#6##0" + ret i64 %"tmp#7##0" +case.1.switch.0: + %"tmp#8##0" = add i64 %"#rec##0", -1 + %"tmp#9##0" = inttoptr i64 %"tmp#8##0" to ptr + %"tmp#10##0" = load i64, ptr %"tmp#9##0" + ret i64 %"tmp#10##0" +case.2.switch.0: + %"tmp#11##0" = add i64 %"#rec##0", -2 + %"tmp#12##0" = inttoptr i64 %"tmp#11##0" to ptr + %"tmp#13##0" = load i64, ptr %"tmp#12##0" + ret i64 %"tmp#13##0" } - -define external fastcc i64 @"common_fields.title<1>"(i64 %"#rec##0", i64 %"#field##0") { -entry: - %0 = and i64 %"#rec##0", 3 - switch i64 %0, label %switch.3.2 [i64 0, label %switch.3.0 i64 1, label %switch.3.1 i64 2, label %switch.3.2] -switch.3.0: - %1 = trunc i64 32 to i32 - %2 = tail call ccc i8* @wybe_malloc(i32 %1) - %3 = ptrtoint i8* %2 to i64 - %4 = inttoptr i64 %3 to i8* - %5 = inttoptr i64 %"#rec##0" to i8* - %6 = trunc i64 32 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %4, i8* %5, i32 %6, i1 0) - %7 = inttoptr i64 %3 to i64* - store i64 %"#field##0", i64* %7 - ret i64 %3 -switch.3.1: - %8 = trunc i64 24 to i32 - %9 = tail call ccc i8* @wybe_malloc(i32 %8) - %10 = ptrtoint i8* %9 to i64 - %11 = add i64 %10, 1 - %12 = sub i64 %"#rec##0", 1 - %13 = inttoptr i64 %10 to i8* - %14 = inttoptr i64 %12 to i8* - %15 = trunc i64 24 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %13, i8* %14, i32 %15, i1 0) - %16 = add i64 %11, -1 - %17 = inttoptr i64 %16 to i64* - store i64 %"#field##0", i64* %17 - ret i64 %11 -switch.3.2: - %18 = trunc i64 32 to i32 - %19 = tail call ccc i8* @wybe_malloc(i32 %18) - %20 = ptrtoint i8* %19 to i64 - %21 = add i64 %20, 2 - %22 = sub i64 %"#rec##0", 2 - %23 = inttoptr i64 %20 to i8* - %24 = inttoptr i64 %22 to i8* - %25 = trunc i64 32 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %23, i8* %24, i32 %25, i1 0) - %26 = add i64 %21, -2 - %27 = inttoptr i64 %26 to i64* - store i64 %"#field##0", i64* %27 - ret i64 %21 +define external fastcc i64 @"common_fields.title<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#1##0" = and i64 %"#rec##0", 3 + switch i64 %"tmp#1##0", label %case.2.switch.0 [ + i64 0, label %case.0.switch.0 + i64 1, label %case.1.switch.0 + i64 2, label %case.2.switch.0 ] +case.0.switch.0: + %"tmp#6##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#7##0" = call ccc ptr @wybe_malloc(i32 32) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#7##0", ptr %"tmp#6##0", i64 32, i1 0) + %"tmp#8##0" = ptrtoint ptr %"tmp#7##0" to i64 + %"tmp#9##0" = inttoptr i64 %"tmp#8##0" to ptr + store i64 %"#field##0", ptr %"tmp#9##0" + ret i64 %"tmp#8##0" +case.1.switch.0: + %"tmp#10##0" = sub i64 %"#rec##0", 1 + %"tmp#11##0" = inttoptr i64 %"tmp#10##0" to ptr + %"tmp#12##0" = call ccc ptr @wybe_malloc(i32 24) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#12##0", ptr %"tmp#11##0", i64 24, i1 0) + %"tmp#13##0" = ptrtoint ptr %"tmp#12##0" to i64 + %"tmp#14##0" = add i64 %"tmp#13##0", 1 + %"tmp#15##0" = add i64 %"tmp#14##0", -1 + %"tmp#16##0" = inttoptr i64 %"tmp#15##0" to ptr + store i64 %"#field##0", ptr %"tmp#16##0" + ret i64 %"tmp#14##0" +case.2.switch.0: + %"tmp#17##0" = sub i64 %"#rec##0", 2 + %"tmp#18##0" = inttoptr i64 %"tmp#17##0" to ptr + %"tmp#19##0" = call ccc ptr @wybe_malloc(i32 32) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#19##0", ptr %"tmp#18##0", i64 32, i1 0) + %"tmp#20##0" = ptrtoint ptr %"tmp#19##0" to i64 + %"tmp#21##0" = add i64 %"tmp#20##0", 2 + %"tmp#22##0" = add i64 %"tmp#21##0", -2 + %"tmp#23##0" = inttoptr i64 %"tmp#22##0" to ptr + store i64 %"#field##0", ptr %"tmp#23##0" + ret i64 %"tmp#21##0" } - -define external fastcc i1 @"common_fields.~=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = tail call fastcc i1 @"common_fields.=<0>"(i64 %"#left##0", i64 %"#right##0") - %1 = xor i1 %0, 1 - ret i1 %1 +define external fastcc i1 @"common_fields.~=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#0##0" = tail call fastcc i1 @"common_fields.=<0>"(i64 %"#left##0", i64 %"#right##0") + %"tmp#1##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#1##0" } diff --git a/test-cases/final-dump/commonsubexpr.exp b/test-cases/final-dump/commonsubexpr.exp index 1a869125e..5b0b78914 100644 --- a/test-cases/final-dump/commonsubexpr.exp +++ b/test-cases/final-dump/commonsubexpr.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module commonsubexpr representation : (not a type) public submods : @@ -44,47 +47,37 @@ common_subexpr(x##0:wybe.int)<{<>}; {<>}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'commonsubexpr' +source_filename = "!ROOT!/final-dump/commonsubexpr.wybe" +target triple ???? - - - -declare external ccc void @putchar(i8) - - -declare external ccc void @print_int(i64) +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"commonsubexpr.<0>"() { -entry: - tail call ccc void @print_int(i64 198) - tail call ccc void @putchar(i8 10) - tail call ccc void @print_int(i64 198) - tail call ccc void @putchar(i8 10) - tail call ccc void @print_int(i64 11) - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"commonsubexpr.<0>"() { + call ccc void @print_int(i64 198) + call ccc void @putchar(i8 10) + call ccc void @print_int(i64 198) + call ccc void @putchar(i8 10) + call ccc void @print_int(i64 11) + call ccc void @putchar(i8 10) + ret void } - -define external fastcc void @"commonsubexpr.common_subexpr<0>"(i64 %"x##0") alwaysinline { -entry: - %0 = add i64 %"x##0", 1 - %1 = sub i64 %"x##0", 1 - %2 = mul i64 %0, %1 - %3 = add i64 %2, %2 - tail call ccc void @print_int(i64 %3) - tail call ccc void @putchar(i8 10) - tail call ccc void @print_int(i64 %3) - tail call ccc void @putchar(i8 10) - tail call ccc void @print_int(i64 %0) - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"commonsubexpr.common_subexpr<0>"(i64 %"x##0") { + %"tmp#2##0" = add i64 %"x##0", 1 + %"tmp#64##0" = sub i64 %"x##0", 1 + %"tmp#50##0" = mul i64 %"tmp#2##0", %"tmp#64##0" + %"tmp#0##0" = add i64 %"tmp#50##0", %"tmp#50##0" + call ccc void @print_int(i64 %"tmp#0##0") + call ccc void @putchar(i8 10) + call ccc void @print_int(i64 %"tmp#0##0") + call ccc void @putchar(i8 10) + call ccc void @print_int(i64 %"tmp#2##0") + call ccc void @putchar(i8 10) + ret void } diff --git a/test-cases/final-dump/compute.exp b/test-cases/final-dump/compute.exp index 4489f0ad2..9c7e4813b 100644 --- a/test-cases/final-dump/compute.exp +++ b/test-cases/final-dump/compute.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module compute representation : (not a type) public submods : @@ -25,39 +28,28 @@ module top-level code > public {semipure} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'compute' +source_filename = "!ROOT!/final-dump/compute.wybe" +target triple ???? - - - -declare external ccc void @putchar(i8) - - -declare external ccc void @print_float(double) - - -declare external ccc void @print_int(i64) +declare external fastcc i64 @"math.utils.factorial<0>"(i64) +declare external ccc void @print_float(double) +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -declare external fastcc i64 @"math.utils.factorial<0>"(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"compute.<0>"() { -entry: - %0 = tail call fastcc i64 @"math.utils.factorial<0>"(i64 4) - tail call ccc void @print_int(i64 %0) - tail call ccc void @putchar(i8 10) - tail call ccc void @print_float(double 6.555556e1) - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"compute.<0>"() { + %"tmp#0##0" = tail call fastcc i64 @"math.utils.factorial<0>"(i64 4) + call ccc void @print_int(i64 %"tmp#0##0") + call ccc void @putchar(i8 10) + call ccc void @print_float(double 65.55555555555556) + call ccc void @putchar(i8 10) + ret void } + -------------------------------------------------- Module math representation : (not a type) @@ -77,16 +69,15 @@ entry: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'math' +source_filename = "!ROOT!/final-dump/math/_.wybe" +target triple ???? - - - -declare external ccc i8* @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) -------------------------------------------------- Module math.temperature representation : (not a type) @@ -107,24 +98,21 @@ toCelsius(f##0:wybe.float, ?#result##0:wybe.float)<{}; {}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'math.temperature' +source_filename = "!ROOT!/final-dump/math/temperature.wybe" +target triple ???? - +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc double @"math.temperature.toCelsius<0>"(double %"f##0") alwaysinline { -entry: - %0 = fsub double %"f##0", 3.200000e1 - %1 = fdiv double %0, 1.800000e0 - ret double %1 +define external fastcc double @"math.temperature.toCelsius<0>"(double %"f##0") { + %"tmp#1##0" = fsub double %"f##0", 32.0 + %"tmp#6##0" = fdiv double %"tmp#1##0", 1.8 + ret double %"tmp#6##0" } + -------------------------------------------------- Module math.utils representation : (not a type) @@ -165,47 +153,33 @@ factorial(n##0:wybe.int, ?#result##0:wybe.int)<{}; {}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'math.utils' +source_filename = "!ROOT!/final-dump/math/utils.wybe" +target triple ???? - - - -@math.utils.1 = constant {i64, i64} { i64 27, i64 ptrtoint ([?? x i8]* @math.utils.0 to i64) } - - -@math.utils.0 = constant [?? x i8] c"Utils has been initialised.\00" +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c"Utils has been initialised.\00", align 8 +@"string#1" = private unnamed_addr constant {i64, i64} { i64 27, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -declare external ccc void @putchar(i8) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"math.utils.<0>"() alwaysinline { -entry: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @math.utils.1, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"math.utils.<0>"() { + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#1" to i64 )) + call ccc void @putchar(i8 10) + ret void } - -define external fastcc i64 @"math.utils.factorial<0>"(i64 %"n##0") { -entry: - %0 = icmp sle i64 %"n##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - ret i64 1 -if.else: - %1 = sub i64 %"n##0", 1 - %2 = tail call fastcc i64 @"math.utils.factorial<0>"(i64 %1) - %3 = mul i64 %"n##0", %2 - ret i64 %3 +define external fastcc i64 @"math.utils.factorial<0>"(i64 %"n##0") { + %"tmp#4##0" = icmp sle i64 %"n##0", 0 + br i1 %"tmp#4##0", label %if.then.0, label %if.else.0 +if.then.0: + ret i64 1 +if.else.0: + %"tmp#3##0" = sub i64 %"n##0", 1 + %"tmp#2##0" = tail call fastcc i64 @"math.utils.factorial<0>"(i64 %"tmp#3##0") + %"tmp#11##0" = mul i64 %"n##0", %"tmp#2##0" + ret i64 %"tmp#11##0" } diff --git a/test-cases/final-dump/cond_expr_no_else.exp b/test-cases/final-dump/cond_expr_no_else.exp index 0cc1aed03..04c41a4e5 100644 --- a/test-cases/final-dump/cond_expr_no_else.exp +++ b/test-cases/final-dump/cond_expr_no_else.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module cond_expr_no_else representation : (not a type) public submods : @@ -171,192 +174,150 @@ vowel_num(c##0:wybe.char, ?#result##0:wybe.int, ?#success##0:wybe.bool)<{}; {}; LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'cond_expr_no_else' - - - - -@cond_expr_no_else.1 = constant {i64, i64} { i64 9, i64 ptrtoint ([?? x i8]* @cond_expr_no_else.0 to i64) } - - -@cond_expr_no_else.3 = constant {i64, i64} { i64 10, i64 ptrtoint ([?? x i8]* @cond_expr_no_else.2 to i64) } - - -@cond_expr_no_else.5 = constant {i64, i64} { i64 18, i64 ptrtoint ([?? x i8]* @cond_expr_no_else.4 to i64) } - - -@cond_expr_no_else.7 = constant {i64, i64} { i64 18, i64 ptrtoint ([?? x i8]* @cond_expr_no_else.6 to i64) } - - -@cond_expr_no_else.2 = constant [?? x i8] c"-5:int -> \00" - - -@cond_expr_no_else.0 = constant [?? x i8] c"5:int -> \00" - - -@cond_expr_no_else.4 = constant [?? x i8] c"e is vowel number \00" - - -@cond_expr_no_else.6 = constant [?? x i8] c"f is vowel number \00" - - -declare external ccc void @putchar(i8) - - -declare external fastcc void @"wybe.string.print<0>[410bae77d3]"(i64) - - -declare external fastcc i64 @"wybe.string.,,<0>"(i64, i64) - - -declare external fastcc i64 @"wybe.int.fmt<2>"(i64, i64, i8) - - -declare external fastcc i64 @"wybe.count.fmt<2>"(i64, i64, i8) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"cond_expr_no_else.<0>"() { -entry: - %0 = tail call fastcc {i64, i1} @"cond_expr_no_else.to_count<0>"(i64 5) - %1 = extractvalue {i64, i1} %0, 0 - %2 = extractvalue {i64, i1} %0, 1 - br i1 %2, label %if.then, label %if.else -if.then: - tail call fastcc void @"cond_expr_no_else.#cont#1<0>"(i64 %1) - ret void -if.else: - tail call fastcc void @"cond_expr_no_else.#cont#1<0>"(i64 10) - ret void +source_filename = "!ROOT!/final-dump/cond_expr_no_else.wybe" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c"-5:int -> \00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c"5:int -> \00", align 8 +@"cstring#2" = private unnamed_addr constant [ ?? x i8 ] c"e is vowel number \00", align 8 +@"cstring#3" = private unnamed_addr constant [ ?? x i8 ] c"f is vowel number \00", align 8 +@"string#4" = private unnamed_addr constant {i64, i64} { i64 10, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +@"string#5" = private unnamed_addr constant {i64, i64} { i64 9, i64 ptrtoint( ptr @"cstring#1" to i64 ) }, align 8 +@"string#6" = private unnamed_addr constant {i64, i64} { i64 18, i64 ptrtoint( ptr @"cstring#2" to i64 ) }, align 8 +@"string#7" = private unnamed_addr constant {i64, i64} { i64 18, i64 ptrtoint( ptr @"cstring#3" to i64 ) }, align 8 + +declare external fastcc i64 @"wybe.count.fmt<2>"(i64, i64, i8) +declare external fastcc i64 @"wybe.int.fmt<2>"(i64, i64, i8) +declare external fastcc i64 @"wybe.string.,,<0>"(i64, i64) +declare external fastcc void @"wybe.string.print<0>[410bae77d3]"(i64) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"cond_expr_no_else.<0>"() { + %"tmp#20##0" = tail call fastcc {i64, i1} @"cond_expr_no_else.to_count<0>"(i64 5) + %"tmp#3##0" = extractvalue {i64, i1}%"tmp#20##0", 0 + %"tmp#19##0" = extractvalue {i64, i1}%"tmp#20##0", 1 + br i1 %"tmp#19##0", label %if.then.0, label %if.else.0 +if.then.0: + tail call fastcc void @"cond_expr_no_else.#cont#1<0>"(i64 %"tmp#3##0") + ret void +if.else.0: + tail call fastcc void @"cond_expr_no_else.#cont#1<0>"(i64 10) + ret void } - -define external fastcc void @"cond_expr_no_else.#cont#1<0>"(i64 %"tmp#2##0") { -entry: - %0 = tail call fastcc i64 @"wybe.count.fmt<2>"(i64 %"tmp#2##0", i64 0, i8 32) - %1 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @cond_expr_no_else.1, i32 0, i32 0) to i64), i64 %0) - tail call fastcc void @"wybe.string.print<0>[410bae77d3]"(i64 %1) - tail call ccc void @putchar(i8 10) - %2 = tail call fastcc {i64, i1} @"cond_expr_no_else.to_count<0>"(i64 -5) - %3 = extractvalue {i64, i1} %2, 0 - %4 = extractvalue {i64, i1} %2, 1 - br i1 %4, label %if.then, label %if.else -if.then: - musttail call fastcc void @"cond_expr_no_else.#cont#2<0>"(i64 %3) - ret void -if.else: - musttail call fastcc void @"cond_expr_no_else.#cont#2<0>"(i64 10) - ret void +define external fastcc void @"cond_expr_no_else.#cont#1<0>"(i64 %"tmp#2##0") { + %"tmp#1##0" = tail call fastcc i64 @"wybe.count.fmt<2>"(i64 %"tmp#2##0", i64 0, i8 32) + %"tmp#0##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint( ptr @"string#5" to i64 ), i64 %"tmp#1##0") + tail call fastcc void @"wybe.string.print<0>[410bae77d3]"(i64 %"tmp#0##0") + call ccc void @putchar(i8 10) + %"tmp#23##0" = tail call fastcc {i64, i1} @"cond_expr_no_else.to_count<0>"(i64 -5) + %"tmp#7##0" = extractvalue {i64, i1}%"tmp#23##0", 0 + %"tmp#18##0" = extractvalue {i64, i1}%"tmp#23##0", 1 + br i1 %"tmp#18##0", label %if.then.0, label %if.else.0 +if.then.0: + tail call fastcc void @"cond_expr_no_else.#cont#2<0>"(i64 %"tmp#7##0") + ret void +if.else.0: + tail call fastcc void @"cond_expr_no_else.#cont#2<0>"(i64 10) + ret void } - -define external fastcc void @"cond_expr_no_else.#cont#2<0>"(i64 %"tmp#6##0") { -entry: - %0 = tail call fastcc i64 @"wybe.count.fmt<2>"(i64 %"tmp#6##0", i64 0, i8 32) - %1 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @cond_expr_no_else.3, i32 0, i32 0) to i64), i64 %0) - tail call fastcc void @"wybe.string.print<0>[410bae77d3]"(i64 %1) - tail call ccc void @putchar(i8 10) - %2 = tail call fastcc {i64, i1} @"cond_expr_no_else.vowel_num<0>"(i8 101) - %3 = extractvalue {i64, i1} %2, 0 - %4 = extractvalue {i64, i1} %2, 1 - br i1 %4, label %if.then, label %if.else -if.then: - musttail call fastcc void @"cond_expr_no_else.#cont#3<0>"(i64 %3) - ret void -if.else: - musttail call fastcc void @"cond_expr_no_else.#cont#3<0>"(i64 0) - ret void +define external fastcc void @"cond_expr_no_else.#cont#2<0>"(i64 %"tmp#6##0") { + %"tmp#5##0" = tail call fastcc i64 @"wybe.count.fmt<2>"(i64 %"tmp#6##0", i64 0, i8 32) + %"tmp#4##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint( ptr @"string#4" to i64 ), i64 %"tmp#5##0") + tail call fastcc void @"wybe.string.print<0>[410bae77d3]"(i64 %"tmp#4##0") + call ccc void @putchar(i8 10) + %"tmp#22##0" = tail call fastcc {i64, i1} @"cond_expr_no_else.vowel_num<0>"(i8 101) + %"tmp#11##0" = extractvalue {i64, i1}%"tmp#22##0", 0 + %"tmp#17##0" = extractvalue {i64, i1}%"tmp#22##0", 1 + br i1 %"tmp#17##0", label %if.then.0, label %if.else.0 +if.then.0: + tail call fastcc void @"cond_expr_no_else.#cont#3<0>"(i64 %"tmp#11##0") + ret void +if.else.0: + tail call fastcc void @"cond_expr_no_else.#cont#3<0>"(i64 0) + ret void } - -define external fastcc void @"cond_expr_no_else.#cont#3<0>"(i64 %"tmp#10##0") { -entry: - %0 = tail call fastcc i64 @"wybe.int.fmt<2>"(i64 %"tmp#10##0", i64 0, i8 32) - %1 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @cond_expr_no_else.5, i32 0, i32 0) to i64), i64 %0) - tail call fastcc void @"wybe.string.print<0>[410bae77d3]"(i64 %1) - tail call ccc void @putchar(i8 10) - %2 = tail call fastcc {i64, i1} @"cond_expr_no_else.vowel_num<0>"(i8 102) - %3 = extractvalue {i64, i1} %2, 0 - %4 = extractvalue {i64, i1} %2, 1 - br i1 %4, label %if.then, label %if.else -if.then: - musttail call fastcc void @"cond_expr_no_else.#cont#4<0>"(i64 %3) - ret void -if.else: - musttail call fastcc void @"cond_expr_no_else.#cont#4<0>"(i64 0) - ret void +define external fastcc void @"cond_expr_no_else.#cont#3<0>"(i64 %"tmp#10##0") { + %"tmp#9##0" = tail call fastcc i64 @"wybe.int.fmt<2>"(i64 %"tmp#10##0", i64 0, i8 32) + %"tmp#8##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint( ptr @"string#6" to i64 ), i64 %"tmp#9##0") + tail call fastcc void @"wybe.string.print<0>[410bae77d3]"(i64 %"tmp#8##0") + call ccc void @putchar(i8 10) + %"tmp#21##0" = tail call fastcc {i64, i1} @"cond_expr_no_else.vowel_num<0>"(i8 102) + %"tmp#15##0" = extractvalue {i64, i1}%"tmp#21##0", 0 + %"tmp#16##0" = extractvalue {i64, i1}%"tmp#21##0", 1 + br i1 %"tmp#16##0", label %if.then.0, label %if.else.0 +if.then.0: + tail call fastcc void @"cond_expr_no_else.#cont#4<0>"(i64 %"tmp#15##0") + ret void +if.else.0: + tail call fastcc void @"cond_expr_no_else.#cont#4<0>"(i64 0) + ret void } - -define external fastcc void @"cond_expr_no_else.#cont#4<0>"(i64 %"tmp#14##0") { -entry: - %0 = tail call fastcc i64 @"wybe.int.fmt<2>"(i64 %"tmp#14##0", i64 0, i8 32) - %1 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @cond_expr_no_else.7, i32 0, i32 0) to i64), i64 %0) - tail call fastcc void @"wybe.string.print<0>[410bae77d3]"(i64 %1) - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"cond_expr_no_else.#cont#4<0>"(i64 %"tmp#14##0") { + %"tmp#13##0" = tail call fastcc i64 @"wybe.int.fmt<2>"(i64 %"tmp#14##0", i64 0, i8 32) + %"tmp#12##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint( ptr @"string#7" to i64 ), i64 %"tmp#13##0") + tail call fastcc void @"wybe.string.print<0>[410bae77d3]"(i64 %"tmp#12##0") + call ccc void @putchar(i8 10) + ret void } - -define external fastcc {i64, i1} @"cond_expr_no_else.to_count<0>"(i64 %"i##0") { -entry: - %0 = icmp sge i64 %"i##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = insertvalue {i64, i1} undef, i64 %"i##0", 0 - %2 = insertvalue {i64, i1} %1, i1 1, 1 - ret {i64, i1} %2 -if.else: - %3 = insertvalue {i64, i1} undef, i64 undef, 0 - %4 = insertvalue {i64, i1} %3, i1 0, 1 - ret {i64, i1} %4 +define external fastcc {i64, i1} @"cond_expr_no_else.to_count<0>"(i64 %"i##0") { + %"tmp#1##0" = icmp sge i64 %"i##0", 0 + br i1 %"tmp#1##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#4##0" = insertvalue {i64, i1} undef, i64 %"i##0", 0 + %"tmp#5##0" = insertvalue {i64, i1} %"tmp#4##0", i1 1, 1 + ret {i64, i1} %"tmp#5##0" +if.else.0: + %"tmp#6##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#7##0" = insertvalue {i64, i1} %"tmp#6##0", i1 0, 1 + ret {i64, i1} %"tmp#7##0" } - -define external fastcc {i64, i1} @"cond_expr_no_else.vowel_num<0>"(i8 %"c##0") { -entry: - %0 = icmp eq i8 %"c##0", 97 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = insertvalue {i64, i1} undef, i64 1, 0 - %2 = insertvalue {i64, i1} %1, i1 1, 1 - ret {i64, i1} %2 -if.else: - %3 = icmp eq i8 %"c##0", 101 - br i1 %3, label %if.then1, label %if.else1 -if.then1: - %4 = insertvalue {i64, i1} undef, i64 2, 0 - %5 = insertvalue {i64, i1} %4, i1 1, 1 - ret {i64, i1} %5 -if.else1: - %6 = icmp eq i8 %"c##0", 105 - br i1 %6, label %if.then2, label %if.else2 -if.then2: - %7 = insertvalue {i64, i1} undef, i64 3, 0 - %8 = insertvalue {i64, i1} %7, i1 1, 1 - ret {i64, i1} %8 -if.else2: - %9 = icmp eq i8 %"c##0", 111 - br i1 %9, label %if.then3, label %if.else3 -if.then3: - %10 = insertvalue {i64, i1} undef, i64 4, 0 - %11 = insertvalue {i64, i1} %10, i1 1, 1 - ret {i64, i1} %11 -if.else3: - %12 = icmp eq i8 %"c##0", 117 - br i1 %12, label %if.then4, label %if.else4 -if.then4: - %13 = insertvalue {i64, i1} undef, i64 5, 0 - %14 = insertvalue {i64, i1} %13, i1 1, 1 - ret {i64, i1} %14 -if.else4: - %15 = insertvalue {i64, i1} undef, i64 undef, 0 - %16 = insertvalue {i64, i1} %15, i1 0, 1 - ret {i64, i1} %16 +define external fastcc {i64, i1} @"cond_expr_no_else.vowel_num<0>"(i8 %"c##0") { + %"tmp#5##0" = icmp eq i8 %"c##0", 97 + br i1 %"tmp#5##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#16##0" = insertvalue {i64, i1} undef, i64 1, 0 + %"tmp#17##0" = insertvalue {i64, i1} %"tmp#16##0", i1 1, 1 + ret {i64, i1} %"tmp#17##0" +if.else.0: + %"tmp#4##0" = icmp eq i8 %"c##0", 101 + br i1 %"tmp#4##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#18##0" = insertvalue {i64, i1} undef, i64 2, 0 + %"tmp#19##0" = insertvalue {i64, i1} %"tmp#18##0", i1 1, 1 + ret {i64, i1} %"tmp#19##0" +if.else.1: + %"tmp#3##0" = icmp eq i8 %"c##0", 105 + br i1 %"tmp#3##0", label %if.then.2, label %if.else.2 +if.then.2: + %"tmp#20##0" = insertvalue {i64, i1} undef, i64 3, 0 + %"tmp#21##0" = insertvalue {i64, i1} %"tmp#20##0", i1 1, 1 + ret {i64, i1} %"tmp#21##0" +if.else.2: + %"tmp#2##0" = icmp eq i8 %"c##0", 111 + br i1 %"tmp#2##0", label %if.then.3, label %if.else.3 +if.then.3: + %"tmp#22##0" = insertvalue {i64, i1} undef, i64 4, 0 + %"tmp#23##0" = insertvalue {i64, i1} %"tmp#22##0", i1 1, 1 + ret {i64, i1} %"tmp#23##0" +if.else.3: + %"tmp#1##0" = icmp eq i8 %"c##0", 117 + br i1 %"tmp#1##0", label %if.then.4, label %if.else.4 +if.then.4: + %"tmp#24##0" = insertvalue {i64, i1} undef, i64 5, 0 + %"tmp#25##0" = insertvalue {i64, i1} %"tmp#24##0", i1 1, 1 + ret {i64, i1} %"tmp#25##0" +if.else.4: + %"tmp#26##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#27##0" = insertvalue {i64, i1} %"tmp#26##0", i1 0, 1 + ret {i64, i1} %"tmp#27##0" } diff --git a/test-cases/final-dump/constfold.exp b/test-cases/final-dump/constfold.exp index 3b3786352..f1891e156 100644 --- a/test-cases/final-dump/constfold.exp +++ b/test-cases/final-dump/constfold.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module constfold representation : (not a type) public submods : @@ -45,37 +48,27 @@ fortytwo(?#result##0:wybe.int)<{}; {}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'constfold' - - - - -declare external ccc i8* @wybe_malloc(i32) +source_filename = "!ROOT!/final-dump/constfold.wybe" +target triple ???? -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) - -define external fastcc i64 @"constfold.fold_add<0>"() alwaysinline { -entry: - ret i64 42 +define external fastcc i64 @"constfold.fold_add<0>"() { + ret i64 42 } - -define external fastcc i64 @"constfold.fold_mult<0>"() alwaysinline { -entry: - ret i64 42 +define external fastcc i64 @"constfold.fold_mult<0>"() { + ret i64 42 } - -define external fastcc i64 @"constfold.fold_test<0>"() alwaysinline { -entry: - ret i64 42 +define external fastcc i64 @"constfold.fold_test<0>"() { + ret i64 42 } - -define external fastcc i64 @"constfold.fortytwo<0>"() alwaysinline { -entry: - ret i64 42 +define external fastcc i64 @"constfold.fortytwo<0>"() { + ret i64 42 } diff --git a/test-cases/final-dump/constructors.exp b/test-cases/final-dump/constructors.exp index 41849e525..2d620475a 100644 --- a/test-cases/final-dump/constructors.exp +++ b/test-cases/final-dump/constructors.exp @@ -1,7 +1,10 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module constructors - representation : address + representation : pointer public submods : public resources: public procs : constructors.=<0> @@ -113,118 +116,99 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'constructors' - - - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i1 @"constructors.=<0>"(i64 %"#left##0", i64 %"#right##0") { -entry: - %0 = icmp ne i64 %"#left##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"#left##0" to i64* - %2 = load i64, i64* %1 - %3 = icmp ne i64 %"#right##0", 0 - br i1 %3, label %if.then1, label %if.else1 -if.else: - %7 = icmp eq i64 %"#right##0", 0 - ret i1 %7 -if.then1: - %4 = inttoptr i64 %"#right##0" to i64* - %5 = load i64, i64* %4 - %6 = icmp eq i64 %2, %5 - ret i1 %6 -if.else1: - ret i1 0 +source_filename = "!ROOT!/final-dump/constructors.wybe" +target triple ???? + + +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc i1 @"constructors.=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#0##0" = icmp ne i64 %"#left##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#11##0" = inttoptr i64 %"#left##0" to ptr + %"#left#value##0" = load i64, ptr %"tmp#11##0" + %"tmp#8##0" = icmp ne i64 %"#right##0", 0 + br i1 %"tmp#8##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#12##0" = inttoptr i64 %"#right##0" to ptr + %"#right#value##0" = load i64, ptr %"tmp#12##0" + %"tmp#13##0" = icmp eq i64 %"#left#value##0", %"#right#value##0" + ret i1 %"tmp#13##0" +if.else.1: + ret i1 0 +if.else.0: + %"tmp#14##0" = icmp eq i64 %"#right##0", 0 + ret i1 %"tmp#14##0" } - -define external fastcc i64 @"constructors.just<0>"(i64 %"value##0") alwaysinline { -entry: - %0 = trunc i64 8 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"value##0", i64* %3 - ret i64 %2 +define external fastcc i64 @"constructors.just<0>"(i64 %"value##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 8) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"value##0", ptr %"tmp#1##0" + ret i64 %"#rec##0" } - -define external fastcc {i64, i1} @"constructors.just<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#result##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"#result##0" to i64* - %2 = load i64, i64* %1 - %3 = insertvalue {i64, i1} undef, i64 %2, 0 - %4 = insertvalue {i64, i1} %3, i1 1, 1 - ret {i64, i1} %4 -if.else: - %5 = insertvalue {i64, i1} undef, i64 undef, 0 - %6 = insertvalue {i64, i1} %5, i1 0, 1 - ret {i64, i1} %6 +define external fastcc {i64, i1} @"constructors.just<1>"(i64 %"#result##0") { + %"tmp#0##0" = icmp ne i64 %"#result##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = inttoptr i64 %"#result##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + %"tmp#3##0" = insertvalue {i64, i1} undef, i64 %"tmp#2##0", 0 + %"tmp#4##0" = insertvalue {i64, i1} %"tmp#3##0", i1 1, 1 + ret {i64, i1} %"tmp#4##0" +if.else.0: + %"tmp#5##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#6##0" = insertvalue {i64, i1} %"tmp#5##0", i1 0, 1 + ret {i64, i1} %"tmp#6##0" } - -define external fastcc i64 @"constructors.nothing<0>"() alwaysinline { -entry: - ret i64 0 +define external fastcc i64 @"constructors.nothing<0>"() { + ret i64 0 } - -define external fastcc {i64, i1} @"constructors.value<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"#rec##0" to i64* - %2 = load i64, i64* %1 - %3 = insertvalue {i64, i1} undef, i64 %2, 0 - %4 = insertvalue {i64, i1} %3, i1 1, 1 - ret {i64, i1} %4 -if.else: - %5 = insertvalue {i64, i1} undef, i64 undef, 0 - %6 = insertvalue {i64, i1} %5, i1 0, 1 - ret {i64, i1} %6 +define external fastcc {i64, i1} @"constructors.value<0>"(i64 %"#rec##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + %"tmp#3##0" = insertvalue {i64, i1} undef, i64 %"tmp#2##0", 0 + %"tmp#4##0" = insertvalue {i64, i1} %"tmp#3##0", i1 1, 1 + ret {i64, i1} %"tmp#4##0" +if.else.0: + %"tmp#5##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#6##0" = insertvalue {i64, i1} %"tmp#5##0", i1 0, 1 + ret {i64, i1} %"tmp#6##0" } - -define external fastcc {i64, i1} @"constructors.value<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = trunc i64 8 to i32 - %2 = tail call ccc i8* @wybe_malloc(i32 %1) - %3 = ptrtoint i8* %2 to i64 - %4 = inttoptr i64 %3 to i8* - %5 = inttoptr i64 %"#rec##0" to i8* - %6 = trunc i64 8 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %4, i8* %5, i32 %6, i1 0) - %7 = inttoptr i64 %3 to i64* - store i64 %"#field##0", i64* %7 - %8 = insertvalue {i64, i1} undef, i64 %3, 0 - %9 = insertvalue {i64, i1} %8, i1 1, 1 - ret {i64, i1} %9 -if.else: - %10 = insertvalue {i64, i1} undef, i64 0, 0 - %11 = insertvalue {i64, i1} %10, i1 0, 1 - ret {i64, i1} %11 +define external fastcc {i64, i1} @"constructors.value<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#2##0" = call ccc ptr @wybe_malloc(i32 8) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#2##0", ptr %"tmp#1##0", i64 8, i1 0) + %"tmp#3##0" = ptrtoint ptr %"tmp#2##0" to i64 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 %"#field##0", ptr %"tmp#4##0" + %"tmp#5##0" = insertvalue {i64, i1} undef, i64 %"tmp#3##0", 0 + %"tmp#6##0" = insertvalue {i64, i1} %"tmp#5##0", i1 1, 1 + ret {i64, i1} %"tmp#6##0" +if.else.0: + %"tmp#7##0" = insertvalue {i64, i1} undef, i64 0, 0 + %"tmp#8##0" = insertvalue {i64, i1} %"tmp#7##0", i1 0, 1 + ret {i64, i1} %"tmp#8##0" } - -define external fastcc i1 @"constructors.~=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = tail call fastcc i1 @"constructors.=<0>"(i64 %"#left##0", i64 %"#right##0") - %1 = xor i1 %0, 1 - ret i1 %1 +define external fastcc i1 @"constructors.~=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#0##0" = tail call fastcc i1 @"constructors.=<0>"(i64 %"#left##0", i64 %"#right##0") + %"tmp#1##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#1##0" } diff --git a/test-cases/final-dump/continuation_args.exp b/test-cases/final-dump/continuation_args.exp index 3a2e382df..6ac78ff01 100644 --- a/test-cases/final-dump/continuation_args.exp +++ b/test-cases/final-dump/continuation_args.exp @@ -1,7 +1,10 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module continuation_args - representation : address + representation : pointer public submods : public resources: public procs : continuation_args.=<0> @@ -51,7 +54,8 @@ proc b > {inline} (0 calls) b(c##0:continuation_args.d, ?#result##3:continuation_args)<{}; {}; {}>: AliasPairs: [] InterestingCallProperties: [] - foreign llvm or(~c##0:continuation_args, 2:continuation_args, ?#result##3:continuation_args) @continuation_args:nn:nn + foreign lpvm cast(~c##0:continuation_args.d, ?#temp##0:continuation_args) @continuation_args:nn:nn + foreign llvm or(~#temp##0:continuation_args, 2:continuation_args, ?#result##3:continuation_args) @continuation_args:nn:nn proc b > {inline} (8 calls) 1: continuation_args.b<1> b(?c##0:continuation_args.d, #result##0:continuation_args, ?#success##0:wybe.bool)<{}; {}; {}>: @@ -99,7 +103,8 @@ c(#rec##0:continuation_args, ?#rec##2:continuation_args, #field##0:continuation_ 1: foreign llvm and(~#rec##0:continuation_args, -2:continuation_args, ?#rec##1:continuation_args) @continuation_args:nn:nn - foreign llvm or(~#field##0:continuation_args, ~#rec##1:continuation_args, ?#rec##2:continuation_args) @continuation_args:nn:nn + foreign lpvm cast(~#field##0:continuation_args.d, ?#temp##0:continuation_args) @continuation_args:nn:nn + foreign llvm or(~#rec##1:continuation_args, ~#temp##0:continuation_args, ?#rec##2:continuation_args) @continuation_args:nn:nn foreign llvm move(1:wybe.bool, ?#success##0:wybe.bool) @@ -122,118 +127,101 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'continuation_args' - - - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i1 @"continuation_args.=<0>"(i64 %"#left##0", i64 %"#right##0") { -entry: - %0 = icmp ne i64 %"#left##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = and i64 %"#left##0", 1 - %2 = trunc i64 %1 to i1 - %3 = icmp ne i64 %"#right##0", 0 - br i1 %3, label %if.then1, label %if.else1 -if.else: - %7 = icmp eq i64 %"#right##0", 0 - ret i1 %7 -if.then1: - %4 = and i64 %"#right##0", 1 - %5 = trunc i64 %4 to i1 - %6 = icmp eq i1 %2, %5 - ret i1 %6 -if.else1: - ret i1 0 +source_filename = "!ROOT!/final-dump/continuation_args.wybe" +target triple ???? + + +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc i1 @"continuation_args.=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#0##0" = icmp ne i64 %"#left##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#7##0" = and i64 %"#left##0", 1 + %"#left#c##0" = trunc i64 %"tmp#7##0" to i1 + %"tmp#9##0" = icmp ne i64 %"#right##0", 0 + br i1 %"tmp#9##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#10##0" = and i64 %"#right##0", 1 + %"#right#c##0" = trunc i64 %"tmp#10##0" to i1 + %"tmp#14##0" = icmp eq i1 %"#left#c##0", %"#right#c##0" + ret i1 %"tmp#14##0" +if.else.1: + ret i1 0 +if.else.0: + %"tmp#15##0" = icmp eq i64 %"#right##0", 0 + ret i1 %"tmp#15##0" } - -define external fastcc i64 @"continuation_args.a<0>"() alwaysinline { -entry: - ret i64 0 +define external fastcc i64 @"continuation_args.a<0>"() { + ret i64 0 } - -define external fastcc i64 @"continuation_args.b<0>"(i1 %"c##0") alwaysinline { -entry: - %0 = zext i1 %"c##0" to i64 - %1 = or i64 %0, 2 - ret i64 %1 +define external fastcc i64 @"continuation_args.b<0>"(i1 %"c##0") { + %"#temp##0" = zext i1 %"c##0" to i64 + %"tmp#0##0" = or i64 %"#temp##0", 2 + ret i64 %"tmp#0##0" } - -define external fastcc {i1, i1} @"continuation_args.b<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#result##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = and i64 %"#result##0", 1 - %2 = trunc i64 %1 to i1 - %3 = insertvalue {i1, i1} undef, i1 %2, 0 - %4 = insertvalue {i1, i1} %3, i1 1, 1 - ret {i1, i1} %4 -if.else: - %5 = insertvalue {i1, i1} undef, i1 undef, 0 - %6 = insertvalue {i1, i1} %5, i1 0, 1 - ret {i1, i1} %6 +define external fastcc {i1, i1} @"continuation_args.b<1>"(i64 %"#result##0") { + %"tmp#0##0" = icmp ne i64 %"#result##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"#temp2##0" = and i64 %"#result##0", 1 + %"tmp#1##0" = trunc i64 %"#temp2##0" to i1 + %"tmp#2##0" = insertvalue {i1, i1} undef, i1 %"tmp#1##0", 0 + %"tmp#3##0" = insertvalue {i1, i1} %"tmp#2##0", i1 1, 1 + ret {i1, i1} %"tmp#3##0" +if.else.0: + %"tmp#4##0" = insertvalue {i1, i1} undef, i1 undef, 0 + %"tmp#5##0" = insertvalue {i1, i1} %"tmp#4##0", i1 0, 1 + ret {i1, i1} %"tmp#5##0" } - -define external fastcc {i1, i1} @"continuation_args.c<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = and i64 %"#rec##0", 1 - %2 = trunc i64 %1 to i1 - %3 = insertvalue {i1, i1} undef, i1 %2, 0 - %4 = insertvalue {i1, i1} %3, i1 1, 1 - ret {i1, i1} %4 -if.else: - %5 = insertvalue {i1, i1} undef, i1 undef, 0 - %6 = insertvalue {i1, i1} %5, i1 0, 1 - ret {i1, i1} %6 +define external fastcc {i1, i1} @"continuation_args.c<0>"(i64 %"#rec##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"#field##0" = and i64 %"#rec##0", 1 + %"tmp#1##0" = trunc i64 %"#field##0" to i1 + %"tmp#2##0" = insertvalue {i1, i1} undef, i1 %"tmp#1##0", 0 + %"tmp#3##0" = insertvalue {i1, i1} %"tmp#2##0", i1 1, 1 + ret {i1, i1} %"tmp#3##0" +if.else.0: + %"tmp#4##0" = insertvalue {i1, i1} undef, i1 undef, 0 + %"tmp#5##0" = insertvalue {i1, i1} %"tmp#4##0", i1 0, 1 + ret {i1, i1} %"tmp#5##0" } - -define external fastcc {i64, i1} @"continuation_args.c<1>"(i64 %"#rec##0", i1 %"#field##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = and i64 %"#rec##0", -2 - %2 = zext i1 %"#field##0" to i64 - %3 = or i64 %2, %1 - %4 = insertvalue {i64, i1} undef, i64 %3, 0 - %5 = insertvalue {i64, i1} %4, i1 1, 1 - ret {i64, i1} %5 -if.else: - %6 = insertvalue {i64, i1} undef, i64 0, 0 - %7 = insertvalue {i64, i1} %6, i1 0, 1 - ret {i64, i1} %7 +define external fastcc {i64, i1} @"continuation_args.c<1>"(i64 %"#rec##0", i1 %"#field##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"#rec##1" = and i64 %"#rec##0", -2 + %"#temp##0" = zext i1 %"#field##0" to i64 + %"tmp#1##0" = or i64 %"#rec##1", %"#temp##0" + %"tmp#2##0" = insertvalue {i64, i1} undef, i64 %"tmp#1##0", 0 + %"tmp#3##0" = insertvalue {i64, i1} %"tmp#2##0", i1 1, 1 + ret {i64, i1} %"tmp#3##0" +if.else.0: + %"tmp#4##0" = insertvalue {i64, i1} undef, i64 0, 0 + %"tmp#5##0" = insertvalue {i64, i1} %"tmp#4##0", i1 0, 1 + ret {i64, i1} %"tmp#5##0" } - -define external fastcc i64 @"continuation_args.foo<0>"() alwaysinline { -entry: - ret i64 0 +define external fastcc i64 @"continuation_args.foo<0>"() { + ret i64 0 } - -define external fastcc i1 @"continuation_args.~=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = tail call fastcc i1 @"continuation_args.=<0>"(i64 %"#left##0", i64 %"#right##0") - %1 = xor i1 %0, 1 - ret i1 %1 +define external fastcc i1 @"continuation_args.~=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#0##0" = tail call fastcc i1 @"continuation_args.=<0>"(i64 %"#left##0", i64 %"#right##0") + %"tmp#1##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#1##0" } + -------------------------------------------------- Module continuation_args.d representation : 1 bit unsigned @@ -281,40 +269,30 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'continuation_args.d' - - +source_filename = "!ROOT!/final-dump/continuation_args.wybe" +target triple ???? -declare external ccc i8* @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i1 @"continuation_args.d.=<0>"(i1 %"#left##0", i1 %"#right##0") alwaysinline { -entry: - %0 = icmp eq i1 %"#left##0", %"#right##0" - ret i1 %0 +define external fastcc i1 @"continuation_args.d.=<0>"(i1 %"#left##0", i1 %"#right##0") { + %"tmp#1##0" = icmp eq i1 %"#left##0", %"#right##0" + ret i1 %"tmp#1##0" } - -define external fastcc i1 @"continuation_args.d.e<0>"() alwaysinline { -entry: - ret i1 0 +define external fastcc i1 @"continuation_args.d.e<0>"() { + ret i1 0 } - -define external fastcc i1 @"continuation_args.d.f<0>"() alwaysinline { -entry: - ret i1 1 +define external fastcc i1 @"continuation_args.d.f<0>"() { + ret i1 1 } - -define external fastcc i1 @"continuation_args.d.~=<0>"(i1 %"#left##0", i1 %"#right##0") alwaysinline { -entry: - %0 = icmp eq i1 %"#left##0", %"#right##0" - %1 = xor i1 %0, 1 - ret i1 %1 +define external fastcc i1 @"continuation_args.d.~=<0>"(i1 %"#left##0", i1 %"#right##0") { + %"tmp#0##0" = icmp eq i1 %"#left##0", %"#right##0" + %"tmp#3##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#3##0" } diff --git a/test-cases/final-dump/coordinate.exp b/test-cases/final-dump/coordinate.exp index 5536d57d9..01dd64209 100644 --- a/test-cases/final-dump/coordinate.exp +++ b/test-cases/final-dump/coordinate.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module coordinate representation : (not a type) public submods : Coordinate -> coordinate.Coordinate @@ -54,75 +57,56 @@ fcopy(crd1##0:coordinate.Coordinate, ?#result##0:coordinate.Coordinate)<{}; {}; LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'coordinate' - - - - -@coordinate.1 = constant {i64, i64} { i64 20, i64 ptrtoint ([?? x i8]* @coordinate.0 to i64) } - - -@coordinate.3 = constant {i64, i64} { i64 20, i64 ptrtoint ([?? x i8]* @coordinate.2 to i64) } - - -@coordinate.0 = constant [?? x i8] c"expect crd1^z=8000: \00" - - -@coordinate.2 = constant [?? x i8] c"expect crd2^z=1000: \00" - - -declare external ccc void @putchar(i8) - - -declare external ccc void @print_int(i64) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"coordinate.<0>"() { -entry: - %0 = trunc i64 24 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 1000, i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 1000, i64* %5 - %6 = add i64 %2, 16 - %7 = inttoptr i64 %6 to i64* - store i64 1000, i64* %7 - %8 = add i64 %2, 16 - %9 = inttoptr i64 %8 to i64* - store i64 8000, i64* %9 - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @coordinate.1, i32 0, i32 0) to i64)) - %10 = add i64 %2, 16 - %11 = inttoptr i64 %10 to i64* - %12 = load i64, i64* %11 - tail call ccc void @print_int(i64 %12) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @coordinate.3, i32 0, i32 0) to i64)) - tail call ccc void @print_int(i64 1000) - tail call ccc void @putchar(i8 10) - ret void +source_filename = "!ROOT!/final-dump/coordinate.wybe" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c"expect crd1^z=8000: \00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c"expect crd2^z=1000: \00", align 8 +@"string#2" = private unnamed_addr constant {i64, i64} { i64 20, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +@"string#3" = private unnamed_addr constant {i64, i64} { i64 20, i64 ptrtoint( ptr @"cstring#1" to i64 ) }, align 8 + +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"coordinate.<0>"() { + %"tmp#24##0" = call ccc ptr @wybe_malloc(i32 24) + %"tmp#7##0" = ptrtoint ptr %"tmp#24##0" to i64 + %"tmp#25##0" = inttoptr i64 %"tmp#7##0" to ptr + store i64 1000, ptr %"tmp#25##0" + %"tmp#26##0" = add i64 %"tmp#7##0", 8 + %"tmp#27##0" = inttoptr i64 %"tmp#26##0" to ptr + store i64 1000, ptr %"tmp#27##0" + %"tmp#28##0" = add i64 %"tmp#7##0", 16 + %"tmp#29##0" = inttoptr i64 %"tmp#28##0" to ptr + store i64 1000, ptr %"tmp#29##0" + %"tmp#30##0" = add i64 %"tmp#7##0", 16 + %"tmp#31##0" = inttoptr i64 %"tmp#30##0" to ptr + store i64 8000, ptr %"tmp#31##0" + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#2" to i64 )) + %"tmp#32##0" = add i64 %"tmp#7##0", 16 + %"tmp#33##0" = inttoptr i64 %"tmp#32##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#33##0" + call ccc void @print_int(i64 %"tmp#2##0") + call ccc void @putchar(i8 10) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#3" to i64 )) + call ccc void @print_int(i64 1000) + call ccc void @putchar(i8 10) + ret void } - -define external fastcc i64 @"coordinate.fcopy<0>"(i64 %"crd1##0") alwaysinline { -entry: - ret i64 %"crd1##0" +define external fastcc i64 @"coordinate.fcopy<0>"(i64 %"crd1##0") { + ret i64 %"crd1##0" } + -------------------------------------------------- Module coordinate.Coordinate - representation : address + representation : pointer public submods : public resources: public procs : coordinate.Coordinate.=<0> @@ -261,189 +245,158 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'coordinate.Coordinate' - - - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i1 @"coordinate.Coordinate.=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = add i64 %"#left##0", 16 - %6 = inttoptr i64 %5 to i64* - %7 = load i64, i64* %6 - %8 = inttoptr i64 %"#right##0" to i64* - %9 = load i64, i64* %8 - %10 = add i64 %"#right##0", 8 - %11 = inttoptr i64 %10 to i64* - %12 = load i64, i64* %11 - %13 = add i64 %"#right##0", 16 - %14 = inttoptr i64 %13 to i64* - %15 = load i64, i64* %14 - %16 = icmp eq i64 %1, %9 - br i1 %16, label %if.then, label %if.else -if.then: - %17 = icmp eq i64 %4, %12 - br i1 %17, label %if.then1, label %if.else1 -if.else: - ret i1 0 -if.then1: - %18 = icmp eq i64 %7, %15 - ret i1 %18 -if.else1: - ret i1 0 +source_filename = "!ROOT!/final-dump/coordinate.wybe" +target triple ???? + + +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc i1 @"coordinate.Coordinate.=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#12##0" = inttoptr i64 %"#left##0" to ptr + %"#left#x##0" = load i64, ptr %"tmp#12##0" + %"tmp#13##0" = add i64 %"#left##0", 8 + %"tmp#14##0" = inttoptr i64 %"tmp#13##0" to ptr + %"#left#y##0" = load i64, ptr %"tmp#14##0" + %"tmp#15##0" = add i64 %"#left##0", 16 + %"tmp#16##0" = inttoptr i64 %"tmp#15##0" to ptr + %"#left#z##0" = load i64, ptr %"tmp#16##0" + %"tmp#17##0" = inttoptr i64 %"#right##0" to ptr + %"#right#x##0" = load i64, ptr %"tmp#17##0" + %"tmp#18##0" = add i64 %"#right##0", 8 + %"tmp#19##0" = inttoptr i64 %"tmp#18##0" to ptr + %"#right#y##0" = load i64, ptr %"tmp#19##0" + %"tmp#20##0" = add i64 %"#right##0", 16 + %"tmp#21##0" = inttoptr i64 %"tmp#20##0" to ptr + %"#right#z##0" = load i64, ptr %"tmp#21##0" + %"tmp#1##0" = icmp eq i64 %"#left#x##0", %"#right#x##0" + br i1 %"tmp#1##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = icmp eq i64 %"#left#y##0", %"#right#y##0" + br i1 %"tmp#2##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#22##0" = icmp eq i64 %"#left#z##0", %"#right#z##0" + ret i1 %"tmp#22##0" +if.else.1: + ret i1 0 +if.else.0: + ret i1 0 } - -define external fastcc i64 @"coordinate.Coordinate.Coordinate<0>"(i64 %"x##0", i64 %"y##0", i64 %"z##0") alwaysinline { -entry: - %0 = trunc i64 24 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"x##0", i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"y##0", i64* %5 - %6 = add i64 %2, 16 - %7 = inttoptr i64 %6 to i64* - store i64 %"z##0", i64* %7 - ret i64 %2 +define external fastcc i64 @"coordinate.Coordinate.Coordinate<0>"(i64 %"x##0", i64 %"y##0", i64 %"z##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 24) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"x##0", ptr %"tmp#1##0" + %"tmp#2##0" = add i64 %"#rec##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"y##0", ptr %"tmp#3##0" + %"tmp#4##0" = add i64 %"#rec##0", 16 + %"tmp#5##0" = inttoptr i64 %"tmp#4##0" to ptr + store i64 %"z##0", ptr %"tmp#5##0" + ret i64 %"#rec##0" } - -define external fastcc {i64, i64, i64} @"coordinate.Coordinate.Coordinate<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#result##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#result##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = add i64 %"#result##0", 16 - %6 = inttoptr i64 %5 to i64* - %7 = load i64, i64* %6 - %8 = insertvalue {i64, i64, i64} undef, i64 %1, 0 - %9 = insertvalue {i64, i64, i64} %8, i64 %4, 1 - %10 = insertvalue {i64, i64, i64} %9, i64 %7, 2 - ret {i64, i64, i64} %10 +define external fastcc {i64, i64, i64} @"coordinate.Coordinate.Coordinate<1>"(i64 %"#result##0") { + %"tmp#0##0" = inttoptr i64 %"#result##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + %"tmp#2##0" = add i64 %"#result##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#3##0" + %"tmp#5##0" = add i64 %"#result##0", 16 + %"tmp#6##0" = inttoptr i64 %"tmp#5##0" to ptr + %"tmp#7##0" = load i64, ptr %"tmp#6##0" + %"tmp#8##0" = insertvalue {i64, i64, i64} undef, i64 %"tmp#1##0", 0 + %"tmp#9##0" = insertvalue {i64, i64, i64} %"tmp#8##0", i64 %"tmp#4##0", 1 + %"tmp#10##0" = insertvalue {i64, i64, i64} %"tmp#9##0", i64 %"tmp#7##0", 2 + ret {i64, i64, i64} %"tmp#10##0" } - -define external fastcc i64 @"coordinate.Coordinate.x<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#rec##0" to i64* - %1 = load i64, i64* %0 - ret i64 %1 +define external fastcc i64 @"coordinate.Coordinate.x<0>"(i64 %"#rec##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + ret i64 %"tmp#1##0" } - -define external fastcc i64 @"coordinate.Coordinate.x<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 24 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 24 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = inttoptr i64 %2 to i64* - store i64 %"#field##0", i64* %6 - ret i64 %2 +define external fastcc i64 @"coordinate.Coordinate.x<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 24) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 24, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"#field##0", ptr %"tmp#3##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"coordinate.Coordinate.y<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = add i64 %"#rec##0", 8 - %1 = inttoptr i64 %0 to i64* - %2 = load i64, i64* %1 - ret i64 %2 +define external fastcc i64 @"coordinate.Coordinate.y<0>"(i64 %"#rec##0") { + %"tmp#0##0" = add i64 %"#rec##0", 8 + %"tmp#1##0" = inttoptr i64 %"tmp#0##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"coordinate.Coordinate.y<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 24 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 24 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = add i64 %2, 8 - %7 = inttoptr i64 %6 to i64* - store i64 %"#field##0", i64* %7 - ret i64 %2 +define external fastcc i64 @"coordinate.Coordinate.y<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 24) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 24, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = add i64 %"tmp#2##0", 8 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 %"#field##0", ptr %"tmp#4##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"coordinate.Coordinate.z<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = add i64 %"#rec##0", 16 - %1 = inttoptr i64 %0 to i64* - %2 = load i64, i64* %1 - ret i64 %2 +define external fastcc i64 @"coordinate.Coordinate.z<0>"(i64 %"#rec##0") { + %"tmp#0##0" = add i64 %"#rec##0", 16 + %"tmp#1##0" = inttoptr i64 %"tmp#0##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"coordinate.Coordinate.z<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 24 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 24 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = add i64 %2, 16 - %7 = inttoptr i64 %6 to i64* - store i64 %"#field##0", i64* %7 - ret i64 %2 +define external fastcc i64 @"coordinate.Coordinate.z<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 24) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 24, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = add i64 %"tmp#2##0", 16 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 %"#field##0", ptr %"tmp#4##0" + ret i64 %"tmp#2##0" } - -define external fastcc i1 @"coordinate.Coordinate.~=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = add i64 %"#left##0", 16 - %6 = inttoptr i64 %5 to i64* - %7 = load i64, i64* %6 - %8 = inttoptr i64 %"#right##0" to i64* - %9 = load i64, i64* %8 - %10 = add i64 %"#right##0", 8 - %11 = inttoptr i64 %10 to i64* - %12 = load i64, i64* %11 - %13 = add i64 %"#right##0", 16 - %14 = inttoptr i64 %13 to i64* - %15 = load i64, i64* %14 - %16 = icmp eq i64 %1, %9 - br i1 %16, label %if.then, label %if.else -if.then: - %17 = icmp eq i64 %4, %12 - br i1 %17, label %if.then1, label %if.else1 -if.else: - %21 = xor i1 0, 1 - ret i1 %21 -if.then1: - %18 = icmp eq i64 %7, %15 - %19 = xor i1 %18, 1 - ret i1 %19 -if.else1: - %20 = xor i1 0, 1 - ret i1 %20 +define external fastcc i1 @"coordinate.Coordinate.~=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#11##0" = inttoptr i64 %"#left##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#11##0" + %"tmp#12##0" = add i64 %"#left##0", 8 + %"tmp#13##0" = inttoptr i64 %"tmp#12##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#13##0" + %"tmp#14##0" = add i64 %"#left##0", 16 + %"tmp#15##0" = inttoptr i64 %"tmp#14##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#15##0" + %"tmp#16##0" = inttoptr i64 %"#right##0" to ptr + %"tmp#6##0" = load i64, ptr %"tmp#16##0" + %"tmp#17##0" = add i64 %"#right##0", 8 + %"tmp#18##0" = inttoptr i64 %"tmp#17##0" to ptr + %"tmp#7##0" = load i64, ptr %"tmp#18##0" + %"tmp#19##0" = add i64 %"#right##0", 16 + %"tmp#20##0" = inttoptr i64 %"tmp#19##0" to ptr + %"tmp#8##0" = load i64, ptr %"tmp#20##0" + %"tmp#9##0" = icmp eq i64 %"tmp#3##0", %"tmp#6##0" + br i1 %"tmp#9##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#10##0" = icmp eq i64 %"tmp#4##0", %"tmp#7##0" + br i1 %"tmp#10##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#0##0" = icmp eq i64 %"tmp#5##0", %"tmp#8##0" + %"tmp#21##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#21##0" +if.else.1: + %"tmp#22##0" = xor i1 0, 1 + ret i1 %"tmp#22##0" +if.else.0: + %"tmp#23##0" = xor i1 0, 1 + ret i1 %"tmp#23##0" } diff --git a/test-cases/final-dump/ctor_char.exp b/test-cases/final-dump/ctor_char.exp index 26358f0b7..fe432475a 100644 --- a/test-cases/final-dump/ctor_char.exp +++ b/test-cases/final-dump/ctor_char.exp @@ -1,7 +1,10 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module ctor_char - representation : address + representation : pointer public submods : public resources: public procs : ctor_char.<0> @@ -16,13 +19,14 @@ module top-level code > public {semipure} (0 calls) ()<{<>}; {<>}; {}>: AliasPairs: [] InterestingCallProperties: [] - foreign llvm shl('a':ctor_char, 1:ctor_char, ?tmp#3##0:ctor_char) @ctor_char:nn:nn - foreign llvm or(~tmp#3##0:ctor_char, 512:ctor_char, ?tmp#1##0:ctor_char) @ctor_char:nn:nn + foreign lpvm cast('a':wybe.char, ?tmp#3##0:ctor_char) @ctor_char:nn:nn + foreign llvm shl(~tmp#3##0:ctor_char, 1:ctor_char, ?tmp#4##0:ctor_char) @ctor_char:nn:nn + foreign llvm or(~tmp#4##0:ctor_char, 512:ctor_char, ?tmp#1##0:ctor_char) @ctor_char:nn:nn ctor_char.foo<0>(~tmp#1##0:ctor_char, ?tmp#0##0:wybe.char) #1 @ctor_char:nn:nn - foreign lpvm load(<>:wybe.phantom, ?%tmp#5##0:wybe.phantom) @ctor_char:nn:nn - foreign c putchar(~tmp#0##0:wybe.char, ~tmp#5##0:wybe.phantom, ?tmp#6##0:wybe.phantom) @ctor_char:nn:nn - foreign c putchar('\n':wybe.char, ~tmp#6##0:wybe.phantom, ?tmp#7##0:wybe.phantom) @ctor_char:nn:nn - foreign lpvm store(~%tmp#7##0:wybe.phantom, <>:wybe.phantom) @ctor_char:nn:nn + foreign lpvm load(<>:wybe.phantom, ?%tmp#6##0:wybe.phantom) @ctor_char:nn:nn + foreign c putchar(~tmp#0##0:wybe.char, ~tmp#6##0:wybe.phantom, ?tmp#7##0:wybe.phantom) @ctor_char:nn:nn + foreign c putchar('\n':wybe.char, ~tmp#7##0:wybe.phantom, ?tmp#8##0:wybe.phantom) @ctor_char:nn:nn + foreign lpvm store(~%tmp#8##0:wybe.phantom, <>:wybe.phantom) @ctor_char:nn:nn proc = > public (2 calls) @@ -140,8 +144,9 @@ c(#rec##0:ctor_char, ?#rec##2:ctor_char, #field##0:wybe.char, ?#success##0:wybe. 1: foreign llvm and(~#rec##0:ctor_char, -511:ctor_char, ?#rec##1:ctor_char) @ctor_char:nn:nn - foreign llvm shl(~#field##0:ctor_char, 1:ctor_char, ?#temp##0:ctor_char) @ctor_char:nn:nn - foreign llvm or(~#rec##1:ctor_char, ~#temp##0:ctor_char, ?#rec##2:ctor_char) @ctor_char:nn:nn + foreign lpvm cast(~#field##0:wybe.char, ?#temp##0:ctor_char) @ctor_char:nn:nn + foreign llvm shl(~#temp##0:ctor_char, 1:ctor_char, ?#temp##1:ctor_char) @ctor_char:nn:nn + foreign llvm or(~#rec##1:ctor_char, ~#temp##1:ctor_char, ?#rec##2:ctor_char) @ctor_char:nn:nn foreign llvm move(1:wybe.bool, ?#success##0:wybe.bool) @@ -160,8 +165,9 @@ proc ctor > {inline} (1 calls) ctor(c##0:wybe.char, ?#result##3:ctor_char)<{}; {}; {}>: AliasPairs: [] InterestingCallProperties: [] - foreign llvm shl(~c##0:ctor_char, 1:ctor_char, ?#temp##0:ctor_char) @ctor_char:nn:nn - foreign llvm or(~#temp##0:ctor_char, 512:ctor_char, ?#result##3:ctor_char) @ctor_char:nn:nn + foreign lpvm cast(~c##0:wybe.char, ?#temp##0:ctor_char) @ctor_char:nn:nn + foreign llvm shl(~#temp##0:ctor_char, 1:ctor_char, ?#temp##1:ctor_char) @ctor_char:nn:nn + foreign llvm or(~#temp##1:ctor_char, 512:ctor_char, ?#result##3:ctor_char) @ctor_char:nn:nn proc ctor > {inline} (13 calls) 1: ctor_char.ctor<1> ctor(?c##0:wybe.char, #result##0:ctor_char, ?#success##0:wybe.bool)<{}; {}; {}>: @@ -259,246 +265,221 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'ctor_char' - - - - -declare external ccc void @putchar(i8) +source_filename = "!ROOT!/final-dump/ctor_char.wybe" +target triple ???? -declare external ccc i8* @wybe_malloc(i32) +declare external ccc void @putchar(i8) +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"ctor_char.<0>"() { -entry: - %0 = shl i64 97, 1 - %1 = or i64 %0, 512 - %2 = tail call fastcc i8 @"ctor_char.foo<0>"(i64 %1) - tail call ccc void @putchar(i8 %2) - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"ctor_char.<0>"() { + %"tmp#3##0" = zext i8 97 to i64 + %"tmp#4##0" = shl i64 %"tmp#3##0", 1 + %"tmp#1##0" = or i64 %"tmp#4##0", 512 + %"tmp#0##0" = tail call fastcc i8 @"ctor_char.foo<0>"(i64 %"tmp#1##0") + call ccc void @putchar(i8 %"tmp#0##0") + call ccc void @putchar(i8 10) + ret void } - -define external fastcc i1 @"ctor_char.=<0>"(i64 %"#left##0", i64 %"#right##0") { -entry: - %0 = icmp ne i64 %"#left##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = and i64 %"#left##0", 1 - %2 = icmp eq i64 %1, 0 - br i1 %2, label %if.then1, label %if.else1 -if.else: - %24 = icmp eq i64 %"#right##0", 0 - ret i1 %24 -if.then1: - %3 = lshr i64 %"#left##0", 1 - %4 = and i64 %3, 255 - %5 = trunc i64 %4 to i8 - %6 = icmp ne i64 %"#right##0", 0 - br i1 %6, label %if.then2, label %if.else2 -if.else1: - %13 = icmp eq i64 %1, 1 - br i1 %13, label %if.then4, label %if.else4 -if.then2: - %7 = and i64 %"#right##0", 1 - %8 = icmp eq i64 %7, 0 - br i1 %8, label %if.then3, label %if.else3 -if.else2: - ret i1 0 -if.then3: - %9 = lshr i64 %"#right##0", 1 - %10 = and i64 %9, 255 - %11 = trunc i64 %10 to i8 - %12 = icmp eq i8 %5, %11 - ret i1 %12 -if.else3: - ret i1 0 -if.then4: - %14 = add i64 %"#left##0", -1 - %15 = inttoptr i64 %14 to i64* - %16 = load i64, i64* %15 - %17 = icmp ne i64 %"#right##0", 0 - br i1 %17, label %if.then5, label %if.else5 -if.else4: - ret i1 0 -if.then5: - %18 = and i64 %"#right##0", 1 - %19 = icmp eq i64 %18, 1 - br i1 %19, label %if.then6, label %if.else6 -if.else5: - ret i1 0 -if.then6: - %20 = add i64 %"#right##0", -1 - %21 = inttoptr i64 %20 to i64* - %22 = load i64, i64* %21 - %23 = musttail call fastcc i1 @"ctor_char.=<0>"(i64 %16, i64 %22) - ret i1 %23 -if.else6: - ret i1 0 +define external fastcc i1 @"ctor_char.=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#0##0" = icmp ne i64 %"#left##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#10##0" = and i64 %"#left##0", 1 + %"tmp#11##0" = icmp eq i64 %"tmp#10##0", 0 + br i1 %"tmp#11##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#12##0" = lshr i64 %"#left##0", 1 + %"tmp#13##0" = and i64 %"tmp#12##0", 255 + %"#left#c##0" = trunc i64 %"tmp#13##0" to i8 + %"tmp#23##0" = icmp ne i64 %"#right##0", 0 + br i1 %"tmp#23##0", label %if.then.2, label %if.else.2 +if.then.2: + %"tmp#24##0" = and i64 %"#right##0", 1 + %"tmp#25##0" = icmp eq i64 %"tmp#24##0", 0 + br i1 %"tmp#25##0", label %if.then.3, label %if.else.3 +if.then.3: + %"tmp#26##0" = lshr i64 %"#right##0", 1 + %"tmp#27##0" = and i64 %"tmp#26##0", 255 + %"#right#c##0" = trunc i64 %"tmp#27##0" to i8 + %"tmp#30##0" = icmp eq i8 %"#left#c##0", %"#right#c##0" + ret i1 %"tmp#30##0" +if.else.3: + ret i1 0 +if.else.2: + ret i1 0 +if.else.1: + %"tmp#17##0" = icmp eq i64 %"tmp#10##0", 1 + br i1 %"tmp#17##0", label %if.then.4, label %if.else.4 +if.then.4: + %"tmp#31##0" = add i64 %"#left##0", -1 + %"tmp#32##0" = inttoptr i64 %"tmp#31##0" to ptr + %"#left#other_ctor#1##0" = load i64, ptr %"tmp#32##0" + %"tmp#19##0" = icmp ne i64 %"#right##0", 0 + br i1 %"tmp#19##0", label %if.then.5, label %if.else.5 +if.then.5: + %"tmp#20##0" = and i64 %"#right##0", 1 + %"tmp#21##0" = icmp eq i64 %"tmp#20##0", 1 + br i1 %"tmp#21##0", label %if.then.6, label %if.else.6 +if.then.6: + %"tmp#33##0" = add i64 %"#right##0", -1 + %"tmp#34##0" = inttoptr i64 %"tmp#33##0" to ptr + %"#right#other_ctor#1##0" = load i64, ptr %"tmp#34##0" + %"tmp#35##0" = tail call fastcc i1 @"ctor_char.=<0>"(i64 %"#left#other_ctor#1##0", i64 %"#right#other_ctor#1##0") + ret i1 %"tmp#35##0" +if.else.6: + ret i1 0 +if.else.5: + ret i1 0 +if.else.4: + ret i1 0 +if.else.0: + %"tmp#36##0" = icmp eq i64 %"#right##0", 0 + ret i1 %"tmp#36##0" } - -define external fastcc {i8, i1} @"ctor_char.c<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = and i64 %"#rec##0", 1 - %2 = icmp eq i64 %1, 0 - br i1 %2, label %if.then1, label %if.else1 -if.else: - %10 = insertvalue {i8, i1} undef, i8 undef, 0 - %11 = insertvalue {i8, i1} %10, i1 0, 1 - ret {i8, i1} %11 -if.then1: - %3 = lshr i64 %"#rec##0", 1 - %4 = and i64 %3, 255 - %5 = trunc i64 %4 to i8 - %6 = insertvalue {i8, i1} undef, i8 %5, 0 - %7 = insertvalue {i8, i1} %6, i1 1, 1 - ret {i8, i1} %7 -if.else1: - %8 = insertvalue {i8, i1} undef, i8 undef, 0 - %9 = insertvalue {i8, i1} %8, i1 0, 1 - ret {i8, i1} %9 +define external fastcc {i8, i1} @"ctor_char.c<0>"(i64 %"#rec##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = and i64 %"#rec##0", 1 + %"tmp#1##0" = icmp eq i64 %"tmp#2##0", 0 + br i1 %"tmp#1##0", label %if.then.1, label %if.else.1 +if.then.1: + %"#rec##1" = lshr i64 %"#rec##0", 1 + %"#field##0" = and i64 %"#rec##1", 255 + %"tmp#3##0" = trunc i64 %"#field##0" to i8 + %"tmp#4##0" = insertvalue {i8, i1} undef, i8 %"tmp#3##0", 0 + %"tmp#5##0" = insertvalue {i8, i1} %"tmp#4##0", i1 1, 1 + ret {i8, i1} %"tmp#5##0" +if.else.1: + %"tmp#6##0" = insertvalue {i8, i1} undef, i8 undef, 0 + %"tmp#7##0" = insertvalue {i8, i1} %"tmp#6##0", i1 0, 1 + ret {i8, i1} %"tmp#7##0" +if.else.0: + %"tmp#8##0" = insertvalue {i8, i1} undef, i8 undef, 0 + %"tmp#9##0" = insertvalue {i8, i1} %"tmp#8##0", i1 0, 1 + ret {i8, i1} %"tmp#9##0" } - -define external fastcc {i64, i1} @"ctor_char.c<1>"(i64 %"#rec##0", i8 %"#field##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = and i64 %"#rec##0", 1 - %2 = icmp eq i64 %1, 0 - br i1 %2, label %if.then1, label %if.else1 -if.else: - %11 = insertvalue {i64, i1} undef, i64 0, 0 - %12 = insertvalue {i64, i1} %11, i1 0, 1 - ret {i64, i1} %12 -if.then1: - %3 = and i64 %"#rec##0", -511 - %4 = zext i8 %"#field##0" to i64 - %5 = shl i64 %4, 1 - %6 = or i64 %3, %5 - %7 = insertvalue {i64, i1} undef, i64 %6, 0 - %8 = insertvalue {i64, i1} %7, i1 1, 1 - ret {i64, i1} %8 -if.else1: - %9 = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 - %10 = insertvalue {i64, i1} %9, i1 0, 1 - ret {i64, i1} %10 +define external fastcc {i64, i1} @"ctor_char.c<1>"(i64 %"#rec##0", i8 %"#field##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = and i64 %"#rec##0", 1 + %"tmp#1##0" = icmp eq i64 %"tmp#2##0", 0 + br i1 %"tmp#1##0", label %if.then.1, label %if.else.1 +if.then.1: + %"#rec##1" = and i64 %"#rec##0", -511 + %"#temp##0" = zext i8 %"#field##0" to i64 + %"#temp##1" = shl i64 %"#temp##0", 1 + %"tmp#3##0" = or i64 %"#rec##1", %"#temp##1" + %"tmp#4##0" = insertvalue {i64, i1} undef, i64 %"tmp#3##0", 0 + %"tmp#5##0" = insertvalue {i64, i1} %"tmp#4##0", i1 1, 1 + ret {i64, i1} %"tmp#5##0" +if.else.1: + %"tmp#6##0" = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 + %"tmp#7##0" = insertvalue {i64, i1} %"tmp#6##0", i1 0, 1 + ret {i64, i1} %"tmp#7##0" +if.else.0: + %"tmp#8##0" = insertvalue {i64, i1} undef, i64 0, 0 + %"tmp#9##0" = insertvalue {i64, i1} %"tmp#8##0", i1 0, 1 + ret {i64, i1} %"tmp#9##0" } - -define external fastcc i64 @"ctor_char.const<0>"() alwaysinline { -entry: - ret i64 0 +define external fastcc i64 @"ctor_char.const<0>"() { + ret i64 0 } - -define external fastcc i64 @"ctor_char.ctor<0>"(i8 %"c##0") alwaysinline { -entry: - %0 = zext i8 %"c##0" to i64 - %1 = shl i64 %0, 1 - %2 = or i64 %1, 512 - ret i64 %2 +define external fastcc i64 @"ctor_char.ctor<0>"(i8 %"c##0") { + %"#temp##0" = zext i8 %"c##0" to i64 + %"#temp##1" = shl i64 %"#temp##0", 1 + %"tmp#0##0" = or i64 %"#temp##1", 512 + ret i64 %"tmp#0##0" } - -define external fastcc {i8, i1} @"ctor_char.ctor<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#result##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = and i64 %"#result##0", 1 - %2 = icmp eq i64 %1, 0 - br i1 %2, label %if.then1, label %if.else1 -if.else: - %10 = insertvalue {i8, i1} undef, i8 undef, 0 - %11 = insertvalue {i8, i1} %10, i1 0, 1 - ret {i8, i1} %11 -if.then1: - %3 = lshr i64 %"#result##0", 1 - %4 = and i64 %3, 255 - %5 = trunc i64 %4 to i8 - %6 = insertvalue {i8, i1} undef, i8 %5, 0 - %7 = insertvalue {i8, i1} %6, i1 1, 1 - ret {i8, i1} %7 -if.else1: - %8 = insertvalue {i8, i1} undef, i8 undef, 0 - %9 = insertvalue {i8, i1} %8, i1 0, 1 - ret {i8, i1} %9 +define external fastcc {i8, i1} @"ctor_char.ctor<1>"(i64 %"#result##0") { + %"tmp#0##0" = icmp ne i64 %"#result##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = and i64 %"#result##0", 1 + %"tmp#1##0" = icmp eq i64 %"tmp#2##0", 0 + br i1 %"tmp#1##0", label %if.then.1, label %if.else.1 +if.then.1: + %"#temp##0" = lshr i64 %"#result##0", 1 + %"#temp2##0" = and i64 %"#temp##0", 255 + %"tmp#3##0" = trunc i64 %"#temp2##0" to i8 + %"tmp#4##0" = insertvalue {i8, i1} undef, i8 %"tmp#3##0", 0 + %"tmp#5##0" = insertvalue {i8, i1} %"tmp#4##0", i1 1, 1 + ret {i8, i1} %"tmp#5##0" +if.else.1: + %"tmp#6##0" = insertvalue {i8, i1} undef, i8 undef, 0 + %"tmp#7##0" = insertvalue {i8, i1} %"tmp#6##0", i1 0, 1 + ret {i8, i1} %"tmp#7##0" +if.else.0: + %"tmp#8##0" = insertvalue {i8, i1} undef, i8 undef, 0 + %"tmp#9##0" = insertvalue {i8, i1} %"tmp#8##0", i1 0, 1 + ret {i8, i1} %"tmp#9##0" } - -define external fastcc i8 @"ctor_char.foo<0>"(i64 %"this##0") { -entry: - %0 = icmp ne i64 %"this##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = and i64 %"this##0", 1 - %2 = icmp eq i64 %1, 0 - br i1 %2, label %if.then1, label %if.else1 -if.else: - ret i8 48 -if.then1: - %3 = lshr i64 %"this##0", 1 - %4 = and i64 %3, 255 - %5 = trunc i64 %4 to i8 - ret i8 %5 -if.else1: - ret i8 48 +define external fastcc i8 @"ctor_char.foo<0>"(i64 %"this##0") { + %"tmp#3##0" = icmp ne i64 %"this##0", 0 + br i1 %"tmp#3##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#4##0" = and i64 %"this##0", 1 + %"tmp#5##0" = icmp eq i64 %"tmp#4##0", 0 + br i1 %"tmp#5##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#6##0" = lshr i64 %"this##0", 1 + %"tmp#7##0" = and i64 %"tmp#6##0", 255 + %"tmp#8##0" = trunc i64 %"tmp#7##0" to i8 + ret i8 %"tmp#8##0" +if.else.1: + ret i8 48 +if.else.0: + ret i8 48 } - -define external fastcc i64 @"ctor_char.other_ctor<0>"(i64 %"other_ctor#1##0") alwaysinline { -entry: - %0 = trunc i64 8 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"other_ctor#1##0", i64* %3 - %4 = or i64 %2, 1 - ret i64 %4 +define external fastcc i64 @"ctor_char.other_ctor<0>"(i64 %"other_ctor#1##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 8) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"other_ctor#1##0", ptr %"tmp#1##0" + %"tmp#2##0" = or i64 %"#rec##0", 1 + ret i64 %"tmp#2##0" } - -define external fastcc {i64, i1} @"ctor_char.other_ctor<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#result##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = and i64 %"#result##0", 1 - %2 = icmp eq i64 %1, 1 - br i1 %2, label %if.then1, label %if.else1 -if.else: - %10 = insertvalue {i64, i1} undef, i64 undef, 0 - %11 = insertvalue {i64, i1} %10, i1 0, 1 - ret {i64, i1} %11 -if.then1: - %3 = add i64 %"#result##0", -1 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = insertvalue {i64, i1} undef, i64 %5, 0 - %7 = insertvalue {i64, i1} %6, i1 1, 1 - ret {i64, i1} %7 -if.else1: - %8 = insertvalue {i64, i1} undef, i64 undef, 0 - %9 = insertvalue {i64, i1} %8, i1 0, 1 - ret {i64, i1} %9 +define external fastcc {i64, i1} @"ctor_char.other_ctor<1>"(i64 %"#result##0") { + %"tmp#0##0" = icmp ne i64 %"#result##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = and i64 %"#result##0", 1 + %"tmp#1##0" = icmp eq i64 %"tmp#2##0", 1 + br i1 %"tmp#1##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#3##0" = add i64 %"#result##0", -1 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#4##0" + %"tmp#6##0" = insertvalue {i64, i1} undef, i64 %"tmp#5##0", 0 + %"tmp#7##0" = insertvalue {i64, i1} %"tmp#6##0", i1 1, 1 + ret {i64, i1} %"tmp#7##0" +if.else.1: + %"tmp#8##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#9##0" = insertvalue {i64, i1} %"tmp#8##0", i1 0, 1 + ret {i64, i1} %"tmp#9##0" +if.else.0: + %"tmp#10##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#11##0" = insertvalue {i64, i1} %"tmp#10##0", i1 0, 1 + ret {i64, i1} %"tmp#11##0" } - -define external fastcc i1 @"ctor_char.~=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = tail call fastcc i1 @"ctor_char.=<0>"(i64 %"#left##0", i64 %"#right##0") - %1 = xor i1 %0, 1 - ret i1 %1 +define external fastcc i1 @"ctor_char.~=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#0##0" = tail call fastcc i1 @"ctor_char.=<0>"(i64 %"#left##0", i64 %"#right##0") + %"tmp#1##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#1##0" } diff --git a/test-cases/final-dump/ctor_char2.exp b/test-cases/final-dump/ctor_char2.exp index e6f1736af..d606ed32c 100644 --- a/test-cases/final-dump/ctor_char2.exp +++ b/test-cases/final-dump/ctor_char2.exp @@ -1,7 +1,10 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module ctor_char2 - representation : address + representation : pointer public submods : public resources: public procs : ctor_char2.<0> @@ -16,13 +19,14 @@ module top-level code > public {semipure} (0 calls) ()<{<>}; {<>}; {}>: AliasPairs: [] InterestingCallProperties: [] - foreign llvm shl('a':ctor_char2, 2:ctor_char2, ?tmp#3##0:ctor_char2) @ctor_char2:nn:nn - foreign llvm or(~tmp#3##0:ctor_char2, 1024:ctor_char2, ?tmp#1##0:ctor_char2) @ctor_char2:nn:nn + foreign lpvm cast('a':wybe.char, ?tmp#3##0:ctor_char2) @ctor_char2:nn:nn + foreign llvm shl(~tmp#3##0:ctor_char2, 2:ctor_char2, ?tmp#4##0:ctor_char2) @ctor_char2:nn:nn + foreign llvm or(~tmp#4##0:ctor_char2, 1024:ctor_char2, ?tmp#1##0:ctor_char2) @ctor_char2:nn:nn ctor_char2.foo<0>(~tmp#1##0:ctor_char2, ?tmp#0##0:wybe.char) #1 @ctor_char2:nn:nn - foreign lpvm load(<>:wybe.phantom, ?%tmp#5##0:wybe.phantom) @ctor_char2:nn:nn - foreign c putchar(~tmp#0##0:wybe.char, ~tmp#5##0:wybe.phantom, ?tmp#6##0:wybe.phantom) @ctor_char2:nn:nn - foreign c putchar('\n':wybe.char, ~tmp#6##0:wybe.phantom, ?tmp#7##0:wybe.phantom) @ctor_char2:nn:nn - foreign lpvm store(~%tmp#7##0:wybe.phantom, <>:wybe.phantom) @ctor_char2:nn:nn + foreign lpvm load(<>:wybe.phantom, ?%tmp#6##0:wybe.phantom) @ctor_char2:nn:nn + foreign c putchar(~tmp#0##0:wybe.char, ~tmp#6##0:wybe.phantom, ?tmp#7##0:wybe.phantom) @ctor_char2:nn:nn + foreign c putchar('\n':wybe.char, ~tmp#7##0:wybe.phantom, ?tmp#8##0:wybe.phantom) @ctor_char2:nn:nn + foreign lpvm store(~%tmp#8##0:wybe.phantom, <>:wybe.phantom) @ctor_char2:nn:nn proc = > public (3 calls) @@ -186,8 +190,9 @@ c(#rec##0:ctor_char2, ?#rec##2:ctor_char2, #field##0:wybe.char, ?#success##0:wyb 1: foreign llvm and(~#rec##0:ctor_char2, -1021:ctor_char2, ?#rec##1:ctor_char2) @ctor_char2:nn:nn - foreign llvm shl(~#field##0:ctor_char2, 2:ctor_char2, ?#temp##0:ctor_char2) @ctor_char2:nn:nn - foreign llvm or(~#rec##1:ctor_char2, ~#temp##0:ctor_char2, ?#rec##2:ctor_char2) @ctor_char2:nn:nn + foreign lpvm cast(~#field##0:wybe.char, ?#temp##0:ctor_char2) @ctor_char2:nn:nn + foreign llvm shl(~#temp##0:ctor_char2, 2:ctor_char2, ?#temp##1:ctor_char2) @ctor_char2:nn:nn + foreign llvm or(~#rec##1:ctor_char2, ~#temp##1:ctor_char2, ?#rec##2:ctor_char2) @ctor_char2:nn:nn foreign llvm move(1:wybe.bool, ?#success##0:wybe.bool) @@ -206,8 +211,9 @@ proc ctor > {inline} (1 calls) ctor(c##0:wybe.char, ?#result##3:ctor_char2)<{}; {}; {}>: AliasPairs: [] InterestingCallProperties: [] - foreign llvm shl(~c##0:ctor_char2, 2:ctor_char2, ?#temp##0:ctor_char2) @ctor_char2:nn:nn - foreign llvm or(~#temp##0:ctor_char2, 1024:ctor_char2, ?#result##3:ctor_char2) @ctor_char2:nn:nn + foreign lpvm cast(~c##0:wybe.char, ?#temp##0:ctor_char2) @ctor_char2:nn:nn + foreign llvm shl(~#temp##0:ctor_char2, 2:ctor_char2, ?#temp##1:ctor_char2) @ctor_char2:nn:nn + foreign llvm or(~#temp##1:ctor_char2, 1024:ctor_char2, ?#result##3:ctor_char2) @ctor_char2:nn:nn proc ctor > {inline} (15 calls) 1: ctor_char2.ctor<1> ctor(?c##0:wybe.char, #result##0:ctor_char2, ?#success##0:wybe.bool)<{}; {}; {}>: @@ -305,298 +311,271 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'ctor_char2' - - - - -declare external ccc void @putchar(i8) +source_filename = "!ROOT!/final-dump/ctor_char2.wybe" +target triple ???? -declare external ccc i8* @wybe_malloc(i32) +declare external ccc void @putchar(i8) +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"ctor_char2.<0>"() { -entry: - %0 = shl i64 97, 2 - %1 = or i64 %0, 1024 - %2 = tail call fastcc i8 @"ctor_char2.foo<0>"(i64 %1) - tail call ccc void @putchar(i8 %2) - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"ctor_char2.<0>"() { + %"tmp#3##0" = zext i8 97 to i64 + %"tmp#4##0" = shl i64 %"tmp#3##0", 2 + %"tmp#1##0" = or i64 %"tmp#4##0", 1024 + %"tmp#0##0" = tail call fastcc i8 @"ctor_char2.foo<0>"(i64 %"tmp#1##0") + call ccc void @putchar(i8 %"tmp#0##0") + call ccc void @putchar(i8 10) + ret void } - -define external fastcc i1 @"ctor_char2.=<0>"(i64 %"#left##0", i64 %"#right##0") { -entry: - %0 = icmp ne i64 %"#left##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = and i64 %"#left##0", 3 - switch i64 %1, label %switch.3.2 [i64 0, label %switch.3.0 i64 1, label %switch.3.1 i64 2, label %switch.3.2] -if.else: - %32 = icmp eq i64 %"#right##0", 0 - ret i1 %32 -switch.3.0: - %2 = lshr i64 %"#left##0", 2 - %3 = and i64 %2, 255 - %4 = trunc i64 %3 to i8 - %5 = icmp ne i64 %"#right##0", 0 - br i1 %5, label %if.then1, label %if.else1 -switch.3.1: - %12 = add i64 %"#left##0", -1 - %13 = inttoptr i64 %12 to i64* - %14 = load i64, i64* %13 - %15 = icmp ne i64 %"#right##0", 0 - br i1 %15, label %if.then3, label %if.else3 -switch.3.2: - %22 = add i64 %"#left##0", -2 - %23 = inttoptr i64 %22 to i64* - %24 = load i64, i64* %23 - %25 = icmp ne i64 %"#right##0", 0 - br i1 %25, label %if.then5, label %if.else5 -if.then1: - %6 = and i64 %"#right##0", 3 - %7 = icmp eq i64 %6, 0 - br i1 %7, label %if.then2, label %if.else2 -if.else1: - ret i1 0 -if.then2: - %8 = lshr i64 %"#right##0", 2 - %9 = and i64 %8, 255 - %10 = trunc i64 %9 to i8 - %11 = icmp eq i8 %4, %10 - ret i1 %11 -if.else2: - ret i1 0 -if.then3: - %16 = and i64 %"#right##0", 3 - %17 = icmp eq i64 %16, 1 - br i1 %17, label %if.then4, label %if.else4 -if.else3: - ret i1 0 -if.then4: - %18 = add i64 %"#right##0", -1 - %19 = inttoptr i64 %18 to i64* - %20 = load i64, i64* %19 - %21 = musttail call fastcc i1 @"ctor_char2.=<0>"(i64 %14, i64 %20) - ret i1 %21 -if.else4: - ret i1 0 -if.then5: - %26 = and i64 %"#right##0", 3 - %27 = icmp eq i64 %26, 2 - br i1 %27, label %if.then6, label %if.else6 -if.else5: - ret i1 0 -if.then6: - %28 = add i64 %"#right##0", -2 - %29 = inttoptr i64 %28 to i64* - %30 = load i64, i64* %29 - %31 = musttail call fastcc i1 @"ctor_char2.=<0>"(i64 %24, i64 %30) - ret i1 %31 -if.else6: - ret i1 0 +define external fastcc i1 @"ctor_char2.=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#0##0" = icmp ne i64 %"#left##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#13##0" = and i64 %"#left##0", 3 + switch i64 %"tmp#13##0", label %case.2.switch.1 [ + i64 0, label %case.0.switch.1 + i64 1, label %case.1.switch.1 + i64 2, label %case.2.switch.1 ] +case.0.switch.1: + %"tmp#15##0" = lshr i64 %"#left##0", 2 + %"tmp#16##0" = and i64 %"tmp#15##0", 255 + %"#left#c##0" = trunc i64 %"tmp#16##0" to i8 + %"tmp#34##0" = icmp ne i64 %"#right##0", 0 + br i1 %"tmp#34##0", label %if.then.2, label %if.else.2 +if.then.2: + %"tmp#35##0" = and i64 %"#right##0", 3 + %"tmp#36##0" = icmp eq i64 %"tmp#35##0", 0 + br i1 %"tmp#36##0", label %if.then.3, label %if.else.3 +if.then.3: + %"tmp#37##0" = lshr i64 %"#right##0", 2 + %"tmp#38##0" = and i64 %"tmp#37##0", 255 + %"#right#c##0" = trunc i64 %"tmp#38##0" to i8 + %"tmp#41##0" = icmp eq i8 %"#left#c##0", %"#right#c##0" + ret i1 %"tmp#41##0" +if.else.3: + ret i1 0 +if.else.2: + ret i1 0 +case.1.switch.1: + %"tmp#42##0" = add i64 %"#left##0", -1 + %"tmp#43##0" = inttoptr i64 %"tmp#42##0" to ptr + %"#left#other_ctor#1##0" = load i64, ptr %"tmp#43##0" + %"tmp#30##0" = icmp ne i64 %"#right##0", 0 + br i1 %"tmp#30##0", label %if.then.4, label %if.else.4 +if.then.4: + %"tmp#31##0" = and i64 %"#right##0", 3 + %"tmp#32##0" = icmp eq i64 %"tmp#31##0", 1 + br i1 %"tmp#32##0", label %if.then.5, label %if.else.5 +if.then.5: + %"tmp#44##0" = add i64 %"#right##0", -1 + %"tmp#45##0" = inttoptr i64 %"tmp#44##0" to ptr + %"#right#other_ctor#1##0" = load i64, ptr %"tmp#45##0" + %"tmp#46##0" = tail call fastcc i1 @"ctor_char2.=<0>"(i64 %"#left#other_ctor#1##0", i64 %"#right#other_ctor#1##0") + ret i1 %"tmp#46##0" +if.else.5: + ret i1 0 +if.else.4: + ret i1 0 +case.2.switch.1: + %"tmp#47##0" = add i64 %"#left##0", -2 + %"tmp#48##0" = inttoptr i64 %"tmp#47##0" to ptr + %"#left#another_ctor#1##0" = load i64, ptr %"tmp#48##0" + %"tmp#26##0" = icmp ne i64 %"#right##0", 0 + br i1 %"tmp#26##0", label %if.then.6, label %if.else.6 +if.then.6: + %"tmp#27##0" = and i64 %"#right##0", 3 + %"tmp#28##0" = icmp eq i64 %"tmp#27##0", 2 + br i1 %"tmp#28##0", label %if.then.7, label %if.else.7 +if.then.7: + %"tmp#49##0" = add i64 %"#right##0", -2 + %"tmp#50##0" = inttoptr i64 %"tmp#49##0" to ptr + %"#right#another_ctor#1##0" = load i64, ptr %"tmp#50##0" + %"tmp#51##0" = tail call fastcc i1 @"ctor_char2.=<0>"(i64 %"#left#another_ctor#1##0", i64 %"#right#another_ctor#1##0") + ret i1 %"tmp#51##0" +if.else.7: + ret i1 0 +if.else.6: + ret i1 0 +if.else.0: + %"tmp#52##0" = icmp eq i64 %"#right##0", 0 + ret i1 %"tmp#52##0" } - -define external fastcc i64 @"ctor_char2.another_ctor<0>"(i64 %"another_ctor#1##0") alwaysinline { -entry: - %0 = trunc i64 8 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"another_ctor#1##0", i64* %3 - %4 = or i64 %2, 2 - ret i64 %4 +define external fastcc i64 @"ctor_char2.another_ctor<0>"(i64 %"another_ctor#1##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 8) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"another_ctor#1##0", ptr %"tmp#1##0" + %"tmp#2##0" = or i64 %"#rec##0", 2 + ret i64 %"tmp#2##0" } - -define external fastcc {i64, i1} @"ctor_char2.another_ctor<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#result##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = and i64 %"#result##0", 3 - %2 = icmp eq i64 %1, 2 - br i1 %2, label %if.then1, label %if.else1 -if.else: - %10 = insertvalue {i64, i1} undef, i64 undef, 0 - %11 = insertvalue {i64, i1} %10, i1 0, 1 - ret {i64, i1} %11 -if.then1: - %3 = add i64 %"#result##0", -2 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = insertvalue {i64, i1} undef, i64 %5, 0 - %7 = insertvalue {i64, i1} %6, i1 1, 1 - ret {i64, i1} %7 -if.else1: - %8 = insertvalue {i64, i1} undef, i64 undef, 0 - %9 = insertvalue {i64, i1} %8, i1 0, 1 - ret {i64, i1} %9 +define external fastcc {i64, i1} @"ctor_char2.another_ctor<1>"(i64 %"#result##0") { + %"tmp#0##0" = icmp ne i64 %"#result##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = and i64 %"#result##0", 3 + %"tmp#1##0" = icmp eq i64 %"tmp#2##0", 2 + br i1 %"tmp#1##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#3##0" = add i64 %"#result##0", -2 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#4##0" + %"tmp#6##0" = insertvalue {i64, i1} undef, i64 %"tmp#5##0", 0 + %"tmp#7##0" = insertvalue {i64, i1} %"tmp#6##0", i1 1, 1 + ret {i64, i1} %"tmp#7##0" +if.else.1: + %"tmp#8##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#9##0" = insertvalue {i64, i1} %"tmp#8##0", i1 0, 1 + ret {i64, i1} %"tmp#9##0" +if.else.0: + %"tmp#10##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#11##0" = insertvalue {i64, i1} %"tmp#10##0", i1 0, 1 + ret {i64, i1} %"tmp#11##0" } - -define external fastcc {i8, i1} @"ctor_char2.c<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = and i64 %"#rec##0", 3 - %2 = icmp eq i64 %1, 0 - br i1 %2, label %if.then1, label %if.else1 -if.else: - %10 = insertvalue {i8, i1} undef, i8 undef, 0 - %11 = insertvalue {i8, i1} %10, i1 0, 1 - ret {i8, i1} %11 -if.then1: - %3 = lshr i64 %"#rec##0", 2 - %4 = and i64 %3, 255 - %5 = trunc i64 %4 to i8 - %6 = insertvalue {i8, i1} undef, i8 %5, 0 - %7 = insertvalue {i8, i1} %6, i1 1, 1 - ret {i8, i1} %7 -if.else1: - %8 = insertvalue {i8, i1} undef, i8 undef, 0 - %9 = insertvalue {i8, i1} %8, i1 0, 1 - ret {i8, i1} %9 +define external fastcc {i8, i1} @"ctor_char2.c<0>"(i64 %"#rec##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = and i64 %"#rec##0", 3 + %"tmp#1##0" = icmp eq i64 %"tmp#2##0", 0 + br i1 %"tmp#1##0", label %if.then.1, label %if.else.1 +if.then.1: + %"#rec##1" = lshr i64 %"#rec##0", 2 + %"#field##0" = and i64 %"#rec##1", 255 + %"tmp#3##0" = trunc i64 %"#field##0" to i8 + %"tmp#4##0" = insertvalue {i8, i1} undef, i8 %"tmp#3##0", 0 + %"tmp#5##0" = insertvalue {i8, i1} %"tmp#4##0", i1 1, 1 + ret {i8, i1} %"tmp#5##0" +if.else.1: + %"tmp#6##0" = insertvalue {i8, i1} undef, i8 undef, 0 + %"tmp#7##0" = insertvalue {i8, i1} %"tmp#6##0", i1 0, 1 + ret {i8, i1} %"tmp#7##0" +if.else.0: + %"tmp#8##0" = insertvalue {i8, i1} undef, i8 undef, 0 + %"tmp#9##0" = insertvalue {i8, i1} %"tmp#8##0", i1 0, 1 + ret {i8, i1} %"tmp#9##0" } - -define external fastcc {i64, i1} @"ctor_char2.c<1>"(i64 %"#rec##0", i8 %"#field##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = and i64 %"#rec##0", 3 - %2 = icmp eq i64 %1, 0 - br i1 %2, label %if.then1, label %if.else1 -if.else: - %11 = insertvalue {i64, i1} undef, i64 0, 0 - %12 = insertvalue {i64, i1} %11, i1 0, 1 - ret {i64, i1} %12 -if.then1: - %3 = and i64 %"#rec##0", -1021 - %4 = zext i8 %"#field##0" to i64 - %5 = shl i64 %4, 2 - %6 = or i64 %3, %5 - %7 = insertvalue {i64, i1} undef, i64 %6, 0 - %8 = insertvalue {i64, i1} %7, i1 1, 1 - ret {i64, i1} %8 -if.else1: - %9 = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 - %10 = insertvalue {i64, i1} %9, i1 0, 1 - ret {i64, i1} %10 +define external fastcc {i64, i1} @"ctor_char2.c<1>"(i64 %"#rec##0", i8 %"#field##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = and i64 %"#rec##0", 3 + %"tmp#1##0" = icmp eq i64 %"tmp#2##0", 0 + br i1 %"tmp#1##0", label %if.then.1, label %if.else.1 +if.then.1: + %"#rec##1" = and i64 %"#rec##0", -1021 + %"#temp##0" = zext i8 %"#field##0" to i64 + %"#temp##1" = shl i64 %"#temp##0", 2 + %"tmp#3##0" = or i64 %"#rec##1", %"#temp##1" + %"tmp#4##0" = insertvalue {i64, i1} undef, i64 %"tmp#3##0", 0 + %"tmp#5##0" = insertvalue {i64, i1} %"tmp#4##0", i1 1, 1 + ret {i64, i1} %"tmp#5##0" +if.else.1: + %"tmp#6##0" = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 + %"tmp#7##0" = insertvalue {i64, i1} %"tmp#6##0", i1 0, 1 + ret {i64, i1} %"tmp#7##0" +if.else.0: + %"tmp#8##0" = insertvalue {i64, i1} undef, i64 0, 0 + %"tmp#9##0" = insertvalue {i64, i1} %"tmp#8##0", i1 0, 1 + ret {i64, i1} %"tmp#9##0" } - -define external fastcc i64 @"ctor_char2.const<0>"() alwaysinline { -entry: - ret i64 0 +define external fastcc i64 @"ctor_char2.const<0>"() { + ret i64 0 } - -define external fastcc i64 @"ctor_char2.ctor<0>"(i8 %"c##0") alwaysinline { -entry: - %0 = zext i8 %"c##0" to i64 - %1 = shl i64 %0, 2 - %2 = or i64 %1, 1024 - ret i64 %2 +define external fastcc i64 @"ctor_char2.ctor<0>"(i8 %"c##0") { + %"#temp##0" = zext i8 %"c##0" to i64 + %"#temp##1" = shl i64 %"#temp##0", 2 + %"tmp#0##0" = or i64 %"#temp##1", 1024 + ret i64 %"tmp#0##0" } - -define external fastcc {i8, i1} @"ctor_char2.ctor<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#result##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = and i64 %"#result##0", 3 - %2 = icmp eq i64 %1, 0 - br i1 %2, label %if.then1, label %if.else1 -if.else: - %10 = insertvalue {i8, i1} undef, i8 undef, 0 - %11 = insertvalue {i8, i1} %10, i1 0, 1 - ret {i8, i1} %11 -if.then1: - %3 = lshr i64 %"#result##0", 2 - %4 = and i64 %3, 255 - %5 = trunc i64 %4 to i8 - %6 = insertvalue {i8, i1} undef, i8 %5, 0 - %7 = insertvalue {i8, i1} %6, i1 1, 1 - ret {i8, i1} %7 -if.else1: - %8 = insertvalue {i8, i1} undef, i8 undef, 0 - %9 = insertvalue {i8, i1} %8, i1 0, 1 - ret {i8, i1} %9 +define external fastcc {i8, i1} @"ctor_char2.ctor<1>"(i64 %"#result##0") { + %"tmp#0##0" = icmp ne i64 %"#result##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = and i64 %"#result##0", 3 + %"tmp#1##0" = icmp eq i64 %"tmp#2##0", 0 + br i1 %"tmp#1##0", label %if.then.1, label %if.else.1 +if.then.1: + %"#temp##0" = lshr i64 %"#result##0", 2 + %"#temp2##0" = and i64 %"#temp##0", 255 + %"tmp#3##0" = trunc i64 %"#temp2##0" to i8 + %"tmp#4##0" = insertvalue {i8, i1} undef, i8 %"tmp#3##0", 0 + %"tmp#5##0" = insertvalue {i8, i1} %"tmp#4##0", i1 1, 1 + ret {i8, i1} %"tmp#5##0" +if.else.1: + %"tmp#6##0" = insertvalue {i8, i1} undef, i8 undef, 0 + %"tmp#7##0" = insertvalue {i8, i1} %"tmp#6##0", i1 0, 1 + ret {i8, i1} %"tmp#7##0" +if.else.0: + %"tmp#8##0" = insertvalue {i8, i1} undef, i8 undef, 0 + %"tmp#9##0" = insertvalue {i8, i1} %"tmp#8##0", i1 0, 1 + ret {i8, i1} %"tmp#9##0" } - -define external fastcc i8 @"ctor_char2.foo<0>"(i64 %"this##0") { -entry: - %0 = icmp ne i64 %"this##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = and i64 %"this##0", 3 - %2 = icmp eq i64 %1, 0 - br i1 %2, label %if.then1, label %if.else1 -if.else: - ret i8 48 -if.then1: - %3 = lshr i64 %"this##0", 2 - %4 = and i64 %3, 255 - %5 = trunc i64 %4 to i8 - ret i8 %5 -if.else1: - ret i8 48 +define external fastcc i8 @"ctor_char2.foo<0>"(i64 %"this##0") { + %"tmp#3##0" = icmp ne i64 %"this##0", 0 + br i1 %"tmp#3##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#4##0" = and i64 %"this##0", 3 + %"tmp#5##0" = icmp eq i64 %"tmp#4##0", 0 + br i1 %"tmp#5##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#6##0" = lshr i64 %"this##0", 2 + %"tmp#7##0" = and i64 %"tmp#6##0", 255 + %"tmp#8##0" = trunc i64 %"tmp#7##0" to i8 + ret i8 %"tmp#8##0" +if.else.1: + ret i8 48 +if.else.0: + ret i8 48 } - -define external fastcc i64 @"ctor_char2.other_ctor<0>"(i64 %"other_ctor#1##0") alwaysinline { -entry: - %0 = trunc i64 8 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"other_ctor#1##0", i64* %3 - %4 = or i64 %2, 1 - ret i64 %4 +define external fastcc i64 @"ctor_char2.other_ctor<0>"(i64 %"other_ctor#1##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 8) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"other_ctor#1##0", ptr %"tmp#1##0" + %"tmp#2##0" = or i64 %"#rec##0", 1 + ret i64 %"tmp#2##0" } - -define external fastcc {i64, i1} @"ctor_char2.other_ctor<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#result##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = and i64 %"#result##0", 3 - %2 = icmp eq i64 %1, 1 - br i1 %2, label %if.then1, label %if.else1 -if.else: - %10 = insertvalue {i64, i1} undef, i64 undef, 0 - %11 = insertvalue {i64, i1} %10, i1 0, 1 - ret {i64, i1} %11 -if.then1: - %3 = add i64 %"#result##0", -1 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = insertvalue {i64, i1} undef, i64 %5, 0 - %7 = insertvalue {i64, i1} %6, i1 1, 1 - ret {i64, i1} %7 -if.else1: - %8 = insertvalue {i64, i1} undef, i64 undef, 0 - %9 = insertvalue {i64, i1} %8, i1 0, 1 - ret {i64, i1} %9 +define external fastcc {i64, i1} @"ctor_char2.other_ctor<1>"(i64 %"#result##0") { + %"tmp#0##0" = icmp ne i64 %"#result##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = and i64 %"#result##0", 3 + %"tmp#1##0" = icmp eq i64 %"tmp#2##0", 1 + br i1 %"tmp#1##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#3##0" = add i64 %"#result##0", -1 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#4##0" + %"tmp#6##0" = insertvalue {i64, i1} undef, i64 %"tmp#5##0", 0 + %"tmp#7##0" = insertvalue {i64, i1} %"tmp#6##0", i1 1, 1 + ret {i64, i1} %"tmp#7##0" +if.else.1: + %"tmp#8##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#9##0" = insertvalue {i64, i1} %"tmp#8##0", i1 0, 1 + ret {i64, i1} %"tmp#9##0" +if.else.0: + %"tmp#10##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#11##0" = insertvalue {i64, i1} %"tmp#10##0", i1 0, 1 + ret {i64, i1} %"tmp#11##0" } - -define external fastcc i1 @"ctor_char2.~=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = tail call fastcc i1 @"ctor_char2.=<0>"(i64 %"#left##0", i64 %"#right##0") - %1 = xor i1 %0, 1 - ret i1 %1 +define external fastcc i1 @"ctor_char2.~=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#0##0" = tail call fastcc i1 @"ctor_char2.=<0>"(i64 %"#left##0", i64 %"#right##0") + %"tmp#1##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#1##0" } diff --git a/test-cases/final-dump/ctor_visibility.exp b/test-cases/final-dump/ctor_visibility.exp index 0016e4ea0..593697a69 100644 --- a/test-cases/final-dump/ctor_visibility.exp +++ b/test-cases/final-dump/ctor_visibility.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module ctor_visibility representation : (not a type) public submods : @@ -21,16 +24,15 @@ AFTER EVERYTHING: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'ctor_visibility' +source_filename = "!ROOT!/final-dump/ctor_visibility.wybe" +target triple ???? - - - -declare external ccc i8* @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) -------------------------------------------------- Module ctor_visibility.all_priv representation : 1 bit unsigned @@ -77,43 +79,34 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'ctor_visibility.all_priv' +source_filename = "!ROOT!/final-dump/ctor_visibility.wybe" +target triple ???? - +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i1 @"ctor_visibility.all_priv.=<0>"(i1 %"#left##0", i1 %"#right##0") alwaysinline { -entry: - %0 = icmp eq i1 %"#left##0", %"#right##0" - ret i1 %0 +define external fastcc i1 @"ctor_visibility.all_priv.=<0>"(i1 %"#left##0", i1 %"#right##0") { + %"tmp#1##0" = icmp eq i1 %"#left##0", %"#right##0" + ret i1 %"tmp#1##0" } - -define external fastcc i1 @"ctor_visibility.all_priv.bar<0>"() alwaysinline { -entry: - ret i1 1 +define external fastcc i1 @"ctor_visibility.all_priv.bar<0>"() { + ret i1 1 } - -define external fastcc i1 @"ctor_visibility.all_priv.foo<0>"() alwaysinline { -entry: - ret i1 0 +define external fastcc i1 @"ctor_visibility.all_priv.foo<0>"() { + ret i1 0 } - -define external fastcc i1 @"ctor_visibility.all_priv.~=<0>"(i1 %"#left##0", i1 %"#right##0") alwaysinline { -entry: - %0 = icmp eq i1 %"#left##0", %"#right##0" - %1 = xor i1 %0, 1 - ret i1 %1 +define external fastcc i1 @"ctor_visibility.all_priv.~=<0>"(i1 %"#left##0", i1 %"#right##0") { + %"tmp#0##0" = icmp eq i1 %"#left##0", %"#right##0" + %"tmp#3##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#3##0" } + -------------------------------------------------- Module ctor_visibility.all_public_long representation : 1 bit unsigned @@ -162,43 +155,34 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'ctor_visibility.all_public_long' +source_filename = "!ROOT!/final-dump/ctor_visibility.wybe" +target triple ???? - - - -declare external ccc i8* @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i1 @"ctor_visibility.all_public_long.=<0>"(i1 %"#left##0", i1 %"#right##0") alwaysinline { -entry: - %0 = icmp eq i1 %"#left##0", %"#right##0" - ret i1 %0 +define external fastcc i1 @"ctor_visibility.all_public_long.=<0>"(i1 %"#left##0", i1 %"#right##0") { + %"tmp#1##0" = icmp eq i1 %"#left##0", %"#right##0" + ret i1 %"tmp#1##0" } - -define external fastcc i1 @"ctor_visibility.all_public_long.bar<0>"() alwaysinline { -entry: - ret i1 1 +define external fastcc i1 @"ctor_visibility.all_public_long.bar<0>"() { + ret i1 1 } - -define external fastcc i1 @"ctor_visibility.all_public_long.foo<0>"() alwaysinline { -entry: - ret i1 0 +define external fastcc i1 @"ctor_visibility.all_public_long.foo<0>"() { + ret i1 0 } - -define external fastcc i1 @"ctor_visibility.all_public_long.~=<0>"(i1 %"#left##0", i1 %"#right##0") alwaysinline { -entry: - %0 = icmp eq i1 %"#left##0", %"#right##0" - %1 = xor i1 %0, 1 - ret i1 %1 +define external fastcc i1 @"ctor_visibility.all_public_long.~=<0>"(i1 %"#left##0", i1 %"#right##0") { + %"tmp#0##0" = icmp eq i1 %"#left##0", %"#right##0" + %"tmp#3##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#3##0" } + -------------------------------------------------- Module ctor_visibility.all_public_short representation : 1 bit unsigned @@ -247,43 +231,34 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'ctor_visibility.all_public_short' - - - - -declare external ccc i8* @wybe_malloc(i32) +source_filename = "!ROOT!/final-dump/ctor_visibility.wybe" +target triple ???? -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) - -define external fastcc i1 @"ctor_visibility.all_public_short.=<0>"(i1 %"#left##0", i1 %"#right##0") alwaysinline { -entry: - %0 = icmp eq i1 %"#left##0", %"#right##0" - ret i1 %0 +define external fastcc i1 @"ctor_visibility.all_public_short.=<0>"(i1 %"#left##0", i1 %"#right##0") { + %"tmp#1##0" = icmp eq i1 %"#left##0", %"#right##0" + ret i1 %"tmp#1##0" } - -define external fastcc i1 @"ctor_visibility.all_public_short.bar<0>"() alwaysinline { -entry: - ret i1 1 +define external fastcc i1 @"ctor_visibility.all_public_short.bar<0>"() { + ret i1 1 } - -define external fastcc i1 @"ctor_visibility.all_public_short.foo<0>"() alwaysinline { -entry: - ret i1 0 +define external fastcc i1 @"ctor_visibility.all_public_short.foo<0>"() { + ret i1 0 } - -define external fastcc i1 @"ctor_visibility.all_public_short.~=<0>"(i1 %"#left##0", i1 %"#right##0") alwaysinline { -entry: - %0 = icmp eq i1 %"#left##0", %"#right##0" - %1 = xor i1 %0, 1 - ret i1 %1 +define external fastcc i1 @"ctor_visibility.all_public_short.~=<0>"(i1 %"#left##0", i1 %"#right##0") { + %"tmp#0##0" = icmp eq i1 %"#left##0", %"#right##0" + %"tmp#3##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#3##0" } + -------------------------------------------------- Module ctor_visibility.ctor_keyword representation : 1 bit unsigned @@ -330,43 +305,34 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'ctor_visibility.ctor_keyword' +source_filename = "!ROOT!/final-dump/ctor_visibility.wybe" +target triple ???? - - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -define external fastcc i1 @"ctor_visibility.ctor_keyword.=<0>"(i1 %"#left##0", i1 %"#right##0") alwaysinline { -entry: - %0 = icmp eq i1 %"#left##0", %"#right##0" - ret i1 %0 +define external fastcc i1 @"ctor_visibility.ctor_keyword.=<0>"(i1 %"#left##0", i1 %"#right##0") { + %"tmp#1##0" = icmp eq i1 %"#left##0", %"#right##0" + ret i1 %"tmp#1##0" } - -define external fastcc i1 @"ctor_visibility.ctor_keyword.bar<0>"() alwaysinline { -entry: - ret i1 1 +define external fastcc i1 @"ctor_visibility.ctor_keyword.bar<0>"() { + ret i1 1 } - -define external fastcc i1 @"ctor_visibility.ctor_keyword.foo<0>"() alwaysinline { -entry: - ret i1 0 +define external fastcc i1 @"ctor_visibility.ctor_keyword.foo<0>"() { + ret i1 0 } - -define external fastcc i1 @"ctor_visibility.ctor_keyword.~=<0>"(i1 %"#left##0", i1 %"#right##0") alwaysinline { -entry: - %0 = icmp eq i1 %"#left##0", %"#right##0" - %1 = xor i1 %0, 1 - ret i1 %1 +define external fastcc i1 @"ctor_visibility.ctor_keyword.~=<0>"(i1 %"#left##0", i1 %"#right##0") { + %"tmp#0##0" = icmp eq i1 %"#left##0", %"#right##0" + %"tmp#3##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#3##0" } + -------------------------------------------------- Module ctor_visibility.one_pub representation : 1 bit unsigned @@ -414,43 +380,34 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'ctor_visibility.one_pub' +source_filename = "!ROOT!/final-dump/ctor_visibility.wybe" +target triple ???? - +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i1 @"ctor_visibility.one_pub.=<0>"(i1 %"#left##0", i1 %"#right##0") alwaysinline { -entry: - %0 = icmp eq i1 %"#left##0", %"#right##0" - ret i1 %0 +define external fastcc i1 @"ctor_visibility.one_pub.=<0>"(i1 %"#left##0", i1 %"#right##0") { + %"tmp#1##0" = icmp eq i1 %"#left##0", %"#right##0" + ret i1 %"tmp#1##0" } - -define external fastcc i1 @"ctor_visibility.one_pub.bar<0>"() alwaysinline { -entry: - ret i1 1 +define external fastcc i1 @"ctor_visibility.one_pub.bar<0>"() { + ret i1 1 } - -define external fastcc i1 @"ctor_visibility.one_pub.foo<0>"() alwaysinline { -entry: - ret i1 0 +define external fastcc i1 @"ctor_visibility.one_pub.foo<0>"() { + ret i1 0 } - -define external fastcc i1 @"ctor_visibility.one_pub.~=<0>"(i1 %"#left##0", i1 %"#right##0") alwaysinline { -entry: - %0 = icmp eq i1 %"#left##0", %"#right##0" - %1 = xor i1 %0, 1 - ret i1 %1 +define external fastcc i1 @"ctor_visibility.one_pub.~=<0>"(i1 %"#left##0", i1 %"#right##0") { + %"tmp#0##0" = icmp eq i1 %"#left##0", %"#right##0" + %"tmp#3##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#3##0" } + -------------------------------------------------- Module ctor_visibility.one_pub2 representation : 1 bit unsigned @@ -498,46 +455,37 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'ctor_visibility.one_pub2' +source_filename = "!ROOT!/final-dump/ctor_visibility.wybe" +target triple ???? - - - -declare external ccc i8* @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i1 @"ctor_visibility.one_pub2.=<0>"(i1 %"#left##0", i1 %"#right##0") alwaysinline { -entry: - %0 = icmp eq i1 %"#left##0", %"#right##0" - ret i1 %0 +define external fastcc i1 @"ctor_visibility.one_pub2.=<0>"(i1 %"#left##0", i1 %"#right##0") { + %"tmp#1##0" = icmp eq i1 %"#left##0", %"#right##0" + ret i1 %"tmp#1##0" } - -define external fastcc i1 @"ctor_visibility.one_pub2.bar<0>"() alwaysinline { -entry: - ret i1 1 +define external fastcc i1 @"ctor_visibility.one_pub2.bar<0>"() { + ret i1 1 } - -define external fastcc i1 @"ctor_visibility.one_pub2.foo<0>"() alwaysinline { -entry: - ret i1 0 +define external fastcc i1 @"ctor_visibility.one_pub2.foo<0>"() { + ret i1 0 } - -define external fastcc i1 @"ctor_visibility.one_pub2.~=<0>"(i1 %"#left##0", i1 %"#right##0") alwaysinline { -entry: - %0 = icmp eq i1 %"#left##0", %"#right##0" - %1 = xor i1 %0, 1 - ret i1 %1 +define external fastcc i1 @"ctor_visibility.one_pub2.~=<0>"(i1 %"#left##0", i1 %"#right##0") { + %"tmp#0##0" = icmp eq i1 %"#left##0", %"#right##0" + %"tmp#3##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#3##0" } + -------------------------------------------------- Module ctor_visibility.with_fields - representation : address + representation : pointer public submods : public resources: public procs : ctor_visibility.with_fields.=<0> @@ -735,244 +683,213 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'ctor_visibility.with_fields' - - - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i1 @"ctor_visibility.with_fields.=<0>"(i64 %"#left##0", i64 %"#right##0") { -entry: - %0 = and i64 %"#left##0", 1 - %1 = icmp eq i64 %0, 0 - br i1 %1, label %if.then, label %if.else -if.then: - %2 = inttoptr i64 %"#left##0" to i64* - %3 = load i64, i64* %2 - %4 = and i64 %"#right##0", 1 - %5 = icmp eq i64 %4, 0 - br i1 %5, label %if.then1, label %if.else1 -if.else: - %9 = icmp eq i64 %0, 1 - br i1 %9, label %if.then2, label %if.else2 -if.then1: - %6 = inttoptr i64 %"#right##0" to i64* - %7 = load i64, i64* %6 - %8 = icmp eq i64 %3, %7 - ret i1 %8 -if.else1: - ret i1 0 -if.then2: - %10 = add i64 %"#left##0", -1 - %11 = inttoptr i64 %10 to i64* - %12 = load i64, i64* %11 - %13 = add i64 %"#left##0", 7 - %14 = inttoptr i64 %13 to i64* - %15 = load i64, i64* %14 - %16 = and i64 %"#right##0", 1 - %17 = icmp eq i64 %16, 1 - br i1 %17, label %if.then3, label %if.else3 -if.else2: - ret i1 0 -if.then3: - %18 = add i64 %"#right##0", -1 - %19 = inttoptr i64 %18 to i64* - %20 = load i64, i64* %19 - %21 = add i64 %"#right##0", 7 - %22 = inttoptr i64 %21 to i64* - %23 = load i64, i64* %22 - %24 = icmp eq i64 %12, %20 - br i1 %24, label %if.then4, label %if.else4 -if.else3: - ret i1 0 -if.then4: - %25 = icmp eq i64 %15, %23 - ret i1 %25 -if.else4: - ret i1 0 +source_filename = "!ROOT!/final-dump/ctor_visibility.wybe" +target triple ???? + + +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc i1 @"ctor_visibility.with_fields.=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#9##0" = and i64 %"#left##0", 1 + %"tmp#10##0" = icmp eq i64 %"tmp#9##0", 0 + br i1 %"tmp#10##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#26##0" = inttoptr i64 %"#left##0" to ptr + %"#left#a##0" = load i64, ptr %"tmp#26##0" + %"tmp#22##0" = and i64 %"#right##0", 1 + %"tmp#23##0" = icmp eq i64 %"tmp#22##0", 0 + br i1 %"tmp#23##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#27##0" = inttoptr i64 %"#right##0" to ptr + %"#right#a##0" = load i64, ptr %"tmp#27##0" + %"tmp#28##0" = icmp eq i64 %"#left#a##0", %"#right#a##0" + ret i1 %"tmp#28##0" +if.else.1: + ret i1 0 +if.else.0: + %"tmp#13##0" = icmp eq i64 %"tmp#9##0", 1 + br i1 %"tmp#13##0", label %if.then.2, label %if.else.2 +if.then.2: + %"tmp#29##0" = add i64 %"#left##0", -1 + %"tmp#30##0" = inttoptr i64 %"tmp#29##0" to ptr + %"#left#a##1" = load i64, ptr %"tmp#30##0" + %"tmp#31##0" = add i64 %"#left##0", 7 + %"tmp#32##0" = inttoptr i64 %"tmp#31##0" to ptr + %"#left#b##0" = load i64, ptr %"tmp#32##0" + %"tmp#15##0" = and i64 %"#right##0", 1 + %"tmp#16##0" = icmp eq i64 %"tmp#15##0", 1 + br i1 %"tmp#16##0", label %if.then.3, label %if.else.3 +if.then.3: + %"tmp#33##0" = add i64 %"#right##0", -1 + %"tmp#34##0" = inttoptr i64 %"tmp#33##0" to ptr + %"tmp#35##0" = load i64, ptr %"tmp#34##0" + %"tmp#36##0" = add i64 %"#right##0", 7 + %"tmp#37##0" = inttoptr i64 %"tmp#36##0" to ptr + %"#right#b##0" = load i64, ptr %"tmp#37##0" + %"tmp#4##0" = icmp eq i64 %"#left#a##1", %"tmp#35##0" + br i1 %"tmp#4##0", label %if.then.4, label %if.else.4 +if.then.4: + %"tmp#38##0" = icmp eq i64 %"#left#b##0", %"#right#b##0" + ret i1 %"tmp#38##0" +if.else.4: + ret i1 0 +if.else.3: + ret i1 0 +if.else.2: + ret i1 0 } - -define external fastcc i64 @"ctor_visibility.with_fields.a<0>"(i64 %"#rec##0") { -entry: - %0 = and i64 %"#rec##0", 1 - %1 = icmp eq i64 %0, 0 - br i1 %1, label %if.then, label %if.else -if.then: - %2 = inttoptr i64 %"#rec##0" to i64* - %3 = load i64, i64* %2 - ret i64 %3 -if.else: - %4 = add i64 %"#rec##0", -1 - %5 = inttoptr i64 %4 to i64* - %6 = load i64, i64* %5 - ret i64 %6 +define external fastcc i64 @"ctor_visibility.with_fields.a<0>"(i64 %"#rec##0") { + %"tmp#1##0" = and i64 %"#rec##0", 1 + %"tmp#0##0" = icmp eq i64 %"tmp#1##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#2##0" + ret i64 %"tmp#3##0" +if.else.0: + %"tmp#4##0" = add i64 %"#rec##0", -1 + %"tmp#5##0" = inttoptr i64 %"tmp#4##0" to ptr + %"tmp#6##0" = load i64, ptr %"tmp#5##0" + ret i64 %"tmp#6##0" } - -define external fastcc i64 @"ctor_visibility.with_fields.a<1>"(i64 %"#rec##0", i64 %"#field##0") { -entry: - %0 = and i64 %"#rec##0", 1 - %1 = icmp eq i64 %0, 0 - br i1 %1, label %if.then, label %if.else -if.then: - %2 = trunc i64 8 to i32 - %3 = tail call ccc i8* @wybe_malloc(i32 %2) - %4 = ptrtoint i8* %3 to i64 - %5 = inttoptr i64 %4 to i8* - %6 = inttoptr i64 %"#rec##0" to i8* - %7 = trunc i64 8 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %5, i8* %6, i32 %7, i1 0) - %8 = inttoptr i64 %4 to i64* - store i64 %"#field##0", i64* %8 - ret i64 %4 -if.else: - %9 = trunc i64 16 to i32 - %10 = tail call ccc i8* @wybe_malloc(i32 %9) - %11 = ptrtoint i8* %10 to i64 - %12 = add i64 %11, 1 - %13 = sub i64 %"#rec##0", 1 - %14 = inttoptr i64 %11 to i8* - %15 = inttoptr i64 %13 to i8* - %16 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %14, i8* %15, i32 %16, i1 0) - %17 = add i64 %12, -1 - %18 = inttoptr i64 %17 to i64* - store i64 %"#field##0", i64* %18 - ret i64 %12 +define external fastcc i64 @"ctor_visibility.with_fields.a<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#1##0" = and i64 %"#rec##0", 1 + %"tmp#0##0" = icmp eq i64 %"tmp#1##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#3##0" = call ccc ptr @wybe_malloc(i32 8) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#3##0", ptr %"tmp#2##0", i64 8, i1 0) + %"tmp#4##0" = ptrtoint ptr %"tmp#3##0" to i64 + %"tmp#5##0" = inttoptr i64 %"tmp#4##0" to ptr + store i64 %"#field##0", ptr %"tmp#5##0" + ret i64 %"tmp#4##0" +if.else.0: + %"tmp#6##0" = sub i64 %"#rec##0", 1 + %"tmp#7##0" = inttoptr i64 %"tmp#6##0" to ptr + %"tmp#8##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#8##0", ptr %"tmp#7##0", i64 16, i1 0) + %"tmp#9##0" = ptrtoint ptr %"tmp#8##0" to i64 + %"tmp#10##0" = add i64 %"tmp#9##0", 1 + %"tmp#11##0" = add i64 %"tmp#10##0", -1 + %"tmp#12##0" = inttoptr i64 %"tmp#11##0" to ptr + store i64 %"#field##0", ptr %"tmp#12##0" + ret i64 %"tmp#10##0" } - -define external fastcc {i64, i1} @"ctor_visibility.with_fields.b<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = and i64 %"#rec##0", 1 - %1 = icmp eq i64 %0, 1 - br i1 %1, label %if.then, label %if.else -if.then: - %2 = add i64 %"#rec##0", 7 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = insertvalue {i64, i1} undef, i64 %4, 0 - %6 = insertvalue {i64, i1} %5, i1 1, 1 - ret {i64, i1} %6 -if.else: - %7 = insertvalue {i64, i1} undef, i64 undef, 0 - %8 = insertvalue {i64, i1} %7, i1 0, 1 - ret {i64, i1} %8 +define external fastcc {i64, i1} @"ctor_visibility.with_fields.b<0>"(i64 %"#rec##0") { + %"tmp#1##0" = and i64 %"#rec##0", 1 + %"tmp#0##0" = icmp eq i64 %"tmp#1##0", 1 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = add i64 %"#rec##0", 7 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#3##0" + %"tmp#5##0" = insertvalue {i64, i1} undef, i64 %"tmp#4##0", 0 + %"tmp#6##0" = insertvalue {i64, i1} %"tmp#5##0", i1 1, 1 + ret {i64, i1} %"tmp#6##0" +if.else.0: + %"tmp#7##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#8##0" = insertvalue {i64, i1} %"tmp#7##0", i1 0, 1 + ret {i64, i1} %"tmp#8##0" } - -define external fastcc {i64, i1} @"ctor_visibility.with_fields.b<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = and i64 %"#rec##0", 1 - %1 = icmp eq i64 %0, 1 - br i1 %1, label %if.then, label %if.else -if.then: - %2 = trunc i64 16 to i32 - %3 = tail call ccc i8* @wybe_malloc(i32 %2) - %4 = ptrtoint i8* %3 to i64 - %5 = add i64 %4, 1 - %6 = sub i64 %"#rec##0", 1 - %7 = inttoptr i64 %4 to i8* - %8 = inttoptr i64 %6 to i8* - %9 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %7, i8* %8, i32 %9, i1 0) - %10 = add i64 %5, 7 - %11 = inttoptr i64 %10 to i64* - store i64 %"#field##0", i64* %11 - %12 = insertvalue {i64, i1} undef, i64 %5, 0 - %13 = insertvalue {i64, i1} %12, i1 1, 1 - ret {i64, i1} %13 -if.else: - %14 = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 - %15 = insertvalue {i64, i1} %14, i1 0, 1 - ret {i64, i1} %15 +define external fastcc {i64, i1} @"ctor_visibility.with_fields.b<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#1##0" = and i64 %"#rec##0", 1 + %"tmp#0##0" = icmp eq i64 %"tmp#1##0", 1 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = sub i64 %"#rec##0", 1 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#4##0", ptr %"tmp#3##0", i64 16, i1 0) + %"tmp#5##0" = ptrtoint ptr %"tmp#4##0" to i64 + %"tmp#6##0" = add i64 %"tmp#5##0", 1 + %"tmp#7##0" = add i64 %"tmp#6##0", 7 + %"tmp#8##0" = inttoptr i64 %"tmp#7##0" to ptr + store i64 %"#field##0", ptr %"tmp#8##0" + %"tmp#9##0" = insertvalue {i64, i1} undef, i64 %"tmp#6##0", 0 + %"tmp#10##0" = insertvalue {i64, i1} %"tmp#9##0", i1 1, 1 + ret {i64, i1} %"tmp#10##0" +if.else.0: + %"tmp#11##0" = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 + %"tmp#12##0" = insertvalue {i64, i1} %"tmp#11##0", i1 0, 1 + ret {i64, i1} %"tmp#12##0" } - -define external fastcc i64 @"ctor_visibility.with_fields.bar<0>"(i64 %"a##0", i64 %"b##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"a##0", i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"b##0", i64* %5 - %6 = or i64 %2, 1 - ret i64 %6 +define external fastcc i64 @"ctor_visibility.with_fields.bar<0>"(i64 %"a##0", i64 %"b##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 16) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"a##0", ptr %"tmp#1##0" + %"tmp#2##0" = add i64 %"#rec##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"b##0", ptr %"tmp#3##0" + %"tmp#4##0" = or i64 %"#rec##0", 1 + ret i64 %"tmp#4##0" } - -define external fastcc {i64, i64, i1} @"ctor_visibility.with_fields.bar<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = and i64 %"#result##0", 1 - %1 = icmp eq i64 %0, 1 - br i1 %1, label %if.then, label %if.else -if.then: - %2 = add i64 %"#result##0", -1 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = add i64 %"#result##0", 7 - %6 = inttoptr i64 %5 to i64* - %7 = load i64, i64* %6 - %8 = insertvalue {i64, i64, i1} undef, i64 %4, 0 - %9 = insertvalue {i64, i64, i1} %8, i64 %7, 1 - %10 = insertvalue {i64, i64, i1} %9, i1 1, 2 - ret {i64, i64, i1} %10 -if.else: - %11 = insertvalue {i64, i64, i1} undef, i64 undef, 0 - %12 = insertvalue {i64, i64, i1} %11, i64 undef, 1 - %13 = insertvalue {i64, i64, i1} %12, i1 0, 2 - ret {i64, i64, i1} %13 +define external fastcc {i64, i64, i1} @"ctor_visibility.with_fields.bar<1>"(i64 %"#result##0") { + %"tmp#1##0" = and i64 %"#result##0", 1 + %"tmp#0##0" = icmp eq i64 %"tmp#1##0", 1 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = add i64 %"#result##0", -1 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#3##0" + %"tmp#5##0" = add i64 %"#result##0", 7 + %"tmp#6##0" = inttoptr i64 %"tmp#5##0" to ptr + %"tmp#7##0" = load i64, ptr %"tmp#6##0" + %"tmp#8##0" = insertvalue {i64, i64, i1} undef, i64 %"tmp#4##0", 0 + %"tmp#9##0" = insertvalue {i64, i64, i1} %"tmp#8##0", i64 %"tmp#7##0", 1 + %"tmp#10##0" = insertvalue {i64, i64, i1} %"tmp#9##0", i1 1, 2 + ret {i64, i64, i1} %"tmp#10##0" +if.else.0: + %"tmp#11##0" = insertvalue {i64, i64, i1} undef, i64 undef, 0 + %"tmp#12##0" = insertvalue {i64, i64, i1} %"tmp#11##0", i64 undef, 1 + %"tmp#13##0" = insertvalue {i64, i64, i1} %"tmp#12##0", i1 0, 2 + ret {i64, i64, i1} %"tmp#13##0" } - -define external fastcc i64 @"ctor_visibility.with_fields.foo<0>"(i64 %"a##0") alwaysinline { -entry: - %0 = trunc i64 8 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"a##0", i64* %3 - ret i64 %2 +define external fastcc i64 @"ctor_visibility.with_fields.foo<0>"(i64 %"a##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 8) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"a##0", ptr %"tmp#1##0" + ret i64 %"#rec##0" } - -define external fastcc {i64, i1} @"ctor_visibility.with_fields.foo<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = and i64 %"#result##0", 1 - %1 = icmp eq i64 %0, 0 - br i1 %1, label %if.then, label %if.else -if.then: - %2 = inttoptr i64 %"#result##0" to i64* - %3 = load i64, i64* %2 - %4 = insertvalue {i64, i1} undef, i64 %3, 0 - %5 = insertvalue {i64, i1} %4, i1 1, 1 - ret {i64, i1} %5 -if.else: - %6 = insertvalue {i64, i1} undef, i64 undef, 0 - %7 = insertvalue {i64, i1} %6, i1 0, 1 - ret {i64, i1} %7 +define external fastcc {i64, i1} @"ctor_visibility.with_fields.foo<1>"(i64 %"#result##0") { + %"tmp#1##0" = and i64 %"#result##0", 1 + %"tmp#0##0" = icmp eq i64 %"tmp#1##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = inttoptr i64 %"#result##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#2##0" + %"tmp#4##0" = insertvalue {i64, i1} undef, i64 %"tmp#3##0", 0 + %"tmp#5##0" = insertvalue {i64, i1} %"tmp#4##0", i1 1, 1 + ret {i64, i1} %"tmp#5##0" +if.else.0: + %"tmp#6##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#7##0" = insertvalue {i64, i1} %"tmp#6##0", i1 0, 1 + ret {i64, i1} %"tmp#7##0" } - -define external fastcc i1 @"ctor_visibility.with_fields.~=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = tail call fastcc i1 @"ctor_visibility.with_fields.=<0>"(i64 %"#left##0", i64 %"#right##0") - %1 = xor i1 %0, 1 - ret i1 %1 +define external fastcc i1 @"ctor_visibility.with_fields.~=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#0##0" = tail call fastcc i1 @"ctor_visibility.with_fields.=<0>"(i64 %"#left##0", i64 %"#right##0") + %"tmp#1##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#1##0" } + -------------------------------------------------- Module ctor_visibility.with_fields2 - representation : address + representation : pointer public submods : public resources: public procs : ctor_visibility.with_fields2.=<0> @@ -1158,212 +1075,183 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'ctor_visibility.with_fields2' - - - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i1 @"ctor_visibility.with_fields2.=<0>"(i64 %"#left##0", i64 %"#right##0") { -entry: - %0 = and i64 %"#left##0", 1 - %1 = icmp eq i64 %0, 0 - br i1 %1, label %if.then, label %if.else -if.then: - %2 = inttoptr i64 %"#left##0" to i64* - %3 = load i64, i64* %2 - %4 = and i64 %"#right##0", 1 - %5 = icmp eq i64 %4, 0 - br i1 %5, label %if.then1, label %if.else1 -if.else: - %9 = icmp eq i64 %0, 1 - br i1 %9, label %if.then2, label %if.else2 -if.then1: - %6 = inttoptr i64 %"#right##0" to i64* - %7 = load i64, i64* %6 - %8 = icmp eq i64 %3, %7 - ret i1 %8 -if.else1: - ret i1 0 -if.then2: - %10 = add i64 %"#left##0", -1 - %11 = inttoptr i64 %10 to i64* - %12 = load i64, i64* %11 - %13 = and i64 %"#right##0", 1 - %14 = icmp eq i64 %13, 1 - br i1 %14, label %if.then3, label %if.else3 -if.else2: - ret i1 0 -if.then3: - %15 = add i64 %"#right##0", -1 - %16 = inttoptr i64 %15 to i64* - %17 = load i64, i64* %16 - %18 = icmp eq i64 %12, %17 - ret i1 %18 -if.else3: - ret i1 0 +source_filename = "!ROOT!/final-dump/ctor_visibility.wybe" +target triple ???? + + +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc i1 @"ctor_visibility.with_fields2.=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#8##0" = and i64 %"#left##0", 1 + %"tmp#9##0" = icmp eq i64 %"tmp#8##0", 0 + br i1 %"tmp#9##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#23##0" = inttoptr i64 %"#left##0" to ptr + %"#left#a##0" = load i64, ptr %"tmp#23##0" + %"tmp#19##0" = and i64 %"#right##0", 1 + %"tmp#20##0" = icmp eq i64 %"tmp#19##0", 0 + br i1 %"tmp#20##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#24##0" = inttoptr i64 %"#right##0" to ptr + %"#right#a##0" = load i64, ptr %"tmp#24##0" + %"tmp#25##0" = icmp eq i64 %"#left#a##0", %"#right#a##0" + ret i1 %"tmp#25##0" +if.else.1: + ret i1 0 +if.else.0: + %"tmp#12##0" = icmp eq i64 %"tmp#8##0", 1 + br i1 %"tmp#12##0", label %if.then.2, label %if.else.2 +if.then.2: + %"tmp#26##0" = add i64 %"#left##0", -1 + %"tmp#27##0" = inttoptr i64 %"tmp#26##0" to ptr + %"#left#b##0" = load i64, ptr %"tmp#27##0" + %"tmp#14##0" = and i64 %"#right##0", 1 + %"tmp#15##0" = icmp eq i64 %"tmp#14##0", 1 + br i1 %"tmp#15##0", label %if.then.3, label %if.else.3 +if.then.3: + %"tmp#28##0" = add i64 %"#right##0", -1 + %"tmp#29##0" = inttoptr i64 %"tmp#28##0" to ptr + %"#right#b##0" = load i64, ptr %"tmp#29##0" + %"tmp#30##0" = icmp eq i64 %"#left#b##0", %"#right#b##0" + ret i1 %"tmp#30##0" +if.else.3: + ret i1 0 +if.else.2: + ret i1 0 } - -define external fastcc {i64, i1} @"ctor_visibility.with_fields2.a<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = and i64 %"#rec##0", 1 - %1 = icmp eq i64 %0, 0 - br i1 %1, label %if.then, label %if.else -if.then: - %2 = inttoptr i64 %"#rec##0" to i64* - %3 = load i64, i64* %2 - %4 = insertvalue {i64, i1} undef, i64 %3, 0 - %5 = insertvalue {i64, i1} %4, i1 1, 1 - ret {i64, i1} %5 -if.else: - %6 = insertvalue {i64, i1} undef, i64 undef, 0 - %7 = insertvalue {i64, i1} %6, i1 0, 1 - ret {i64, i1} %7 +define external fastcc {i64, i1} @"ctor_visibility.with_fields2.a<0>"(i64 %"#rec##0") { + %"tmp#1##0" = and i64 %"#rec##0", 1 + %"tmp#0##0" = icmp eq i64 %"tmp#1##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#2##0" + %"tmp#4##0" = insertvalue {i64, i1} undef, i64 %"tmp#3##0", 0 + %"tmp#5##0" = insertvalue {i64, i1} %"tmp#4##0", i1 1, 1 + ret {i64, i1} %"tmp#5##0" +if.else.0: + %"tmp#6##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#7##0" = insertvalue {i64, i1} %"tmp#6##0", i1 0, 1 + ret {i64, i1} %"tmp#7##0" } - -define external fastcc {i64, i1} @"ctor_visibility.with_fields2.a<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = and i64 %"#rec##0", 1 - %1 = icmp eq i64 %0, 0 - br i1 %1, label %if.then, label %if.else -if.then: - %2 = trunc i64 8 to i32 - %3 = tail call ccc i8* @wybe_malloc(i32 %2) - %4 = ptrtoint i8* %3 to i64 - %5 = inttoptr i64 %4 to i8* - %6 = inttoptr i64 %"#rec##0" to i8* - %7 = trunc i64 8 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %5, i8* %6, i32 %7, i1 0) - %8 = inttoptr i64 %4 to i64* - store i64 %"#field##0", i64* %8 - %9 = insertvalue {i64, i1} undef, i64 %4, 0 - %10 = insertvalue {i64, i1} %9, i1 1, 1 - ret {i64, i1} %10 -if.else: - %11 = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 - %12 = insertvalue {i64, i1} %11, i1 0, 1 - ret {i64, i1} %12 +define external fastcc {i64, i1} @"ctor_visibility.with_fields2.a<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#1##0" = and i64 %"#rec##0", 1 + %"tmp#0##0" = icmp eq i64 %"tmp#1##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#3##0" = call ccc ptr @wybe_malloc(i32 8) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#3##0", ptr %"tmp#2##0", i64 8, i1 0) + %"tmp#4##0" = ptrtoint ptr %"tmp#3##0" to i64 + %"tmp#5##0" = inttoptr i64 %"tmp#4##0" to ptr + store i64 %"#field##0", ptr %"tmp#5##0" + %"tmp#6##0" = insertvalue {i64, i1} undef, i64 %"tmp#4##0", 0 + %"tmp#7##0" = insertvalue {i64, i1} %"tmp#6##0", i1 1, 1 + ret {i64, i1} %"tmp#7##0" +if.else.0: + %"tmp#8##0" = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 + %"tmp#9##0" = insertvalue {i64, i1} %"tmp#8##0", i1 0, 1 + ret {i64, i1} %"tmp#9##0" } - -define external fastcc {i64, i1} @"ctor_visibility.with_fields2.b<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = and i64 %"#rec##0", 1 - %1 = icmp eq i64 %0, 1 - br i1 %1, label %if.then, label %if.else -if.then: - %2 = add i64 %"#rec##0", -1 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = insertvalue {i64, i1} undef, i64 %4, 0 - %6 = insertvalue {i64, i1} %5, i1 1, 1 - ret {i64, i1} %6 -if.else: - %7 = insertvalue {i64, i1} undef, i64 undef, 0 - %8 = insertvalue {i64, i1} %7, i1 0, 1 - ret {i64, i1} %8 +define external fastcc {i64, i1} @"ctor_visibility.with_fields2.b<0>"(i64 %"#rec##0") { + %"tmp#1##0" = and i64 %"#rec##0", 1 + %"tmp#0##0" = icmp eq i64 %"tmp#1##0", 1 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = add i64 %"#rec##0", -1 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#3##0" + %"tmp#5##0" = insertvalue {i64, i1} undef, i64 %"tmp#4##0", 0 + %"tmp#6##0" = insertvalue {i64, i1} %"tmp#5##0", i1 1, 1 + ret {i64, i1} %"tmp#6##0" +if.else.0: + %"tmp#7##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#8##0" = insertvalue {i64, i1} %"tmp#7##0", i1 0, 1 + ret {i64, i1} %"tmp#8##0" } - -define external fastcc {i64, i1} @"ctor_visibility.with_fields2.b<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = and i64 %"#rec##0", 1 - %1 = icmp eq i64 %0, 1 - br i1 %1, label %if.then, label %if.else -if.then: - %2 = trunc i64 8 to i32 - %3 = tail call ccc i8* @wybe_malloc(i32 %2) - %4 = ptrtoint i8* %3 to i64 - %5 = add i64 %4, 1 - %6 = sub i64 %"#rec##0", 1 - %7 = inttoptr i64 %4 to i8* - %8 = inttoptr i64 %6 to i8* - %9 = trunc i64 8 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %7, i8* %8, i32 %9, i1 0) - %10 = add i64 %5, -1 - %11 = inttoptr i64 %10 to i64* - store i64 %"#field##0", i64* %11 - %12 = insertvalue {i64, i1} undef, i64 %5, 0 - %13 = insertvalue {i64, i1} %12, i1 1, 1 - ret {i64, i1} %13 -if.else: - %14 = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 - %15 = insertvalue {i64, i1} %14, i1 0, 1 - ret {i64, i1} %15 +define external fastcc {i64, i1} @"ctor_visibility.with_fields2.b<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#1##0" = and i64 %"#rec##0", 1 + %"tmp#0##0" = icmp eq i64 %"tmp#1##0", 1 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = sub i64 %"#rec##0", 1 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = call ccc ptr @wybe_malloc(i32 8) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#4##0", ptr %"tmp#3##0", i64 8, i1 0) + %"tmp#5##0" = ptrtoint ptr %"tmp#4##0" to i64 + %"tmp#6##0" = add i64 %"tmp#5##0", 1 + %"tmp#7##0" = add i64 %"tmp#6##0", -1 + %"tmp#8##0" = inttoptr i64 %"tmp#7##0" to ptr + store i64 %"#field##0", ptr %"tmp#8##0" + %"tmp#9##0" = insertvalue {i64, i1} undef, i64 %"tmp#6##0", 0 + %"tmp#10##0" = insertvalue {i64, i1} %"tmp#9##0", i1 1, 1 + ret {i64, i1} %"tmp#10##0" +if.else.0: + %"tmp#11##0" = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 + %"tmp#12##0" = insertvalue {i64, i1} %"tmp#11##0", i1 0, 1 + ret {i64, i1} %"tmp#12##0" } - -define external fastcc i64 @"ctor_visibility.with_fields2.bar<0>"(i64 %"b##0") alwaysinline { -entry: - %0 = trunc i64 8 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"b##0", i64* %3 - %4 = or i64 %2, 1 - ret i64 %4 +define external fastcc i64 @"ctor_visibility.with_fields2.bar<0>"(i64 %"b##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 8) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"b##0", ptr %"tmp#1##0" + %"tmp#2##0" = or i64 %"#rec##0", 1 + ret i64 %"tmp#2##0" } - -define external fastcc {i64, i1} @"ctor_visibility.with_fields2.bar<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = and i64 %"#result##0", 1 - %1 = icmp eq i64 %0, 1 - br i1 %1, label %if.then, label %if.else -if.then: - %2 = add i64 %"#result##0", -1 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = insertvalue {i64, i1} undef, i64 %4, 0 - %6 = insertvalue {i64, i1} %5, i1 1, 1 - ret {i64, i1} %6 -if.else: - %7 = insertvalue {i64, i1} undef, i64 undef, 0 - %8 = insertvalue {i64, i1} %7, i1 0, 1 - ret {i64, i1} %8 +define external fastcc {i64, i1} @"ctor_visibility.with_fields2.bar<1>"(i64 %"#result##0") { + %"tmp#1##0" = and i64 %"#result##0", 1 + %"tmp#0##0" = icmp eq i64 %"tmp#1##0", 1 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = add i64 %"#result##0", -1 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#3##0" + %"tmp#5##0" = insertvalue {i64, i1} undef, i64 %"tmp#4##0", 0 + %"tmp#6##0" = insertvalue {i64, i1} %"tmp#5##0", i1 1, 1 + ret {i64, i1} %"tmp#6##0" +if.else.0: + %"tmp#7##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#8##0" = insertvalue {i64, i1} %"tmp#7##0", i1 0, 1 + ret {i64, i1} %"tmp#8##0" } - -define external fastcc i64 @"ctor_visibility.with_fields2.foo<0>"(i64 %"a##0") alwaysinline { -entry: - %0 = trunc i64 8 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"a##0", i64* %3 - ret i64 %2 +define external fastcc i64 @"ctor_visibility.with_fields2.foo<0>"(i64 %"a##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 8) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"a##0", ptr %"tmp#1##0" + ret i64 %"#rec##0" } - -define external fastcc {i64, i1} @"ctor_visibility.with_fields2.foo<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = and i64 %"#result##0", 1 - %1 = icmp eq i64 %0, 0 - br i1 %1, label %if.then, label %if.else -if.then: - %2 = inttoptr i64 %"#result##0" to i64* - %3 = load i64, i64* %2 - %4 = insertvalue {i64, i1} undef, i64 %3, 0 - %5 = insertvalue {i64, i1} %4, i1 1, 1 - ret {i64, i1} %5 -if.else: - %6 = insertvalue {i64, i1} undef, i64 undef, 0 - %7 = insertvalue {i64, i1} %6, i1 0, 1 - ret {i64, i1} %7 +define external fastcc {i64, i1} @"ctor_visibility.with_fields2.foo<1>"(i64 %"#result##0") { + %"tmp#1##0" = and i64 %"#result##0", 1 + %"tmp#0##0" = icmp eq i64 %"tmp#1##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = inttoptr i64 %"#result##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#2##0" + %"tmp#4##0" = insertvalue {i64, i1} undef, i64 %"tmp#3##0", 0 + %"tmp#5##0" = insertvalue {i64, i1} %"tmp#4##0", i1 1, 1 + ret {i64, i1} %"tmp#5##0" +if.else.0: + %"tmp#6##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#7##0" = insertvalue {i64, i1} %"tmp#6##0", i1 0, 1 + ret {i64, i1} %"tmp#7##0" } - -define external fastcc i1 @"ctor_visibility.with_fields2.~=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = tail call fastcc i1 @"ctor_visibility.with_fields2.=<0>"(i64 %"#left##0", i64 %"#right##0") - %1 = xor i1 %0, 1 - ret i1 %1 +define external fastcc i1 @"ctor_visibility.with_fields2.~=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#0##0" = tail call fastcc i1 @"ctor_visibility.with_fields2.=<0>"(i64 %"#left##0", i64 %"#right##0") + %"tmp#1##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#1##0" } diff --git a/test-cases/final-dump/current_module_alias.exp b/test-cases/final-dump/current_module_alias.exp index ab0f4d75b..fe535f9df 100644 --- a/test-cases/final-dump/current_module_alias.exp +++ b/test-cases/final-dump/current_module_alias.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module current_module_alias representation : (not a type) public submods : @@ -33,39 +36,30 @@ toCelsius(f##0:wybe.float, ?#result##0:wybe.float)<{}; {}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'current_module_alias' +source_filename = "!ROOT!/final-dump/current_module_alias.wybe" +target triple ???? - - - -declare external ccc void @putchar(i8) - - -declare external ccc void @print_float(double) - - -declare external ccc i8* @wybe_malloc(i32) +declare external ccc void @print_float(double) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"current_module_alias.<0>"() { -entry: - %0 = tail call fastcc double @"current_module_alias.toCelsius<0>"(double 1.000000e0) - tail call ccc void @print_float(double %0) - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"current_module_alias.<0>"() { + %"tmp#0##0" = tail call fastcc double @"current_module_alias.toCelsius<0>"(double 1.0) + call ccc void @print_float(double %"tmp#0##0") + call ccc void @putchar(i8 10) + ret void } - -define external fastcc double @"current_module_alias.toCelsius<0>"(double %"f##0") noinline { -entry: - %0 = fsub double %"f##0", 3.200000e1 - %1 = fdiv double %0, 1.800000e0 - ret double %1 +define external fastcc double @"current_module_alias.toCelsius<0>"(double %"f##0") { + %"tmp#1##0" = fsub double %"f##0", 32.0 + %"tmp#6##0" = fdiv double %"tmp#1##0", 1.8 + ret double %"tmp#6##0" } + -------------------------------------------------- Module math.temperature representation : (not a type) @@ -86,21 +80,17 @@ toCelsius(f##0:wybe.float, ?#result##0:wybe.float)<{}; {}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'math.temperature' +source_filename = "!ROOT!/final-dump/math/temperature.wybe" +target triple ???? - - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -define external fastcc double @"math.temperature.toCelsius<0>"(double %"f##0") alwaysinline { -entry: - %0 = fsub double %"f##0", 3.200000e1 - %1 = fdiv double %0, 1.800000e0 - ret double %1 +define external fastcc double @"math.temperature.toCelsius<0>"(double %"f##0") { + %"tmp#1##0" = fsub double %"f##0", 32.0 + %"tmp#6##0" = fdiv double %"tmp#1##0", 1.8 + ret double %"tmp#6##0" } diff --git a/test-cases/final-dump/current_module_alias_fail.exp b/test-cases/final-dump/current_module_alias_fail.exp index 3e3f88f13..84ef7bb45 100644 --- a/test-cases/final-dump/current_module_alias_fail.exp +++ b/test-cases/final-dump/current_module_alias_fail.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module current_module_alias_fail representation : (not a type) public submods : @@ -33,39 +36,30 @@ toCelsius(f##0:wybe.float, ?#result##0:wybe.float)<{}; {}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'current_module_alias_fail' +source_filename = "!ROOT!/final-dump/current_module_alias_fail.wybe" +target triple ???? - - - -declare external ccc void @putchar(i8) - - -declare external ccc void @print_float(double) - - -declare external ccc i8* @wybe_malloc(i32) +declare external ccc void @print_float(double) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"current_module_alias_fail.<0>"() { -entry: - %0 = tail call fastcc double @"current_module_alias_fail.toCelsius<0>"(double 1.000000e0) - tail call ccc void @print_float(double %0) - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"current_module_alias_fail.<0>"() { + %"tmp#0##0" = tail call fastcc double @"current_module_alias_fail.toCelsius<0>"(double 1.0) + call ccc void @print_float(double %"tmp#0##0") + call ccc void @putchar(i8 10) + ret void } - -define external fastcc double @"current_module_alias_fail.toCelsius<0>"(double %"f##0") noinline { -entry: - %0 = fsub double %"f##0", 3.200000e1 - %1 = fdiv double %0, 1.800000e0 - ret double %1 +define external fastcc double @"current_module_alias_fail.toCelsius<0>"(double %"f##0") { + %"tmp#1##0" = fsub double %"f##0", 32.0 + %"tmp#6##0" = fdiv double %"tmp#1##0", 1.8 + ret double %"tmp#6##0" } + -------------------------------------------------- Module math.temperature representation : (not a type) @@ -86,23 +80,19 @@ toCelsius(f##0:wybe.float, ?#result##0:wybe.float)<{}; {}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'math.temperature' +source_filename = "!ROOT!/final-dump/math/temperature.wybe" +target triple ???? - - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -define external fastcc double @"math.temperature.toCelsius<0>"(double %"f##0") alwaysinline { -entry: - %0 = fsub double %"f##0", 3.200000e1 - %1 = fdiv double %0, 1.800000e0 - ret double %1 +define external fastcc double @"math.temperature.toCelsius<0>"(double %"f##0") { + %"tmp#1##0" = fsub double %"f##0", 32.0 + %"tmp#6##0" = fdiv double %"tmp#1##0", 1.8 + ret double %"tmp#6##0" } final-dump/current_module_alias_fail.wybe:5:10: Multiple procedures match this call's types and flows: current_module_alias_fail.toCelsius<0> diff --git a/test-cases/final-dump/current_module_alias_type_args.exp b/test-cases/final-dump/current_module_alias_type_args.exp index b5af444a1..bfe461c11 100644 --- a/test-cases/final-dump/current_module_alias_type_args.exp +++ b/test-cases/final-dump/current_module_alias_type_args.exp @@ -1,7 +1,10 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module current_module_alias_type_args(T) - representation : address + representation : pointer public submods : public resources: public procs : current_module_alias_type_args.<0> @@ -130,168 +133,139 @@ tail(#rec##0:current_module_alias_type_args(T) <{}; {}; {0}>, ?#rec##1:current_m LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'current_module_alias_type_args' - - - - -declare external ccc void @putchar(i8) - - -declare external ccc void @print_int(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"current_module_alias_type_args.<0>"() { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 42, i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 0, i64* %5 - %6 = icmp ne i64 %2, 0 - br i1 %6, label %if.then, label %if.else -if.then: - %7 = inttoptr i64 %2 to i64* - %8 = load i64, i64* %7 - tail call ccc void @print_int(i64 %8) - tail call ccc void @putchar(i8 10) - ret void -if.else: - ret void +source_filename = "!ROOT!/final-dump/current_module_alias_type_args.wybe" +target triple ???? + + +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"current_module_alias_type_args.<0>"() { + %"tmp#14##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#6##0" = ptrtoint ptr %"tmp#14##0" to i64 + %"tmp#15##0" = inttoptr i64 %"tmp#6##0" to ptr + store i64 42, ptr %"tmp#15##0" + %"tmp#16##0" = add i64 %"tmp#6##0", 8 + %"tmp#17##0" = inttoptr i64 %"tmp#16##0" to ptr + store i64 0, ptr %"tmp#17##0" + %"tmp#9##0" = icmp ne i64 %"tmp#6##0", 0 + br i1 %"tmp#9##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#18##0" = inttoptr i64 %"tmp#6##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#18##0" + call ccc void @print_int(i64 %"tmp#2##0") + call ccc void @putchar(i8 10) + ret void +if.else.0: + ret void } - -define external fastcc i64 @"current_module_alias_type_args.cons<0>"(i64 %"head##0", i64 %"tail##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"head##0", i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"tail##0", i64* %5 - ret i64 %2 +define external fastcc i64 @"current_module_alias_type_args.cons<0>"(i64 %"head##0", i64 %"tail##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 16) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"head##0", ptr %"tmp#1##0" + %"tmp#2##0" = add i64 %"#rec##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"tail##0", ptr %"tmp#3##0" + ret i64 %"#rec##0" } - -define external fastcc {i64, i64, i1} @"current_module_alias_type_args.cons<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#result##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"#result##0" to i64* - %2 = load i64, i64* %1 - %3 = add i64 %"#result##0", 8 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = insertvalue {i64, i64, i1} undef, i64 %2, 0 - %7 = insertvalue {i64, i64, i1} %6, i64 %5, 1 - %8 = insertvalue {i64, i64, i1} %7, i1 1, 2 - ret {i64, i64, i1} %8 -if.else: - %9 = insertvalue {i64, i64, i1} undef, i64 undef, 0 - %10 = insertvalue {i64, i64, i1} %9, i64 undef, 1 - %11 = insertvalue {i64, i64, i1} %10, i1 0, 2 - ret {i64, i64, i1} %11 +define external fastcc {i64, i64, i1} @"current_module_alias_type_args.cons<1>"(i64 %"#result##0") { + %"tmp#0##0" = icmp ne i64 %"#result##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = inttoptr i64 %"#result##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + %"tmp#3##0" = add i64 %"#result##0", 8 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#4##0" + %"tmp#6##0" = insertvalue {i64, i64, i1} undef, i64 %"tmp#2##0", 0 + %"tmp#7##0" = insertvalue {i64, i64, i1} %"tmp#6##0", i64 %"tmp#5##0", 1 + %"tmp#8##0" = insertvalue {i64, i64, i1} %"tmp#7##0", i1 1, 2 + ret {i64, i64, i1} %"tmp#8##0" +if.else.0: + %"tmp#9##0" = insertvalue {i64, i64, i1} undef, i64 undef, 0 + %"tmp#10##0" = insertvalue {i64, i64, i1} %"tmp#9##0", i64 undef, 1 + %"tmp#11##0" = insertvalue {i64, i64, i1} %"tmp#10##0", i1 0, 2 + ret {i64, i64, i1} %"tmp#11##0" } - -define external fastcc i64 @"current_module_alias_type_args.empty<0>"() alwaysinline { -entry: - ret i64 0 +define external fastcc i64 @"current_module_alias_type_args.empty<0>"() { + ret i64 0 } - -define external fastcc {i64, i1} @"current_module_alias_type_args.head<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"#rec##0" to i64* - %2 = load i64, i64* %1 - %3 = insertvalue {i64, i1} undef, i64 %2, 0 - %4 = insertvalue {i64, i1} %3, i1 1, 1 - ret {i64, i1} %4 -if.else: - %5 = insertvalue {i64, i1} undef, i64 undef, 0 - %6 = insertvalue {i64, i1} %5, i1 0, 1 - ret {i64, i1} %6 +define external fastcc {i64, i1} @"current_module_alias_type_args.head<0>"(i64 %"#rec##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + %"tmp#3##0" = insertvalue {i64, i1} undef, i64 %"tmp#2##0", 0 + %"tmp#4##0" = insertvalue {i64, i1} %"tmp#3##0", i1 1, 1 + ret {i64, i1} %"tmp#4##0" +if.else.0: + %"tmp#5##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#6##0" = insertvalue {i64, i1} %"tmp#5##0", i1 0, 1 + ret {i64, i1} %"tmp#6##0" } - -define external fastcc {i64, i1} @"current_module_alias_type_args.head<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = trunc i64 16 to i32 - %2 = tail call ccc i8* @wybe_malloc(i32 %1) - %3 = ptrtoint i8* %2 to i64 - %4 = inttoptr i64 %3 to i8* - %5 = inttoptr i64 %"#rec##0" to i8* - %6 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %4, i8* %5, i32 %6, i1 0) - %7 = inttoptr i64 %3 to i64* - store i64 %"#field##0", i64* %7 - %8 = insertvalue {i64, i1} undef, i64 %3, 0 - %9 = insertvalue {i64, i1} %8, i1 1, 1 - ret {i64, i1} %9 -if.else: - %10 = insertvalue {i64, i1} undef, i64 0, 0 - %11 = insertvalue {i64, i1} %10, i1 0, 1 - ret {i64, i1} %11 +define external fastcc {i64, i1} @"current_module_alias_type_args.head<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#2##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#2##0", ptr %"tmp#1##0", i64 16, i1 0) + %"tmp#3##0" = ptrtoint ptr %"tmp#2##0" to i64 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 %"#field##0", ptr %"tmp#4##0" + %"tmp#5##0" = insertvalue {i64, i1} undef, i64 %"tmp#3##0", 0 + %"tmp#6##0" = insertvalue {i64, i1} %"tmp#5##0", i1 1, 1 + ret {i64, i1} %"tmp#6##0" +if.else.0: + %"tmp#7##0" = insertvalue {i64, i1} undef, i64 0, 0 + %"tmp#8##0" = insertvalue {i64, i1} %"tmp#7##0", i1 0, 1 + ret {i64, i1} %"tmp#8##0" } - -define external fastcc {i64, i1} @"current_module_alias_type_args.tail<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = add i64 %"#rec##0", 8 - %2 = inttoptr i64 %1 to i64* - %3 = load i64, i64* %2 - %4 = insertvalue {i64, i1} undef, i64 %3, 0 - %5 = insertvalue {i64, i1} %4, i1 1, 1 - ret {i64, i1} %5 -if.else: - %6 = insertvalue {i64, i1} undef, i64 undef, 0 - %7 = insertvalue {i64, i1} %6, i1 0, 1 - ret {i64, i1} %7 +define external fastcc {i64, i1} @"current_module_alias_type_args.tail<0>"(i64 %"#rec##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = add i64 %"#rec##0", 8 + %"tmp#2##0" = inttoptr i64 %"tmp#1##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#2##0" + %"tmp#4##0" = insertvalue {i64, i1} undef, i64 %"tmp#3##0", 0 + %"tmp#5##0" = insertvalue {i64, i1} %"tmp#4##0", i1 1, 1 + ret {i64, i1} %"tmp#5##0" +if.else.0: + %"tmp#6##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#7##0" = insertvalue {i64, i1} %"tmp#6##0", i1 0, 1 + ret {i64, i1} %"tmp#7##0" } - -define external fastcc {i64, i1} @"current_module_alias_type_args.tail<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = trunc i64 16 to i32 - %2 = tail call ccc i8* @wybe_malloc(i32 %1) - %3 = ptrtoint i8* %2 to i64 - %4 = inttoptr i64 %3 to i8* - %5 = inttoptr i64 %"#rec##0" to i8* - %6 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %4, i8* %5, i32 %6, i1 0) - %7 = add i64 %3, 8 - %8 = inttoptr i64 %7 to i64* - store i64 %"#field##0", i64* %8 - %9 = insertvalue {i64, i1} undef, i64 %3, 0 - %10 = insertvalue {i64, i1} %9, i1 1, 1 - ret {i64, i1} %10 -if.else: - %11 = insertvalue {i64, i1} undef, i64 0, 0 - %12 = insertvalue {i64, i1} %11, i1 0, 1 - ret {i64, i1} %12 +define external fastcc {i64, i1} @"current_module_alias_type_args.tail<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#2##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#2##0", ptr %"tmp#1##0", i64 16, i1 0) + %"tmp#3##0" = ptrtoint ptr %"tmp#2##0" to i64 + %"tmp#4##0" = add i64 %"tmp#3##0", 8 + %"tmp#5##0" = inttoptr i64 %"tmp#4##0" to ptr + store i64 %"#field##0", ptr %"tmp#5##0" + %"tmp#6##0" = insertvalue {i64, i1} undef, i64 %"tmp#3##0", 0 + %"tmp#7##0" = insertvalue {i64, i1} %"tmp#6##0", i1 1, 1 + ret {i64, i1} %"tmp#7##0" +if.else.0: + %"tmp#8##0" = insertvalue {i64, i1} undef, i64 0, 0 + %"tmp#9##0" = insertvalue {i64, i1} %"tmp#8##0", i1 0, 1 + ret {i64, i1} %"tmp#9##0" } diff --git a/test-cases/final-dump/current_module_alias_warning.exp b/test-cases/final-dump/current_module_alias_warning.exp index 6363e0032..09115a1a5 100644 --- a/test-cases/final-dump/current_module_alias_warning.exp +++ b/test-cases/final-dump/current_module_alias_warning.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module current_module_alias_warning representation : (not a type) public submods : @@ -41,47 +44,36 @@ toCelsius(f##0:wybe.float, ?#result##0:wybe.float)<{}; {}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'current_module_alias_warning' +source_filename = "!ROOT!/final-dump/current_module_alias_warning.wybe" +target triple ???? - - - -declare external ccc void @putchar(i8) - - -declare external ccc void @print_float(double) - - -declare external ccc i8* @wybe_malloc(i32) +declare external ccc void @print_float(double) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"current_module_alias_warning.<0>"() { -entry: - %0 = tail call fastcc double @"current_module_alias_warning.toCelsius<0>"(double 1.000000e0) - tail call ccc void @print_float(double %0) - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"current_module_alias_warning.<0>"() { + %"tmp#0##0" = tail call fastcc double @"current_module_alias_warning.toCelsius<0>"(double 1.0) + call ccc void @print_float(double %"tmp#0##0") + call ccc void @putchar(i8 10) + ret void } - -define external fastcc double @"current_module_alias_warning.toCelsius<0>"(double %"f##0") noinline { -entry: - %0 = fsub double %"f##0", 3.200000e1 - %1 = fdiv double %0, 1.800000e0 - ret double %1 +define external fastcc double @"current_module_alias_warning.toCelsius<0>"(double %"f##0") { + %"tmp#1##0" = fsub double %"f##0", 32.0 + %"tmp#6##0" = fdiv double %"tmp#1##0", 1.8 + ret double %"tmp#6##0" } - -define external fastcc double @"current_module_alias_warning.toCelsius<1>"(double %"f##0") noinline { -entry: - %0 = fsub double %"f##0", 3.200000e1 - %1 = fdiv double %0, 1.800000e0 - ret double %1 +define external fastcc double @"current_module_alias_warning.toCelsius<1>"(double %"f##0") { + %"tmp#1##0" = fsub double %"f##0", 32.0 + %"tmp#6##0" = fdiv double %"tmp#1##0", 1.8 + ret double %"tmp#6##0" } + -------------------------------------------------- Module math.temperature representation : (not a type) @@ -102,23 +94,19 @@ toCelsius(f##0:wybe.float, ?#result##0:wybe.float)<{}; {}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'math.temperature' +source_filename = "!ROOT!/final-dump/math/temperature.wybe" +target triple ???? - - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -define external fastcc double @"math.temperature.toCelsius<0>"(double %"f##0") alwaysinline { -entry: - %0 = fsub double %"f##0", 3.200000e1 - %1 = fdiv double %0, 1.800000e0 - ret double %1 +define external fastcc double @"math.temperature.toCelsius<0>"(double %"f##0") { + %"tmp#1##0" = fsub double %"f##0", 32.0 + %"tmp#6##0" = fdiv double %"tmp#1##0", 1.8 + ret double %"tmp#6##0" } final-dump/current_module_alias_warning.wybe:6:10: Multiple procedures match this call's types and flows: current_module_alias_warning.toCelsius<0> diff --git a/test-cases/final-dump/ddd.exp b/test-cases/final-dump/ddd.exp index e5350f1a5..005b6f87b 100644 --- a/test-cases/final-dump/ddd.exp +++ b/test-cases/final-dump/ddd.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module ddd representation : (not a type) public submods : @@ -21,33 +24,21 @@ module top-level code > public {inline,semipure} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'ddd' +source_filename = "!ROOT!/final-dump/ddd.wybe" +target triple ???? - - - -@ddd.1 = constant {i64, i64} { i64 9, i64 ptrtoint ([?? x i8]* @ddd.0 to i64) } - - -@ddd.0 = constant [?? x i8] c"DDD: Init\00" - - -declare external ccc void @putchar(i8) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c"DDD: Init\00", align 8 +@"string#1" = private unnamed_addr constant {i64, i64} { i64 9, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -define external fastcc void @"ddd.<0>"() alwaysinline { -entry: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @ddd.1, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"ddd.<0>"() { + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#1" to i64 )) + call ccc void @putchar(i8 10) + ret void } diff --git a/test-cases/final-dump/dead_cell_size.exp b/test-cases/final-dump/dead_cell_size.exp index 33b49c264..030fc2dac 100644 --- a/test-cases/final-dump/dead_cell_size.exp +++ b/test-cases/final-dump/dead_cell_size.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module dead_cell_size representation : (not a type) public submods : t -> dead_cell_size.t @@ -65,7 +68,7 @@ module top-level code > public {semipure} (0 calls) proc bar > public (1 calls) -0: dead_cell_size.bar<0>[410bae77d3] +0: dead_cell_size.bar<0> bar(x##0:dead_cell_size.t, ?x##1:dead_cell_size.t)<{}; {}; {}>: AliasPairs: [(x##0,x##1)] InterestingCallProperties: [InterestingUnaliased 0] @@ -108,7 +111,7 @@ bar(x##0:dead_cell_size.t, ?x##1:dead_cell_size.t)<{}; {}; {}>: proc diff_type > public (1 calls) -0: dead_cell_size.diff_type<0>[410bae77d3] +0: dead_cell_size.diff_type<0> diff_type(x##0:dead_cell_size.t, ?y##0:dead_cell_size.t2)<{}; {}; {}>: AliasPairs: [] InterestingCallProperties: [InterestingUnaliased 0] @@ -288,319 +291,258 @@ print_t2(x##0:dead_cell_size.t2)<{<>}; {<>}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'dead_cell_size' - - - - -@dead_cell_size.5 = constant {i64, i64} { i64 1, i64 ptrtoint ([?? x i8]* @dead_cell_size.4 to i64) } - - -@dead_cell_size.9 = constant {i64, i64} { i64 1, i64 ptrtoint ([?? x i8]* @dead_cell_size.8 to i64) } - - -@dead_cell_size.1 = constant {i64, i64} { i64 2, i64 ptrtoint ([?? x i8]* @dead_cell_size.0 to i64) } - - -@dead_cell_size.11 = constant {i64, i64} { i64 3, i64 ptrtoint ([?? x i8]* @dead_cell_size.10 to i64) } - - -@dead_cell_size.13 = constant {i64, i64} { i64 3, i64 ptrtoint ([?? x i8]* @dead_cell_size.12 to i64) } - - -@dead_cell_size.3 = constant {i64, i64} { i64 3, i64 ptrtoint ([?? x i8]* @dead_cell_size.2 to i64) } - - -@dead_cell_size.7 = constant {i64, i64} { i64 3, i64 ptrtoint ([?? x i8]* @dead_cell_size.6 to i64) } - - -@dead_cell_size.15 = constant {i64, i64} { i64 4, i64 ptrtoint ([?? x i8]* @dead_cell_size.14 to i64) } - - -@dead_cell_size.4 = constant [?? x i8] c")\00" - - -@dead_cell_size.8 = constant [?? x i8] c",\00" - - -@dead_cell_size.12 = constant [?? x i8] c"t2a\00" - - -@dead_cell_size.14 = constant [?? x i8] c"t2b(\00" - - -@dead_cell_size.0 = constant [?? x i8] c"ta\00" - - -@dead_cell_size.2 = constant [?? x i8] c"tb(\00" - - -@dead_cell_size.6 = constant [?? x i8] c"tc(\00" - - -@dead_cell_size.10 = constant [?? x i8] c"td(\00" - - -declare external ccc void @putchar(i8) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc void @print_int(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"dead_cell_size.<0>"() { -entry: - %0 = trunc i64 8 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 9, i64* %3 - %4 = tail call fastcc i64 @"dead_cell_size.foo<0>"(i64 %2) - tail call fastcc void @"dead_cell_size.print_t<0>"(i64 %4) - %5 = trunc i64 8 to i32 - %6 = tail call ccc i8* @wybe_malloc(i32 %5) - %7 = ptrtoint i8* %6 to i64 - %8 = inttoptr i64 %7 to i64* - store i64 9, i64* %8 - %9 = tail call fastcc i64 @"dead_cell_size.bar<0>[410bae77d3]"(i64 %7) - tail call fastcc void @"dead_cell_size.print_t<0>"(i64 %9) - %10 = trunc i64 8 to i32 - %11 = tail call ccc i8* @wybe_malloc(i32 %10) - %12 = ptrtoint i8* %11 to i64 - %13 = inttoptr i64 %12 to i64* - store i64 9, i64* %13 - %14 = tail call fastcc i64 @"dead_cell_size.diff_type<0>[410bae77d3]"(i64 %12) - tail call fastcc void @"dead_cell_size.print_t2<0>"(i64 %14) - ret void +source_filename = "!ROOT!/final-dump/dead_cell_size.wybe" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c")\00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c",\00", align 8 +@"cstring#2" = private unnamed_addr constant [ ?? x i8 ] c"t2a\00", align 8 +@"cstring#3" = private unnamed_addr constant [ ?? x i8 ] c"t2b(\00", align 8 +@"cstring#4" = private unnamed_addr constant [ ?? x i8 ] c"ta\00", align 8 +@"cstring#5" = private unnamed_addr constant [ ?? x i8 ] c"tb(\00", align 8 +@"cstring#6" = private unnamed_addr constant [ ?? x i8 ] c"tc(\00", align 8 +@"cstring#7" = private unnamed_addr constant [ ?? x i8 ] c"td(\00", align 8 +@"string#8" = private unnamed_addr constant {i64, i64} { i64 1, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +@"string#9" = private unnamed_addr constant {i64, i64} { i64 1, i64 ptrtoint( ptr @"cstring#1" to i64 ) }, align 8 +@"string#10" = private unnamed_addr constant {i64, i64} { i64 3, i64 ptrtoint( ptr @"cstring#2" to i64 ) }, align 8 +@"string#11" = private unnamed_addr constant {i64, i64} { i64 4, i64 ptrtoint( ptr @"cstring#3" to i64 ) }, align 8 +@"string#12" = private unnamed_addr constant {i64, i64} { i64 2, i64 ptrtoint( ptr @"cstring#4" to i64 ) }, align 8 +@"string#13" = private unnamed_addr constant {i64, i64} { i64 3, i64 ptrtoint( ptr @"cstring#5" to i64 ) }, align 8 +@"string#14" = private unnamed_addr constant {i64, i64} { i64 3, i64 ptrtoint( ptr @"cstring#6" to i64 ) }, align 8 +@"string#15" = private unnamed_addr constant {i64, i64} { i64 3, i64 ptrtoint( ptr @"cstring#7" to i64 ) }, align 8 + +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"dead_cell_size.<0>"() { + %"tmp#15##0" = call ccc ptr @wybe_malloc(i32 8) + %"tmp#7##0" = ptrtoint ptr %"tmp#15##0" to i64 + %"tmp#16##0" = inttoptr i64 %"tmp#7##0" to ptr + store i64 9, ptr %"tmp#16##0" + %"tmp#0##0" = tail call fastcc i64 @"dead_cell_size.foo<0>"(i64 %"tmp#7##0") + tail call fastcc void @"dead_cell_size.print_t<0>"(i64 %"tmp#0##0") + %"tmp#17##0" = call ccc ptr @wybe_malloc(i32 8) + %"tmp#10##0" = ptrtoint ptr %"tmp#17##0" to i64 + %"tmp#18##0" = inttoptr i64 %"tmp#10##0" to ptr + store i64 9, ptr %"tmp#18##0" + %"tmp#2##0" = tail call fastcc i64 @"dead_cell_size.bar<0>[410bae77d3]"(i64 %"tmp#10##0") + tail call fastcc void @"dead_cell_size.print_t<0>"(i64 %"tmp#2##0") + %"tmp#19##0" = call ccc ptr @wybe_malloc(i32 8) + %"tmp#13##0" = ptrtoint ptr %"tmp#19##0" to i64 + %"tmp#20##0" = inttoptr i64 %"tmp#13##0" to ptr + store i64 9, ptr %"tmp#20##0" + %"tmp#4##0" = tail call fastcc i64 @"dead_cell_size.diff_type<0>[410bae77d3]"(i64 %"tmp#13##0") + tail call fastcc void @"dead_cell_size.print_t2<0>"(i64 %"tmp#4##0") + ret void } - -define external fastcc i64 @"dead_cell_size.bar<0>"(i64 %"x##0") { -entry: - %0 = icmp ne i64 %"x##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = and i64 %"x##0", 3 - %2 = icmp eq i64 %1, 0 - br i1 %2, label %if.then1, label %if.else1 -if.else: - ret i64 0 -if.then1: - %3 = inttoptr i64 %"x##0" to i64* - %4 = load i64, i64* %3 - %5 = trunc i64 8 to i32 - %6 = tail call ccc i8* @wybe_malloc(i32 %5) - %7 = ptrtoint i8* %6 to i64 - %8 = inttoptr i64 %7 to i64* - store i64 %4, i64* %8 - %9 = or i64 %7, 2 - ret i64 %9 -if.else1: - ret i64 %"x##0" +define external fastcc i64 @"dead_cell_size.bar<0>"(i64 %"x##0") { + %"tmp#3##0" = icmp ne i64 %"x##0", 0 + br i1 %"tmp#3##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#4##0" = and i64 %"x##0", 3 + %"tmp#5##0" = icmp eq i64 %"tmp#4##0", 0 + br i1 %"tmp#5##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#9##0" = inttoptr i64 %"x##0" to ptr + %"a##0" = load i64, ptr %"tmp#9##0" + %"tmp#10##0" = call ccc ptr @wybe_malloc(i32 8) + %"tmp#7##0" = ptrtoint ptr %"tmp#10##0" to i64 + %"tmp#11##0" = inttoptr i64 %"tmp#7##0" to ptr + store i64 %"a##0", ptr %"tmp#11##0" + %"tmp#12##0" = or i64 %"tmp#7##0", 2 + ret i64 %"tmp#12##0" +if.else.1: + ret i64 %"x##0" +if.else.0: + ret i64 0 } - -define external fastcc i64 @"dead_cell_size.bar<0>[410bae77d3]"(i64 %"x##0") { -entry: - %0 = icmp ne i64 %"x##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = and i64 %"x##0", 3 - %2 = icmp eq i64 %1, 0 - br i1 %2, label %if.then1, label %if.else1 -if.else: - ret i64 0 -if.then1: - %3 = or i64 %"x##0", 2 - ret i64 %3 -if.else1: - ret i64 %"x##0" +define external fastcc i64 @"dead_cell_size.bar<0>[410bae77d3]"(i64 %"x##0") { + %"tmp#3##0" = icmp ne i64 %"x##0", 0 + br i1 %"tmp#3##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#4##0" = and i64 %"x##0", 3 + %"tmp#5##0" = icmp eq i64 %"tmp#4##0", 0 + br i1 %"tmp#5##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#9##0" = or i64 %"x##0", 2 + ret i64 %"tmp#9##0" +if.else.1: + ret i64 %"x##0" +if.else.0: + ret i64 0 } - -define external fastcc i64 @"dead_cell_size.diff_type<0>"(i64 %"x##0") { -entry: - %0 = icmp ne i64 %"x##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = and i64 %"x##0", 3 - %2 = icmp eq i64 %1, 0 - br i1 %2, label %if.then1, label %if.else1 -if.else: - %13 = trunc i64 8 to i32 - %14 = tail call ccc i8* @wybe_malloc(i32 %13) - %15 = ptrtoint i8* %14 to i64 - %16 = inttoptr i64 %15 to i64* - store i64 -1, i64* %16 - ret i64 %15 -if.then1: - %3 = inttoptr i64 %"x##0" to i64* - %4 = load i64, i64* %3 - %5 = trunc i64 8 to i32 - %6 = tail call ccc i8* @wybe_malloc(i32 %5) - %7 = ptrtoint i8* %6 to i64 - %8 = inttoptr i64 %7 to i64* - store i64 %4, i64* %8 - ret i64 %7 -if.else1: - %9 = trunc i64 8 to i32 - %10 = tail call ccc i8* @wybe_malloc(i32 %9) - %11 = ptrtoint i8* %10 to i64 - %12 = inttoptr i64 %11 to i64* - store i64 -1, i64* %12 - ret i64 %11 +define external fastcc i64 @"dead_cell_size.diff_type<0>"(i64 %"x##0") { + %"tmp#4##0" = icmp ne i64 %"x##0", 0 + br i1 %"tmp#4##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#5##0" = and i64 %"x##0", 3 + %"tmp#6##0" = icmp eq i64 %"tmp#5##0", 0 + br i1 %"tmp#6##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#13##0" = inttoptr i64 %"x##0" to ptr + %"a##0" = load i64, ptr %"tmp#13##0" + %"tmp#14##0" = call ccc ptr @wybe_malloc(i32 8) + %"tmp#11##0" = ptrtoint ptr %"tmp#14##0" to i64 + %"tmp#15##0" = inttoptr i64 %"tmp#11##0" to ptr + store i64 %"a##0", ptr %"tmp#15##0" + ret i64 %"tmp#11##0" +if.else.1: + %"tmp#16##0" = call ccc ptr @wybe_malloc(i32 8) + %"tmp#8##0" = ptrtoint ptr %"tmp#16##0" to i64 + %"tmp#17##0" = inttoptr i64 %"tmp#8##0" to ptr + store i64 -1, ptr %"tmp#17##0" + ret i64 %"tmp#8##0" +if.else.0: + %"tmp#18##0" = call ccc ptr @wybe_malloc(i32 8) + %"tmp#19##0" = ptrtoint ptr %"tmp#18##0" to i64 + %"tmp#20##0" = inttoptr i64 %"tmp#19##0" to ptr + store i64 -1, ptr %"tmp#20##0" + ret i64 %"tmp#19##0" } - -define external fastcc i64 @"dead_cell_size.diff_type<0>[410bae77d3]"(i64 %"x##0") { -entry: - %0 = icmp ne i64 %"x##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = and i64 %"x##0", 3 - %2 = icmp eq i64 %1, 0 - br i1 %2, label %if.then1, label %if.else1 -if.else: - %7 = trunc i64 8 to i32 - %8 = tail call ccc i8* @wybe_malloc(i32 %7) - %9 = ptrtoint i8* %8 to i64 - %10 = inttoptr i64 %9 to i64* - store i64 -1, i64* %10 - ret i64 %9 -if.then1: - ret i64 %"x##0" -if.else1: - %3 = trunc i64 8 to i32 - %4 = tail call ccc i8* @wybe_malloc(i32 %3) - %5 = ptrtoint i8* %4 to i64 - %6 = inttoptr i64 %5 to i64* - store i64 -1, i64* %6 - ret i64 %5 +define external fastcc i64 @"dead_cell_size.diff_type<0>[410bae77d3]"(i64 %"x##0") { + %"tmp#4##0" = icmp ne i64 %"x##0", 0 + br i1 %"tmp#4##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#5##0" = and i64 %"x##0", 3 + %"tmp#6##0" = icmp eq i64 %"tmp#5##0", 0 + br i1 %"tmp#6##0", label %if.then.1, label %if.else.1 +if.then.1: + ret i64 %"x##0" +if.else.1: + %"tmp#13##0" = call ccc ptr @wybe_malloc(i32 8) + %"tmp#8##0" = ptrtoint ptr %"tmp#13##0" to i64 + %"tmp#14##0" = inttoptr i64 %"tmp#8##0" to ptr + store i64 -1, ptr %"tmp#14##0" + ret i64 %"tmp#8##0" +if.else.0: + %"tmp#15##0" = call ccc ptr @wybe_malloc(i32 8) + %"tmp#16##0" = ptrtoint ptr %"tmp#15##0" to i64 + %"tmp#17##0" = inttoptr i64 %"tmp#16##0" to ptr + store i64 -1, ptr %"tmp#17##0" + ret i64 %"tmp#16##0" } - -define external fastcc i64 @"dead_cell_size.foo<0>"(i64 %"x##0") { -entry: - %0 = icmp ne i64 %"x##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = and i64 %"x##0", 3 - %2 = icmp eq i64 %1, 0 - br i1 %2, label %if.then1, label %if.else1 -if.else: - ret i64 0 -if.then1: - %3 = inttoptr i64 %"x##0" to i64* - %4 = load i64, i64* %3 - %5 = trunc i64 24 to i32 - %6 = tail call ccc i8* @wybe_malloc(i32 %5) - %7 = ptrtoint i8* %6 to i64 - %8 = inttoptr i64 %7 to i64* - store i64 %4, i64* %8 - %9 = add i64 %7, 8 - %10 = inttoptr i64 %9 to i64* - store i64 2, i64* %10 - %11 = add i64 %7, 16 - %12 = inttoptr i64 %11 to i64* - store i64 3, i64* %12 - %13 = or i64 %7, 1 - ret i64 %13 -if.else1: - ret i64 %"x##0" +define external fastcc i64 @"dead_cell_size.foo<0>"(i64 %"x##0") { + %"tmp#3##0" = icmp ne i64 %"x##0", 0 + br i1 %"tmp#3##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#4##0" = and i64 %"x##0", 3 + %"tmp#5##0" = icmp eq i64 %"tmp#4##0", 0 + br i1 %"tmp#5##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#13##0" = inttoptr i64 %"x##0" to ptr + %"a##0" = load i64, ptr %"tmp#13##0" + %"tmp#14##0" = call ccc ptr @wybe_malloc(i32 24) + %"tmp#9##0" = ptrtoint ptr %"tmp#14##0" to i64 + %"tmp#15##0" = inttoptr i64 %"tmp#9##0" to ptr + store i64 %"a##0", ptr %"tmp#15##0" + %"tmp#16##0" = add i64 %"tmp#9##0", 8 + %"tmp#17##0" = inttoptr i64 %"tmp#16##0" to ptr + store i64 2, ptr %"tmp#17##0" + %"tmp#18##0" = add i64 %"tmp#9##0", 16 + %"tmp#19##0" = inttoptr i64 %"tmp#18##0" to ptr + store i64 3, ptr %"tmp#19##0" + %"tmp#20##0" = or i64 %"tmp#9##0", 1 + ret i64 %"tmp#20##0" +if.else.1: + ret i64 %"x##0" +if.else.0: + ret i64 0 } - -define external fastcc void @"dead_cell_size.print_t<0>"(i64 %"x##0") { -entry: - %0 = tail call fastcc i1 @"dead_cell_size.t.=<0>"(i64 0, i64 %"x##0") - br i1 %0, label %if.then, label %if.else -if.then: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @dead_cell_size.1, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - ret void -if.else: - %1 = icmp ne i64 %"x##0", 0 - br i1 %1, label %if.then1, label %if.else1 -if.then1: - %2 = and i64 %"x##0", 3 - switch i64 %2, label %switch.3.2 [i64 0, label %switch.3.0 i64 1, label %switch.3.1 i64 2, label %switch.3.2] -if.else1: - tail call ccc void @putchar(i8 10) - ret void -switch.3.0: - %3 = inttoptr i64 %"x##0" to i64* - %4 = load i64, i64* %3 - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @dead_cell_size.3, i32 0, i32 0) to i64)) - tail call ccc void @print_int(i64 %4) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @dead_cell_size.5, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - ret void -switch.3.1: - %5 = add i64 %"x##0", -1 - %6 = inttoptr i64 %5 to i64* - %7 = load i64, i64* %6 - %8 = add i64 %"x##0", 7 - %9 = inttoptr i64 %8 to i64* - %10 = load i64, i64* %9 - %11 = add i64 %"x##0", 15 - %12 = inttoptr i64 %11 to i64* - %13 = load i64, i64* %12 - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @dead_cell_size.7, i32 0, i32 0) to i64)) - tail call ccc void @print_int(i64 %7) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @dead_cell_size.9, i32 0, i32 0) to i64)) - tail call ccc void @print_int(i64 %10) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @dead_cell_size.9, i32 0, i32 0) to i64)) - tail call ccc void @print_int(i64 %13) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @dead_cell_size.5, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - ret void -switch.3.2: - %14 = add i64 %"x##0", -2 - %15 = inttoptr i64 %14 to i64* - %16 = load i64, i64* %15 - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @dead_cell_size.11, i32 0, i32 0) to i64)) - tail call ccc void @print_int(i64 %16) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @dead_cell_size.5, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"dead_cell_size.print_t<0>"(i64 %"x##0") { + %"tmp#4##0" = tail call fastcc i1 @"dead_cell_size.t.=<0>"(i64 0, i64 %"x##0") + br i1 %"tmp#4##0", label %if.then.0, label %if.else.0 +if.then.0: + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#12" to i64 )) + call ccc void @putchar(i8 10) + ret void +if.else.0: + %"tmp#6##0" = icmp ne i64 %"x##0", 0 + br i1 %"tmp#6##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#7##0" = and i64 %"x##0", 3 + switch i64 %"tmp#7##0", label %case.2.switch.2 [ + i64 0, label %case.0.switch.2 + i64 1, label %case.1.switch.2 + i64 2, label %case.2.switch.2 ] +case.0.switch.2: + %"tmp#42##0" = inttoptr i64 %"x##0" to ptr + %"a##0" = load i64, ptr %"tmp#42##0" + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#13" to i64 )) + call ccc void @print_int(i64 %"a##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#8" to i64 )) + call ccc void @putchar(i8 10) + ret void +case.1.switch.2: + %"tmp#43##0" = add i64 %"x##0", -1 + %"tmp#44##0" = inttoptr i64 %"tmp#43##0" to ptr + %"a##1" = load i64, ptr %"tmp#44##0" + %"tmp#45##0" = add i64 %"x##0", 7 + %"tmp#46##0" = inttoptr i64 %"tmp#45##0" to ptr + %"b##0" = load i64, ptr %"tmp#46##0" + %"tmp#47##0" = add i64 %"x##0", 15 + %"tmp#48##0" = inttoptr i64 %"tmp#47##0" to ptr + %"c##0" = load i64, ptr %"tmp#48##0" + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#14" to i64 )) + call ccc void @print_int(i64 %"a##1") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#9" to i64 )) + call ccc void @print_int(i64 %"b##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#9" to i64 )) + call ccc void @print_int(i64 %"c##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#8" to i64 )) + call ccc void @putchar(i8 10) + ret void +case.2.switch.2: + %"tmp#49##0" = add i64 %"x##0", -2 + %"tmp#50##0" = inttoptr i64 %"tmp#49##0" to ptr + %"a##2" = load i64, ptr %"tmp#50##0" + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#15" to i64 )) + call ccc void @print_int(i64 %"a##2") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#8" to i64 )) + call ccc void @putchar(i8 10) + ret void +if.else.1: + call ccc void @putchar(i8 10) + ret void } - -define external fastcc void @"dead_cell_size.print_t2<0>"(i64 %"x##0") { -entry: - %0 = tail call fastcc i1 @"dead_cell_size.t2.=<0>"(i64 0, i64 %"x##0") - br i1 %0, label %if.then, label %if.else -if.then: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @dead_cell_size.13, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - ret void -if.else: - %1 = icmp ne i64 %"x##0", 0 - br i1 %1, label %if.then1, label %if.else1 -if.then1: - %2 = inttoptr i64 %"x##0" to i64* - %3 = load i64, i64* %2 - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @dead_cell_size.15, i32 0, i32 0) to i64)) - tail call ccc void @print_int(i64 %3) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @dead_cell_size.5, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - ret void -if.else1: - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"dead_cell_size.print_t2<0>"(i64 %"x##0") { + %"tmp#2##0" = tail call fastcc i1 @"dead_cell_size.t2.=<0>"(i64 0, i64 %"x##0") + br i1 %"tmp#2##0", label %if.then.0, label %if.else.0 +if.then.0: + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#10" to i64 )) + call ccc void @putchar(i8 10) + ret void +if.else.0: + %"tmp#4##0" = icmp ne i64 %"x##0", 0 + br i1 %"tmp#4##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#14##0" = inttoptr i64 %"x##0" to ptr + %"a##0" = load i64, ptr %"tmp#14##0" + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#11" to i64 )) + call ccc void @print_int(i64 %"a##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#8" to i64 )) + call ccc void @putchar(i8 10) + ret void +if.else.1: + call ccc void @putchar(i8 10) + ret void } + -------------------------------------------------- Module dead_cell_size.t - representation : address + representation : pointer public submods : public resources: public procs : dead_cell_size.t.=<0> @@ -1098,557 +1040,504 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'dead_cell_size.t' - - - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i1 @"dead_cell_size.t.=<0>"(i64 %"#left##0", i64 %"#right##0") { -entry: - %0 = icmp ne i64 %"#left##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = and i64 %"#left##0", 3 - switch i64 %1, label %switch.3.2 [i64 0, label %switch.3.0 i64 1, label %switch.3.1 i64 2, label %switch.3.2] -if.else: - %44 = icmp eq i64 %"#right##0", 0 - ret i1 %44 -switch.3.0: - %2 = inttoptr i64 %"#left##0" to i64* - %3 = load i64, i64* %2 - %4 = icmp ne i64 %"#right##0", 0 - br i1 %4, label %if.then1, label %if.else1 -switch.3.1: - %10 = add i64 %"#left##0", -1 - %11 = inttoptr i64 %10 to i64* - %12 = load i64, i64* %11 - %13 = add i64 %"#left##0", 7 - %14 = inttoptr i64 %13 to i64* - %15 = load i64, i64* %14 - %16 = add i64 %"#left##0", 15 - %17 = inttoptr i64 %16 to i64* - %18 = load i64, i64* %17 - %19 = icmp ne i64 %"#right##0", 0 - br i1 %19, label %if.then3, label %if.else3 -switch.3.2: - %34 = add i64 %"#left##0", -2 - %35 = inttoptr i64 %34 to i64* - %36 = load i64, i64* %35 - %37 = icmp ne i64 %"#right##0", 0 - br i1 %37, label %if.then7, label %if.else7 -if.then1: - %5 = and i64 %"#right##0", 3 - %6 = icmp eq i64 %5, 0 - br i1 %6, label %if.then2, label %if.else2 -if.else1: - ret i1 0 -if.then2: - %7 = inttoptr i64 %"#right##0" to i64* - %8 = load i64, i64* %7 - %9 = icmp eq i64 %3, %8 - ret i1 %9 -if.else2: - ret i1 0 -if.then3: - %20 = and i64 %"#right##0", 3 - %21 = icmp eq i64 %20, 1 - br i1 %21, label %if.then4, label %if.else4 -if.else3: - ret i1 0 -if.then4: - %22 = add i64 %"#right##0", -1 - %23 = inttoptr i64 %22 to i64* - %24 = load i64, i64* %23 - %25 = add i64 %"#right##0", 7 - %26 = inttoptr i64 %25 to i64* - %27 = load i64, i64* %26 - %28 = add i64 %"#right##0", 15 - %29 = inttoptr i64 %28 to i64* - %30 = load i64, i64* %29 - %31 = icmp eq i64 %12, %24 - br i1 %31, label %if.then5, label %if.else5 -if.else4: - ret i1 0 -if.then5: - %32 = icmp eq i64 %15, %27 - br i1 %32, label %if.then6, label %if.else6 -if.else5: - ret i1 0 -if.then6: - %33 = icmp eq i64 %18, %30 - ret i1 %33 -if.else6: - ret i1 0 -if.then7: - %38 = and i64 %"#right##0", 3 - %39 = icmp eq i64 %38, 2 - br i1 %39, label %if.then8, label %if.else8 -if.else7: - ret i1 0 -if.then8: - %40 = add i64 %"#right##0", -2 - %41 = inttoptr i64 %40 to i64* - %42 = load i64, i64* %41 - %43 = icmp eq i64 %36, %42 - ret i1 %43 -if.else8: - ret i1 0 +source_filename = "!ROOT!/final-dump/dead_cell_size.wybe" +target triple ???? + + +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc i1 @"dead_cell_size.t.=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#0##0" = icmp ne i64 %"#left##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#15##0" = and i64 %"#left##0", 3 + switch i64 %"tmp#15##0", label %case.2.switch.1 [ + i64 0, label %case.0.switch.1 + i64 1, label %case.1.switch.1 + i64 2, label %case.2.switch.1 ] +case.0.switch.1: + %"tmp#47##0" = inttoptr i64 %"#left##0" to ptr + %"#left#tb1##0" = load i64, ptr %"tmp#47##0" + %"tmp#42##0" = icmp ne i64 %"#right##0", 0 + br i1 %"tmp#42##0", label %if.then.2, label %if.else.2 +if.then.2: + %"tmp#43##0" = and i64 %"#right##0", 3 + %"tmp#44##0" = icmp eq i64 %"tmp#43##0", 0 + br i1 %"tmp#44##0", label %if.then.3, label %if.else.3 +if.then.3: + %"tmp#48##0" = inttoptr i64 %"#right##0" to ptr + %"#right#tb1##0" = load i64, ptr %"tmp#48##0" + %"tmp#49##0" = icmp eq i64 %"#left#tb1##0", %"#right#tb1##0" + ret i1 %"tmp#49##0" +if.else.3: + ret i1 0 +if.else.2: + ret i1 0 +case.1.switch.1: + %"tmp#50##0" = add i64 %"#left##0", -1 + %"tmp#51##0" = inttoptr i64 %"tmp#50##0" to ptr + %"#left#tc1##0" = load i64, ptr %"tmp#51##0" + %"tmp#52##0" = add i64 %"#left##0", 7 + %"tmp#53##0" = inttoptr i64 %"tmp#52##0" to ptr + %"#left#tc2##0" = load i64, ptr %"tmp#53##0" + %"tmp#54##0" = add i64 %"#left##0", 15 + %"tmp#55##0" = inttoptr i64 %"tmp#54##0" to ptr + %"#left#tc3##0" = load i64, ptr %"tmp#55##0" + %"tmp#32##0" = icmp ne i64 %"#right##0", 0 + br i1 %"tmp#32##0", label %if.then.4, label %if.else.4 +if.then.4: + %"tmp#33##0" = and i64 %"#right##0", 3 + %"tmp#34##0" = icmp eq i64 %"tmp#33##0", 1 + br i1 %"tmp#34##0", label %if.then.5, label %if.else.5 +if.then.5: + %"tmp#56##0" = add i64 %"#right##0", -1 + %"tmp#57##0" = inttoptr i64 %"tmp#56##0" to ptr + %"#right#tc1##0" = load i64, ptr %"tmp#57##0" + %"tmp#58##0" = add i64 %"#right##0", 7 + %"tmp#59##0" = inttoptr i64 %"tmp#58##0" to ptr + %"#right#tc2##0" = load i64, ptr %"tmp#59##0" + %"tmp#60##0" = add i64 %"#right##0", 15 + %"tmp#61##0" = inttoptr i64 %"tmp#60##0" to ptr + %"#right#tc3##0" = load i64, ptr %"tmp#61##0" + %"tmp#5##0" = icmp eq i64 %"#left#tc1##0", %"#right#tc1##0" + br i1 %"tmp#5##0", label %if.then.6, label %if.else.6 +if.then.6: + %"tmp#6##0" = icmp eq i64 %"#left#tc2##0", %"#right#tc2##0" + br i1 %"tmp#6##0", label %if.then.7, label %if.else.7 +if.then.7: + %"tmp#62##0" = icmp eq i64 %"#left#tc3##0", %"#right#tc3##0" + ret i1 %"tmp#62##0" +if.else.7: + ret i1 0 +if.else.6: + ret i1 0 +if.else.5: + ret i1 0 +if.else.4: + ret i1 0 +case.2.switch.1: + %"tmp#63##0" = add i64 %"#left##0", -2 + %"tmp#64##0" = inttoptr i64 %"tmp#63##0" to ptr + %"#left#td1##0" = load i64, ptr %"tmp#64##0" + %"tmp#26##0" = icmp ne i64 %"#right##0", 0 + br i1 %"tmp#26##0", label %if.then.8, label %if.else.8 +if.then.8: + %"tmp#27##0" = and i64 %"#right##0", 3 + %"tmp#28##0" = icmp eq i64 %"tmp#27##0", 2 + br i1 %"tmp#28##0", label %if.then.9, label %if.else.9 +if.then.9: + %"tmp#65##0" = add i64 %"#right##0", -2 + %"tmp#66##0" = inttoptr i64 %"tmp#65##0" to ptr + %"#right#td1##0" = load i64, ptr %"tmp#66##0" + %"tmp#67##0" = icmp eq i64 %"#left#td1##0", %"#right#td1##0" + ret i1 %"tmp#67##0" +if.else.9: + ret i1 0 +if.else.8: + ret i1 0 +if.else.0: + %"tmp#68##0" = icmp eq i64 %"#right##0", 0 + ret i1 %"tmp#68##0" } - -define external fastcc i64 @"dead_cell_size.t.ta<0>"() alwaysinline { -entry: - ret i64 0 +define external fastcc i64 @"dead_cell_size.t.ta<0>"() { + ret i64 0 } - -define external fastcc i64 @"dead_cell_size.t.tb<0>"(i64 %"tb1##0") alwaysinline { -entry: - %0 = trunc i64 8 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"tb1##0", i64* %3 - ret i64 %2 +define external fastcc i64 @"dead_cell_size.t.tb<0>"(i64 %"tb1##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 8) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"tb1##0", ptr %"tmp#1##0" + ret i64 %"#rec##0" } - -define external fastcc {i64, i1} @"dead_cell_size.t.tb<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#result##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = and i64 %"#result##0", 3 - %2 = icmp eq i64 %1, 0 - br i1 %2, label %if.then1, label %if.else1 -if.else: - %9 = insertvalue {i64, i1} undef, i64 undef, 0 - %10 = insertvalue {i64, i1} %9, i1 0, 1 - ret {i64, i1} %10 -if.then1: - %3 = inttoptr i64 %"#result##0" to i64* - %4 = load i64, i64* %3 - %5 = insertvalue {i64, i1} undef, i64 %4, 0 - %6 = insertvalue {i64, i1} %5, i1 1, 1 - ret {i64, i1} %6 -if.else1: - %7 = insertvalue {i64, i1} undef, i64 undef, 0 - %8 = insertvalue {i64, i1} %7, i1 0, 1 - ret {i64, i1} %8 +define external fastcc {i64, i1} @"dead_cell_size.t.tb<1>"(i64 %"#result##0") { + %"tmp#0##0" = icmp ne i64 %"#result##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = and i64 %"#result##0", 3 + %"tmp#1##0" = icmp eq i64 %"tmp#2##0", 0 + br i1 %"tmp#1##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#3##0" = inttoptr i64 %"#result##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#3##0" + %"tmp#5##0" = insertvalue {i64, i1} undef, i64 %"tmp#4##0", 0 + %"tmp#6##0" = insertvalue {i64, i1} %"tmp#5##0", i1 1, 1 + ret {i64, i1} %"tmp#6##0" +if.else.1: + %"tmp#7##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#8##0" = insertvalue {i64, i1} %"tmp#7##0", i1 0, 1 + ret {i64, i1} %"tmp#8##0" +if.else.0: + %"tmp#9##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#10##0" = insertvalue {i64, i1} %"tmp#9##0", i1 0, 1 + ret {i64, i1} %"tmp#10##0" } - -define external fastcc {i64, i1} @"dead_cell_size.t.tb1<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = and i64 %"#rec##0", 3 - %2 = icmp eq i64 %1, 0 - br i1 %2, label %if.then1, label %if.else1 -if.else: - %9 = insertvalue {i64, i1} undef, i64 undef, 0 - %10 = insertvalue {i64, i1} %9, i1 0, 1 - ret {i64, i1} %10 -if.then1: - %3 = inttoptr i64 %"#rec##0" to i64* - %4 = load i64, i64* %3 - %5 = insertvalue {i64, i1} undef, i64 %4, 0 - %6 = insertvalue {i64, i1} %5, i1 1, 1 - ret {i64, i1} %6 -if.else1: - %7 = insertvalue {i64, i1} undef, i64 undef, 0 - %8 = insertvalue {i64, i1} %7, i1 0, 1 - ret {i64, i1} %8 +define external fastcc {i64, i1} @"dead_cell_size.t.tb1<0>"(i64 %"#rec##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = and i64 %"#rec##0", 3 + %"tmp#1##0" = icmp eq i64 %"tmp#2##0", 0 + br i1 %"tmp#1##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#3##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#3##0" + %"tmp#5##0" = insertvalue {i64, i1} undef, i64 %"tmp#4##0", 0 + %"tmp#6##0" = insertvalue {i64, i1} %"tmp#5##0", i1 1, 1 + ret {i64, i1} %"tmp#6##0" +if.else.1: + %"tmp#7##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#8##0" = insertvalue {i64, i1} %"tmp#7##0", i1 0, 1 + ret {i64, i1} %"tmp#8##0" +if.else.0: + %"tmp#9##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#10##0" = insertvalue {i64, i1} %"tmp#9##0", i1 0, 1 + ret {i64, i1} %"tmp#10##0" } - -define external fastcc {i64, i1} @"dead_cell_size.t.tb1<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = and i64 %"#rec##0", 3 - %2 = icmp eq i64 %1, 0 - br i1 %2, label %if.then1, label %if.else1 -if.else: - %14 = insertvalue {i64, i1} undef, i64 0, 0 - %15 = insertvalue {i64, i1} %14, i1 0, 1 - ret {i64, i1} %15 -if.then1: - %3 = trunc i64 8 to i32 - %4 = tail call ccc i8* @wybe_malloc(i32 %3) - %5 = ptrtoint i8* %4 to i64 - %6 = inttoptr i64 %5 to i8* - %7 = inttoptr i64 %"#rec##0" to i8* - %8 = trunc i64 8 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %6, i8* %7, i32 %8, i1 0) - %9 = inttoptr i64 %5 to i64* - store i64 %"#field##0", i64* %9 - %10 = insertvalue {i64, i1} undef, i64 %5, 0 - %11 = insertvalue {i64, i1} %10, i1 1, 1 - ret {i64, i1} %11 -if.else1: - %12 = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 - %13 = insertvalue {i64, i1} %12, i1 0, 1 - ret {i64, i1} %13 +define external fastcc {i64, i1} @"dead_cell_size.t.tb1<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = and i64 %"#rec##0", 3 + %"tmp#1##0" = icmp eq i64 %"tmp#2##0", 0 + br i1 %"tmp#1##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#3##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#4##0" = call ccc ptr @wybe_malloc(i32 8) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#4##0", ptr %"tmp#3##0", i64 8, i1 0) + %"tmp#5##0" = ptrtoint ptr %"tmp#4##0" to i64 + %"tmp#6##0" = inttoptr i64 %"tmp#5##0" to ptr + store i64 %"#field##0", ptr %"tmp#6##0" + %"tmp#7##0" = insertvalue {i64, i1} undef, i64 %"tmp#5##0", 0 + %"tmp#8##0" = insertvalue {i64, i1} %"tmp#7##0", i1 1, 1 + ret {i64, i1} %"tmp#8##0" +if.else.1: + %"tmp#9##0" = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 + %"tmp#10##0" = insertvalue {i64, i1} %"tmp#9##0", i1 0, 1 + ret {i64, i1} %"tmp#10##0" +if.else.0: + %"tmp#11##0" = insertvalue {i64, i1} undef, i64 0, 0 + %"tmp#12##0" = insertvalue {i64, i1} %"tmp#11##0", i1 0, 1 + ret {i64, i1} %"tmp#12##0" } - -define external fastcc i64 @"dead_cell_size.t.tc<0>"(i64 %"tc1##0", i64 %"tc2##0", i64 %"tc3##0") alwaysinline { -entry: - %0 = trunc i64 24 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"tc1##0", i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"tc2##0", i64* %5 - %6 = add i64 %2, 16 - %7 = inttoptr i64 %6 to i64* - store i64 %"tc3##0", i64* %7 - %8 = or i64 %2, 1 - ret i64 %8 +define external fastcc i64 @"dead_cell_size.t.tc<0>"(i64 %"tc1##0", i64 %"tc2##0", i64 %"tc3##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 24) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"tc1##0", ptr %"tmp#1##0" + %"tmp#2##0" = add i64 %"#rec##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"tc2##0", ptr %"tmp#3##0" + %"tmp#4##0" = add i64 %"#rec##0", 16 + %"tmp#5##0" = inttoptr i64 %"tmp#4##0" to ptr + store i64 %"tc3##0", ptr %"tmp#5##0" + %"tmp#6##0" = or i64 %"#rec##0", 1 + ret i64 %"tmp#6##0" } - -define external fastcc {i64, i64, i64, i1} @"dead_cell_size.t.tc<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#result##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = and i64 %"#result##0", 3 - %2 = icmp eq i64 %1, 1 - br i1 %2, label %if.then1, label %if.else1 -if.else: - %20 = insertvalue {i64, i64, i64, i1} undef, i64 undef, 0 - %21 = insertvalue {i64, i64, i64, i1} %20, i64 undef, 1 - %22 = insertvalue {i64, i64, i64, i1} %21, i64 undef, 2 - %23 = insertvalue {i64, i64, i64, i1} %22, i1 0, 3 - ret {i64, i64, i64, i1} %23 -if.then1: - %3 = add i64 %"#result##0", -1 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = add i64 %"#result##0", 7 - %7 = inttoptr i64 %6 to i64* - %8 = load i64, i64* %7 - %9 = add i64 %"#result##0", 15 - %10 = inttoptr i64 %9 to i64* - %11 = load i64, i64* %10 - %12 = insertvalue {i64, i64, i64, i1} undef, i64 %5, 0 - %13 = insertvalue {i64, i64, i64, i1} %12, i64 %8, 1 - %14 = insertvalue {i64, i64, i64, i1} %13, i64 %11, 2 - %15 = insertvalue {i64, i64, i64, i1} %14, i1 1, 3 - ret {i64, i64, i64, i1} %15 -if.else1: - %16 = insertvalue {i64, i64, i64, i1} undef, i64 undef, 0 - %17 = insertvalue {i64, i64, i64, i1} %16, i64 undef, 1 - %18 = insertvalue {i64, i64, i64, i1} %17, i64 undef, 2 - %19 = insertvalue {i64, i64, i64, i1} %18, i1 0, 3 - ret {i64, i64, i64, i1} %19 +define external fastcc {i64, i64, i64, i1} @"dead_cell_size.t.tc<1>"(i64 %"#result##0") { + %"tmp#0##0" = icmp ne i64 %"#result##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = and i64 %"#result##0", 3 + %"tmp#1##0" = icmp eq i64 %"tmp#2##0", 1 + br i1 %"tmp#1##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#3##0" = add i64 %"#result##0", -1 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#4##0" + %"tmp#6##0" = add i64 %"#result##0", 7 + %"tmp#7##0" = inttoptr i64 %"tmp#6##0" to ptr + %"tmp#8##0" = load i64, ptr %"tmp#7##0" + %"tmp#9##0" = add i64 %"#result##0", 15 + %"tmp#10##0" = inttoptr i64 %"tmp#9##0" to ptr + %"tmp#11##0" = load i64, ptr %"tmp#10##0" + %"tmp#12##0" = insertvalue {i64, i64, i64, i1} undef, i64 %"tmp#5##0", 0 + %"tmp#13##0" = insertvalue {i64, i64, i64, i1} %"tmp#12##0", i64 %"tmp#8##0", 1 + %"tmp#14##0" = insertvalue {i64, i64, i64, i1} %"tmp#13##0", i64 %"tmp#11##0", 2 + %"tmp#15##0" = insertvalue {i64, i64, i64, i1} %"tmp#14##0", i1 1, 3 + ret {i64, i64, i64, i1} %"tmp#15##0" +if.else.1: + %"tmp#16##0" = insertvalue {i64, i64, i64, i1} undef, i64 undef, 0 + %"tmp#17##0" = insertvalue {i64, i64, i64, i1} %"tmp#16##0", i64 undef, 1 + %"tmp#18##0" = insertvalue {i64, i64, i64, i1} %"tmp#17##0", i64 undef, 2 + %"tmp#19##0" = insertvalue {i64, i64, i64, i1} %"tmp#18##0", i1 0, 3 + ret {i64, i64, i64, i1} %"tmp#19##0" +if.else.0: + %"tmp#20##0" = insertvalue {i64, i64, i64, i1} undef, i64 undef, 0 + %"tmp#21##0" = insertvalue {i64, i64, i64, i1} %"tmp#20##0", i64 undef, 1 + %"tmp#22##0" = insertvalue {i64, i64, i64, i1} %"tmp#21##0", i64 undef, 2 + %"tmp#23##0" = insertvalue {i64, i64, i64, i1} %"tmp#22##0", i1 0, 3 + ret {i64, i64, i64, i1} %"tmp#23##0" } - -define external fastcc {i64, i1} @"dead_cell_size.t.tc1<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = and i64 %"#rec##0", 3 - %2 = icmp eq i64 %1, 1 - br i1 %2, label %if.then1, label %if.else1 -if.else: - %10 = insertvalue {i64, i1} undef, i64 undef, 0 - %11 = insertvalue {i64, i1} %10, i1 0, 1 - ret {i64, i1} %11 -if.then1: - %3 = add i64 %"#rec##0", -1 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = insertvalue {i64, i1} undef, i64 %5, 0 - %7 = insertvalue {i64, i1} %6, i1 1, 1 - ret {i64, i1} %7 -if.else1: - %8 = insertvalue {i64, i1} undef, i64 undef, 0 - %9 = insertvalue {i64, i1} %8, i1 0, 1 - ret {i64, i1} %9 +define external fastcc {i64, i1} @"dead_cell_size.t.tc1<0>"(i64 %"#rec##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = and i64 %"#rec##0", 3 + %"tmp#1##0" = icmp eq i64 %"tmp#2##0", 1 + br i1 %"tmp#1##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#3##0" = add i64 %"#rec##0", -1 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#4##0" + %"tmp#6##0" = insertvalue {i64, i1} undef, i64 %"tmp#5##0", 0 + %"tmp#7##0" = insertvalue {i64, i1} %"tmp#6##0", i1 1, 1 + ret {i64, i1} %"tmp#7##0" +if.else.1: + %"tmp#8##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#9##0" = insertvalue {i64, i1} %"tmp#8##0", i1 0, 1 + ret {i64, i1} %"tmp#9##0" +if.else.0: + %"tmp#10##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#11##0" = insertvalue {i64, i1} %"tmp#10##0", i1 0, 1 + ret {i64, i1} %"tmp#11##0" } - -define external fastcc {i64, i1} @"dead_cell_size.t.tc1<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = and i64 %"#rec##0", 3 - %2 = icmp eq i64 %1, 1 - br i1 %2, label %if.then1, label %if.else1 -if.else: - %17 = insertvalue {i64, i1} undef, i64 0, 0 - %18 = insertvalue {i64, i1} %17, i1 0, 1 - ret {i64, i1} %18 -if.then1: - %3 = trunc i64 24 to i32 - %4 = tail call ccc i8* @wybe_malloc(i32 %3) - %5 = ptrtoint i8* %4 to i64 - %6 = add i64 %5, 1 - %7 = sub i64 %"#rec##0", 1 - %8 = inttoptr i64 %5 to i8* - %9 = inttoptr i64 %7 to i8* - %10 = trunc i64 24 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %8, i8* %9, i32 %10, i1 0) - %11 = add i64 %6, -1 - %12 = inttoptr i64 %11 to i64* - store i64 %"#field##0", i64* %12 - %13 = insertvalue {i64, i1} undef, i64 %6, 0 - %14 = insertvalue {i64, i1} %13, i1 1, 1 - ret {i64, i1} %14 -if.else1: - %15 = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 - %16 = insertvalue {i64, i1} %15, i1 0, 1 - ret {i64, i1} %16 +define external fastcc {i64, i1} @"dead_cell_size.t.tc1<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = and i64 %"#rec##0", 3 + %"tmp#1##0" = icmp eq i64 %"tmp#2##0", 1 + br i1 %"tmp#1##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#3##0" = sub i64 %"#rec##0", 1 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + %"tmp#5##0" = call ccc ptr @wybe_malloc(i32 24) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#5##0", ptr %"tmp#4##0", i64 24, i1 0) + %"tmp#6##0" = ptrtoint ptr %"tmp#5##0" to i64 + %"tmp#7##0" = add i64 %"tmp#6##0", 1 + %"tmp#8##0" = add i64 %"tmp#7##0", -1 + %"tmp#9##0" = inttoptr i64 %"tmp#8##0" to ptr + store i64 %"#field##0", ptr %"tmp#9##0" + %"tmp#10##0" = insertvalue {i64, i1} undef, i64 %"tmp#7##0", 0 + %"tmp#11##0" = insertvalue {i64, i1} %"tmp#10##0", i1 1, 1 + ret {i64, i1} %"tmp#11##0" +if.else.1: + %"tmp#12##0" = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 + %"tmp#13##0" = insertvalue {i64, i1} %"tmp#12##0", i1 0, 1 + ret {i64, i1} %"tmp#13##0" +if.else.0: + %"tmp#14##0" = insertvalue {i64, i1} undef, i64 0, 0 + %"tmp#15##0" = insertvalue {i64, i1} %"tmp#14##0", i1 0, 1 + ret {i64, i1} %"tmp#15##0" } - -define external fastcc {i64, i1} @"dead_cell_size.t.tc2<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = and i64 %"#rec##0", 3 - %2 = icmp eq i64 %1, 1 - br i1 %2, label %if.then1, label %if.else1 -if.else: - %10 = insertvalue {i64, i1} undef, i64 undef, 0 - %11 = insertvalue {i64, i1} %10, i1 0, 1 - ret {i64, i1} %11 -if.then1: - %3 = add i64 %"#rec##0", 7 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = insertvalue {i64, i1} undef, i64 %5, 0 - %7 = insertvalue {i64, i1} %6, i1 1, 1 - ret {i64, i1} %7 -if.else1: - %8 = insertvalue {i64, i1} undef, i64 undef, 0 - %9 = insertvalue {i64, i1} %8, i1 0, 1 - ret {i64, i1} %9 +define external fastcc {i64, i1} @"dead_cell_size.t.tc2<0>"(i64 %"#rec##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = and i64 %"#rec##0", 3 + %"tmp#1##0" = icmp eq i64 %"tmp#2##0", 1 + br i1 %"tmp#1##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#3##0" = add i64 %"#rec##0", 7 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#4##0" + %"tmp#6##0" = insertvalue {i64, i1} undef, i64 %"tmp#5##0", 0 + %"tmp#7##0" = insertvalue {i64, i1} %"tmp#6##0", i1 1, 1 + ret {i64, i1} %"tmp#7##0" +if.else.1: + %"tmp#8##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#9##0" = insertvalue {i64, i1} %"tmp#8##0", i1 0, 1 + ret {i64, i1} %"tmp#9##0" +if.else.0: + %"tmp#10##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#11##0" = insertvalue {i64, i1} %"tmp#10##0", i1 0, 1 + ret {i64, i1} %"tmp#11##0" } - -define external fastcc {i64, i1} @"dead_cell_size.t.tc2<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = and i64 %"#rec##0", 3 - %2 = icmp eq i64 %1, 1 - br i1 %2, label %if.then1, label %if.else1 -if.else: - %17 = insertvalue {i64, i1} undef, i64 0, 0 - %18 = insertvalue {i64, i1} %17, i1 0, 1 - ret {i64, i1} %18 -if.then1: - %3 = trunc i64 24 to i32 - %4 = tail call ccc i8* @wybe_malloc(i32 %3) - %5 = ptrtoint i8* %4 to i64 - %6 = add i64 %5, 1 - %7 = sub i64 %"#rec##0", 1 - %8 = inttoptr i64 %5 to i8* - %9 = inttoptr i64 %7 to i8* - %10 = trunc i64 24 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %8, i8* %9, i32 %10, i1 0) - %11 = add i64 %6, 7 - %12 = inttoptr i64 %11 to i64* - store i64 %"#field##0", i64* %12 - %13 = insertvalue {i64, i1} undef, i64 %6, 0 - %14 = insertvalue {i64, i1} %13, i1 1, 1 - ret {i64, i1} %14 -if.else1: - %15 = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 - %16 = insertvalue {i64, i1} %15, i1 0, 1 - ret {i64, i1} %16 +define external fastcc {i64, i1} @"dead_cell_size.t.tc2<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = and i64 %"#rec##0", 3 + %"tmp#1##0" = icmp eq i64 %"tmp#2##0", 1 + br i1 %"tmp#1##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#3##0" = sub i64 %"#rec##0", 1 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + %"tmp#5##0" = call ccc ptr @wybe_malloc(i32 24) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#5##0", ptr %"tmp#4##0", i64 24, i1 0) + %"tmp#6##0" = ptrtoint ptr %"tmp#5##0" to i64 + %"tmp#7##0" = add i64 %"tmp#6##0", 1 + %"tmp#8##0" = add i64 %"tmp#7##0", 7 + %"tmp#9##0" = inttoptr i64 %"tmp#8##0" to ptr + store i64 %"#field##0", ptr %"tmp#9##0" + %"tmp#10##0" = insertvalue {i64, i1} undef, i64 %"tmp#7##0", 0 + %"tmp#11##0" = insertvalue {i64, i1} %"tmp#10##0", i1 1, 1 + ret {i64, i1} %"tmp#11##0" +if.else.1: + %"tmp#12##0" = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 + %"tmp#13##0" = insertvalue {i64, i1} %"tmp#12##0", i1 0, 1 + ret {i64, i1} %"tmp#13##0" +if.else.0: + %"tmp#14##0" = insertvalue {i64, i1} undef, i64 0, 0 + %"tmp#15##0" = insertvalue {i64, i1} %"tmp#14##0", i1 0, 1 + ret {i64, i1} %"tmp#15##0" } - -define external fastcc {i64, i1} @"dead_cell_size.t.tc3<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = and i64 %"#rec##0", 3 - %2 = icmp eq i64 %1, 1 - br i1 %2, label %if.then1, label %if.else1 -if.else: - %10 = insertvalue {i64, i1} undef, i64 undef, 0 - %11 = insertvalue {i64, i1} %10, i1 0, 1 - ret {i64, i1} %11 -if.then1: - %3 = add i64 %"#rec##0", 15 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = insertvalue {i64, i1} undef, i64 %5, 0 - %7 = insertvalue {i64, i1} %6, i1 1, 1 - ret {i64, i1} %7 -if.else1: - %8 = insertvalue {i64, i1} undef, i64 undef, 0 - %9 = insertvalue {i64, i1} %8, i1 0, 1 - ret {i64, i1} %9 +define external fastcc {i64, i1} @"dead_cell_size.t.tc3<0>"(i64 %"#rec##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = and i64 %"#rec##0", 3 + %"tmp#1##0" = icmp eq i64 %"tmp#2##0", 1 + br i1 %"tmp#1##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#3##0" = add i64 %"#rec##0", 15 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#4##0" + %"tmp#6##0" = insertvalue {i64, i1} undef, i64 %"tmp#5##0", 0 + %"tmp#7##0" = insertvalue {i64, i1} %"tmp#6##0", i1 1, 1 + ret {i64, i1} %"tmp#7##0" +if.else.1: + %"tmp#8##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#9##0" = insertvalue {i64, i1} %"tmp#8##0", i1 0, 1 + ret {i64, i1} %"tmp#9##0" +if.else.0: + %"tmp#10##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#11##0" = insertvalue {i64, i1} %"tmp#10##0", i1 0, 1 + ret {i64, i1} %"tmp#11##0" } - -define external fastcc {i64, i1} @"dead_cell_size.t.tc3<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = and i64 %"#rec##0", 3 - %2 = icmp eq i64 %1, 1 - br i1 %2, label %if.then1, label %if.else1 -if.else: - %17 = insertvalue {i64, i1} undef, i64 0, 0 - %18 = insertvalue {i64, i1} %17, i1 0, 1 - ret {i64, i1} %18 -if.then1: - %3 = trunc i64 24 to i32 - %4 = tail call ccc i8* @wybe_malloc(i32 %3) - %5 = ptrtoint i8* %4 to i64 - %6 = add i64 %5, 1 - %7 = sub i64 %"#rec##0", 1 - %8 = inttoptr i64 %5 to i8* - %9 = inttoptr i64 %7 to i8* - %10 = trunc i64 24 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %8, i8* %9, i32 %10, i1 0) - %11 = add i64 %6, 15 - %12 = inttoptr i64 %11 to i64* - store i64 %"#field##0", i64* %12 - %13 = insertvalue {i64, i1} undef, i64 %6, 0 - %14 = insertvalue {i64, i1} %13, i1 1, 1 - ret {i64, i1} %14 -if.else1: - %15 = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 - %16 = insertvalue {i64, i1} %15, i1 0, 1 - ret {i64, i1} %16 +define external fastcc {i64, i1} @"dead_cell_size.t.tc3<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = and i64 %"#rec##0", 3 + %"tmp#1##0" = icmp eq i64 %"tmp#2##0", 1 + br i1 %"tmp#1##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#3##0" = sub i64 %"#rec##0", 1 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + %"tmp#5##0" = call ccc ptr @wybe_malloc(i32 24) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#5##0", ptr %"tmp#4##0", i64 24, i1 0) + %"tmp#6##0" = ptrtoint ptr %"tmp#5##0" to i64 + %"tmp#7##0" = add i64 %"tmp#6##0", 1 + %"tmp#8##0" = add i64 %"tmp#7##0", 15 + %"tmp#9##0" = inttoptr i64 %"tmp#8##0" to ptr + store i64 %"#field##0", ptr %"tmp#9##0" + %"tmp#10##0" = insertvalue {i64, i1} undef, i64 %"tmp#7##0", 0 + %"tmp#11##0" = insertvalue {i64, i1} %"tmp#10##0", i1 1, 1 + ret {i64, i1} %"tmp#11##0" +if.else.1: + %"tmp#12##0" = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 + %"tmp#13##0" = insertvalue {i64, i1} %"tmp#12##0", i1 0, 1 + ret {i64, i1} %"tmp#13##0" +if.else.0: + %"tmp#14##0" = insertvalue {i64, i1} undef, i64 0, 0 + %"tmp#15##0" = insertvalue {i64, i1} %"tmp#14##0", i1 0, 1 + ret {i64, i1} %"tmp#15##0" } - -define external fastcc i64 @"dead_cell_size.t.td<0>"(i64 %"td1##0") alwaysinline { -entry: - %0 = trunc i64 8 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"td1##0", i64* %3 - %4 = or i64 %2, 2 - ret i64 %4 +define external fastcc i64 @"dead_cell_size.t.td<0>"(i64 %"td1##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 8) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"td1##0", ptr %"tmp#1##0" + %"tmp#2##0" = or i64 %"#rec##0", 2 + ret i64 %"tmp#2##0" } - -define external fastcc {i64, i1} @"dead_cell_size.t.td<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#result##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = and i64 %"#result##0", 3 - %2 = icmp eq i64 %1, 2 - br i1 %2, label %if.then1, label %if.else1 -if.else: - %10 = insertvalue {i64, i1} undef, i64 undef, 0 - %11 = insertvalue {i64, i1} %10, i1 0, 1 - ret {i64, i1} %11 -if.then1: - %3 = add i64 %"#result##0", -2 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = insertvalue {i64, i1} undef, i64 %5, 0 - %7 = insertvalue {i64, i1} %6, i1 1, 1 - ret {i64, i1} %7 -if.else1: - %8 = insertvalue {i64, i1} undef, i64 undef, 0 - %9 = insertvalue {i64, i1} %8, i1 0, 1 - ret {i64, i1} %9 +define external fastcc {i64, i1} @"dead_cell_size.t.td<1>"(i64 %"#result##0") { + %"tmp#0##0" = icmp ne i64 %"#result##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = and i64 %"#result##0", 3 + %"tmp#1##0" = icmp eq i64 %"tmp#2##0", 2 + br i1 %"tmp#1##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#3##0" = add i64 %"#result##0", -2 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#4##0" + %"tmp#6##0" = insertvalue {i64, i1} undef, i64 %"tmp#5##0", 0 + %"tmp#7##0" = insertvalue {i64, i1} %"tmp#6##0", i1 1, 1 + ret {i64, i1} %"tmp#7##0" +if.else.1: + %"tmp#8##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#9##0" = insertvalue {i64, i1} %"tmp#8##0", i1 0, 1 + ret {i64, i1} %"tmp#9##0" +if.else.0: + %"tmp#10##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#11##0" = insertvalue {i64, i1} %"tmp#10##0", i1 0, 1 + ret {i64, i1} %"tmp#11##0" } - -define external fastcc {i64, i1} @"dead_cell_size.t.td1<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = and i64 %"#rec##0", 3 - %2 = icmp eq i64 %1, 2 - br i1 %2, label %if.then1, label %if.else1 -if.else: - %10 = insertvalue {i64, i1} undef, i64 undef, 0 - %11 = insertvalue {i64, i1} %10, i1 0, 1 - ret {i64, i1} %11 -if.then1: - %3 = add i64 %"#rec##0", -2 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = insertvalue {i64, i1} undef, i64 %5, 0 - %7 = insertvalue {i64, i1} %6, i1 1, 1 - ret {i64, i1} %7 -if.else1: - %8 = insertvalue {i64, i1} undef, i64 undef, 0 - %9 = insertvalue {i64, i1} %8, i1 0, 1 - ret {i64, i1} %9 +define external fastcc {i64, i1} @"dead_cell_size.t.td1<0>"(i64 %"#rec##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = and i64 %"#rec##0", 3 + %"tmp#1##0" = icmp eq i64 %"tmp#2##0", 2 + br i1 %"tmp#1##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#3##0" = add i64 %"#rec##0", -2 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#4##0" + %"tmp#6##0" = insertvalue {i64, i1} undef, i64 %"tmp#5##0", 0 + %"tmp#7##0" = insertvalue {i64, i1} %"tmp#6##0", i1 1, 1 + ret {i64, i1} %"tmp#7##0" +if.else.1: + %"tmp#8##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#9##0" = insertvalue {i64, i1} %"tmp#8##0", i1 0, 1 + ret {i64, i1} %"tmp#9##0" +if.else.0: + %"tmp#10##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#11##0" = insertvalue {i64, i1} %"tmp#10##0", i1 0, 1 + ret {i64, i1} %"tmp#11##0" } - -define external fastcc {i64, i1} @"dead_cell_size.t.td1<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = and i64 %"#rec##0", 3 - %2 = icmp eq i64 %1, 2 - br i1 %2, label %if.then1, label %if.else1 -if.else: - %17 = insertvalue {i64, i1} undef, i64 0, 0 - %18 = insertvalue {i64, i1} %17, i1 0, 1 - ret {i64, i1} %18 -if.then1: - %3 = trunc i64 8 to i32 - %4 = tail call ccc i8* @wybe_malloc(i32 %3) - %5 = ptrtoint i8* %4 to i64 - %6 = add i64 %5, 2 - %7 = sub i64 %"#rec##0", 2 - %8 = inttoptr i64 %5 to i8* - %9 = inttoptr i64 %7 to i8* - %10 = trunc i64 8 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %8, i8* %9, i32 %10, i1 0) - %11 = add i64 %6, -2 - %12 = inttoptr i64 %11 to i64* - store i64 %"#field##0", i64* %12 - %13 = insertvalue {i64, i1} undef, i64 %6, 0 - %14 = insertvalue {i64, i1} %13, i1 1, 1 - ret {i64, i1} %14 -if.else1: - %15 = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 - %16 = insertvalue {i64, i1} %15, i1 0, 1 - ret {i64, i1} %16 +define external fastcc {i64, i1} @"dead_cell_size.t.td1<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = and i64 %"#rec##0", 3 + %"tmp#1##0" = icmp eq i64 %"tmp#2##0", 2 + br i1 %"tmp#1##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#3##0" = sub i64 %"#rec##0", 2 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + %"tmp#5##0" = call ccc ptr @wybe_malloc(i32 8) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#5##0", ptr %"tmp#4##0", i64 8, i1 0) + %"tmp#6##0" = ptrtoint ptr %"tmp#5##0" to i64 + %"tmp#7##0" = add i64 %"tmp#6##0", 2 + %"tmp#8##0" = add i64 %"tmp#7##0", -2 + %"tmp#9##0" = inttoptr i64 %"tmp#8##0" to ptr + store i64 %"#field##0", ptr %"tmp#9##0" + %"tmp#10##0" = insertvalue {i64, i1} undef, i64 %"tmp#7##0", 0 + %"tmp#11##0" = insertvalue {i64, i1} %"tmp#10##0", i1 1, 1 + ret {i64, i1} %"tmp#11##0" +if.else.1: + %"tmp#12##0" = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 + %"tmp#13##0" = insertvalue {i64, i1} %"tmp#12##0", i1 0, 1 + ret {i64, i1} %"tmp#13##0" +if.else.0: + %"tmp#14##0" = insertvalue {i64, i1} undef, i64 0, 0 + %"tmp#15##0" = insertvalue {i64, i1} %"tmp#14##0", i1 0, 1 + ret {i64, i1} %"tmp#15##0" } - -define external fastcc i1 @"dead_cell_size.t.~=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = tail call fastcc i1 @"dead_cell_size.t.=<0>"(i64 %"#left##0", i64 %"#right##0") - %1 = xor i1 %0, 1 - ret i1 %1 +define external fastcc i1 @"dead_cell_size.t.~=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#0##0" = tail call fastcc i1 @"dead_cell_size.t.=<0>"(i64 %"#left##0", i64 %"#right##0") + %"tmp#1##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#1##0" } + -------------------------------------------------- Module dead_cell_size.t2 - representation : address + representation : pointer public submods : public resources: public procs : dead_cell_size.t2.=<0> @@ -1761,118 +1650,99 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'dead_cell_size.t2' - - - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i1 @"dead_cell_size.t2.=<0>"(i64 %"#left##0", i64 %"#right##0") { -entry: - %0 = icmp ne i64 %"#left##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"#left##0" to i64* - %2 = load i64, i64* %1 - %3 = icmp ne i64 %"#right##0", 0 - br i1 %3, label %if.then1, label %if.else1 -if.else: - %7 = icmp eq i64 %"#right##0", 0 - ret i1 %7 -if.then1: - %4 = inttoptr i64 %"#right##0" to i64* - %5 = load i64, i64* %4 - %6 = icmp eq i64 %2, %5 - ret i1 %6 -if.else1: - ret i1 0 +source_filename = "!ROOT!/final-dump/dead_cell_size.wybe" +target triple ???? + + +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc i1 @"dead_cell_size.t2.=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#0##0" = icmp ne i64 %"#left##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#11##0" = inttoptr i64 %"#left##0" to ptr + %"#left#a##0" = load i64, ptr %"tmp#11##0" + %"tmp#8##0" = icmp ne i64 %"#right##0", 0 + br i1 %"tmp#8##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#12##0" = inttoptr i64 %"#right##0" to ptr + %"#right#a##0" = load i64, ptr %"tmp#12##0" + %"tmp#13##0" = icmp eq i64 %"#left#a##0", %"#right#a##0" + ret i1 %"tmp#13##0" +if.else.1: + ret i1 0 +if.else.0: + %"tmp#14##0" = icmp eq i64 %"#right##0", 0 + ret i1 %"tmp#14##0" } - -define external fastcc {i64, i1} @"dead_cell_size.t2.a<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"#rec##0" to i64* - %2 = load i64, i64* %1 - %3 = insertvalue {i64, i1} undef, i64 %2, 0 - %4 = insertvalue {i64, i1} %3, i1 1, 1 - ret {i64, i1} %4 -if.else: - %5 = insertvalue {i64, i1} undef, i64 undef, 0 - %6 = insertvalue {i64, i1} %5, i1 0, 1 - ret {i64, i1} %6 +define external fastcc {i64, i1} @"dead_cell_size.t2.a<0>"(i64 %"#rec##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + %"tmp#3##0" = insertvalue {i64, i1} undef, i64 %"tmp#2##0", 0 + %"tmp#4##0" = insertvalue {i64, i1} %"tmp#3##0", i1 1, 1 + ret {i64, i1} %"tmp#4##0" +if.else.0: + %"tmp#5##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#6##0" = insertvalue {i64, i1} %"tmp#5##0", i1 0, 1 + ret {i64, i1} %"tmp#6##0" } - -define external fastcc {i64, i1} @"dead_cell_size.t2.a<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = trunc i64 8 to i32 - %2 = tail call ccc i8* @wybe_malloc(i32 %1) - %3 = ptrtoint i8* %2 to i64 - %4 = inttoptr i64 %3 to i8* - %5 = inttoptr i64 %"#rec##0" to i8* - %6 = trunc i64 8 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %4, i8* %5, i32 %6, i1 0) - %7 = inttoptr i64 %3 to i64* - store i64 %"#field##0", i64* %7 - %8 = insertvalue {i64, i1} undef, i64 %3, 0 - %9 = insertvalue {i64, i1} %8, i1 1, 1 - ret {i64, i1} %9 -if.else: - %10 = insertvalue {i64, i1} undef, i64 0, 0 - %11 = insertvalue {i64, i1} %10, i1 0, 1 - ret {i64, i1} %11 +define external fastcc {i64, i1} @"dead_cell_size.t2.a<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#2##0" = call ccc ptr @wybe_malloc(i32 8) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#2##0", ptr %"tmp#1##0", i64 8, i1 0) + %"tmp#3##0" = ptrtoint ptr %"tmp#2##0" to i64 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 %"#field##0", ptr %"tmp#4##0" + %"tmp#5##0" = insertvalue {i64, i1} undef, i64 %"tmp#3##0", 0 + %"tmp#6##0" = insertvalue {i64, i1} %"tmp#5##0", i1 1, 1 + ret {i64, i1} %"tmp#6##0" +if.else.0: + %"tmp#7##0" = insertvalue {i64, i1} undef, i64 0, 0 + %"tmp#8##0" = insertvalue {i64, i1} %"tmp#7##0", i1 0, 1 + ret {i64, i1} %"tmp#8##0" } - -define external fastcc i64 @"dead_cell_size.t2.t2a<0>"() alwaysinline { -entry: - ret i64 0 +define external fastcc i64 @"dead_cell_size.t2.t2a<0>"() { + ret i64 0 } - -define external fastcc i64 @"dead_cell_size.t2.t2b<0>"(i64 %"a##0") alwaysinline { -entry: - %0 = trunc i64 8 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"a##0", i64* %3 - ret i64 %2 +define external fastcc i64 @"dead_cell_size.t2.t2b<0>"(i64 %"a##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 8) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"a##0", ptr %"tmp#1##0" + ret i64 %"#rec##0" } - -define external fastcc {i64, i1} @"dead_cell_size.t2.t2b<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#result##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"#result##0" to i64* - %2 = load i64, i64* %1 - %3 = insertvalue {i64, i1} undef, i64 %2, 0 - %4 = insertvalue {i64, i1} %3, i1 1, 1 - ret {i64, i1} %4 -if.else: - %5 = insertvalue {i64, i1} undef, i64 undef, 0 - %6 = insertvalue {i64, i1} %5, i1 0, 1 - ret {i64, i1} %6 +define external fastcc {i64, i1} @"dead_cell_size.t2.t2b<1>"(i64 %"#result##0") { + %"tmp#0##0" = icmp ne i64 %"#result##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = inttoptr i64 %"#result##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + %"tmp#3##0" = insertvalue {i64, i1} undef, i64 %"tmp#2##0", 0 + %"tmp#4##0" = insertvalue {i64, i1} %"tmp#3##0", i1 1, 1 + ret {i64, i1} %"tmp#4##0" +if.else.0: + %"tmp#5##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#6##0" = insertvalue {i64, i1} %"tmp#5##0", i1 0, 1 + ret {i64, i1} %"tmp#6##0" } - -define external fastcc i1 @"dead_cell_size.t2.~=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = tail call fastcc i1 @"dead_cell_size.t2.=<0>"(i64 %"#left##0", i64 %"#right##0") - %1 = xor i1 %0, 1 - ret i1 %1 +define external fastcc i1 @"dead_cell_size.t2.~=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#0##0" = tail call fastcc i1 @"dead_cell_size.t2.=<0>"(i64 %"#left##0", i64 %"#right##0") + %"tmp#1##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#1##0" } diff --git a/test-cases/final-dump/decimal.exp b/test-cases/final-dump/decimal.exp index 1fd572c44..f7641b68f 100644 --- a/test-cases/final-dump/decimal.exp +++ b/test-cases/final-dump/decimal.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module decimal representation : (not a type) public submods : @@ -39,48 +42,38 @@ module top-level code > public {semipure} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'decimal' - - - - -declare external ccc void @putchar(i8) - - -declare external ccc void @print_float(double) - - -declare external ccc void @print_int(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"decimal.<0>"() { -entry: - tail call ccc void @print_float(double 1.000000e-2) - tail call ccc void @putchar(i8 10) - tail call ccc void @print_int(i64 255) - tail call ccc void @putchar(i8 10) - tail call ccc void @print_int(i64 42) - tail call ccc void @putchar(i8 10) - tail call ccc void @print_int(i64 63) - tail call ccc void @putchar(i8 10) - tail call ccc void @print_float(double 1.000000e100) - tail call ccc void @putchar(i8 10) - tail call ccc void @print_float(double 1.000010e2) - tail call ccc void @putchar(i8 10) - tail call ccc void @print_float(double 5.001000e4) - tail call ccc void @putchar(i8 10) - tail call ccc void @print_int(i64 1000000000) - tail call ccc void @putchar(i8 10) - tail call ccc void @print_float(double 5.001000e-14) - tail call ccc void @putchar(i8 10) - tail call ccc void @print_float(double -1.000000e1) - tail call ccc void @putchar(i8 10) - ret void +source_filename = "!ROOT!/final-dump/decimal.wybe" +target triple ???? + + +declare external ccc void @print_float(double) +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"decimal.<0>"() { + call ccc void @print_float(double 1.0e-2) + call ccc void @putchar(i8 10) + call ccc void @print_int(i64 255) + call ccc void @putchar(i8 10) + call ccc void @print_int(i64 42) + call ccc void @putchar(i8 10) + call ccc void @print_int(i64 63) + call ccc void @putchar(i8 10) + call ccc void @print_float(double 1.0e100) + call ccc void @putchar(i8 10) + call ccc void @print_float(double 100.001) + call ccc void @putchar(i8 10) + call ccc void @print_float(double 50010.0) + call ccc void @putchar(i8 10) + call ccc void @print_int(i64 1000000000) + call ccc void @putchar(i8 10) + call ccc void @print_float(double 5.0010000000000006e-14) + call ccc void @putchar(i8 10) + call ccc void @print_float(double -10.0) + call ccc void @putchar(i8 10) + ret void } diff --git a/test-cases/final-dump/det_for.exp b/test-cases/final-dump/det_for.exp index a67766abf..240e9d594 100644 --- a/test-cases/final-dump/det_for.exp +++ b/test-cases/final-dump/det_for.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module det_for representation : (not a type) public submods : @@ -40,45 +43,33 @@ proc [|] > {inline} (1 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'det_for' +source_filename = "!ROOT!/final-dump/det_for.wybe" +target triple ???? - - - -declare external ccc void @putchar(i8) - - -declare external ccc void @print_int(i64) +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"det_for.<0>"() alwaysinline { -entry: - tail call fastcc void @"det_for.#cont#1<0>"(i64 0) - ret void +define external fastcc void @"det_for.<0>"() { + tail call fastcc void @"det_for.#cont#1<0>"(i64 0) + ret void } - -define external fastcc void @"det_for.#cont#1<0>"(i64 %"tmp#0##0") { -entry: - %0 = add i64 %"tmp#0##0", 1 - tail call ccc void @print_int(i64 %"tmp#0##0") - tail call ccc void @putchar(i8 10) - musttail call fastcc void @"det_for.#cont#1<0>"(i64 %0) - ret void +define external fastcc void @"det_for.#cont#1<0>"(i64 %"tmp#0##0") { + %"tmp#0##1" = add i64 %"tmp#0##0", 1 + call ccc void @print_int(i64 %"tmp#0##0") + call ccc void @putchar(i8 10) + tail call fastcc void @"det_for.#cont#1<0>"(i64 %"tmp#0##1") + ret void } - -define external fastcc {i64, i64} @"det_for.[|]<0>"(i64 %"current##0") alwaysinline { -entry: - %0 = add i64 %"current##0", 1 - %1 = insertvalue {i64, i64} undef, i64 %"current##0", 0 - %2 = insertvalue {i64, i64} %1, i64 %0, 1 - ret {i64, i64} %2 +define external fastcc {i64, i64} @"det_for.[|]<0>"(i64 %"current##0") { + %"tmp#3##0" = add i64 %"current##0", 1 + %"tmp#4##0" = insertvalue {i64, i64} undef, i64 %"current##0", 0 + %"tmp#5##0" = insertvalue {i64, i64} %"tmp#4##0", i64 %"tmp#3##0", 1 + ret {i64, i64} %"tmp#5##0" } diff --git a/test-cases/final-dump/disjunction.exp b/test-cases/final-dump/disjunction.exp index 5140a6e99..1e02819ff 100644 --- a/test-cases/final-dump/disjunction.exp +++ b/test-cases/final-dump/disjunction.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module disjunction representation : (not a type) public submods : @@ -91,85 +94,75 @@ saturating_tail2(lst##0:wybe.list(T) <{}; {}; {0}>, ?#result##0:wybe.list(T) <{} LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'disjunction' - - - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i1 @"disjunction.in<0>"(i64 %"e##0", i64 %"lst##0") { -entry: - %0 = icmp ne i64 %"lst##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"lst##0" to i64* - %2 = load i64, i64* %1 - %3 = icmp eq i64 %"e##0", %2 - br i1 %3, label %if.then1, label %if.else1 -if.else: - ret i1 0 -if.then1: - ret i1 1 -if.else1: - %4 = add i64 %"lst##0", 8 - %5 = inttoptr i64 %4 to i64* - %6 = load i64, i64* %5 - %7 = musttail call fastcc i1 @"disjunction.in<0>"(i64 %"e##0", i64 %6) - ret i1 %7 +source_filename = "!ROOT!/final-dump/disjunction.wybe" +target triple ???? + + +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc i1 @"disjunction.in<0>"(i64 %"e##0", i64 %"lst##0") { + %"tmp#6##0" = icmp ne i64 %"lst##0", 0 + br i1 %"tmp#6##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#13##0" = inttoptr i64 %"lst##0" to ptr + %"h##0" = load i64, ptr %"tmp#13##0" + %"tmp#4##0" = icmp eq i64 %"e##0", %"h##0" + br i1 %"tmp#4##0", label %if.then.1, label %if.else.1 +if.then.1: + ret i1 1 +if.else.1: + %"tmp#14##0" = add i64 %"lst##0", 8 + %"tmp#15##0" = inttoptr i64 %"tmp#14##0" to ptr + %"tmp#0##0" = load i64, ptr %"tmp#15##0" + %"tmp#16##0" = tail call fastcc i1 @"disjunction.in<0>"(i64 %"e##0", i64 %"tmp#0##0") + ret i1 %"tmp#16##0" +if.else.0: + ret i1 0 } - -define external fastcc i1 @"disjunction.member<0>"(i64 %"e##0", i64 %"lst##0") { -entry: - %0 = icmp ne i64 %"lst##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"lst##0" to i64* - %2 = load i64, i64* %1 - %3 = add i64 %"lst##0", 8 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = icmp eq i64 %"e##0", %2 - br i1 %6, label %if.then1, label %if.else1 -if.else: - ret i1 0 -if.then1: - ret i1 1 -if.else1: - %7 = musttail call fastcc i1 @"disjunction.member<0>"(i64 %"e##0", i64 %5) - ret i1 %7 +define external fastcc i1 @"disjunction.member<0>"(i64 %"e##0", i64 %"lst##0") { + %"tmp#4##0" = icmp ne i64 %"lst##0", 0 + br i1 %"tmp#4##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#7##0" = inttoptr i64 %"lst##0" to ptr + %"h##0" = load i64, ptr %"tmp#7##0" + %"tmp#8##0" = add i64 %"lst##0", 8 + %"tmp#9##0" = inttoptr i64 %"tmp#8##0" to ptr + %"t##0" = load i64, ptr %"tmp#9##0" + %"tmp#2##0" = icmp eq i64 %"e##0", %"h##0" + br i1 %"tmp#2##0", label %if.then.1, label %if.else.1 +if.then.1: + ret i1 1 +if.else.1: + %"tmp#10##0" = tail call fastcc i1 @"disjunction.member<0>"(i64 %"e##0", i64 %"t##0") + ret i1 %"tmp#10##0" +if.else.0: + ret i1 0 } - -define external fastcc i64 @"disjunction.saturating_tail<0>"(i64 %"lst##0") { -entry: - %0 = icmp ne i64 %"lst##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = add i64 %"lst##0", 8 - %2 = inttoptr i64 %1 to i64* - %3 = load i64, i64* %2 - ret i64 %3 -if.else: - ret i64 0 +define external fastcc i64 @"disjunction.saturating_tail<0>"(i64 %"lst##0") { + %"tmp#4##0" = icmp ne i64 %"lst##0", 0 + br i1 %"tmp#4##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#5##0" = add i64 %"lst##0", 8 + %"tmp#6##0" = inttoptr i64 %"tmp#5##0" to ptr + %"tmp#7##0" = load i64, ptr %"tmp#6##0" + ret i64 %"tmp#7##0" +if.else.0: + ret i64 0 } - -define external fastcc i64 @"disjunction.saturating_tail2<0>"(i64 %"lst##0") { -entry: - %0 = icmp ne i64 %"lst##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = add i64 %"lst##0", 8 - %2 = inttoptr i64 %1 to i64* - %3 = load i64, i64* %2 - ret i64 %3 -if.else: - ret i64 0 +define external fastcc i64 @"disjunction.saturating_tail2<0>"(i64 %"lst##0") { + %"tmp#5##0" = icmp ne i64 %"lst##0", 0 + br i1 %"tmp#5##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#6##0" = add i64 %"lst##0", 8 + %"tmp#7##0" = inttoptr i64 %"tmp#6##0" to ptr + %"tmp#8##0" = load i64, ptr %"tmp#7##0" + ret i64 %"tmp#8##0" +if.else.0: + ret i64 0 } diff --git a/test-cases/final-dump/disjunctive-cond.exp b/test-cases/final-dump/disjunctive-cond.exp index c5a555722..61fe7609c 100644 --- a/test-cases/final-dump/disjunctive-cond.exp +++ b/test-cases/final-dump/disjunctive-cond.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module disjunctive-cond representation : (not a type) public submods : @@ -118,128 +121,94 @@ proc #cont#3 > {semipure} (7 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'disjunctive-cond' - - - - -@disjunctive-cond.5 = constant {i64, i64} { i64 7, i64 ptrtoint ([?? x i8]* @disjunctive-cond.4 to i64) } - - -@disjunctive-cond.1 = constant {i64, i64} { i64 8, i64 ptrtoint ([?? x i8]* @disjunctive-cond.0 to i64) } - - -@disjunctive-cond.3 = constant {i64, i64} { i64 9, i64 ptrtoint ([?? x i8]* @disjunctive-cond.2 to i64) } - - -@disjunctive-cond.7 = constant {i64, i64} { i64 9, i64 ptrtoint ([?? x i8]* @disjunctive-cond.6 to i64) } - - -@disjunctive-cond.9 = constant {i64, i64} { i64 10, i64 ptrtoint ([?? x i8]* @disjunctive-cond.8 to i64) } - - -@disjunctive-cond.0 = constant [?? x i8] c"all good\00" - - -@disjunctive-cond.2 = constant [?? x i8] c"also good\00" - - -@disjunctive-cond.6 = constant [?? x i8] c"more good\00" - - -@disjunctive-cond.4 = constant [?? x i8] c"no good\00" - - -@disjunctive-cond.8 = constant [?? x i8] c"still good\00" - - -declare external ccc void @putchar(i8) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"disjunctive-cond.<0>"() { -entry: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @disjunctive-cond.1, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"disjunctive-cond.#cont#1<0>"(i1 1, i1 0) - ret void +source_filename = "!ROOT!/final-dump/disjunctive-cond.wybe" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c"all good\00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c"also good\00", align 8 +@"cstring#2" = private unnamed_addr constant [ ?? x i8 ] c"more good\00", align 8 +@"cstring#3" = private unnamed_addr constant [ ?? x i8 ] c"no good\00", align 8 +@"cstring#4" = private unnamed_addr constant [ ?? x i8 ] c"still good\00", align 8 +@"string#5" = private unnamed_addr constant {i64, i64} { i64 8, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +@"string#6" = private unnamed_addr constant {i64, i64} { i64 9, i64 ptrtoint( ptr @"cstring#1" to i64 ) }, align 8 +@"string#7" = private unnamed_addr constant {i64, i64} { i64 9, i64 ptrtoint( ptr @"cstring#2" to i64 ) }, align 8 +@"string#8" = private unnamed_addr constant {i64, i64} { i64 7, i64 ptrtoint( ptr @"cstring#3" to i64 ) }, align 8 +@"string#9" = private unnamed_addr constant {i64, i64} { i64 10, i64 ptrtoint( ptr @"cstring#4" to i64 ) }, align 8 + +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"disjunctive-cond.<0>"() { + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#5" to i64 )) + call ccc void @putchar(i8 10) + tail call fastcc void @"disjunctive-cond.#cont#1<0>"(i1 1, i1 0) + ret void } - -define external fastcc void @"disjunctive-cond.#cont#1<0>"(i1 %"a##0", i1 %"b##0") { -entry: - br i1 %"a##0", label %if.then, label %if.else -if.then: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @disjunctive-cond.3, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - musttail call fastcc void @"disjunctive-cond.#cont#2<0>"(i1 1, i1 %"b##0") - ret void -if.else: - br i1 %"b##0", label %if.then1, label %if.else1 -if.then1: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @disjunctive-cond.3, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - musttail call fastcc void @"disjunctive-cond.#cont#2<0>"(i1 0, i1 1) - ret void -if.else1: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @disjunctive-cond.5, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - musttail call fastcc void @"disjunctive-cond.#cont#2<0>"(i1 0, i1 0) - ret void +define external fastcc void @"disjunctive-cond.#cont#1<0>"(i1 %"a##0", i1 %"b##0") { + br i1 %"a##0", label %if.then.0, label %if.else.0 +if.then.0: + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#6" to i64 )) + call ccc void @putchar(i8 10) + tail call fastcc void @"disjunctive-cond.#cont#2<0>"(i1 1, i1 %"b##0") + ret void +if.else.0: + br i1 %"b##0", label %if.then.1, label %if.else.1 +if.then.1: + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#6" to i64 )) + call ccc void @putchar(i8 10) + tail call fastcc void @"disjunctive-cond.#cont#2<0>"(i1 0, i1 1) + ret void +if.else.1: + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#8" to i64 )) + call ccc void @putchar(i8 10) + tail call fastcc void @"disjunctive-cond.#cont#2<0>"(i1 0, i1 0) + ret void } - -define external fastcc void @"disjunctive-cond.#cont#2<0>"(i1 %"a##0", i1 %"b##0") { -entry: - br i1 %"a##0", label %if.then, label %if.else -if.then: - br i1 %"b##0", label %if.then1, label %if.else1 -if.else: - %0 = xor i1 %"b##0", 1 - br i1 %0, label %if.then2, label %if.else2 -if.then1: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @disjunctive-cond.5, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - musttail call fastcc void @"disjunctive-cond.#cont#3<0>"(i1 1, i1 1) - ret void -if.else1: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @disjunctive-cond.7, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - musttail call fastcc void @"disjunctive-cond.#cont#3<0>"(i1 1, i1 0) - ret void -if.then2: - musttail call fastcc void @"disjunctive-cond.#cont#3<0>"(i1 0, i1 %"b##0") - ret void -if.else2: - musttail call fastcc void @"disjunctive-cond.#cont#3<0>"(i1 0, i1 %"b##0") - ret void +define external fastcc void @"disjunctive-cond.#cont#2<0>"(i1 %"a##0", i1 %"b##0") { + br i1 %"a##0", label %if.then.0, label %if.else.0 +if.then.0: + br i1 %"b##0", label %if.then.1, label %if.else.1 +if.then.1: + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#8" to i64 )) + call ccc void @putchar(i8 10) + tail call fastcc void @"disjunctive-cond.#cont#3<0>"(i1 1, i1 1) + ret void +if.else.1: + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#7" to i64 )) + call ccc void @putchar(i8 10) + tail call fastcc void @"disjunctive-cond.#cont#3<0>"(i1 1, i1 0) + ret void +if.else.0: + %"tmp#2##0" = xor i1 %"b##0", 1 + br i1 %"tmp#2##0", label %if.then.2, label %if.else.2 +if.then.2: + tail call fastcc void @"disjunctive-cond.#cont#3<0>"(i1 0, i1 %"b##0") + ret void +if.else.2: + tail call fastcc void @"disjunctive-cond.#cont#3<0>"(i1 0, i1 %"b##0") + ret void } - -define external fastcc void @"disjunctive-cond.#cont#3<0>"(i1 %"a##0", i1 %"b##0") { -entry: - br i1 %"a##0", label %if.then, label %if.else -if.then: - br i1 %"b##0", label %if.then1, label %if.else1 -if.else: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @disjunctive-cond.9, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - ret void -if.then1: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @disjunctive-cond.5, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - ret void -if.else1: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @disjunctive-cond.9, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"disjunctive-cond.#cont#3<0>"(i1 %"a##0", i1 %"b##0") { + br i1 %"a##0", label %if.then.0, label %if.else.0 +if.then.0: + br i1 %"b##0", label %if.then.1, label %if.else.1 +if.then.1: + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#8" to i64 )) + call ccc void @putchar(i8 10) + ret void +if.else.1: + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#9" to i64 )) + call ccc void @putchar(i8 10) + ret void +if.else.0: + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#9" to i64 )) + call ccc void @putchar(i8 10) + ret void } diff --git a/test-cases/final-dump/dont_care_constraint.exp b/test-cases/final-dump/dont_care_constraint.exp index ca89a271a..c8363fdc8 100644 --- a/test-cases/final-dump/dont_care_constraint.exp +++ b/test-cases/final-dump/dont_care_constraint.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module dont_care_constraint representation : (not a type) public submods : @@ -20,23 +23,17 @@ module top-level code > public {inline,semipure} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'dont_care_constraint' +source_filename = "!ROOT!/final-dump/dont_care_constraint.wybe" +target triple ???? - - - -declare external ccc i64 @read_line() - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) +declare external ccc i64 @read_line() +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -define external fastcc void @"dont_care_constraint.<0>"() alwaysinline { -entry: - %0 = tail call ccc i64 @read_line() - ret void +define external fastcc void @"dont_care_constraint.<0>"() { + %"tmp#2##0" = call ccc i64 @read_line() + ret void } diff --git a/test-cases/final-dump/early_error.exp b/test-cases/final-dump/early_error.exp index 93d1cb6ac..ea70e5346 100644 --- a/test-cases/final-dump/early_error.exp +++ b/test-cases/final-dump/early_error.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module early_error representation : (not a type) public submods : @@ -32,57 +35,35 @@ my_error(msg##0:wybe.string)<{}; {}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'early_error' - - - - -@early_error.1 = constant {i64, i64} { i64 17, i64 ptrtoint ([?? x i8]* @early_error.0 to i64) } - - -@early_error.3 = constant {i64, i64} { i64 31, i64 ptrtoint ([?? x i8]* @early_error.2 to i64) } - - -@early_error.0 = constant [?? x i8] c"should print this\00" - - -@early_error.2 = constant [?? x i8] c"should print this error message\00" - - -declare external ccc void @exit(i64) - - -declare external ccc void @puts(i64) - - -declare external ccc void @putchar(i8) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"early_error.<0>"() { -entry: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @early_error.1, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - tail call ccc void @puts(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @early_error.3, i32 0, i32 0) to i64)) - tail call ccc void @exit(i64 1) - ret void +source_filename = "!ROOT!/final-dump/early_error.wybe" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c"should print this\00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c"should print this error message\00", align 8 +@"string#2" = private unnamed_addr constant {i64, i64} { i64 17, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +@"string#3" = private unnamed_addr constant {i64, i64} { i64 31, i64 ptrtoint( ptr @"cstring#1" to i64 ) }, align 8 + +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @exit(i64) +declare external ccc void @putchar(i8) +declare external ccc void @puts(i64) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"early_error.<0>"() { + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#2" to i64 )) + call ccc void @putchar(i8 10) + call ccc void @puts(i64 ptrtoint( ptr @"string#3" to i64 )) + call ccc void @exit(i64 1) + ret void } - -define external fastcc void @"early_error.my_error<0>"(i64 %"msg##0") alwaysinline { -entry: - tail call ccc void @puts(i64 %"msg##0") - tail call ccc void @exit(i64 1) - ret void +define external fastcc void @"early_error.my_error<0>"(i64 %"msg##0") { + call ccc void @puts(i64 %"msg##0") + call ccc void @exit(i64 1) + ret void } final-dump/early_error.wybe:3:2: In module top-level code, this statement is unreachable  diff --git a/test-cases/final-dump/early_exit.exp b/test-cases/final-dump/early_exit.exp index 0a7630403..ad4b29eef 100644 --- a/test-cases/final-dump/early_exit.exp +++ b/test-cases/final-dump/early_exit.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module early_exit representation : (not a type) public submods : @@ -22,39 +25,25 @@ module top-level code > public {semipure} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'early_exit' +source_filename = "!ROOT!/final-dump/early_exit.wybe" +target triple ???? - - - -@early_exit.1 = constant {i64, i64} { i64 17, i64 ptrtoint ([?? x i8]* @early_exit.0 to i64) } - - -@early_exit.0 = constant [?? x i8] c"should print this\00" - - -declare external ccc void @exit(i64) - - -declare external ccc void @putchar(i8) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c"should print this\00", align 8 +@"string#1" = private unnamed_addr constant {i64, i64} { i64 17, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @exit(i64) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -define external fastcc void @"early_exit.<0>"() { -entry: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @early_exit.1, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - tail call ccc void @exit(i64 1) - ret void +define external fastcc void @"early_exit.<0>"() { + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#1" to i64 )) + call ccc void @putchar(i8 10) + call ccc void @exit(i64 1) + ret void } final-dump/early_exit.wybe:3:2: In module top-level code, this statement is unreachable  diff --git a/test-cases/final-dump/early_exit2.exp b/test-cases/final-dump/early_exit2.exp index f089a26c5..b8529ed25 100644 --- a/test-cases/final-dump/early_exit2.exp +++ b/test-cases/final-dump/early_exit2.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module early_exit2 representation : (not a type) public submods : @@ -30,46 +33,30 @@ my_exit(code##0:wybe.int)<{}; {}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'early_exit2' +source_filename = "!ROOT!/final-dump/early_exit2.wybe" +target triple ???? - - - -@early_exit2.1 = constant {i64, i64} { i64 17, i64 ptrtoint ([?? x i8]* @early_exit2.0 to i64) } - - -@early_exit2.0 = constant [?? x i8] c"should print this\00" - - -declare external ccc void @exit(i64) - +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c"should print this\00", align 8 +@"string#1" = private unnamed_addr constant {i64, i64} { i64 17, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 -declare external ccc void @putchar(i8) +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @exit(i64) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"early_exit2.<0>"() { -entry: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @early_exit2.1, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - tail call ccc void @exit(i64 1) - ret void +define external fastcc void @"early_exit2.<0>"() { + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#1" to i64 )) + call ccc void @putchar(i8 10) + call ccc void @exit(i64 1) + ret void } - -define external fastcc void @"early_exit2.my_exit<0>"(i64 %"code##0") alwaysinline { -entry: - tail call ccc void @exit(i64 %"code##0") - ret void +define external fastcc void @"early_exit2.my_exit<0>"(i64 %"code##0") { + call ccc void @exit(i64 %"code##0") + ret void } final-dump/early_exit2.wybe:3:2: In module top-level code, this statement is unreachable  diff --git a/test-cases/final-dump/empty.exp b/test-cases/final-dump/empty.exp index 8760cf6d9..687abe9ef 100644 --- a/test-cases/final-dump/empty.exp +++ b/test-cases/final-dump/empty.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module empty representation : (not a type) public submods : @@ -12,13 +15,11 @@ AFTER EVERYTHING: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'empty' - - - - -declare external ccc i8* @wybe_malloc(i32) +source_filename = "!ROOT!/final-dump/empty.wybe" +target triple ???? -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) diff --git a/test-cases/final-dump/eof_comment.exp b/test-cases/final-dump/eof_comment.exp index 06192f0a2..170617e6e 100644 --- a/test-cases/final-dump/eof_comment.exp +++ b/test-cases/final-dump/eof_comment.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module eof_comment representation : (not a type) public submods : @@ -21,33 +24,21 @@ module top-level code > public {inline,semipure} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'eof_comment' +source_filename = "!ROOT!/final-dump/eof_comment.wybe" +target triple ???? - - - -@eof_comment.1 = constant {i64, i64} { i64 10, i64 ptrtoint ([?? x i8]* @eof_comment.0 to i64) } - - -@eof_comment.0 = constant [?? x i8] c"Wominjeka!\00" - - -declare external ccc void @putchar(i8) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c"Wominjeka!\00", align 8 +@"string#1" = private unnamed_addr constant {i64, i64} { i64 10, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -define external fastcc void @"eof_comment.<0>"() alwaysinline { -entry: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @eof_comment.1, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"eof_comment.<0>"() { + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#1" to i64 )) + call ccc void @putchar(i8 10) + ret void } diff --git a/test-cases/final-dump/exp_if.exp b/test-cases/final-dump/exp_if.exp index 70c234751..ed8f19d40 100644 --- a/test-cases/final-dump/exp_if.exp +++ b/test-cases/final-dump/exp_if.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module exp_if representation : (not a type) public submods : @@ -36,54 +39,34 @@ if_test(x##0:wybe.int, ?#result##0:wybe.string)<{}; {}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'exp_if' +source_filename = "!ROOT!/final-dump/exp_if.wybe" +target triple ???? - - - -@exp_if.3 = constant {i64, i64} { i64 6, i64 ptrtoint ([?? x i8]* @exp_if.2 to i64) } - - -@exp_if.5 = constant {i64, i64} { i64 7, i64 ptrtoint ([?? x i8]* @exp_if.4 to i64) } - - -@exp_if.1 = constant {i64, i64} { i64 15, i64 ptrtoint ([?? x i8]* @exp_if.0 to i64) } - - -@exp_if.0 = constant [?? x i8] c"expect larger: \00" - +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c"expect larger: \00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c"larger\00", align 8 +@"cstring#2" = private unnamed_addr constant [ ?? x i8 ] c"smaller\00", align 8 +@"string#3" = private unnamed_addr constant {i64, i64} { i64 15, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +@"string#4" = private unnamed_addr constant {i64, i64} { i64 6, i64 ptrtoint( ptr @"cstring#1" to i64 ) }, align 8 +@"string#5" = private unnamed_addr constant {i64, i64} { i64 7, i64 ptrtoint( ptr @"cstring#2" to i64 ) }, align 8 -@exp_if.2 = constant [?? x i8] c"larger\00" +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) - -@exp_if.4 = constant [?? x i8] c"smaller\00" - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"exp_if.<0>"() alwaysinline { -entry: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @exp_if.1, i32 0, i32 0) to i64)) - %0 = tail call fastcc i64 @"exp_if.if_test<0>"(i64 3) - tail call fastcc void @"wybe.string.print<0>"(i64 %0) - ret void +define external fastcc void @"exp_if.<0>"() { + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#3" to i64 )) + %"tmp#0##0" = tail call fastcc i64 @"exp_if.if_test<0>"(i64 3) + tail call fastcc void @"wybe.string.print<0>"(i64 %"tmp#0##0") + ret void } - -define external fastcc i64 @"exp_if.if_test<0>"(i64 %"x##0") { -entry: - %0 = icmp sgt i64 %"x##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - ret i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @exp_if.3, i32 0, i32 0) to i64) -if.else: - ret i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @exp_if.5, i32 0, i32 0) to i64) +define external fastcc i64 @"exp_if.if_test<0>"(i64 %"x##0") { + %"tmp#1##0" = icmp sgt i64 %"x##0", 0 + br i1 %"tmp#1##0", label %if.then.0, label %if.else.0 +if.then.0: + ret i64 ptrtoint( ptr @"string#4" to i64 ) +if.else.0: + ret i64 ptrtoint( ptr @"string#5" to i64 ) } diff --git a/test-cases/final-dump/exp_print.exp b/test-cases/final-dump/exp_print.exp index 6c5b5f46e..6db977a47 100644 --- a/test-cases/final-dump/exp_print.exp +++ b/test-cases/final-dump/exp_print.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module exp_print representation : (not a type) public submods : @@ -31,50 +34,32 @@ module top-level code > public {semipure} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'exp_print' - - - - -@exp_print.1 = constant {i64, i64} { i64 41, i64 ptrtoint ([?? x i8]* @exp_print.0 to i64) } - - -@exp_print.3 = constant {i64, i64} { i64 45, i64 ptrtoint ([?? x i8]* @exp_print.2 to i64) } - - -@exp_print.0 = constant [?? x i8] c"print(x:string) creates a newline already\00" - - -@exp_print.2 = constant [?? x i8] c"println(x:string) generates an extra newline?\00" - - -declare external ccc void @print_int(i64) - - -declare external ccc void @putchar(i8) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"exp_print.<0>"() { -entry: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @exp_print.1, i32 0, i32 0) to i64)) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @exp_print.3, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @exp_print.3, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - tail call ccc void @putchar(i8 99) - tail call ccc void @putchar(i8 10) - tail call ccc void @print_int(i64 1) - tail call ccc void @putchar(i8 10) - tail call ccc void @print_int(i64 1) - ret void +source_filename = "!ROOT!/final-dump/exp_print.wybe" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c"print(x:string) creates a newline already\00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c"println(x:string) generates an extra newline?\00", align 8 +@"string#2" = private unnamed_addr constant {i64, i64} { i64 41, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +@"string#3" = private unnamed_addr constant {i64, i64} { i64 45, i64 ptrtoint( ptr @"cstring#1" to i64 ) }, align 8 + +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"exp_print.<0>"() { + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#2" to i64 )) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#3" to i64 )) + call ccc void @putchar(i8 10) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#3" to i64 )) + call ccc void @putchar(i8 10) + call ccc void @putchar(i8 99) + call ccc void @putchar(i8 10) + call ccc void @print_int(i64 1) + call ccc void @putchar(i8 10) + call ccc void @print_int(i64 1) + ret void } diff --git a/test-cases/final-dump/exp_simple.exp b/test-cases/final-dump/exp_simple.exp index eee84952c..b00d77f12 100644 --- a/test-cases/final-dump/exp_simple.exp +++ b/test-cases/final-dump/exp_simple.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module exp_simple representation : (not a type) public submods : @@ -41,55 +44,37 @@ foreign_add(?#result##0:wybe.int)<{}; {}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'exp_simple' - - - - -@exp_simple.1 = constant {i64, i64} { i64 5, i64 ptrtoint ([?? x i8]* @exp_simple.0 to i64) } - - -@exp_simple.0 = constant [?? x i8] c"hello\00" - - -declare external ccc void @print_int(i64) - - -declare external ccc void @putchar(i8) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc void @print_float(double) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"exp_simple.<0>"() { -entry: - tail call ccc void @print_int(i64 3) - tail call ccc void @putchar(i8 10) - tail call ccc void @print_float(double 3.600000e0) - tail call ccc void @putchar(i8 10) - tail call ccc void @putchar(i8 104) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @exp_simple.1, i32 0, i32 0) to i64)) - tail call ccc void @print_int(i64 3) - tail call ccc void @putchar(i8 10) - tail call ccc void @print_int(i64 1001) - tail call ccc void @putchar(i8 10) - tail call ccc void @print_int(i64 3) - ret void +source_filename = "!ROOT!/final-dump/exp_simple.wybe" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c"hello\00", align 8 +@"string#1" = private unnamed_addr constant {i64, i64} { i64 5, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 + +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @print_float(double) +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"exp_simple.<0>"() { + call ccc void @print_int(i64 3) + call ccc void @putchar(i8 10) + call ccc void @print_float(double 3.5999999999999996) + call ccc void @putchar(i8 10) + call ccc void @putchar(i8 104) + call ccc void @putchar(i8 10) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#1" to i64 )) + call ccc void @print_int(i64 3) + call ccc void @putchar(i8 10) + call ccc void @print_int(i64 1001) + call ccc void @putchar(i8 10) + call ccc void @print_int(i64 3) + ret void } - -define external fastcc i64 @"exp_simple.foreign_add<0>"() alwaysinline { -entry: - ret i64 3 +define external fastcc i64 @"exp_simple.foreign_add<0>"() { + ret i64 3 } diff --git a/test-cases/final-dump/explicit_type_warning.exp b/test-cases/final-dump/explicit_type_warning.exp index b76f8c539..0df5bd3a2 100644 --- a/test-cases/final-dump/explicit_type_warning.exp +++ b/test-cases/final-dump/explicit_type_warning.exp @@ -1,7 +1,10 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module explicit_type_warning - representation : address + representation : pointer public submods : public resources: public procs : explicit_type_warning.=<0> @@ -169,198 +172,170 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'explicit_type_warning' - - - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i1 @"explicit_type_warning.=<0>"(i64 %"#left##0", i64 %"#right##0") { -entry: - %0 = icmp ne i64 %"#left##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"#left##0" to i64* - %2 = load i64, i64* %1 - %3 = add i64 %"#left##0", 8 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = icmp ne i64 %"#right##0", 0 - br i1 %6, label %if.then1, label %if.else1 -if.else: - %14 = icmp eq i64 %"#right##0", 0 - ret i1 %14 -if.then1: - %7 = inttoptr i64 %"#right##0" to i64* - %8 = load i64, i64* %7 - %9 = add i64 %"#right##0", 8 - %10 = inttoptr i64 %9 to i64* - %11 = load i64, i64* %10 - %12 = icmp eq i64 %2, %8 - br i1 %12, label %if.then2, label %if.else2 -if.else1: - ret i1 0 -if.then2: - %13 = musttail call fastcc i1 @"explicit_type_warning.=<0>"(i64 %5, i64 %11) - ret i1 %13 -if.else2: - ret i1 0 +source_filename = "!ROOT!/final-dump/explicit_type_warning.wybe" +target triple ???? + + +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc i1 @"explicit_type_warning.=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#0##0" = icmp ne i64 %"#left##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#12##0" = inttoptr i64 %"#left##0" to ptr + %"#left#h##0" = load i64, ptr %"tmp#12##0" + %"tmp#13##0" = add i64 %"#left##0", 8 + %"tmp#14##0" = inttoptr i64 %"tmp#13##0" to ptr + %"#left#t##0" = load i64, ptr %"tmp#14##0" + %"tmp#9##0" = icmp ne i64 %"#right##0", 0 + br i1 %"tmp#9##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#15##0" = inttoptr i64 %"#right##0" to ptr + %"#right#h##0" = load i64, ptr %"tmp#15##0" + %"tmp#16##0" = add i64 %"#right##0", 8 + %"tmp#17##0" = inttoptr i64 %"tmp#16##0" to ptr + %"#right#t##0" = load i64, ptr %"tmp#17##0" + %"tmp#4##0" = icmp eq i64 %"#left#h##0", %"#right#h##0" + br i1 %"tmp#4##0", label %if.then.2, label %if.else.2 +if.then.2: + %"tmp#18##0" = tail call fastcc i1 @"explicit_type_warning.=<0>"(i64 %"#left#t##0", i64 %"#right#t##0") + ret i1 %"tmp#18##0" +if.else.2: + ret i1 0 +if.else.1: + ret i1 0 +if.else.0: + %"tmp#19##0" = icmp eq i64 %"#right##0", 0 + ret i1 %"tmp#19##0" } - -define external fastcc {i64, i1} @"explicit_type_warning.h<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"#rec##0" to i64* - %2 = load i64, i64* %1 - %3 = insertvalue {i64, i1} undef, i64 %2, 0 - %4 = insertvalue {i64, i1} %3, i1 1, 1 - ret {i64, i1} %4 -if.else: - %5 = insertvalue {i64, i1} undef, i64 undef, 0 - %6 = insertvalue {i64, i1} %5, i1 0, 1 - ret {i64, i1} %6 +define external fastcc {i64, i1} @"explicit_type_warning.h<0>"(i64 %"#rec##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + %"tmp#3##0" = insertvalue {i64, i1} undef, i64 %"tmp#2##0", 0 + %"tmp#4##0" = insertvalue {i64, i1} %"tmp#3##0", i1 1, 1 + ret {i64, i1} %"tmp#4##0" +if.else.0: + %"tmp#5##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#6##0" = insertvalue {i64, i1} %"tmp#5##0", i1 0, 1 + ret {i64, i1} %"tmp#6##0" } - -define external fastcc {i64, i1} @"explicit_type_warning.h<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = trunc i64 16 to i32 - %2 = tail call ccc i8* @wybe_malloc(i32 %1) - %3 = ptrtoint i8* %2 to i64 - %4 = inttoptr i64 %3 to i8* - %5 = inttoptr i64 %"#rec##0" to i8* - %6 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %4, i8* %5, i32 %6, i1 0) - %7 = inttoptr i64 %3 to i64* - store i64 %"#field##0", i64* %7 - %8 = insertvalue {i64, i1} undef, i64 %3, 0 - %9 = insertvalue {i64, i1} %8, i1 1, 1 - ret {i64, i1} %9 -if.else: - %10 = insertvalue {i64, i1} undef, i64 0, 0 - %11 = insertvalue {i64, i1} %10, i1 0, 1 - ret {i64, i1} %11 +define external fastcc {i64, i1} @"explicit_type_warning.h<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#2##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#2##0", ptr %"tmp#1##0", i64 16, i1 0) + %"tmp#3##0" = ptrtoint ptr %"tmp#2##0" to i64 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 %"#field##0", ptr %"tmp#4##0" + %"tmp#5##0" = insertvalue {i64, i1} undef, i64 %"tmp#3##0", 0 + %"tmp#6##0" = insertvalue {i64, i1} %"tmp#5##0", i1 1, 1 + ret {i64, i1} %"tmp#6##0" +if.else.0: + %"tmp#7##0" = insertvalue {i64, i1} undef, i64 0, 0 + %"tmp#8##0" = insertvalue {i64, i1} %"tmp#7##0", i1 0, 1 + ret {i64, i1} %"tmp#8##0" } - -define external fastcc i64 @"explicit_type_warning.mt<0>"() alwaysinline { -entry: - ret i64 0 +define external fastcc i64 @"explicit_type_warning.mt<0>"() { + ret i64 0 } - -define external fastcc i64 @"explicit_type_warning.oops<0>"(i64 %"h##0", i64 %"t##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"h##0", i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"t##0", i64* %5 - ret i64 %2 +define external fastcc i64 @"explicit_type_warning.oops<0>"(i64 %"h##0", i64 %"t##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 16) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"h##0", ptr %"tmp#1##0" + %"tmp#2##0" = add i64 %"#rec##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"t##0", ptr %"tmp#3##0" + ret i64 %"#rec##0" } - -define external fastcc {i64, i64, i1} @"explicit_type_warning.oops<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#result##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"#result##0" to i64* - %2 = load i64, i64* %1 - %3 = add i64 %"#result##0", 8 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = insertvalue {i64, i64, i1} undef, i64 %2, 0 - %7 = insertvalue {i64, i64, i1} %6, i64 %5, 1 - %8 = insertvalue {i64, i64, i1} %7, i1 1, 2 - ret {i64, i64, i1} %8 -if.else: - %9 = insertvalue {i64, i64, i1} undef, i64 undef, 0 - %10 = insertvalue {i64, i64, i1} %9, i64 undef, 1 - %11 = insertvalue {i64, i64, i1} %10, i1 0, 2 - ret {i64, i64, i1} %11 +define external fastcc {i64, i64, i1} @"explicit_type_warning.oops<1>"(i64 %"#result##0") { + %"tmp#0##0" = icmp ne i64 %"#result##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = inttoptr i64 %"#result##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + %"tmp#3##0" = add i64 %"#result##0", 8 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#4##0" + %"tmp#6##0" = insertvalue {i64, i64, i1} undef, i64 %"tmp#2##0", 0 + %"tmp#7##0" = insertvalue {i64, i64, i1} %"tmp#6##0", i64 %"tmp#5##0", 1 + %"tmp#8##0" = insertvalue {i64, i64, i1} %"tmp#7##0", i1 1, 2 + ret {i64, i64, i1} %"tmp#8##0" +if.else.0: + %"tmp#9##0" = insertvalue {i64, i64, i1} undef, i64 undef, 0 + %"tmp#10##0" = insertvalue {i64, i64, i1} %"tmp#9##0", i64 undef, 1 + %"tmp#11##0" = insertvalue {i64, i64, i1} %"tmp#10##0", i1 0, 2 + ret {i64, i64, i1} %"tmp#11##0" } - -define external fastcc i64 @"explicit_type_warning.oops2<0>"(i64 %"l##0") { -entry: - %0 = icmp ne i64 %"l##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = add i64 %"l##0", 8 - %2 = inttoptr i64 %1 to i64* - %3 = load i64, i64* %2 - %4 = tail call fastcc i64 @"explicit_type_warning.oops2<0>"(i64 %3) - %5 = add i64 %4, 1 - ret i64 %5 -if.else: - ret i64 0 +define external fastcc i64 @"explicit_type_warning.oops2<0>"(i64 %"l##0") { + %"tmp#6##0" = icmp ne i64 %"l##0", 0 + br i1 %"tmp#6##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#9##0" = add i64 %"l##0", 8 + %"tmp#10##0" = inttoptr i64 %"tmp#9##0" to ptr + %"t##0" = load i64, ptr %"tmp#10##0" + %"tmp#3##0" = tail call fastcc i64 @"explicit_type_warning.oops2<0>"(i64 %"t##0") + %"tmp#11##0" = add i64 %"tmp#3##0", 1 + ret i64 %"tmp#11##0" +if.else.0: + ret i64 0 } - -define external fastcc {i64, i1} @"explicit_type_warning.t<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = add i64 %"#rec##0", 8 - %2 = inttoptr i64 %1 to i64* - %3 = load i64, i64* %2 - %4 = insertvalue {i64, i1} undef, i64 %3, 0 - %5 = insertvalue {i64, i1} %4, i1 1, 1 - ret {i64, i1} %5 -if.else: - %6 = insertvalue {i64, i1} undef, i64 undef, 0 - %7 = insertvalue {i64, i1} %6, i1 0, 1 - ret {i64, i1} %7 +define external fastcc {i64, i1} @"explicit_type_warning.t<0>"(i64 %"#rec##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = add i64 %"#rec##0", 8 + %"tmp#2##0" = inttoptr i64 %"tmp#1##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#2##0" + %"tmp#4##0" = insertvalue {i64, i1} undef, i64 %"tmp#3##0", 0 + %"tmp#5##0" = insertvalue {i64, i1} %"tmp#4##0", i1 1, 1 + ret {i64, i1} %"tmp#5##0" +if.else.0: + %"tmp#6##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#7##0" = insertvalue {i64, i1} %"tmp#6##0", i1 0, 1 + ret {i64, i1} %"tmp#7##0" } - -define external fastcc {i64, i1} @"explicit_type_warning.t<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = trunc i64 16 to i32 - %2 = tail call ccc i8* @wybe_malloc(i32 %1) - %3 = ptrtoint i8* %2 to i64 - %4 = inttoptr i64 %3 to i8* - %5 = inttoptr i64 %"#rec##0" to i8* - %6 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %4, i8* %5, i32 %6, i1 0) - %7 = add i64 %3, 8 - %8 = inttoptr i64 %7 to i64* - store i64 %"#field##0", i64* %8 - %9 = insertvalue {i64, i1} undef, i64 %3, 0 - %10 = insertvalue {i64, i1} %9, i1 1, 1 - ret {i64, i1} %10 -if.else: - %11 = insertvalue {i64, i1} undef, i64 0, 0 - %12 = insertvalue {i64, i1} %11, i1 0, 1 - ret {i64, i1} %12 +define external fastcc {i64, i1} @"explicit_type_warning.t<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#2##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#2##0", ptr %"tmp#1##0", i64 16, i1 0) + %"tmp#3##0" = ptrtoint ptr %"tmp#2##0" to i64 + %"tmp#4##0" = add i64 %"tmp#3##0", 8 + %"tmp#5##0" = inttoptr i64 %"tmp#4##0" to ptr + store i64 %"#field##0", ptr %"tmp#5##0" + %"tmp#6##0" = insertvalue {i64, i1} undef, i64 %"tmp#3##0", 0 + %"tmp#7##0" = insertvalue {i64, i1} %"tmp#6##0", i1 1, 1 + ret {i64, i1} %"tmp#7##0" +if.else.0: + %"tmp#8##0" = insertvalue {i64, i1} undef, i64 0, 0 + %"tmp#9##0" = insertvalue {i64, i1} %"tmp#8##0", i1 0, 1 + ret {i64, i1} %"tmp#9##0" } - -define external fastcc i1 @"explicit_type_warning.~=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = tail call fastcc i1 @"explicit_type_warning.=<0>"(i64 %"#left##0", i64 %"#right##0") - %1 = xor i1 %0, 1 - ret i1 %1 +define external fastcc i1 @"explicit_type_warning.~=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#0##0" = tail call fastcc i1 @"explicit_type_warning.=<0>"(i64 %"#left##0", i64 %"#right##0") + %"tmp#1##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#1##0" } final-dump/explicit_type_warning.wybe:3:31: Explicit specification of current type explicit_type_warning, it is recommended to specify type as _ diff --git a/test-cases/final-dump/exporter.exp b/test-cases/final-dump/exporter.exp index 3b7caa4ba..7a40f45e3 100644 --- a/test-cases/final-dump/exporter.exp +++ b/test-cases/final-dump/exporter.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module exporter representation : (not a type) public submods : @@ -27,33 +30,23 @@ three(?n##0:wybe.int)<{<>}; {}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'exporter' +source_filename = "!ROOT!/final-dump/exporter.wybe" +target triple ???? - - - -@"resource#exporter.res" = global i64 undef - - -declare external ccc i64 @ipow(i64, i64) +declare external ccc i64 @ipow(i64, i64) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) +@"resource#exporter.res" = global i64 undef -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i64 @"exporter.fn<0>"(i64 %"i##0") alwaysinline { -entry: - %0 = tail call ccc i64 @ipow(i64 2, i64 %"i##0") - ret i64 %0 +define external fastcc i64 @"exporter.fn<0>"(i64 %"i##0") { + %"tmp#3##0" = call ccc i64 @ipow(i64 2, i64 %"i##0") + ret i64 %"tmp#3##0" } - -define external fastcc i64 @"exporter.three<0>"() alwaysinline { -entry: - %0 = load i64, i64* @"resource#exporter.res" - ret i64 %0 +define external fastcc i64 @"exporter.three<0>"() { + %"tmp#1##0" = load i64, ptr @"resource#exporter.res" + ret i64 %"tmp#1##0" } diff --git a/test-cases/final-dump/extern_anon_params_a.exp b/test-cases/final-dump/extern_anon_params_a.exp index 0fc398a7d..de4764641 100644 --- a/test-cases/final-dump/extern_anon_params_a.exp +++ b/test-cases/final-dump/extern_anon_params_a.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module extern_anon_params_a representation : (not a type) public submods : @@ -41,53 +44,41 @@ run#anon#1(^func##0:{impure}())<{}; {}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'extern_anon_params_a' - - - - -declare external ccc i8* @wybe_malloc(i32) +source_filename = "!ROOT!/final-dump/extern_anon_params_a.wybe" +target triple ???? -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) - -define external fastcc void @"extern_anon_params_a.need<0>"(i64 %"stmt##0") alwaysinline { -entry: - %0 = inttoptr i64 %"stmt##0" to i64* - %1 = load i64, i64* %0 - %2 = inttoptr i64 %1 to void (i64)* - tail call fastcc void %2(i64 %"stmt##0") - ret void +define external fastcc void @"extern_anon_params_a.need<0>"(i64 %"stmt##0") { + %"tmp#1##0" = inttoptr i64 %"stmt##0" to ptr + %"tmp#0##0" = load ptr, ptr %"tmp#1##0" + tail call fastcc void %"tmp#0##0"(i64 %"stmt##0") + ret void } - -define external fastcc void @"extern_anon_params_a.run<0>"(i64 %"func##0") alwaysinline { -entry: - musttail call fastcc void @"extern_anon_params_a.run#anon#1<0>"(i64 %"func##0") - ret void +define external fastcc void @"extern_anon_params_a.run<0>"(i64 %"func##0") { + tail call fastcc void @"extern_anon_params_a.run#anon#1<0>"(i64 %"func##0") + ret void } - -define external fastcc void @"extern_anon_params_a.run#anon#1<0>"(i64 %"func##0") alwaysinline { -entry: - %0 = inttoptr i64 %"func##0" to i64* - %1 = load i64, i64* %0 - %2 = inttoptr i64 %1 to void (i64)* - tail call fastcc void %2(i64 %"func##0") - ret void +define external fastcc void @"extern_anon_params_a.run#anon#1<0>"(i64 %"func##0") { + %"tmp#1##0" = inttoptr i64 %"func##0" to ptr + %"tmp#0##0" = load ptr, ptr %"tmp#1##0" + tail call fastcc void %"tmp#0##0"(i64 %"func##0") + ret void } - -define external fastcc void @"extern_anon_params_a.run#anon#1<1>"(i64 %"#env##0") alwaysinline { -entry: - %0 = add i64 %"#env##0", 8 - %1 = inttoptr i64 %0 to i64* - %2 = load i64, i64* %1 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %4 to void (i64)* - tail call fastcc void %5(i64 %2) - ret void +define external fastcc void @"extern_anon_params_a.run#anon#1<1>"(i64 %"#env##0") { + %"tmp#1##0" = add i64 %"#env##0", 8 + %"tmp#2##0" = inttoptr i64 %"tmp#1##0" to ptr + %"generic#func##0" = load i64, ptr %"tmp#2##0" + %"func##0" = bitcast i64 %"generic#func##0" to i64 + %"tmp#4##0" = inttoptr i64 %"func##0" to ptr + %"tmp#3##0" = load ptr, ptr %"tmp#4##0" + tail call fastcc void %"tmp#3##0"(i64 %"func##0") + ret void } diff --git a/test-cases/final-dump/extern_anon_params_b.exp b/test-cases/final-dump/extern_anon_params_b.exp index 8838bf2bb..c5633b6ba 100644 --- a/test-cases/final-dump/extern_anon_params_b.exp +++ b/test-cases/final-dump/extern_anon_params_b.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module extern_anon_params_a representation : (not a type) public submods : @@ -41,56 +44,45 @@ run#anon#1(^func##0:{impure}())<{}; {}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'extern_anon_params_a' - - - - -declare external ccc i8* @wybe_malloc(i32) +source_filename = "!ROOT!/final-dump/extern_anon_params_a.wybe" +target triple ???? -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) - -define external fastcc void @"extern_anon_params_a.need<0>"(i64 %"stmt##0") alwaysinline { -entry: - %0 = inttoptr i64 %"stmt##0" to i64* - %1 = load i64, i64* %0 - %2 = inttoptr i64 %1 to void (i64)* - tail call fastcc void %2(i64 %"stmt##0") - ret void +define external fastcc void @"extern_anon_params_a.need<0>"(i64 %"stmt##0") { + %"tmp#1##0" = inttoptr i64 %"stmt##0" to ptr + %"tmp#0##0" = load ptr, ptr %"tmp#1##0" + tail call fastcc void %"tmp#0##0"(i64 %"stmt##0") + ret void } - -define external fastcc void @"extern_anon_params_a.run<0>"(i64 %"func##0") alwaysinline { -entry: - musttail call fastcc void @"extern_anon_params_a.run#anon#1<0>"(i64 %"func##0") - ret void +define external fastcc void @"extern_anon_params_a.run<0>"(i64 %"func##0") { + tail call fastcc void @"extern_anon_params_a.run#anon#1<0>"(i64 %"func##0") + ret void } - -define external fastcc void @"extern_anon_params_a.run#anon#1<0>"(i64 %"func##0") alwaysinline { -entry: - %0 = inttoptr i64 %"func##0" to i64* - %1 = load i64, i64* %0 - %2 = inttoptr i64 %1 to void (i64)* - tail call fastcc void %2(i64 %"func##0") - ret void +define external fastcc void @"extern_anon_params_a.run#anon#1<0>"(i64 %"func##0") { + %"tmp#1##0" = inttoptr i64 %"func##0" to ptr + %"tmp#0##0" = load ptr, ptr %"tmp#1##0" + tail call fastcc void %"tmp#0##0"(i64 %"func##0") + ret void } - -define external fastcc void @"extern_anon_params_a.run#anon#1<1>"(i64 %"#env##0") alwaysinline { -entry: - %0 = add i64 %"#env##0", 8 - %1 = inttoptr i64 %0 to i64* - %2 = load i64, i64* %1 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %4 to void (i64)* - tail call fastcc void %5(i64 %2) - ret void +define external fastcc void @"extern_anon_params_a.run#anon#1<1>"(i64 %"#env##0") { + %"tmp#1##0" = add i64 %"#env##0", 8 + %"tmp#2##0" = inttoptr i64 %"tmp#1##0" to ptr + %"generic#func##0" = load i64, ptr %"tmp#2##0" + %"func##0" = bitcast i64 %"generic#func##0" to i64 + %"tmp#4##0" = inttoptr i64 %"func##0" to ptr + %"tmp#3##0" = load ptr, ptr %"tmp#4##0" + tail call fastcc void %"tmp#3##0"(i64 %"func##0") + ret void } + -------------------------------------------------- Module extern_anon_params_b representation : (not a type) @@ -123,38 +115,26 @@ proc #anon#1 > {inline,impure} (1 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'extern_anon_params_b' +source_filename = "!ROOT!/final-dump/extern_anon_params_b.wybe" +target triple ???? - +@"closure#0" = private unnamed_addr constant {ptr} { ptr @"extern_anon_params_b.#anon#1<1>" }, align 8 +declare external fastcc void @"extern_anon_params_a.run#anon#1<0>"(i64) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -@extern_anon_params_b.0 = constant [1 x i64] [i64 ptrtoint (void (i64)* @"extern_anon_params_b.#anon#1<1>" to i64)] - - -declare external fastcc void @"extern_anon_params_a.run#anon#1<0>"(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"extern_anon_params_b.<0>"() alwaysinline { -entry: - tail call fastcc void @"extern_anon_params_a.run#anon#1<0>"(i64 ptrtoint (i64* getelementptr inbounds ([1 x i64], [1 x i64]* @extern_anon_params_b.0, i32 0, i32 0) to i64)) - ret void +define external fastcc void @"extern_anon_params_b.<0>"() { + tail call fastcc void @"extern_anon_params_a.run#anon#1<0>"(i64 ptrtoint( ptr @"closure#0" to i64 )) + ret void } - -define external fastcc void @"extern_anon_params_b.#anon#1<0>"() alwaysinline { -entry: - ret void +define external fastcc void @"extern_anon_params_b.#anon#1<0>"() { + ret void } - -define external fastcc void @"extern_anon_params_b.#anon#1<1>"(i64 %"#env##0") alwaysinline { -entry: - ret void +define external fastcc void @"extern_anon_params_b.#anon#1<1>"(i64 %"#env##0") { + ret void } diff --git a/test-cases/final-dump/factor_bug.exp b/test-cases/final-dump/factor_bug.exp index ae7901bbf..2f0013d15 100644 --- a/test-cases/final-dump/factor_bug.exp +++ b/test-cases/final-dump/factor_bug.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module factor_bug representation : (not a type) public submods : @@ -44,45 +47,31 @@ test(?#result##0:wybe.bool)<{}; {}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'factor_bug' - - - - -declare external ccc void @putchar(i8) - - -declare external ccc void @print_int(i64) +source_filename = "!ROOT!/final-dump/factor_bug.wybe" +target triple ???? -declare external ccc i8* @wybe_malloc(i32) +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"factor_bug.<0>"() alwaysinline { -entry: - tail call ccc void @print_int(i64 20) - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"factor_bug.<0>"() { + call ccc void @print_int(i64 20) + call ccc void @putchar(i8 10) + ret void } - -define external fastcc i64 @"factor_bug.foo<0>"() alwaysinline { -entry: - ret i64 20 +define external fastcc i64 @"factor_bug.foo<0>"() { + ret i64 20 } - -define external fastcc void @"factor_bug.foo#cont#1<0>"(i64 %"ret##0") alwaysinline { -entry: - ret void +define external fastcc void @"factor_bug.foo#cont#1<0>"(i64 %"ret##0") { + ret void } - -define external fastcc i1 @"factor_bug.test<0>"() alwaysinline { -entry: - ret i1 0 +define external fastcc i1 @"factor_bug.test<0>"() { + ret i1 0 } diff --git a/test-cases/final-dump/failure_backtrack.exp b/test-cases/final-dump/failure_backtrack.exp index 59531beb3..d6189bf79 100644 --- a/test-cases/final-dump/failure_backtrack.exp +++ b/test-cases/final-dump/failure_backtrack.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module failure_backtrack representation : (not a type) public submods : @@ -368,443 +371,331 @@ yup(?#success##0:wybe.bool)<{}; {}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'failure_backtrack' - - - - -@"resource#failure_backtrack.r" = global i64 undef - - -@"resource#failure_backtrack.s" = global i64 undef - - -@failure_backtrack.1 = constant {i64, i64} { i64 6, i64 ptrtoint ([?? x i8]* @failure_backtrack.0 to i64) } - - -@failure_backtrack.21 = constant {i64, i64} { i64 6, i64 ptrtoint ([?? x i8]* @failure_backtrack.20 to i64) } - - -@failure_backtrack.23 = constant {i64, i64} { i64 6, i64 ptrtoint ([?? x i8]* @failure_backtrack.22 to i64) } - - -@failure_backtrack.27 = constant {i64, i64} { i64 14, i64 ptrtoint ([?? x i8]* @failure_backtrack.26 to i64) } - - -@failure_backtrack.11 = constant {i64, i64} { i64 15, i64 ptrtoint ([?? x i8]* @failure_backtrack.10 to i64) } - - -@failure_backtrack.5 = constant {i64, i64} { i64 16, i64 ptrtoint ([?? x i8]* @failure_backtrack.4 to i64) } - - -@failure_backtrack.13 = constant {i64, i64} { i64 17, i64 ptrtoint ([?? x i8]* @failure_backtrack.12 to i64) } - - -@failure_backtrack.7 = constant {i64, i64} { i64 23, i64 ptrtoint ([?? x i8]* @failure_backtrack.6 to i64) } - - -@failure_backtrack.3 = constant {i64, i64} { i64 24, i64 ptrtoint ([?? x i8]* @failure_backtrack.2 to i64) } - - -@failure_backtrack.19 = constant {i64, i64} { i64 29, i64 ptrtoint ([?? x i8]* @failure_backtrack.18 to i64) } - - -@failure_backtrack.33 = constant {i64, i64} { i64 29, i64 ptrtoint ([?? x i8]* @failure_backtrack.32 to i64) } - - -@failure_backtrack.15 = constant {i64, i64} { i64 30, i64 ptrtoint ([?? x i8]* @failure_backtrack.14 to i64) } - - -@failure_backtrack.17 = constant {i64, i64} { i64 30, i64 ptrtoint ([?? x i8]* @failure_backtrack.16 to i64) } - - -@failure_backtrack.29 = constant {i64, i64} { i64 30, i64 ptrtoint ([?? x i8]* @failure_backtrack.28 to i64) } - - -@failure_backtrack.31 = constant {i64, i64} { i64 30, i64 ptrtoint ([?? x i8]* @failure_backtrack.30 to i64) } - - -@failure_backtrack.37 = constant {i64, i64} { i64 30, i64 ptrtoint ([?? x i8]* @failure_backtrack.36 to i64) } - - -@failure_backtrack.25 = constant {i64, i64} { i64 31, i64 ptrtoint ([?? x i8]* @failure_backtrack.24 to i64) } - - -@failure_backtrack.35 = constant {i64, i64} { i64 31, i64 ptrtoint ([?? x i8]* @failure_backtrack.34 to i64) } - - -@failure_backtrack.9 = constant {i64, i64} { i64 31, i64 ptrtoint ([?? x i8]* @failure_backtrack.8 to i64) } - - -@failure_backtrack.0 = constant [?? x i8] c", r = \00" - - -@failure_backtrack.20 = constant [?? x i8] c", s = \00" - - -@failure_backtrack.22 = constant [?? x i8] c", y = \00" - - -@failure_backtrack.6 = constant [?? x i8] c"after conditional; x = \00" - - -@failure_backtrack.32 = constant [?? x i8] c"after first disjunction: x = \00" - - -@failure_backtrack.28 = constant [?? x i8] c"after fourth conditional; x = \00" - - -@failure_backtrack.14 = constant [?? x i8] c"after second conditional; x = \00" - - -@failure_backtrack.36 = constant [?? x i8] c"after second disjunction: x = \00" - - -@failure_backtrack.18 = constant [?? x i8] c"after third conditional; x = \00" - - -@failure_backtrack.2 = constant [?? x i8] c"before conditional: x = \00" - - -@failure_backtrack.30 = constant [?? x i8] c"before first disjunction: x = \00" - - -@failure_backtrack.24 = constant [?? x i8] c"before fourth conditional: x = \00" - - -@failure_backtrack.8 = constant [?? x i8] c"before second conditional: x = \00" - - -@failure_backtrack.34 = constant [?? x i8] c"before second disjunction: x = \00" - - -@failure_backtrack.16 = constant [?? x i8] c"before third conditional: x = \00" - - -@failure_backtrack.4 = constant [?? x i8] c"nope fails; x = \00" - - -@failure_backtrack.26 = constant [?? x i8] c"nope succeeds!\00" - - -@failure_backtrack.12 = constant [?? x i8] c"nope2 fails; x = \00" - - -@failure_backtrack.10 = constant [?? x i8] c"nope2 succeeds!\00" - - -declare external ccc void @putchar(i8) - - -declare external fastcc void @"wybe.string.print<0>[410bae77d3]"(i64) - - -declare external fastcc i64 @"wybe.string.,,<0>"(i64, i64) - - -declare external fastcc i64 @"wybe.int.fmt<2>"(i64, i64, i8) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"failure_backtrack.<0>"() { -entry: - %0 = load i64, i64* @"resource#failure_backtrack.r" - %1 = load i64, i64* @"resource#failure_backtrack.s" - store i64 7, i64* @"resource#failure_backtrack.r" - store i64 14, i64* @"resource#failure_backtrack.s" - %2 = tail call fastcc i64 @"wybe.int.fmt<2>"(i64 42, i64 0, i8 32) - %3 = tail call fastcc i64 @"wybe.int.fmt<2>"(i64 7, i64 0, i8 32) - %4 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @failure_backtrack.1, i32 0, i32 0) to i64), i64 %3) - %5 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 %2, i64 %4) - %6 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @failure_backtrack.3, i32 0, i32 0) to i64), i64 %5) - tail call fastcc void @"wybe.string.print<0>"(i64 %6) - tail call ccc void @putchar(i8 10) - %7 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @failure_backtrack.1, i32 0, i32 0) to i64), i64 %3) - %8 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 %2, i64 %7) - %9 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @failure_backtrack.5, i32 0, i32 0) to i64), i64 %8) - tail call fastcc void @"wybe.string.print<0>[410bae77d3]"(i64 %9) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"failure_backtrack.#cont#1<0>"(i64 %0, i64 %1, i64 42, i64 21) - ret void +source_filename = "!ROOT!/final-dump/failure_backtrack.wybe" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c", r = \00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c", s = \00", align 8 +@"cstring#2" = private unnamed_addr constant [ ?? x i8 ] c", y = \00", align 8 +@"cstring#3" = private unnamed_addr constant [ ?? x i8 ] c"after conditional; x = \00", align 8 +@"cstring#4" = private unnamed_addr constant [ ?? x i8 ] c"after first disjunction: x = \00", align 8 +@"cstring#5" = private unnamed_addr constant [ ?? x i8 ] c"after fourth conditional; x = \00", align 8 +@"cstring#6" = private unnamed_addr constant [ ?? x i8 ] c"after second conditional; x = \00", align 8 +@"cstring#7" = private unnamed_addr constant [ ?? x i8 ] c"after second disjunction: x = \00", align 8 +@"cstring#8" = private unnamed_addr constant [ ?? x i8 ] c"after third conditional; x = \00", align 8 +@"cstring#9" = private unnamed_addr constant [ ?? x i8 ] c"before conditional: x = \00", align 8 +@"cstring#10" = private unnamed_addr constant [ ?? x i8 ] c"before first disjunction: x = \00", align 8 +@"cstring#11" = private unnamed_addr constant [ ?? x i8 ] c"before fourth conditional: x = \00", align 8 +@"cstring#12" = private unnamed_addr constant [ ?? x i8 ] c"before second conditional: x = \00", align 8 +@"cstring#13" = private unnamed_addr constant [ ?? x i8 ] c"before second disjunction: x = \00", align 8 +@"cstring#14" = private unnamed_addr constant [ ?? x i8 ] c"before third conditional: x = \00", align 8 +@"cstring#15" = private unnamed_addr constant [ ?? x i8 ] c"nope fails; x = \00", align 8 +@"cstring#16" = private unnamed_addr constant [ ?? x i8 ] c"nope succeeds!\00", align 8 +@"cstring#17" = private unnamed_addr constant [ ?? x i8 ] c"nope2 fails; x = \00", align 8 +@"cstring#18" = private unnamed_addr constant [ ?? x i8 ] c"nope2 succeeds!\00", align 8 +@"string#19" = private unnamed_addr constant {i64, i64} { i64 6, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +@"string#20" = private unnamed_addr constant {i64, i64} { i64 6, i64 ptrtoint( ptr @"cstring#1" to i64 ) }, align 8 +@"string#21" = private unnamed_addr constant {i64, i64} { i64 6, i64 ptrtoint( ptr @"cstring#2" to i64 ) }, align 8 +@"string#22" = private unnamed_addr constant {i64, i64} { i64 23, i64 ptrtoint( ptr @"cstring#3" to i64 ) }, align 8 +@"string#23" = private unnamed_addr constant {i64, i64} { i64 29, i64 ptrtoint( ptr @"cstring#4" to i64 ) }, align 8 +@"string#24" = private unnamed_addr constant {i64, i64} { i64 30, i64 ptrtoint( ptr @"cstring#5" to i64 ) }, align 8 +@"string#25" = private unnamed_addr constant {i64, i64} { i64 30, i64 ptrtoint( ptr @"cstring#6" to i64 ) }, align 8 +@"string#26" = private unnamed_addr constant {i64, i64} { i64 30, i64 ptrtoint( ptr @"cstring#7" to i64 ) }, align 8 +@"string#27" = private unnamed_addr constant {i64, i64} { i64 29, i64 ptrtoint( ptr @"cstring#8" to i64 ) }, align 8 +@"string#28" = private unnamed_addr constant {i64, i64} { i64 24, i64 ptrtoint( ptr @"cstring#9" to i64 ) }, align 8 +@"string#29" = private unnamed_addr constant {i64, i64} { i64 30, i64 ptrtoint( ptr @"cstring#10" to i64 ) }, align 8 +@"string#30" = private unnamed_addr constant {i64, i64} { i64 31, i64 ptrtoint( ptr @"cstring#11" to i64 ) }, align 8 +@"string#31" = private unnamed_addr constant {i64, i64} { i64 31, i64 ptrtoint( ptr @"cstring#12" to i64 ) }, align 8 +@"string#32" = private unnamed_addr constant {i64, i64} { i64 31, i64 ptrtoint( ptr @"cstring#13" to i64 ) }, align 8 +@"string#33" = private unnamed_addr constant {i64, i64} { i64 30, i64 ptrtoint( ptr @"cstring#14" to i64 ) }, align 8 +@"string#34" = private unnamed_addr constant {i64, i64} { i64 16, i64 ptrtoint( ptr @"cstring#15" to i64 ) }, align 8 +@"string#35" = private unnamed_addr constant {i64, i64} { i64 14, i64 ptrtoint( ptr @"cstring#16" to i64 ) }, align 8 +@"string#36" = private unnamed_addr constant {i64, i64} { i64 17, i64 ptrtoint( ptr @"cstring#17" to i64 ) }, align 8 +@"string#37" = private unnamed_addr constant {i64, i64} { i64 15, i64 ptrtoint( ptr @"cstring#18" to i64 ) }, align 8 + +declare external fastcc i64 @"wybe.int.fmt<2>"(i64, i64, i8) +declare external fastcc i64 @"wybe.string.,,<0>"(i64, i64) +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external fastcc void @"wybe.string.print<0>[410bae77d3]"(i64) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) +@"resource#failure_backtrack.r" = global i64 undef +@"resource#failure_backtrack.s" = global i64 undef + +define external fastcc void @"failure_backtrack.<0>"() { + %"tmp#139##0" = load i64, ptr @"resource#failure_backtrack.r" + %"tmp#140##0" = load i64, ptr @"resource#failure_backtrack.s" + store i64 7, ptr @"resource#failure_backtrack.r" + store i64 14, ptr @"resource#failure_backtrack.s" + %"tmp#2##0" = tail call fastcc i64 @"wybe.int.fmt<2>"(i64 42, i64 0, i8 32) + %"tmp#4##0" = tail call fastcc i64 @"wybe.int.fmt<2>"(i64 7, i64 0, i8 32) + %"tmp#3##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint( ptr @"string#19" to i64 ), i64 %"tmp#4##0") + %"tmp#1##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 %"tmp#2##0", i64 %"tmp#3##0") + %"tmp#0##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint( ptr @"string#28" to i64 ), i64 %"tmp#1##0") + tail call fastcc void @"wybe.string.print<0>"(i64 %"tmp#0##0") + call ccc void @putchar(i8 10) + %"tmp#8##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint( ptr @"string#19" to i64 ), i64 %"tmp#4##0") + %"tmp#6##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 %"tmp#2##0", i64 %"tmp#8##0") + %"tmp#5##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint( ptr @"string#34" to i64 ), i64 %"tmp#6##0") + tail call fastcc void @"wybe.string.print<0>[410bae77d3]"(i64 %"tmp#5##0") + call ccc void @putchar(i8 10) + tail call fastcc void @"failure_backtrack.#cont#1<0>"(i64 %"tmp#139##0", i64 %"tmp#140##0", i64 42, i64 21) + ret void } - -define external fastcc void @"failure_backtrack.#cont#1<0>"(i64 %"tmp#139##0", i64 %"tmp#140##0", i64 %"x##0", i64 %"y##0") { -entry: - %0 = tail call fastcc i64 @"wybe.int.fmt<2>"(i64 %"x##0", i64 0, i8 32) - %1 = load i64, i64* @"resource#failure_backtrack.r" - %2 = tail call fastcc i64 @"wybe.int.fmt<2>"(i64 %1, i64 0, i8 32) - %3 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @failure_backtrack.1, i32 0, i32 0) to i64), i64 %2) - %4 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 %0, i64 %3) - %5 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @failure_backtrack.7, i32 0, i32 0) to i64), i64 %4) - tail call fastcc void @"wybe.string.print<0>"(i64 %5) - tail call ccc void @putchar(i8 10) - %6 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @failure_backtrack.1, i32 0, i32 0) to i64), i64 %2) - %7 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 %0, i64 %6) - %8 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @failure_backtrack.9, i32 0, i32 0) to i64), i64 %7) - tail call fastcc void @"wybe.string.print<0>"(i64 %8) - tail call ccc void @putchar(i8 10) - store i64 9, i64* @"resource#failure_backtrack.r" - %9 = tail call fastcc {i64, i1} @"failure_backtrack.nope2<0>"() - %10 = extractvalue {i64, i1} %9, 0 - %11 = extractvalue {i64, i1} %9, 1 - br i1 %11, label %if.then, label %if.else -if.then: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @failure_backtrack.11, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - musttail call fastcc void @"failure_backtrack.#cont#2<0>"(i64 %"tmp#139##0", i64 %"tmp#140##0", i64 %10, i64 %"y##0") - ret void -if.else: - store i64 %1, i64* @"resource#failure_backtrack.r" - %12 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @failure_backtrack.1, i32 0, i32 0) to i64), i64 %2) - %13 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 %0, i64 %12) - %14 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @failure_backtrack.13, i32 0, i32 0) to i64), i64 %13) - tail call fastcc void @"wybe.string.print<0>[410bae77d3]"(i64 %14) - tail call ccc void @putchar(i8 10) - musttail call fastcc void @"failure_backtrack.#cont#2<0>"(i64 %"tmp#139##0", i64 %"tmp#140##0", i64 %"x##0", i64 %"y##0") - ret void +define external fastcc void @"failure_backtrack.#cont#1<0>"(i64 %"tmp#139##0", i64 %"tmp#140##0", i64 %"x##0", i64 %"y##0") { + %"tmp#12##0" = tail call fastcc i64 @"wybe.int.fmt<2>"(i64 %"x##0", i64 0, i8 32) + %"r##0" = load i64, ptr @"resource#failure_backtrack.r" + %"tmp#14##0" = tail call fastcc i64 @"wybe.int.fmt<2>"(i64 %"r##0", i64 0, i8 32) + %"tmp#13##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint( ptr @"string#19" to i64 ), i64 %"tmp#14##0") + %"tmp#11##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 %"tmp#12##0", i64 %"tmp#13##0") + %"tmp#10##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint( ptr @"string#22" to i64 ), i64 %"tmp#11##0") + tail call fastcc void @"wybe.string.print<0>"(i64 %"tmp#10##0") + call ccc void @putchar(i8 10) + %"tmp#18##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint( ptr @"string#19" to i64 ), i64 %"tmp#14##0") + %"tmp#16##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 %"tmp#12##0", i64 %"tmp#18##0") + %"tmp#15##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint( ptr @"string#31" to i64 ), i64 %"tmp#16##0") + tail call fastcc void @"wybe.string.print<0>"(i64 %"tmp#15##0") + call ccc void @putchar(i8 10) + store i64 9, ptr @"resource#failure_backtrack.r" + %"tmp#184##0" = tail call fastcc {i64, i1} @"failure_backtrack.nope2<0>"() + %"x##1" = extractvalue {i64, i1}%"tmp#184##0", 0 + %"tmp#165##0" = extractvalue {i64, i1}%"tmp#184##0", 1 + br i1 %"tmp#165##0", label %if.then.0, label %if.else.0 +if.then.0: + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#37" to i64 )) + call ccc void @putchar(i8 10) + tail call fastcc void @"failure_backtrack.#cont#2<0>"(i64 %"tmp#139##0", i64 %"tmp#140##0", i64 %"x##1", i64 %"y##0") + ret void +if.else.0: + store i64 %"r##0", ptr @"resource#failure_backtrack.r" + %"tmp#23##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint( ptr @"string#19" to i64 ), i64 %"tmp#14##0") + %"tmp#21##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 %"tmp#12##0", i64 %"tmp#23##0") + %"tmp#20##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint( ptr @"string#36" to i64 ), i64 %"tmp#21##0") + tail call fastcc void @"wybe.string.print<0>[410bae77d3]"(i64 %"tmp#20##0") + call ccc void @putchar(i8 10) + tail call fastcc void @"failure_backtrack.#cont#2<0>"(i64 %"tmp#139##0", i64 %"tmp#140##0", i64 %"x##0", i64 %"y##0") + ret void } - -define external fastcc void @"failure_backtrack.#cont#2<0>"(i64 %"tmp#139##0", i64 %"tmp#140##0", i64 %"x##0", i64 %"y##0") { -entry: - %0 = tail call fastcc i64 @"wybe.int.fmt<2>"(i64 %"x##0", i64 0, i8 32) - %1 = load i64, i64* @"resource#failure_backtrack.r" - %2 = tail call fastcc i64 @"wybe.int.fmt<2>"(i64 %1, i64 0, i8 32) - %3 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @failure_backtrack.1, i32 0, i32 0) to i64), i64 %2) - %4 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 %0, i64 %3) - %5 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @failure_backtrack.15, i32 0, i32 0) to i64), i64 %4) - tail call fastcc void @"wybe.string.print<0>"(i64 %5) - tail call ccc void @putchar(i8 10) - %6 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @failure_backtrack.1, i32 0, i32 0) to i64), i64 %2) - %7 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 %0, i64 %6) - %8 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @failure_backtrack.17, i32 0, i32 0) to i64), i64 %7) - tail call fastcc void @"wybe.string.print<0>"(i64 %8) - tail call ccc void @putchar(i8 10) - %9 = tail call fastcc {i64, i1} @"failure_backtrack.nope2<0>"() - %10 = extractvalue {i64, i1} %9, 0 - %11 = extractvalue {i64, i1} %9, 1 - br i1 %11, label %if.then, label %if.else -if.then: - store i64 %10, i64* @"resource#failure_backtrack.r" - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @failure_backtrack.11, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - musttail call fastcc void @"failure_backtrack.#cont#3<0>"(i64 %"tmp#139##0", i64 %"tmp#140##0", i64 25, i64 %"y##0") - ret void -if.else: - %12 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @failure_backtrack.1, i32 0, i32 0) to i64), i64 %2) - %13 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 %0, i64 %12) - %14 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @failure_backtrack.13, i32 0, i32 0) to i64), i64 %13) - tail call fastcc void @"wybe.string.print<0>[410bae77d3]"(i64 %14) - tail call ccc void @putchar(i8 10) - musttail call fastcc void @"failure_backtrack.#cont#3<0>"(i64 %"tmp#139##0", i64 %"tmp#140##0", i64 %"x##0", i64 %"y##0") - ret void +define external fastcc void @"failure_backtrack.#cont#2<0>"(i64 %"tmp#139##0", i64 %"tmp#140##0", i64 %"x##0", i64 %"y##0") { + %"tmp#27##0" = tail call fastcc i64 @"wybe.int.fmt<2>"(i64 %"x##0", i64 0, i8 32) + %"tmp#144##0" = load i64, ptr @"resource#failure_backtrack.r" + %"tmp#29##0" = tail call fastcc i64 @"wybe.int.fmt<2>"(i64 %"tmp#144##0", i64 0, i8 32) + %"tmp#28##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint( ptr @"string#19" to i64 ), i64 %"tmp#29##0") + %"tmp#26##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 %"tmp#27##0", i64 %"tmp#28##0") + %"tmp#25##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint( ptr @"string#25" to i64 ), i64 %"tmp#26##0") + tail call fastcc void @"wybe.string.print<0>"(i64 %"tmp#25##0") + call ccc void @putchar(i8 10) + %"tmp#33##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint( ptr @"string#19" to i64 ), i64 %"tmp#29##0") + %"tmp#31##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 %"tmp#27##0", i64 %"tmp#33##0") + %"tmp#30##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint( ptr @"string#33" to i64 ), i64 %"tmp#31##0") + tail call fastcc void @"wybe.string.print<0>"(i64 %"tmp#30##0") + call ccc void @putchar(i8 10) + %"tmp#183##0" = tail call fastcc {i64, i1} @"failure_backtrack.nope2<0>"() + %"r##3" = extractvalue {i64, i1}%"tmp#183##0", 0 + %"tmp#164##0" = extractvalue {i64, i1}%"tmp#183##0", 1 + br i1 %"tmp#164##0", label %if.then.0, label %if.else.0 +if.then.0: + store i64 %"r##3", ptr @"resource#failure_backtrack.r" + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#37" to i64 )) + call ccc void @putchar(i8 10) + tail call fastcc void @"failure_backtrack.#cont#3<0>"(i64 %"tmp#139##0", i64 %"tmp#140##0", i64 25, i64 %"y##0") + ret void +if.else.0: + %"tmp#38##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint( ptr @"string#19" to i64 ), i64 %"tmp#29##0") + %"tmp#36##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 %"tmp#27##0", i64 %"tmp#38##0") + %"tmp#35##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint( ptr @"string#36" to i64 ), i64 %"tmp#36##0") + tail call fastcc void @"wybe.string.print<0>[410bae77d3]"(i64 %"tmp#35##0") + call ccc void @putchar(i8 10) + tail call fastcc void @"failure_backtrack.#cont#3<0>"(i64 %"tmp#139##0", i64 %"tmp#140##0", i64 %"x##0", i64 %"y##0") + ret void } - -define external fastcc void @"failure_backtrack.#cont#3<0>"(i64 %"tmp#139##0", i64 %"tmp#140##0", i64 %"x##0", i64 %"y##0") { -entry: - %0 = tail call fastcc i64 @"wybe.int.fmt<2>"(i64 %"x##0", i64 0, i8 32) - %1 = load i64, i64* @"resource#failure_backtrack.r" - %2 = tail call fastcc i64 @"wybe.int.fmt<2>"(i64 %1, i64 0, i8 32) - %3 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @failure_backtrack.1, i32 0, i32 0) to i64), i64 %2) - %4 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 %0, i64 %3) - %5 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @failure_backtrack.19, i32 0, i32 0) to i64), i64 %4) - tail call fastcc void @"wybe.string.print<0>"(i64 %5) - tail call ccc void @putchar(i8 10) - %6 = tail call fastcc i64 @"wybe.int.fmt<2>"(i64 %"y##0", i64 0, i8 32) - %7 = load i64, i64* @"resource#failure_backtrack.s" - %8 = tail call fastcc i64 @"wybe.int.fmt<2>"(i64 %7, i64 0, i8 32) - %9 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @failure_backtrack.21, i32 0, i32 0) to i64), i64 %8) - %10 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 %2, i64 %9) - %11 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @failure_backtrack.1, i32 0, i32 0) to i64), i64 %10) - %12 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 %6, i64 %11) - %13 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @failure_backtrack.23, i32 0, i32 0) to i64), i64 %12) - %14 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 %0, i64 %13) - %15 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @failure_backtrack.25, i32 0, i32 0) to i64), i64 %14) - tail call fastcc void @"wybe.string.print<0>"(i64 %15) - tail call ccc void @putchar(i8 10) - store i64 10, i64* @"resource#failure_backtrack.r" - %16 = tail call fastcc i1 @"failure_backtrack.yup<0>"() - br i1 %16, label %if.then, label %if.else -if.then: - store i64 41, i64* @"resource#failure_backtrack.s" - %17 = tail call fastcc i1 @"failure_backtrack.nope<0>"() - br i1 %17, label %if.then1, label %if.else1 -if.else: - store i64 %1, i64* @"resource#failure_backtrack.r" - %25 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @failure_backtrack.21, i32 0, i32 0) to i64), i64 %8) - %26 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 %2, i64 %25) - %27 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @failure_backtrack.1, i32 0, i32 0) to i64), i64 %26) - %28 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 %6, i64 %27) - %29 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @failure_backtrack.23, i32 0, i32 0) to i64), i64 %28) - %30 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 %0, i64 %29) - %31 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @failure_backtrack.5, i32 0, i32 0) to i64), i64 %30) - tail call fastcc void @"wybe.string.print<0>[410bae77d3]"(i64 %31) - tail call ccc void @putchar(i8 10) - musttail call fastcc void @"failure_backtrack.#cont#4<0>"(i64 %"tmp#139##0", i64 %"tmp#140##0", i64 %"x##0", i64 %"y##0") - ret void -if.then1: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @failure_backtrack.27, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - musttail call fastcc void @"failure_backtrack.#cont#4<0>"(i64 %"tmp#139##0", i64 %"tmp#140##0", i64 26, i64 12) - ret void -if.else1: - store i64 %1, i64* @"resource#failure_backtrack.r" - store i64 %7, i64* @"resource#failure_backtrack.s" - %18 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @failure_backtrack.21, i32 0, i32 0) to i64), i64 %8) - %19 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 %2, i64 %18) - %20 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @failure_backtrack.1, i32 0, i32 0) to i64), i64 %19) - %21 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 %6, i64 %20) - %22 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @failure_backtrack.23, i32 0, i32 0) to i64), i64 %21) - %23 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 %0, i64 %22) - %24 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @failure_backtrack.5, i32 0, i32 0) to i64), i64 %23) - tail call fastcc void @"wybe.string.print<0>[410bae77d3]"(i64 %24) - tail call ccc void @putchar(i8 10) - musttail call fastcc void @"failure_backtrack.#cont#4<0>"(i64 %"tmp#139##0", i64 %"tmp#140##0", i64 %"x##0", i64 %"y##0") - ret void +define external fastcc void @"failure_backtrack.#cont#3<0>"(i64 %"tmp#139##0", i64 %"tmp#140##0", i64 %"x##0", i64 %"y##0") { + %"tmp#42##0" = tail call fastcc i64 @"wybe.int.fmt<2>"(i64 %"x##0", i64 0, i8 32) + %"r##0" = load i64, ptr @"resource#failure_backtrack.r" + %"tmp#44##0" = tail call fastcc i64 @"wybe.int.fmt<2>"(i64 %"r##0", i64 0, i8 32) + %"tmp#43##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint( ptr @"string#19" to i64 ), i64 %"tmp#44##0") + %"tmp#41##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 %"tmp#42##0", i64 %"tmp#43##0") + %"tmp#40##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint( ptr @"string#27" to i64 ), i64 %"tmp#41##0") + tail call fastcc void @"wybe.string.print<0>"(i64 %"tmp#40##0") + call ccc void @putchar(i8 10) + %"tmp#50##0" = tail call fastcc i64 @"wybe.int.fmt<2>"(i64 %"y##0", i64 0, i8 32) + %"s##0" = load i64, ptr @"resource#failure_backtrack.s" + %"tmp#55##0" = tail call fastcc i64 @"wybe.int.fmt<2>"(i64 %"s##0", i64 0, i8 32) + %"tmp#54##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint( ptr @"string#20" to i64 ), i64 %"tmp#55##0") + %"tmp#52##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 %"tmp#44##0", i64 %"tmp#54##0") + %"tmp#51##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint( ptr @"string#19" to i64 ), i64 %"tmp#52##0") + %"tmp#49##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 %"tmp#50##0", i64 %"tmp#51##0") + %"tmp#48##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint( ptr @"string#21" to i64 ), i64 %"tmp#49##0") + %"tmp#46##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 %"tmp#42##0", i64 %"tmp#48##0") + %"tmp#45##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint( ptr @"string#30" to i64 ), i64 %"tmp#46##0") + tail call fastcc void @"wybe.string.print<0>"(i64 %"tmp#45##0") + call ccc void @putchar(i8 10) + store i64 10, ptr @"resource#failure_backtrack.r" + %"tmp#162##0" = tail call fastcc i1 @"failure_backtrack.yup<0>"() + br i1 %"tmp#162##0", label %if.then.0, label %if.else.0 +if.then.0: + store i64 41, ptr @"resource#failure_backtrack.s" + %"tmp#163##0" = tail call fastcc i1 @"failure_backtrack.nope<0>"() + br i1 %"tmp#163##0", label %if.then.1, label %if.else.1 +if.then.1: + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#35" to i64 )) + call ccc void @putchar(i8 10) + tail call fastcc void @"failure_backtrack.#cont#4<0>"(i64 %"tmp#139##0", i64 %"tmp#140##0", i64 26, i64 12) + ret void +if.else.1: + store i64 %"r##0", ptr @"resource#failure_backtrack.r" + store i64 %"s##0", ptr @"resource#failure_backtrack.s" + %"tmp#65##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint( ptr @"string#20" to i64 ), i64 %"tmp#55##0") + %"tmp#63##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 %"tmp#44##0", i64 %"tmp#65##0") + %"tmp#62##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint( ptr @"string#19" to i64 ), i64 %"tmp#63##0") + %"tmp#60##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 %"tmp#50##0", i64 %"tmp#62##0") + %"tmp#59##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint( ptr @"string#21" to i64 ), i64 %"tmp#60##0") + %"tmp#57##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 %"tmp#42##0", i64 %"tmp#59##0") + %"tmp#56##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint( ptr @"string#34" to i64 ), i64 %"tmp#57##0") + tail call fastcc void @"wybe.string.print<0>[410bae77d3]"(i64 %"tmp#56##0") + call ccc void @putchar(i8 10) + tail call fastcc void @"failure_backtrack.#cont#4<0>"(i64 %"tmp#139##0", i64 %"tmp#140##0", i64 %"x##0", i64 %"y##0") + ret void +if.else.0: + store i64 %"r##0", ptr @"resource#failure_backtrack.r" + %"tmp#193##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint( ptr @"string#20" to i64 ), i64 %"tmp#55##0") + %"tmp#194##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 %"tmp#44##0", i64 %"tmp#193##0") + %"tmp#195##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint( ptr @"string#19" to i64 ), i64 %"tmp#194##0") + %"tmp#196##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 %"tmp#50##0", i64 %"tmp#195##0") + %"tmp#197##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint( ptr @"string#21" to i64 ), i64 %"tmp#196##0") + %"tmp#198##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 %"tmp#42##0", i64 %"tmp#197##0") + %"tmp#199##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint( ptr @"string#34" to i64 ), i64 %"tmp#198##0") + tail call fastcc void @"wybe.string.print<0>[410bae77d3]"(i64 %"tmp#199##0") + call ccc void @putchar(i8 10) + tail call fastcc void @"failure_backtrack.#cont#4<0>"(i64 %"tmp#139##0", i64 %"tmp#140##0", i64 %"x##0", i64 %"y##0") + ret void } - -define external fastcc void @"failure_backtrack.#cont#4<0>"(i64 %"tmp#139##0", i64 %"tmp#140##0", i64 %"x##0", i64 %"y##0") { -entry: - %0 = tail call fastcc i64 @"wybe.int.fmt<2>"(i64 %"x##0", i64 0, i8 32) - %1 = tail call fastcc i64 @"wybe.int.fmt<2>"(i64 %"y##0", i64 0, i8 32) - %2 = load i64, i64* @"resource#failure_backtrack.r" - %3 = tail call fastcc i64 @"wybe.int.fmt<2>"(i64 %2, i64 0, i8 32) - %4 = load i64, i64* @"resource#failure_backtrack.s" - %5 = tail call fastcc i64 @"wybe.int.fmt<2>"(i64 %4, i64 0, i8 32) - %6 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @failure_backtrack.21, i32 0, i32 0) to i64), i64 %5) - %7 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 %3, i64 %6) - %8 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @failure_backtrack.1, i32 0, i32 0) to i64), i64 %7) - %9 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 %1, i64 %8) - %10 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @failure_backtrack.23, i32 0, i32 0) to i64), i64 %9) - %11 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 %0, i64 %10) - %12 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @failure_backtrack.29, i32 0, i32 0) to i64), i64 %11) - tail call fastcc void @"wybe.string.print<0>"(i64 %12) - tail call ccc void @putchar(i8 10) - %13 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @failure_backtrack.21, i32 0, i32 0) to i64), i64 %5) - %14 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 %3, i64 %13) - %15 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @failure_backtrack.1, i32 0, i32 0) to i64), i64 %14) - %16 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 %1, i64 %15) - %17 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @failure_backtrack.23, i32 0, i32 0) to i64), i64 %16) - %18 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 %0, i64 %17) - %19 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @failure_backtrack.31, i32 0, i32 0) to i64), i64 %18) - tail call fastcc void @"wybe.string.print<0>[410bae77d3]"(i64 %19) - tail call ccc void @putchar(i8 10) - store i64 11, i64* @"resource#failure_backtrack.r" - store i64 40, i64* @"resource#failure_backtrack.s" - %20 = tail call fastcc i1 @"failure_backtrack.nope<0>"() - br i1 %20, label %if.then, label %if.else -if.then: - musttail call fastcc void @"failure_backtrack.#cont#5<0>"(i64 %"tmp#139##0", i64 %"tmp#140##0", i64 27, i64 13) - ret void -if.else: - store i64 %4, i64* @"resource#failure_backtrack.s" - store i64 12, i64* @"resource#failure_backtrack.r" - musttail call fastcc void @"failure_backtrack.#cont#5<0>"(i64 %"tmp#139##0", i64 %"tmp#140##0", i64 28, i64 %"y##0") - ret void +define external fastcc void @"failure_backtrack.#cont#4<0>"(i64 %"tmp#139##0", i64 %"tmp#140##0", i64 %"x##0", i64 %"y##0") { + %"tmp#69##0" = tail call fastcc i64 @"wybe.int.fmt<2>"(i64 %"x##0", i64 0, i8 32) + %"tmp#72##0" = tail call fastcc i64 @"wybe.int.fmt<2>"(i64 %"y##0", i64 0, i8 32) + %"tmp#150##0" = load i64, ptr @"resource#failure_backtrack.r" + %"tmp#75##0" = tail call fastcc i64 @"wybe.int.fmt<2>"(i64 %"tmp#150##0", i64 0, i8 32) + %"s##0" = load i64, ptr @"resource#failure_backtrack.s" + %"tmp#77##0" = tail call fastcc i64 @"wybe.int.fmt<2>"(i64 %"s##0", i64 0, i8 32) + %"tmp#76##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint( ptr @"string#20" to i64 ), i64 %"tmp#77##0") + %"tmp#74##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 %"tmp#75##0", i64 %"tmp#76##0") + %"tmp#73##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint( ptr @"string#19" to i64 ), i64 %"tmp#74##0") + %"tmp#71##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 %"tmp#72##0", i64 %"tmp#73##0") + %"tmp#70##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint( ptr @"string#21" to i64 ), i64 %"tmp#71##0") + %"tmp#68##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 %"tmp#69##0", i64 %"tmp#70##0") + %"tmp#67##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint( ptr @"string#24" to i64 ), i64 %"tmp#68##0") + tail call fastcc void @"wybe.string.print<0>"(i64 %"tmp#67##0") + call ccc void @putchar(i8 10) + %"tmp#87##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint( ptr @"string#20" to i64 ), i64 %"tmp#77##0") + %"tmp#85##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 %"tmp#75##0", i64 %"tmp#87##0") + %"tmp#84##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint( ptr @"string#19" to i64 ), i64 %"tmp#85##0") + %"tmp#82##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 %"tmp#72##0", i64 %"tmp#84##0") + %"tmp#81##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint( ptr @"string#21" to i64 ), i64 %"tmp#82##0") + %"tmp#79##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 %"tmp#69##0", i64 %"tmp#81##0") + %"tmp#78##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint( ptr @"string#29" to i64 ), i64 %"tmp#79##0") + tail call fastcc void @"wybe.string.print<0>[410bae77d3]"(i64 %"tmp#78##0") + call ccc void @putchar(i8 10) + store i64 11, ptr @"resource#failure_backtrack.r" + store i64 40, ptr @"resource#failure_backtrack.s" + %"tmp#161##0" = tail call fastcc i1 @"failure_backtrack.nope<0>"() + br i1 %"tmp#161##0", label %if.then.0, label %if.else.0 +if.then.0: + tail call fastcc void @"failure_backtrack.#cont#5<0>"(i64 %"tmp#139##0", i64 %"tmp#140##0", i64 27, i64 13) + ret void +if.else.0: + store i64 %"s##0", ptr @"resource#failure_backtrack.s" + store i64 12, ptr @"resource#failure_backtrack.r" + tail call fastcc void @"failure_backtrack.#cont#5<0>"(i64 %"tmp#139##0", i64 %"tmp#140##0", i64 28, i64 %"y##0") + ret void } - -define external fastcc void @"failure_backtrack.#cont#5<0>"(i64 %"tmp#139##0", i64 %"tmp#140##0", i64 %"x##0", i64 %"y##0") { -entry: - %0 = tail call fastcc i64 @"wybe.int.fmt<2>"(i64 %"x##0", i64 0, i8 32) - %1 = tail call fastcc i64 @"wybe.int.fmt<2>"(i64 %"y##0", i64 0, i8 32) - %2 = load i64, i64* @"resource#failure_backtrack.r" - %3 = tail call fastcc i64 @"wybe.int.fmt<2>"(i64 %2, i64 0, i8 32) - %4 = load i64, i64* @"resource#failure_backtrack.s" - %5 = tail call fastcc i64 @"wybe.int.fmt<2>"(i64 %4, i64 0, i8 32) - %6 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @failure_backtrack.21, i32 0, i32 0) to i64), i64 %5) - %7 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 %3, i64 %6) - %8 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @failure_backtrack.1, i32 0, i32 0) to i64), i64 %7) - %9 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 %1, i64 %8) - %10 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @failure_backtrack.23, i32 0, i32 0) to i64), i64 %9) - %11 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 %0, i64 %10) - %12 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @failure_backtrack.33, i32 0, i32 0) to i64), i64 %11) - tail call fastcc void @"wybe.string.print<0>[410bae77d3]"(i64 %12) - tail call ccc void @putchar(i8 10) - store i64 14, i64* @"resource#failure_backtrack.s" - %13 = tail call fastcc i64 @"wybe.int.fmt<2>"(i64 42, i64 0, i8 32) - %14 = tail call fastcc i64 @"wybe.int.fmt<2>"(i64 21, i64 0, i8 32) - %15 = tail call fastcc i64 @"wybe.int.fmt<2>"(i64 7, i64 0, i8 32) - %16 = tail call fastcc i64 @"wybe.int.fmt<2>"(i64 14, i64 0, i8 32) - %17 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @failure_backtrack.21, i32 0, i32 0) to i64), i64 %16) - %18 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 %15, i64 %17) - %19 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @failure_backtrack.1, i32 0, i32 0) to i64), i64 %18) - %20 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 %14, i64 %19) - %21 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @failure_backtrack.23, i32 0, i32 0) to i64), i64 %20) - %22 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 %13, i64 %21) - %23 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @failure_backtrack.35, i32 0, i32 0) to i64), i64 %22) - tail call fastcc void @"wybe.string.print<0>[410bae77d3]"(i64 %23) - tail call ccc void @putchar(i8 10) - store i64 12, i64* @"resource#failure_backtrack.r" - %24 = tail call fastcc i1 @"failure_backtrack.nope<0>"() - br i1 %24, label %if.then, label %if.else -if.then: - musttail call fastcc void @"failure_backtrack.#cont#6<0>"(i64 %"tmp#139##0", i64 %"tmp#140##0", i64 28, i64 21) - ret void -if.else: - store i64 13, i64* @"resource#failure_backtrack.r" - %25 = tail call fastcc i1 @"failure_backtrack.nope<0>"() - br i1 %25, label %if.then1, label %if.else1 -if.then1: - musttail call fastcc void @"failure_backtrack.#cont#6<0>"(i64 %"tmp#139##0", i64 %"tmp#140##0", i64 29, i64 21) - ret void -if.else1: - store i64 7, i64* @"resource#failure_backtrack.r" - musttail call fastcc void @"failure_backtrack.#cont#6<0>"(i64 %"tmp#139##0", i64 %"tmp#140##0", i64 42, i64 21) - ret void +define external fastcc void @"failure_backtrack.#cont#5<0>"(i64 %"tmp#139##0", i64 %"tmp#140##0", i64 %"x##0", i64 %"y##0") { + %"tmp#91##0" = tail call fastcc i64 @"wybe.int.fmt<2>"(i64 %"x##0", i64 0, i8 32) + %"tmp#94##0" = tail call fastcc i64 @"wybe.int.fmt<2>"(i64 %"y##0", i64 0, i8 32) + %"r##0" = load i64, ptr @"resource#failure_backtrack.r" + %"tmp#97##0" = tail call fastcc i64 @"wybe.int.fmt<2>"(i64 %"r##0", i64 0, i8 32) + %"s##0" = load i64, ptr @"resource#failure_backtrack.s" + %"tmp#99##0" = tail call fastcc i64 @"wybe.int.fmt<2>"(i64 %"s##0", i64 0, i8 32) + %"tmp#98##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint( ptr @"string#20" to i64 ), i64 %"tmp#99##0") + %"tmp#96##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 %"tmp#97##0", i64 %"tmp#98##0") + %"tmp#95##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint( ptr @"string#19" to i64 ), i64 %"tmp#96##0") + %"tmp#93##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 %"tmp#94##0", i64 %"tmp#95##0") + %"tmp#92##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint( ptr @"string#21" to i64 ), i64 %"tmp#93##0") + %"tmp#90##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 %"tmp#91##0", i64 %"tmp#92##0") + %"tmp#89##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint( ptr @"string#23" to i64 ), i64 %"tmp#90##0") + tail call fastcc void @"wybe.string.print<0>[410bae77d3]"(i64 %"tmp#89##0") + call ccc void @putchar(i8 10) + store i64 14, ptr @"resource#failure_backtrack.s" + %"tmp#102##0" = tail call fastcc i64 @"wybe.int.fmt<2>"(i64 42, i64 0, i8 32) + %"tmp#105##0" = tail call fastcc i64 @"wybe.int.fmt<2>"(i64 21, i64 0, i8 32) + %"tmp#108##0" = tail call fastcc i64 @"wybe.int.fmt<2>"(i64 7, i64 0, i8 32) + %"tmp#110##0" = tail call fastcc i64 @"wybe.int.fmt<2>"(i64 14, i64 0, i8 32) + %"tmp#109##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint( ptr @"string#20" to i64 ), i64 %"tmp#110##0") + %"tmp#107##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 %"tmp#108##0", i64 %"tmp#109##0") + %"tmp#106##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint( ptr @"string#19" to i64 ), i64 %"tmp#107##0") + %"tmp#104##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 %"tmp#105##0", i64 %"tmp#106##0") + %"tmp#103##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint( ptr @"string#21" to i64 ), i64 %"tmp#104##0") + %"tmp#101##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 %"tmp#102##0", i64 %"tmp#103##0") + %"tmp#100##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint( ptr @"string#32" to i64 ), i64 %"tmp#101##0") + tail call fastcc void @"wybe.string.print<0>[410bae77d3]"(i64 %"tmp#100##0") + call ccc void @putchar(i8 10) + store i64 12, ptr @"resource#failure_backtrack.r" + %"tmp#160##0" = tail call fastcc i1 @"failure_backtrack.nope<0>"() + br i1 %"tmp#160##0", label %if.then.0, label %if.else.0 +if.then.0: + tail call fastcc void @"failure_backtrack.#cont#6<0>"(i64 %"tmp#139##0", i64 %"tmp#140##0", i64 28, i64 21) + ret void +if.else.0: + store i64 13, ptr @"resource#failure_backtrack.r" + %"tmp#159##0" = tail call fastcc i1 @"failure_backtrack.nope<0>"() + br i1 %"tmp#159##0", label %if.then.1, label %if.else.1 +if.then.1: + tail call fastcc void @"failure_backtrack.#cont#6<0>"(i64 %"tmp#139##0", i64 %"tmp#140##0", i64 29, i64 21) + ret void +if.else.1: + store i64 7, ptr @"resource#failure_backtrack.r" + tail call fastcc void @"failure_backtrack.#cont#6<0>"(i64 %"tmp#139##0", i64 %"tmp#140##0", i64 42, i64 21) + ret void } - -define external fastcc void @"failure_backtrack.#cont#6<0>"(i64 %"tmp#139##0", i64 %"tmp#140##0", i64 %"x##0", i64 %"y##0") { -entry: - %0 = tail call fastcc i64 @"wybe.int.fmt<2>"(i64 %"x##0", i64 0, i8 32) - %1 = tail call fastcc i64 @"wybe.int.fmt<2>"(i64 %"y##0", i64 0, i8 32) - %2 = load i64, i64* @"resource#failure_backtrack.r" - %3 = tail call fastcc i64 @"wybe.int.fmt<2>"(i64 %2, i64 0, i8 32) - %4 = load i64, i64* @"resource#failure_backtrack.s" - %5 = tail call fastcc i64 @"wybe.int.fmt<2>"(i64 %4, i64 0, i8 32) - %6 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @failure_backtrack.21, i32 0, i32 0) to i64), i64 %5) - %7 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 %3, i64 %6) - %8 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @failure_backtrack.1, i32 0, i32 0) to i64), i64 %7) - %9 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 %1, i64 %8) - %10 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @failure_backtrack.23, i32 0, i32 0) to i64), i64 %9) - %11 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 %0, i64 %10) - %12 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @failure_backtrack.37, i32 0, i32 0) to i64), i64 %11) - tail call fastcc void @"wybe.string.print<0>[410bae77d3]"(i64 %12) - tail call ccc void @putchar(i8 10) - store i64 %"tmp#139##0", i64* @"resource#failure_backtrack.r" - store i64 %"tmp#140##0", i64* @"resource#failure_backtrack.s" - ret void +define external fastcc void @"failure_backtrack.#cont#6<0>"(i64 %"tmp#139##0", i64 %"tmp#140##0", i64 %"x##0", i64 %"y##0") { + %"tmp#113##0" = tail call fastcc i64 @"wybe.int.fmt<2>"(i64 %"x##0", i64 0, i8 32) + %"tmp#116##0" = tail call fastcc i64 @"wybe.int.fmt<2>"(i64 %"y##0", i64 0, i8 32) + %"r##0" = load i64, ptr @"resource#failure_backtrack.r" + %"tmp#119##0" = tail call fastcc i64 @"wybe.int.fmt<2>"(i64 %"r##0", i64 0, i8 32) + %"s##0" = load i64, ptr @"resource#failure_backtrack.s" + %"tmp#121##0" = tail call fastcc i64 @"wybe.int.fmt<2>"(i64 %"s##0", i64 0, i8 32) + %"tmp#120##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint( ptr @"string#20" to i64 ), i64 %"tmp#121##0") + %"tmp#118##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 %"tmp#119##0", i64 %"tmp#120##0") + %"tmp#117##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint( ptr @"string#19" to i64 ), i64 %"tmp#118##0") + %"tmp#115##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 %"tmp#116##0", i64 %"tmp#117##0") + %"tmp#114##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint( ptr @"string#21" to i64 ), i64 %"tmp#115##0") + %"tmp#112##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 %"tmp#113##0", i64 %"tmp#114##0") + %"tmp#111##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint( ptr @"string#26" to i64 ), i64 %"tmp#112##0") + tail call fastcc void @"wybe.string.print<0>[410bae77d3]"(i64 %"tmp#111##0") + call ccc void @putchar(i8 10) + store i64 %"tmp#139##0", ptr @"resource#failure_backtrack.r" + store i64 %"tmp#140##0", ptr @"resource#failure_backtrack.s" + ret void } - -define external fastcc i1 @"failure_backtrack.nope<0>"() noinline { -entry: - ret i1 0 +define external fastcc i1 @"failure_backtrack.nope<0>"() { + ret i1 0 } - -define external fastcc {i64, i1} @"failure_backtrack.nope2<0>"() noinline { -entry: - %0 = insertvalue {i64, i1} undef, i64 2, 0 - %1 = insertvalue {i64, i1} %0, i1 0, 1 - ret {i64, i1} %1 +define external fastcc {i64, i1} @"failure_backtrack.nope2<0>"() { + %"tmp#0##0" = insertvalue {i64, i1} undef, i64 2, 0 + %"tmp#1##0" = insertvalue {i64, i1} %"tmp#0##0", i1 0, 1 + ret {i64, i1} %"tmp#1##0" } - -define external fastcc i1 @"failure_backtrack.yup<0>"() noinline { -entry: - ret i1 1 +define external fastcc i1 @"failure_backtrack.yup<0>"() { + ret i1 1 } diff --git a/test-cases/final-dump/failure_in_cond_test.exp b/test-cases/final-dump/failure_in_cond_test.exp index 1dca68b01..cb94f8d04 100644 --- a/test-cases/final-dump/failure_in_cond_test.exp +++ b/test-cases/final-dump/failure_in_cond_test.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module failure_in_cond_test representation : (not a type) public submods : @@ -29,31 +32,23 @@ foo(?i##3:wybe.int, ?#success##0:wybe.bool)<{}; {}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'failure_in_cond_test' - - - - -declare external ccc void @print_int(i64) +source_filename = "!ROOT!/final-dump/failure_in_cond_test.wybe" +target triple ???? -declare external ccc i8* @wybe_malloc(i32) +declare external ccc void @print_int(i64) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"failure_in_cond_test.<0>"() alwaysinline { -entry: - tail call ccc void @print_int(i64 1) - ret void +define external fastcc void @"failure_in_cond_test.<0>"() { + call ccc void @print_int(i64 1) + ret void } - -define external fastcc {i64, i1} @"failure_in_cond_test.foo<0>"() alwaysinline { -entry: - %0 = insertvalue {i64, i1} undef, i64 1, 0 - %1 = insertvalue {i64, i1} %0, i1 1, 1 - ret {i64, i1} %1 +define external fastcc {i64, i1} @"failure_in_cond_test.foo<0>"() { + %"tmp#0##0" = insertvalue {i64, i1} undef, i64 1, 0 + %"tmp#1##0" = insertvalue {i64, i1} %"tmp#0##0", i1 1, 1 + ret {i64, i1} %"tmp#1##0" } diff --git a/test-cases/final-dump/fn_update.exp b/test-cases/final-dump/fn_update.exp index 670a742e8..3da8c048f 100644 --- a/test-cases/final-dump/fn_update.exp +++ b/test-cases/final-dump/fn_update.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module fn_update representation : (not a type) public submods : @@ -28,55 +31,40 @@ module top-level code > public {semipure} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'fn_update' - - - - -@fn_update.1 = constant {i64, i64} { i64 3, i64 ptrtoint ([?? x i8]* @fn_update.0 to i64) } - - -@fn_update.0 = constant [?? x i8] c"p =\00" - - -declare external fastcc void @"position.printPosition<0>"(i64) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc void @putchar(i8) - - -declare external ccc void @print_int(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"fn_update.<0>"() { -entry: - tail call ccc void @print_int(i64 2) - tail call ccc void @putchar(i8 10) - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 5, i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 10, i64* %5 - %6 = add i64 %2, 8 - %7 = inttoptr i64 %6 to i64* - store i64 20, i64* %7 - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @fn_update.1, i32 0, i32 0) to i64)) - tail call fastcc void @"position.printPosition<0>"(i64 %2) - ret void +source_filename = "!ROOT!/final-dump/fn_update.wybe" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c"p =\00", align 8 +@"string#1" = private unnamed_addr constant {i64, i64} { i64 3, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 + +declare external fastcc void @"position.printPosition<0>"(i64) +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"fn_update.<0>"() { + call ccc void @print_int(i64 2) + call ccc void @putchar(i8 10) + %"tmp#17##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#10##0" = ptrtoint ptr %"tmp#17##0" to i64 + %"tmp#18##0" = inttoptr i64 %"tmp#10##0" to ptr + store i64 5, ptr %"tmp#18##0" + %"tmp#19##0" = add i64 %"tmp#10##0", 8 + %"tmp#20##0" = inttoptr i64 %"tmp#19##0" to ptr + store i64 10, ptr %"tmp#20##0" + %"tmp#21##0" = add i64 %"tmp#10##0", 8 + %"tmp#22##0" = inttoptr i64 %"tmp#21##0" to ptr + store i64 20, ptr %"tmp#22##0" + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#1" to i64 )) + tail call fastcc void @"position.printPosition<0>"(i64 %"tmp#10##0") + ret void } + -------------------------------------------------- Module position representation : (not a type) @@ -119,63 +107,42 @@ printPosition(pos##0:position.position)<{<>}; {<>}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'position' - - - - -@position.3 = constant {i64, i64} { i64 1, i64 ptrtoint ([?? x i8]* @position.2 to i64) } - - -@position.5 = constant {i64, i64} { i64 1, i64 ptrtoint ([?? x i8]* @position.4 to i64) } - - -@position.1 = constant {i64, i64} { i64 2, i64 ptrtoint ([?? x i8]* @position.0 to i64) } - - -@position.0 = constant [?? x i8] c" (\00" - - -@position.4 = constant [?? x i8] c")\00" - - -@position.2 = constant [?? x i8] c",\00" - - -declare external ccc void @putchar(i8) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc void @print_int(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"position.printPosition<0>"(i64 %"pos##0") { -entry: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @position.1, i32 0, i32 0) to i64)) - %0 = inttoptr i64 %"pos##0" to i64* - %1 = load i64, i64* %0 - tail call ccc void @print_int(i64 %1) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @position.3, i32 0, i32 0) to i64)) - %2 = add i64 %"pos##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - tail call ccc void @print_int(i64 %4) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @position.5, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - ret void +source_filename = "!ROOT!/final-dump/position.wybe" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c" (\00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c")\00", align 8 +@"cstring#2" = private unnamed_addr constant [ ?? x i8 ] c",\00", align 8 +@"string#3" = private unnamed_addr constant {i64, i64} { i64 2, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +@"string#4" = private unnamed_addr constant {i64, i64} { i64 1, i64 ptrtoint( ptr @"cstring#1" to i64 ) }, align 8 +@"string#5" = private unnamed_addr constant {i64, i64} { i64 1, i64 ptrtoint( ptr @"cstring#2" to i64 ) }, align 8 + +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"position.printPosition<0>"(i64 %"pos##0") { + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#3" to i64 )) + %"tmp#13##0" = inttoptr i64 %"pos##0" to ptr + %"tmp#0##0" = load i64, ptr %"tmp#13##0" + call ccc void @print_int(i64 %"tmp#0##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#5" to i64 )) + %"tmp#14##0" = add i64 %"pos##0", 8 + %"tmp#15##0" = inttoptr i64 %"tmp#14##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#15##0" + call ccc void @print_int(i64 %"tmp#1##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#4" to i64 )) + call ccc void @putchar(i8 10) + ret void } + -------------------------------------------------- Module position.position - representation : address + representation : pointer public submods : public resources: public procs : position.position.=<0> @@ -277,134 +244,110 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'position.position' - - - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i1 @"position.position.=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %"#right##0" to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = icmp eq i64 %1, %6 - br i1 %10, label %if.then, label %if.else -if.then: - %11 = icmp eq i64 %4, %9 - ret i1 %11 -if.else: - ret i1 0 +source_filename = "!ROOT!/final-dump/position.wybe" +target triple ???? + + +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc i1 @"position.position.=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#9##0" = inttoptr i64 %"#left##0" to ptr + %"#left#x##0" = load i64, ptr %"tmp#9##0" + %"tmp#10##0" = add i64 %"#left##0", 8 + %"tmp#11##0" = inttoptr i64 %"tmp#10##0" to ptr + %"#left#y##0" = load i64, ptr %"tmp#11##0" + %"tmp#12##0" = inttoptr i64 %"#right##0" to ptr + %"#right#x##0" = load i64, ptr %"tmp#12##0" + %"tmp#13##0" = add i64 %"#right##0", 8 + %"tmp#14##0" = inttoptr i64 %"tmp#13##0" to ptr + %"#right#y##0" = load i64, ptr %"tmp#14##0" + %"tmp#1##0" = icmp eq i64 %"#left#x##0", %"#right#x##0" + br i1 %"tmp#1##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#15##0" = icmp eq i64 %"#left#y##0", %"#right#y##0" + ret i1 %"tmp#15##0" +if.else.0: + ret i1 0 } - -define external fastcc i64 @"position.position.position<0>"(i64 %"x##0", i64 %"y##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"x##0", i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"y##0", i64* %5 - ret i64 %2 +define external fastcc i64 @"position.position.position<0>"(i64 %"x##0", i64 %"y##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 16) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"x##0", ptr %"tmp#1##0" + %"tmp#2##0" = add i64 %"#rec##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"y##0", ptr %"tmp#3##0" + ret i64 %"#rec##0" } - -define external fastcc {i64, i64} @"position.position.position<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#result##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#result##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = insertvalue {i64, i64} undef, i64 %1, 0 - %6 = insertvalue {i64, i64} %5, i64 %4, 1 - ret {i64, i64} %6 +define external fastcc {i64, i64} @"position.position.position<1>"(i64 %"#result##0") { + %"tmp#0##0" = inttoptr i64 %"#result##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + %"tmp#2##0" = add i64 %"#result##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#3##0" + %"tmp#5##0" = insertvalue {i64, i64} undef, i64 %"tmp#1##0", 0 + %"tmp#6##0" = insertvalue {i64, i64} %"tmp#5##0", i64 %"tmp#4##0", 1 + ret {i64, i64} %"tmp#6##0" } - -define external fastcc i64 @"position.position.x<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#rec##0" to i64* - %1 = load i64, i64* %0 - ret i64 %1 +define external fastcc i64 @"position.position.x<0>"(i64 %"#rec##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + ret i64 %"tmp#1##0" } - -define external fastcc i64 @"position.position.x<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = inttoptr i64 %2 to i64* - store i64 %"#field##0", i64* %6 - ret i64 %2 +define external fastcc i64 @"position.position.x<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"#field##0", ptr %"tmp#3##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"position.position.y<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = add i64 %"#rec##0", 8 - %1 = inttoptr i64 %0 to i64* - %2 = load i64, i64* %1 - ret i64 %2 +define external fastcc i64 @"position.position.y<0>"(i64 %"#rec##0") { + %"tmp#0##0" = add i64 %"#rec##0", 8 + %"tmp#1##0" = inttoptr i64 %"tmp#0##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"position.position.y<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = add i64 %2, 8 - %7 = inttoptr i64 %6 to i64* - store i64 %"#field##0", i64* %7 - ret i64 %2 +define external fastcc i64 @"position.position.y<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = add i64 %"tmp#2##0", 8 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 %"#field##0", ptr %"tmp#4##0" + ret i64 %"tmp#2##0" } - -define external fastcc i1 @"position.position.~=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %"#right##0" to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = icmp eq i64 %1, %6 - br i1 %10, label %if.then, label %if.else -if.then: - %11 = icmp eq i64 %4, %9 - %12 = xor i1 %11, 1 - ret i1 %12 -if.else: - %13 = xor i1 0, 1 - ret i1 %13 +define external fastcc i1 @"position.position.~=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#8##0" = inttoptr i64 %"#left##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#8##0" + %"tmp#9##0" = add i64 %"#left##0", 8 + %"tmp#10##0" = inttoptr i64 %"tmp#9##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#10##0" + %"tmp#11##0" = inttoptr i64 %"#right##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#11##0" + %"tmp#12##0" = add i64 %"#right##0", 8 + %"tmp#13##0" = inttoptr i64 %"tmp#12##0" to ptr + %"tmp#6##0" = load i64, ptr %"tmp#13##0" + %"tmp#7##0" = icmp eq i64 %"tmp#3##0", %"tmp#5##0" + br i1 %"tmp#7##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#0##0" = icmp eq i64 %"tmp#4##0", %"tmp#6##0" + %"tmp#14##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#14##0" +if.else.0: + %"tmp#15##0" = xor i1 0, 1 + ret i1 %"tmp#15##0" } diff --git a/test-cases/final-dump/foreign_def.exp b/test-cases/final-dump/foreign_def.exp index 2f73b03b7..b818ad180 100644 --- a/test-cases/final-dump/foreign_def.exp +++ b/test-cases/final-dump/foreign_def.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module foreign_def representation : (not a type) public submods : @@ -34,33 +37,25 @@ putchar(c##0:wybe.char)<{<>}; {<>}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'foreign_def' - - - - -declare external ccc void @putchar(i8) +source_filename = "!ROOT!/final-dump/foreign_def.wybe" +target triple ???? -declare external ccc i8* @wybe_malloc(i32) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"foreign_def.<0>"() { -entry: - tail call ccc void @putchar(i8 87) - tail call ccc void @putchar(i8 121) - tail call ccc void @putchar(i8 98) - tail call ccc void @putchar(i8 101) - ret void +define external fastcc void @"foreign_def.<0>"() { + call ccc void @putchar(i8 87) + call ccc void @putchar(i8 121) + call ccc void @putchar(i8 98) + call ccc void @putchar(i8 101) + ret void } - -define external fastcc void @"foreign_def.putchar<0>"(i8 %"c##0") alwaysinline { -entry: - tail call ccc void @putchar(i8 %"c##0") - ret void +define external fastcc void @"foreign_def.putchar<0>"(i8 %"c##0") { + call ccc void @putchar(i8 %"c##0") + ret void } diff --git a/test-cases/final-dump/foreign_def_unordered.exp b/test-cases/final-dump/foreign_def_unordered.exp index 6af11a27d..02c21968a 100644 --- a/test-cases/final-dump/foreign_def_unordered.exp +++ b/test-cases/final-dump/foreign_def_unordered.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module foreign_def_unordered representation : (not a type) public submods : @@ -218,276 +221,194 @@ repeated(x##0:wybe.int)<{<>, < LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'foreign_def_unordered' - - - - -@"resource#foreign_def_unordered.a" = global i64 undef - - -@"resource#foreign_def_unordered.b" = global i64 undef - - -declare external ccc i64 @repeated(i64, i64, i64, i64, i64) - - -declare external ccc i64 @out_in(i64) - - -declare external ccc {i64, i64} @b_out_a_out() - - -declare external ccc {i64, i64} @b_out_a_inout(i64) - - -declare external ccc i64 @b_out_a_in(i64) - - -declare external ccc {i64, i64} @b_inout_a_out(i64) - - -declare external ccc {i64, i64} @b_inout_a_inout(i64, i64) - - -declare external ccc i64 @b_inout_a_in(i64, i64) - - -declare external ccc i64 @b_in_a_out(i64) - - -declare external ccc i64 @b_in_a_inout(i64, i64) - - -declare external ccc {i64, i64} @a_out_b_out() - - -declare external ccc {i64, i64} @a_out_b_inout(i64) - - -declare external ccc i64 @a_out_b_in(i64) - - -declare external ccc {i64, i64} @a_inout_b_out(i64) - - -declare external ccc {i64, i64} @a_inout_b_inout(i64, i64) - - -declare external ccc i64 @a_inout_b_in(i64, i64) - - -declare external ccc i64 @a_in_b_out(i64) - - -declare external ccc i64 @a_in_b_inout(i64, i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"foreign_def_unordered.a_in_b_in<0>"() alwaysinline { -entry: - ret void +source_filename = "!ROOT!/final-dump/foreign_def_unordered.wybe" +target triple ???? + + +declare external ccc i64 @a_in_b_inout(i64, i64) +declare external ccc i64 @a_in_b_out(i64) +declare external ccc i64 @a_inout_b_in(i64, i64) +declare external ccc {i64, i64} @a_inout_b_inout(i64, i64) +declare external ccc {i64, i64} @a_inout_b_out(i64) +declare external ccc i64 @a_out_b_in(i64) +declare external ccc {i64, i64} @a_out_b_inout(i64) +declare external ccc {i64, i64} @a_out_b_out() +declare external ccc i64 @b_in_a_inout(i64, i64) +declare external ccc i64 @b_in_a_out(i64) +declare external ccc i64 @b_inout_a_in(i64, i64) +declare external ccc {i64, i64} @b_inout_a_inout(i64, i64) +declare external ccc {i64, i64} @b_inout_a_out(i64) +declare external ccc i64 @b_out_a_in(i64) +declare external ccc {i64, i64} @b_out_a_inout(i64) +declare external ccc {i64, i64} @b_out_a_out() +declare external ccc i64 @out_in(i64) +declare external ccc i64 @repeated(i64, i64, i64, i64, i64) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) +@"resource#foreign_def_unordered.a" = global i64 undef +@"resource#foreign_def_unordered.b" = global i64 undef + +define external fastcc void @"foreign_def_unordered.a_in_b_in<0>"() { + ret void } - -define external fastcc void @"foreign_def_unordered.a_in_b_inout<0>"() alwaysinline { -entry: - %0 = load i64, i64* @"resource#foreign_def_unordered.a" - %1 = load i64, i64* @"resource#foreign_def_unordered.b" - %2 = tail call ccc i64 @a_in_b_inout(i64 %0, i64 %1) - store i64 %2, i64* @"resource#foreign_def_unordered.b" - ret void +define external fastcc void @"foreign_def_unordered.a_in_b_inout<0>"() { + %"tmp#0##0" = load i64, ptr @"resource#foreign_def_unordered.a" + %"b##0" = load i64, ptr @"resource#foreign_def_unordered.b" + %"b##1" = call ccc i64 @a_in_b_inout(i64 %"tmp#0##0", i64 %"b##0") + store i64 %"b##1", ptr @"resource#foreign_def_unordered.b" + ret void } - -define external fastcc void @"foreign_def_unordered.a_in_b_out<0>"() alwaysinline { -entry: - %0 = load i64, i64* @"resource#foreign_def_unordered.a" - %1 = tail call ccc i64 @a_in_b_out(i64 %0) - store i64 %1, i64* @"resource#foreign_def_unordered.b" - ret void +define external fastcc void @"foreign_def_unordered.a_in_b_out<0>"() { + %"tmp#0##0" = load i64, ptr @"resource#foreign_def_unordered.a" + %"b##0" = call ccc i64 @a_in_b_out(i64 %"tmp#0##0") + store i64 %"b##0", ptr @"resource#foreign_def_unordered.b" + ret void } - -define external fastcc void @"foreign_def_unordered.a_inout_b_in<0>"() alwaysinline { -entry: - %0 = load i64, i64* @"resource#foreign_def_unordered.b" - %1 = load i64, i64* @"resource#foreign_def_unordered.a" - %2 = tail call ccc i64 @a_inout_b_in(i64 %1, i64 %0) - store i64 %2, i64* @"resource#foreign_def_unordered.a" - ret void +define external fastcc void @"foreign_def_unordered.a_inout_b_in<0>"() { + %"tmp#0##0" = load i64, ptr @"resource#foreign_def_unordered.b" + %"a##0" = load i64, ptr @"resource#foreign_def_unordered.a" + %"a##1" = call ccc i64 @a_inout_b_in(i64 %"a##0", i64 %"tmp#0##0") + store i64 %"a##1", ptr @"resource#foreign_def_unordered.a" + ret void } - -define external fastcc void @"foreign_def_unordered.a_inout_b_inout<0>"() alwaysinline { -entry: - %0 = load i64, i64* @"resource#foreign_def_unordered.a" - %1 = load i64, i64* @"resource#foreign_def_unordered.b" - %2 = tail call ccc {i64, i64} @a_inout_b_inout(i64 %0, i64 %1) - %3 = extractvalue {i64, i64} %2, 0 - %4 = extractvalue {i64, i64} %2, 1 - store i64 %3, i64* @"resource#foreign_def_unordered.a" - store i64 %4, i64* @"resource#foreign_def_unordered.b" - ret void +define external fastcc void @"foreign_def_unordered.a_inout_b_inout<0>"() { + %"a##0" = load i64, ptr @"resource#foreign_def_unordered.a" + %"b##0" = load i64, ptr @"resource#foreign_def_unordered.b" + %"tmp#0##0" = call ccc {i64, i64} @a_inout_b_inout(i64 %"a##0", i64 %"b##0") + %"a##1" = extractvalue {i64, i64}%"tmp#0##0", 0 + %"b##1" = extractvalue {i64, i64}%"tmp#0##0", 1 + store i64 %"a##1", ptr @"resource#foreign_def_unordered.a" + store i64 %"b##1", ptr @"resource#foreign_def_unordered.b" + ret void } - -define external fastcc void @"foreign_def_unordered.a_inout_b_out<0>"() alwaysinline { -entry: - %0 = load i64, i64* @"resource#foreign_def_unordered.a" - %1 = tail call ccc {i64, i64} @a_inout_b_out(i64 %0) - %2 = extractvalue {i64, i64} %1, 0 - %3 = extractvalue {i64, i64} %1, 1 - store i64 %2, i64* @"resource#foreign_def_unordered.a" - store i64 %3, i64* @"resource#foreign_def_unordered.b" - ret void +define external fastcc void @"foreign_def_unordered.a_inout_b_out<0>"() { + %"a##0" = load i64, ptr @"resource#foreign_def_unordered.a" + %"tmp#0##0" = call ccc {i64, i64} @a_inout_b_out(i64 %"a##0") + %"a##1" = extractvalue {i64, i64}%"tmp#0##0", 0 + %"b##0" = extractvalue {i64, i64}%"tmp#0##0", 1 + store i64 %"a##1", ptr @"resource#foreign_def_unordered.a" + store i64 %"b##0", ptr @"resource#foreign_def_unordered.b" + ret void } - -define external fastcc void @"foreign_def_unordered.a_out_b_in<0>"() alwaysinline { -entry: - %0 = load i64, i64* @"resource#foreign_def_unordered.b" - %1 = tail call ccc i64 @a_out_b_in(i64 %0) - store i64 %1, i64* @"resource#foreign_def_unordered.a" - ret void +define external fastcc void @"foreign_def_unordered.a_out_b_in<0>"() { + %"tmp#0##0" = load i64, ptr @"resource#foreign_def_unordered.b" + %"a##0" = call ccc i64 @a_out_b_in(i64 %"tmp#0##0") + store i64 %"a##0", ptr @"resource#foreign_def_unordered.a" + ret void } - -define external fastcc void @"foreign_def_unordered.a_out_b_inout<0>"() alwaysinline { -entry: - %0 = load i64, i64* @"resource#foreign_def_unordered.b" - %1 = tail call ccc {i64, i64} @a_out_b_inout(i64 %0) - %2 = extractvalue {i64, i64} %1, 0 - %3 = extractvalue {i64, i64} %1, 1 - store i64 %2, i64* @"resource#foreign_def_unordered.a" - store i64 %3, i64* @"resource#foreign_def_unordered.b" - ret void +define external fastcc void @"foreign_def_unordered.a_out_b_inout<0>"() { + %"b##0" = load i64, ptr @"resource#foreign_def_unordered.b" + %"tmp#0##0" = call ccc {i64, i64} @a_out_b_inout(i64 %"b##0") + %"a##0" = extractvalue {i64, i64}%"tmp#0##0", 0 + %"b##1" = extractvalue {i64, i64}%"tmp#0##0", 1 + store i64 %"a##0", ptr @"resource#foreign_def_unordered.a" + store i64 %"b##1", ptr @"resource#foreign_def_unordered.b" + ret void } - -define external fastcc void @"foreign_def_unordered.a_out_b_out<0>"() alwaysinline { -entry: - %0 = tail call ccc {i64, i64} @a_out_b_out() - %1 = extractvalue {i64, i64} %0, 0 - %2 = extractvalue {i64, i64} %0, 1 - store i64 %1, i64* @"resource#foreign_def_unordered.a" - store i64 %2, i64* @"resource#foreign_def_unordered.b" - ret void +define external fastcc void @"foreign_def_unordered.a_out_b_out<0>"() { + %"tmp#0##0" = call ccc {i64, i64} @a_out_b_out() + %"a##0" = extractvalue {i64, i64}%"tmp#0##0", 0 + %"b##0" = extractvalue {i64, i64}%"tmp#0##0", 1 + store i64 %"a##0", ptr @"resource#foreign_def_unordered.a" + store i64 %"b##0", ptr @"resource#foreign_def_unordered.b" + ret void } - -define external fastcc void @"foreign_def_unordered.b_in_a_in<0>"() alwaysinline { -entry: - ret void +define external fastcc void @"foreign_def_unordered.b_in_a_in<0>"() { + ret void } - -define external fastcc void @"foreign_def_unordered.b_in_a_inout<0>"() alwaysinline { -entry: - %0 = load i64, i64* @"resource#foreign_def_unordered.b" - %1 = load i64, i64* @"resource#foreign_def_unordered.a" - %2 = tail call ccc i64 @b_in_a_inout(i64 %0, i64 %1) - store i64 %2, i64* @"resource#foreign_def_unordered.a" - ret void +define external fastcc void @"foreign_def_unordered.b_in_a_inout<0>"() { + %"tmp#0##0" = load i64, ptr @"resource#foreign_def_unordered.b" + %"a##0" = load i64, ptr @"resource#foreign_def_unordered.a" + %"a##1" = call ccc i64 @b_in_a_inout(i64 %"tmp#0##0", i64 %"a##0") + store i64 %"a##1", ptr @"resource#foreign_def_unordered.a" + ret void } - -define external fastcc void @"foreign_def_unordered.b_in_a_out<0>"() alwaysinline { -entry: - %0 = load i64, i64* @"resource#foreign_def_unordered.b" - %1 = tail call ccc i64 @b_in_a_out(i64 %0) - store i64 %1, i64* @"resource#foreign_def_unordered.a" - ret void +define external fastcc void @"foreign_def_unordered.b_in_a_out<0>"() { + %"tmp#0##0" = load i64, ptr @"resource#foreign_def_unordered.b" + %"a##0" = call ccc i64 @b_in_a_out(i64 %"tmp#0##0") + store i64 %"a##0", ptr @"resource#foreign_def_unordered.a" + ret void } - -define external fastcc void @"foreign_def_unordered.b_inout_a_in<0>"() alwaysinline { -entry: - %0 = load i64, i64* @"resource#foreign_def_unordered.a" - %1 = load i64, i64* @"resource#foreign_def_unordered.b" - %2 = tail call ccc i64 @b_inout_a_in(i64 %1, i64 %0) - store i64 %2, i64* @"resource#foreign_def_unordered.b" - ret void +define external fastcc void @"foreign_def_unordered.b_inout_a_in<0>"() { + %"tmp#0##0" = load i64, ptr @"resource#foreign_def_unordered.a" + %"b##0" = load i64, ptr @"resource#foreign_def_unordered.b" + %"b##1" = call ccc i64 @b_inout_a_in(i64 %"b##0", i64 %"tmp#0##0") + store i64 %"b##1", ptr @"resource#foreign_def_unordered.b" + ret void } - -define external fastcc void @"foreign_def_unordered.b_inout_a_inout<0>"() alwaysinline { -entry: - %0 = load i64, i64* @"resource#foreign_def_unordered.a" - %1 = load i64, i64* @"resource#foreign_def_unordered.b" - %2 = tail call ccc {i64, i64} @b_inout_a_inout(i64 %1, i64 %0) - %3 = extractvalue {i64, i64} %2, 0 - %4 = extractvalue {i64, i64} %2, 1 - store i64 %4, i64* @"resource#foreign_def_unordered.a" - store i64 %3, i64* @"resource#foreign_def_unordered.b" - ret void +define external fastcc void @"foreign_def_unordered.b_inout_a_inout<0>"() { + %"a##0" = load i64, ptr @"resource#foreign_def_unordered.a" + %"b##0" = load i64, ptr @"resource#foreign_def_unordered.b" + %"tmp#0##0" = call ccc {i64, i64} @b_inout_a_inout(i64 %"b##0", i64 %"a##0") + %"b##1" = extractvalue {i64, i64}%"tmp#0##0", 0 + %"a##1" = extractvalue {i64, i64}%"tmp#0##0", 1 + store i64 %"a##1", ptr @"resource#foreign_def_unordered.a" + store i64 %"b##1", ptr @"resource#foreign_def_unordered.b" + ret void } - -define external fastcc void @"foreign_def_unordered.b_inout_a_out<0>"() alwaysinline { -entry: - %0 = load i64, i64* @"resource#foreign_def_unordered.b" - %1 = tail call ccc {i64, i64} @b_inout_a_out(i64 %0) - %2 = extractvalue {i64, i64} %1, 0 - %3 = extractvalue {i64, i64} %1, 1 - store i64 %3, i64* @"resource#foreign_def_unordered.a" - store i64 %2, i64* @"resource#foreign_def_unordered.b" - ret void +define external fastcc void @"foreign_def_unordered.b_inout_a_out<0>"() { + %"b##0" = load i64, ptr @"resource#foreign_def_unordered.b" + %"tmp#0##0" = call ccc {i64, i64} @b_inout_a_out(i64 %"b##0") + %"b##1" = extractvalue {i64, i64}%"tmp#0##0", 0 + %"a##0" = extractvalue {i64, i64}%"tmp#0##0", 1 + store i64 %"a##0", ptr @"resource#foreign_def_unordered.a" + store i64 %"b##1", ptr @"resource#foreign_def_unordered.b" + ret void } - -define external fastcc void @"foreign_def_unordered.b_out_a_in<0>"() alwaysinline { -entry: - %0 = load i64, i64* @"resource#foreign_def_unordered.a" - %1 = tail call ccc i64 @b_out_a_in(i64 %0) - store i64 %1, i64* @"resource#foreign_def_unordered.b" - ret void +define external fastcc void @"foreign_def_unordered.b_out_a_in<0>"() { + %"tmp#0##0" = load i64, ptr @"resource#foreign_def_unordered.a" + %"b##0" = call ccc i64 @b_out_a_in(i64 %"tmp#0##0") + store i64 %"b##0", ptr @"resource#foreign_def_unordered.b" + ret void } - -define external fastcc void @"foreign_def_unordered.b_out_a_inout<0>"() alwaysinline { -entry: - %0 = load i64, i64* @"resource#foreign_def_unordered.a" - %1 = tail call ccc {i64, i64} @b_out_a_inout(i64 %0) - %2 = extractvalue {i64, i64} %1, 0 - %3 = extractvalue {i64, i64} %1, 1 - store i64 %3, i64* @"resource#foreign_def_unordered.a" - store i64 %2, i64* @"resource#foreign_def_unordered.b" - ret void +define external fastcc void @"foreign_def_unordered.b_out_a_inout<0>"() { + %"a##0" = load i64, ptr @"resource#foreign_def_unordered.a" + %"tmp#0##0" = call ccc {i64, i64} @b_out_a_inout(i64 %"a##0") + %"b##0" = extractvalue {i64, i64}%"tmp#0##0", 0 + %"a##1" = extractvalue {i64, i64}%"tmp#0##0", 1 + store i64 %"a##1", ptr @"resource#foreign_def_unordered.a" + store i64 %"b##0", ptr @"resource#foreign_def_unordered.b" + ret void } - -define external fastcc void @"foreign_def_unordered.b_out_a_out<0>"() alwaysinline { -entry: - %0 = tail call ccc {i64, i64} @b_out_a_out() - %1 = extractvalue {i64, i64} %0, 0 - %2 = extractvalue {i64, i64} %0, 1 - store i64 %2, i64* @"resource#foreign_def_unordered.a" - store i64 %1, i64* @"resource#foreign_def_unordered.b" - ret void +define external fastcc void @"foreign_def_unordered.b_out_a_out<0>"() { + %"tmp#0##0" = call ccc {i64, i64} @b_out_a_out() + %"b##0" = extractvalue {i64, i64}%"tmp#0##0", 0 + %"a##0" = extractvalue {i64, i64}%"tmp#0##0", 1 + store i64 %"a##0", ptr @"resource#foreign_def_unordered.a" + store i64 %"b##0", ptr @"resource#foreign_def_unordered.b" + ret void } - -define external fastcc void @"foreign_def_unordered.out_in<0>"() alwaysinline { -entry: - %0 = load i64, i64* @"resource#foreign_def_unordered.a" - %1 = tail call ccc i64 @out_in(i64 %0) - store i64 %1, i64* @"resource#foreign_def_unordered.a" - ret void +define external fastcc void @"foreign_def_unordered.out_in<0>"() { + %"a##0" = load i64, ptr @"resource#foreign_def_unordered.a" + %"a##1" = call ccc i64 @out_in(i64 %"a##0") + store i64 %"a##1", ptr @"resource#foreign_def_unordered.a" + ret void } - -define external fastcc void @"foreign_def_unordered.repeated<0>"(i64 %"x##0") alwaysinline { -entry: - %0 = load i64, i64* @"resource#foreign_def_unordered.b" - %1 = load i64, i64* @"resource#foreign_def_unordered.a" - %2 = tail call ccc i64 @repeated(i64 %"x##0", i64 %1, i64 %0, i64 %0, i64 %1) - store i64 %2, i64* @"resource#foreign_def_unordered.a" - ret void +define external fastcc void @"foreign_def_unordered.repeated<0>"(i64 %"x##0") { + %"tmp#0##0" = load i64, ptr @"resource#foreign_def_unordered.b" + %"a##0" = load i64, ptr @"resource#foreign_def_unordered.a" + %"a##1" = call ccc i64 @repeated(i64 %"x##0", i64 %"a##0", i64 %"tmp#0##0", i64 %"tmp#0##0", i64 %"a##0") + store i64 %"a##1", ptr @"resource#foreign_def_unordered.a" + ret void } diff --git a/test-cases/final-dump/foreign_test.exp b/test-cases/final-dump/foreign_test.exp index b5ef441d0..50c0d8547 100644 --- a/test-cases/final-dump/foreign_test.exp +++ b/test-cases/final-dump/foreign_test.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module foreign_test representation : (not a type) public submods : @@ -87,107 +90,71 @@ neq(x##0:wybe.c_string, y##0:wybe.c_string, ?#success##0:wybe.bool)<{}; {}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'foreign_test' - - - - -@foreign_test.1 = constant {i64, i64} { i64 7, i64 ptrtoint ([?? x i8]* @foreign_test.0 to i64) } - - -@foreign_test.4 = constant {i64, i64} { i64 25, i64 ptrtoint ([?? x i8]* @foreign_test.3 to i64) } - - -@foreign_test.7 = constant {i64, i64} { i64 25, i64 ptrtoint ([?? x i8]* @foreign_test.6 to i64) } - - -@foreign_test.0 = constant [?? x i8] c"lt(1,2)\00" - - -@foreign_test.3 = constant [?? x i8] c"neq(c\22string\22, c\22string\22)\00" - - -@foreign_test.6 = constant [?? x i8] c"neq(c\22string\22, c\22strong\22)\00" - - -@foreign_test.2 = constant [?? x i8] c"string\00" - - -@foreign_test.5 = constant [?? x i8] c"strong\00" - - -declare external ccc i64 @strcmp(i64, i64) - - -declare external ccc void @putchar(i8) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"foreign_test.<0>"() alwaysinline { -entry: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @foreign_test.1, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - musttail call fastcc void @"foreign_test.#cont#2<0>"() - ret void +source_filename = "!ROOT!/final-dump/foreign_test.wybe" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c"lt(1,2)\00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c"neq(c\22string\22, c\22string\22)\00", align 8 +@"cstring#2" = private unnamed_addr constant [ ?? x i8 ] c"neq(c\22string\22, c\22strong\22)\00", align 8 +@"cstring#3" = private unnamed_addr constant [ ?? x i8 ] c"string\00", align 8 +@"cstring#4" = private unnamed_addr constant [ ?? x i8 ] c"strong\00", align 8 +@"string#5" = private unnamed_addr constant {i64, i64} { i64 7, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +@"string#6" = private unnamed_addr constant {i64, i64} { i64 25, i64 ptrtoint( ptr @"cstring#1" to i64 ) }, align 8 +@"string#7" = private unnamed_addr constant {i64, i64} { i64 25, i64 ptrtoint( ptr @"cstring#2" to i64 ) }, align 8 + +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @putchar(i8) +declare external ccc i64 @strcmp(i64, i64) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"foreign_test.<0>"() { + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#5" to i64 )) + call ccc void @putchar(i8 10) + tail call fastcc void @"foreign_test.#cont#2<0>"() + ret void } - -define external fastcc void @"foreign_test.#cont#1<0>"() alwaysinline { -entry: - musttail call fastcc void @"foreign_test.#cont#2<0>"() - ret void +define external fastcc void @"foreign_test.#cont#1<0>"() { + tail call fastcc void @"foreign_test.#cont#2<0>"() + ret void } - -define external fastcc void @"foreign_test.#cont#2<0>"() { -entry: - %0 = tail call ccc i64 @strcmp(i64 ptrtoint (i8* getelementptr inbounds ([?? x i8], [?? x i8]* @foreign_test.2, i32 0, i32 0) to i64), i64 ptrtoint (i8* getelementptr inbounds ([?? x i8], [?? x i8]* @foreign_test.2, i32 0, i32 0) to i64)) - %1 = icmp ne i64 %0, 0 - br i1 %1, label %if.then, label %if.else -if.then: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @foreign_test.4, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - musttail call fastcc void @"foreign_test.#cont#3<0>"() - ret void -if.else: - musttail call fastcc void @"foreign_test.#cont#3<0>"() - ret void +define external fastcc void @"foreign_test.#cont#2<0>"() { + %"tmp#4##0" = call ccc i64 @strcmp(i64 ptrtoint( ptr @"cstring#3" to i64 ), i64 ptrtoint( ptr @"cstring#3" to i64 )) + %"tmp#1##0" = icmp ne i64 %"tmp#4##0", 0 + br i1 %"tmp#1##0", label %if.then.0, label %if.else.0 +if.then.0: + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#6" to i64 )) + call ccc void @putchar(i8 10) + tail call fastcc void @"foreign_test.#cont#3<0>"() + ret void +if.else.0: + tail call fastcc void @"foreign_test.#cont#3<0>"() + ret void } - -define external fastcc void @"foreign_test.#cont#3<0>"() { -entry: - %0 = tail call ccc i64 @strcmp(i64 ptrtoint (i8* getelementptr inbounds ([?? x i8], [?? x i8]* @foreign_test.2, i32 0, i32 0) to i64), i64 ptrtoint (i8* getelementptr inbounds ([?? x i8], [?? x i8]* @foreign_test.5, i32 0, i32 0) to i64)) - %1 = icmp ne i64 %0, 0 - br i1 %1, label %if.then, label %if.else -if.then: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @foreign_test.7, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - ret void -if.else: - ret void +define external fastcc void @"foreign_test.#cont#3<0>"() { + %"tmp#3##0" = call ccc i64 @strcmp(i64 ptrtoint( ptr @"cstring#3" to i64 ), i64 ptrtoint( ptr @"cstring#4" to i64 )) + %"tmp#0##0" = icmp ne i64 %"tmp#3##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#7" to i64 )) + call ccc void @putchar(i8 10) + ret void +if.else.0: + ret void } - -define external fastcc i1 @"foreign_test.lt<0>"(i64 %"x##0", i64 %"y##0") alwaysinline { -entry: - %0 = icmp slt i64 %"x##0", %"y##0" - ret i1 %0 +define external fastcc i1 @"foreign_test.lt<0>"(i64 %"x##0", i64 %"y##0") { + %"tmp#1##0" = icmp slt i64 %"x##0", %"y##0" + ret i1 %"tmp#1##0" } - -define external fastcc i1 @"foreign_test.neq<0>"(i64 %"x##0", i64 %"y##0") alwaysinline { -entry: - %0 = tail call ccc i64 @strcmp(i64 %"x##0", i64 %"y##0") - %1 = icmp ne i64 %0, 0 - ret i1 %1 +define external fastcc i1 @"foreign_test.neq<0>"(i64 %"x##0", i64 %"y##0") { + %"tmp#0##0" = call ccc i64 @strcmp(i64 %"x##0", i64 %"y##0") + %"tmp#2##0" = icmp ne i64 %"tmp#0##0", 0 + ret i1 %"tmp#2##0" } diff --git a/test-cases/final-dump/func_factorial.exp b/test-cases/final-dump/func_factorial.exp index 3045698ab..17ddafedd 100644 --- a/test-cases/final-dump/func_factorial.exp +++ b/test-cases/final-dump/func_factorial.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module func_factorial representation : (not a type) public submods : @@ -40,42 +43,32 @@ factorial(n##0:wybe.int, ?#result##0:wybe.int)<{}; {}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'func_factorial' +source_filename = "!ROOT!/final-dump/func_factorial.wybe" +target triple ???? - - - -declare external ccc void @putchar(i8) - - -declare external ccc void @print_int(i64) +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"func_factorial.<0>"() { -entry: - %0 = tail call fastcc i64 @"func_factorial.factorial<0>"(i64 5) - tail call ccc void @print_int(i64 %0) - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"func_factorial.<0>"() { + %"tmp#0##0" = tail call fastcc i64 @"func_factorial.factorial<0>"(i64 5) + call ccc void @print_int(i64 %"tmp#0##0") + call ccc void @putchar(i8 10) + ret void } - -define external fastcc i64 @"func_factorial.factorial<0>"(i64 %"n##0") { -entry: - %0 = icmp sle i64 %"n##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - ret i64 1 -if.else: - %1 = sub i64 %"n##0", 1 - %2 = tail call fastcc i64 @"func_factorial.factorial<0>"(i64 %1) - %3 = mul i64 %"n##0", %2 - ret i64 %3 +define external fastcc i64 @"func_factorial.factorial<0>"(i64 %"n##0") { + %"tmp#4##0" = icmp sle i64 %"n##0", 0 + br i1 %"tmp#4##0", label %if.then.0, label %if.else.0 +if.then.0: + ret i64 1 +if.else.0: + %"tmp#3##0" = sub i64 %"n##0", 1 + %"tmp#2##0" = tail call fastcc i64 @"func_factorial.factorial<0>"(i64 %"tmp#3##0") + %"tmp#11##0" = mul i64 %"n##0", %"tmp#2##0" + ret i64 %"tmp#11##0" } diff --git a/test-cases/final-dump/func_let.exp b/test-cases/final-dump/func_let.exp index 04b90f016..fe66bbb8e 100644 --- a/test-cases/final-dump/func_let.exp +++ b/test-cases/final-dump/func_let.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module func_let representation : (not a type) public submods : @@ -30,31 +33,23 @@ quad(x##0:wybe.int, ?#result##0:wybe.int)<{}; {}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'func_let' - - - - -declare external ccc void @print_int(i64) +source_filename = "!ROOT!/final-dump/func_let.wybe" +target triple ???? -declare external ccc i8* @wybe_malloc(i32) +declare external ccc void @print_int(i64) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"func_let.<0>"() alwaysinline { -entry: - tail call ccc void @print_int(i64 40) - ret void +define external fastcc void @"func_let.<0>"() { + call ccc void @print_int(i64 40) + ret void } - -define external fastcc i64 @"func_let.quad<0>"(i64 %"x##0") alwaysinline { -entry: - %0 = add i64 %"x##0", %"x##0" - %1 = add i64 %0, %0 - ret i64 %1 +define external fastcc i64 @"func_let.quad<0>"(i64 %"x##0") { + %"tmp#0##0" = add i64 %"x##0", %"x##0" + %"tmp#6##0" = add i64 %"tmp#0##0", %"tmp#0##0" + ret i64 %"tmp#6##0" } diff --git a/test-cases/final-dump/func_quadruple.exp b/test-cases/final-dump/func_quadruple.exp index f3cd667de..8eb58a116 100644 --- a/test-cases/final-dump/func_quadruple.exp +++ b/test-cases/final-dump/func_quadruple.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module func_quadruple representation : (not a type) public submods : @@ -28,28 +31,22 @@ quadruple(a##0:wybe.int, ?#result##0:wybe.int)<{}; {}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'func_quadruple' +source_filename = "!ROOT!/final-dump/func_quadruple.wybe" +target triple ???? - - - -declare external ccc i8* @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i64 @"func_quadruple.double<0>"(i64 %"a##0") alwaysinline { -entry: - %0 = add i64 %"a##0", %"a##0" - ret i64 %0 +define external fastcc i64 @"func_quadruple.double<0>"(i64 %"a##0") { + %"tmp#3##0" = add i64 %"a##0", %"a##0" + ret i64 %"tmp#3##0" } - -define external fastcc i64 @"func_quadruple.quadruple<0>"(i64 %"a##0") alwaysinline { -entry: - %0 = add i64 %"a##0", %"a##0" - %1 = add i64 %0, %0 - ret i64 %1 +define external fastcc i64 @"func_quadruple.quadruple<0>"(i64 %"a##0") { + %"tmp#1##0" = add i64 %"a##0", %"a##0" + %"tmp#4##0" = add i64 %"tmp#1##0", %"tmp#1##0" + ret i64 %"tmp#4##0" } diff --git a/test-cases/final-dump/func_typed.exp b/test-cases/final-dump/func_typed.exp index d648c07cc..f0fd19d5b 100644 --- a/test-cases/final-dump/func_typed.exp +++ b/test-cases/final-dump/func_typed.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module func_typed representation : (not a type) public submods : @@ -18,20 +21,16 @@ plus(a##0:wybe.int, b##0:wybe.int, ?#result##0:wybe.int)<{}; {}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'func_typed' +source_filename = "!ROOT!/final-dump/func_typed.wybe" +target triple ???? - - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -define external fastcc i64 @"func_typed.plus<0>"(i64 %"a##0", i64 %"b##0") alwaysinline { -entry: - %0 = add i64 %"a##0", %"b##0" - ret i64 %0 +define external fastcc i64 @"func_typed.plus<0>"(i64 %"a##0", i64 %"b##0") { + %"tmp#3##0" = add i64 %"a##0", %"b##0" + ret i64 %"tmp#3##0" } diff --git a/test-cases/final-dump/func_untyped.exp b/test-cases/final-dump/func_untyped.exp index 1f8b51abd..94dac142d 100644 --- a/test-cases/final-dump/func_untyped.exp +++ b/test-cases/final-dump/func_untyped.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module func_untyped representation : (not a type) public submods : @@ -18,20 +21,16 @@ incr(a##0:wybe.int, ?#result##0:wybe.int)<{}; {}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'func_untyped' +source_filename = "!ROOT!/final-dump/func_untyped.wybe" +target triple ???? - - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -define external fastcc i64 @"func_untyped.incr<0>"(i64 %"a##0") alwaysinline { -entry: - %0 = add i64 %"a##0", 1 - ret i64 %0 +define external fastcc i64 @"func_untyped.incr<0>"(i64 %"a##0") { + %"tmp#3##0" = add i64 %"a##0", 1 + ret i64 %"tmp#3##0" } diff --git a/test-cases/final-dump/func_where.exp b/test-cases/final-dump/func_where.exp index 463740222..04d3ace8b 100644 --- a/test-cases/final-dump/func_where.exp +++ b/test-cases/final-dump/func_where.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module func_where representation : (not a type) public submods : @@ -19,21 +22,17 @@ quad(x##0:wybe.int, ?#result##0:wybe.int)<{}; {}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'func_where' +source_filename = "!ROOT!/final-dump/func_where.wybe" +target triple ???? - - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -define external fastcc i64 @"func_where.quad<0>"(i64 %"x##0") alwaysinline { -entry: - %0 = add i64 %"x##0", %"x##0" - %1 = add i64 %0, %0 - ret i64 %1 +define external fastcc i64 @"func_where.quad<0>"(i64 %"x##0") { + %"tmp#0##0" = add i64 %"x##0", %"x##0" + %"tmp#6##0" = add i64 %"tmp#0##0", %"tmp#0##0" + ret i64 %"tmp#6##0" } diff --git a/test-cases/final-dump/generic_list.exp b/test-cases/final-dump/generic_list.exp index 219e50802..8b6c898f1 100644 --- a/test-cases/final-dump/generic_list.exp +++ b/test-cases/final-dump/generic_list.exp @@ -1,7 +1,10 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module generic_list(T) - representation : address + representation : pointer public submods : public resources: public procs : generic_list.append<0> @@ -163,188 +166,159 @@ nil(?#result##0:generic_list(T))<{}; {}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'generic_list' - - - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"generic_list.append<0>"(i64 %"x##0", i64 %"y##0", i64* %"#result##0") { -entry: - %0 = icmp ne i64 %"x##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"x##0" to i64* - %2 = load i64, i64* %1 - %3 = add i64 %"x##0", 8 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = trunc i64 16 to i32 - %7 = tail call ccc i8* @wybe_malloc(i32 %6) - %8 = ptrtoint i8* %7 to i64 - %9 = inttoptr i64 %8 to i64* - store i64 %2, i64* %9 - %10 = add i64 %8, 8 - %11 = inttoptr i64 %10 to i64* - store i64 %8, i64* %"#result##0" - musttail call fastcc void @"generic_list.append<0>"(i64 %5, i64 %"y##0", i64* %11) - ret void -if.else: - store i64 %"y##0", i64* %"#result##0" - ret void +source_filename = "!ROOT!/final-dump/generic_list.wybe" +target triple ???? + + +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"generic_list.append<0>"(i64 %"x##0", i64 %"y##0", ptr %"tmp#10##0") { + %"tmp#5##0" = icmp ne i64 %"x##0", 0 + br i1 %"tmp#5##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#11##0" = inttoptr i64 %"x##0" to ptr + %"h##0" = load i64, ptr %"tmp#11##0" + %"tmp#12##0" = add i64 %"x##0", 8 + %"tmp#13##0" = inttoptr i64 %"tmp#12##0" to ptr + %"t##0" = load i64, ptr %"tmp#13##0" + %"tmp#14##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#8##0" = ptrtoint ptr %"tmp#14##0" to i64 + %"tmp#15##0" = inttoptr i64 %"tmp#8##0" to ptr + store i64 %"h##0", ptr %"tmp#15##0" + store i64 %"tmp#8##0", ptr %"tmp#10##0" + %"tmp#16##0" = add i64 %"tmp#8##0", 8 + %"tmp#17##0" = inttoptr i64 %"tmp#16##0" to ptr + musttail call fastcc void @"generic_list.append<0>"(i64 %"t##0", i64 %"y##0", ptr %"tmp#17##0") + ret void +if.else.0: + store i64 %"y##0", ptr %"tmp#10##0" + ret void } - -define external fastcc {i64, i1} @"generic_list.car<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"#rec##0" to i64* - %2 = load i64, i64* %1 - %3 = insertvalue {i64, i1} undef, i64 %2, 0 - %4 = insertvalue {i64, i1} %3, i1 1, 1 - ret {i64, i1} %4 -if.else: - %5 = insertvalue {i64, i1} undef, i64 undef, 0 - %6 = insertvalue {i64, i1} %5, i1 0, 1 - ret {i64, i1} %6 +define external fastcc {i64, i1} @"generic_list.car<0>"(i64 %"#rec##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + %"tmp#3##0" = insertvalue {i64, i1} undef, i64 %"tmp#2##0", 0 + %"tmp#4##0" = insertvalue {i64, i1} %"tmp#3##0", i1 1, 1 + ret {i64, i1} %"tmp#4##0" +if.else.0: + %"tmp#5##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#6##0" = insertvalue {i64, i1} %"tmp#5##0", i1 0, 1 + ret {i64, i1} %"tmp#6##0" } - -define external fastcc {i64, i1} @"generic_list.car<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = trunc i64 16 to i32 - %2 = tail call ccc i8* @wybe_malloc(i32 %1) - %3 = ptrtoint i8* %2 to i64 - %4 = inttoptr i64 %3 to i8* - %5 = inttoptr i64 %"#rec##0" to i8* - %6 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %4, i8* %5, i32 %6, i1 0) - %7 = inttoptr i64 %3 to i64* - store i64 %"#field##0", i64* %7 - %8 = insertvalue {i64, i1} undef, i64 %3, 0 - %9 = insertvalue {i64, i1} %8, i1 1, 1 - ret {i64, i1} %9 -if.else: - %10 = insertvalue {i64, i1} undef, i64 0, 0 - %11 = insertvalue {i64, i1} %10, i1 0, 1 - ret {i64, i1} %11 +define external fastcc {i64, i1} @"generic_list.car<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#2##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#2##0", ptr %"tmp#1##0", i64 16, i1 0) + %"tmp#3##0" = ptrtoint ptr %"tmp#2##0" to i64 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 %"#field##0", ptr %"tmp#4##0" + %"tmp#5##0" = insertvalue {i64, i1} undef, i64 %"tmp#3##0", 0 + %"tmp#6##0" = insertvalue {i64, i1} %"tmp#5##0", i1 1, 1 + ret {i64, i1} %"tmp#6##0" +if.else.0: + %"tmp#7##0" = insertvalue {i64, i1} undef, i64 0, 0 + %"tmp#8##0" = insertvalue {i64, i1} %"tmp#7##0", i1 0, 1 + ret {i64, i1} %"tmp#8##0" } - -define external fastcc {i64, i1} @"generic_list.cdr<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = add i64 %"#rec##0", 8 - %2 = inttoptr i64 %1 to i64* - %3 = load i64, i64* %2 - %4 = insertvalue {i64, i1} undef, i64 %3, 0 - %5 = insertvalue {i64, i1} %4, i1 1, 1 - ret {i64, i1} %5 -if.else: - %6 = insertvalue {i64, i1} undef, i64 undef, 0 - %7 = insertvalue {i64, i1} %6, i1 0, 1 - ret {i64, i1} %7 +define external fastcc {i64, i1} @"generic_list.cdr<0>"(i64 %"#rec##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = add i64 %"#rec##0", 8 + %"tmp#2##0" = inttoptr i64 %"tmp#1##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#2##0" + %"tmp#4##0" = insertvalue {i64, i1} undef, i64 %"tmp#3##0", 0 + %"tmp#5##0" = insertvalue {i64, i1} %"tmp#4##0", i1 1, 1 + ret {i64, i1} %"tmp#5##0" +if.else.0: + %"tmp#6##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#7##0" = insertvalue {i64, i1} %"tmp#6##0", i1 0, 1 + ret {i64, i1} %"tmp#7##0" } - -define external fastcc {i64, i1} @"generic_list.cdr<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = trunc i64 16 to i32 - %2 = tail call ccc i8* @wybe_malloc(i32 %1) - %3 = ptrtoint i8* %2 to i64 - %4 = inttoptr i64 %3 to i8* - %5 = inttoptr i64 %"#rec##0" to i8* - %6 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %4, i8* %5, i32 %6, i1 0) - %7 = add i64 %3, 8 - %8 = inttoptr i64 %7 to i64* - store i64 %"#field##0", i64* %8 - %9 = insertvalue {i64, i1} undef, i64 %3, 0 - %10 = insertvalue {i64, i1} %9, i1 1, 1 - ret {i64, i1} %10 -if.else: - %11 = insertvalue {i64, i1} undef, i64 0, 0 - %12 = insertvalue {i64, i1} %11, i1 0, 1 - ret {i64, i1} %12 +define external fastcc {i64, i1} @"generic_list.cdr<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#2##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#2##0", ptr %"tmp#1##0", i64 16, i1 0) + %"tmp#3##0" = ptrtoint ptr %"tmp#2##0" to i64 + %"tmp#4##0" = add i64 %"tmp#3##0", 8 + %"tmp#5##0" = inttoptr i64 %"tmp#4##0" to ptr + store i64 %"#field##0", ptr %"tmp#5##0" + %"tmp#6##0" = insertvalue {i64, i1} undef, i64 %"tmp#3##0", 0 + %"tmp#7##0" = insertvalue {i64, i1} %"tmp#6##0", i1 1, 1 + ret {i64, i1} %"tmp#7##0" +if.else.0: + %"tmp#8##0" = insertvalue {i64, i1} undef, i64 0, 0 + %"tmp#9##0" = insertvalue {i64, i1} %"tmp#8##0", i1 0, 1 + ret {i64, i1} %"tmp#9##0" } - -define external fastcc i64 @"generic_list.cons<0>"(i64 %"car##0", i64 %"cdr##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"car##0", i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"cdr##0", i64* %5 - ret i64 %2 +define external fastcc i64 @"generic_list.cons<0>"(i64 %"car##0", i64 %"cdr##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 16) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"car##0", ptr %"tmp#1##0" + %"tmp#2##0" = add i64 %"#rec##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"cdr##0", ptr %"tmp#3##0" + ret i64 %"#rec##0" } - -define external fastcc {i64, i64, i1} @"generic_list.cons<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#result##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"#result##0" to i64* - %2 = load i64, i64* %1 - %3 = add i64 %"#result##0", 8 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = insertvalue {i64, i64, i1} undef, i64 %2, 0 - %7 = insertvalue {i64, i64, i1} %6, i64 %5, 1 - %8 = insertvalue {i64, i64, i1} %7, i1 1, 2 - ret {i64, i64, i1} %8 -if.else: - %9 = insertvalue {i64, i64, i1} undef, i64 undef, 0 - %10 = insertvalue {i64, i64, i1} %9, i64 undef, 1 - %11 = insertvalue {i64, i64, i1} %10, i1 0, 2 - ret {i64, i64, i1} %11 +define external fastcc {i64, i64, i1} @"generic_list.cons<1>"(i64 %"#result##0") { + %"tmp#0##0" = icmp ne i64 %"#result##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = inttoptr i64 %"#result##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + %"tmp#3##0" = add i64 %"#result##0", 8 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#4##0" + %"tmp#6##0" = insertvalue {i64, i64, i1} undef, i64 %"tmp#2##0", 0 + %"tmp#7##0" = insertvalue {i64, i64, i1} %"tmp#6##0", i64 %"tmp#5##0", 1 + %"tmp#8##0" = insertvalue {i64, i64, i1} %"tmp#7##0", i1 1, 2 + ret {i64, i64, i1} %"tmp#8##0" +if.else.0: + %"tmp#9##0" = insertvalue {i64, i64, i1} undef, i64 undef, 0 + %"tmp#10##0" = insertvalue {i64, i64, i1} %"tmp#9##0", i64 undef, 1 + %"tmp#11##0" = insertvalue {i64, i64, i1} %"tmp#10##0", i1 0, 2 + ret {i64, i64, i1} %"tmp#11##0" } - -define external fastcc i64 @"generic_list.length<0>"(i64 %"x##0") alwaysinline { -entry: - %0 = tail call fastcc i64 @"generic_list.length1<0>"(i64 %"x##0", i64 0) - ret i64 %0 +define external fastcc i64 @"generic_list.length<0>"(i64 %"x##0") { + %"tmp#1##0" = tail call fastcc i64 @"generic_list.length1<0>"(i64 %"x##0", i64 0) + ret i64 %"tmp#1##0" } - -define external fastcc i64 @"generic_list.length1<0>"(i64 %"x##0", i64 %"acc##0") { -entry: - %0 = icmp ne i64 %"x##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = add i64 %"x##0", 8 - %2 = inttoptr i64 %1 to i64* - %3 = load i64, i64* %2 - %4 = add i64 %"acc##0", 1 - %5 = musttail call fastcc i64 @"generic_list.length1<0>"(i64 %3, i64 %4) - ret i64 %5 -if.else: - ret i64 %"acc##0" +define external fastcc i64 @"generic_list.length1<0>"(i64 %"x##0", i64 %"acc##0") { + %"tmp#5##0" = icmp ne i64 %"x##0", 0 + br i1 %"tmp#5##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#8##0" = add i64 %"x##0", 8 + %"tmp#9##0" = inttoptr i64 %"tmp#8##0" to ptr + %"t##0" = load i64, ptr %"tmp#9##0" + %"tmp#2##0" = add i64 %"acc##0", 1 + %"tmp#10##0" = tail call fastcc i64 @"generic_list.length1<0>"(i64 %"t##0", i64 %"tmp#2##0") + ret i64 %"tmp#10##0" +if.else.0: + ret i64 %"acc##0" } - -define external fastcc i64 @"generic_list.nil<0>"() alwaysinline { -entry: - ret i64 0 +define external fastcc i64 @"generic_list.nil<0>"() { + ret i64 0 } diff --git a/test-cases/final-dump/generic_use.exp b/test-cases/final-dump/generic_use.exp index de13c9603..490d0bea8 100644 --- a/test-cases/final-dump/generic_use.exp +++ b/test-cases/final-dump/generic_use.exp @@ -1,7 +1,10 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module generic_list(T) - representation : address + representation : pointer public submods : public resources: public procs : generic_list.append<0> @@ -163,191 +166,163 @@ nil(?#result##0:generic_list(T))<{}; {}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'generic_list' - - - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"generic_list.append<0>"(i64 %"x##0", i64 %"y##0", i64* %"#result##0") { -entry: - %0 = icmp ne i64 %"x##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"x##0" to i64* - %2 = load i64, i64* %1 - %3 = add i64 %"x##0", 8 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = trunc i64 16 to i32 - %7 = tail call ccc i8* @wybe_malloc(i32 %6) - %8 = ptrtoint i8* %7 to i64 - %9 = inttoptr i64 %8 to i64* - store i64 %2, i64* %9 - %10 = add i64 %8, 8 - %11 = inttoptr i64 %10 to i64* - store i64 %8, i64* %"#result##0" - musttail call fastcc void @"generic_list.append<0>"(i64 %5, i64 %"y##0", i64* %11) - ret void -if.else: - store i64 %"y##0", i64* %"#result##0" - ret void +source_filename = "!ROOT!/final-dump/generic_list.wybe" +target triple ???? + + +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"generic_list.append<0>"(i64 %"x##0", i64 %"y##0", ptr %"tmp#10##0") { + %"tmp#5##0" = icmp ne i64 %"x##0", 0 + br i1 %"tmp#5##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#11##0" = inttoptr i64 %"x##0" to ptr + %"h##0" = load i64, ptr %"tmp#11##0" + %"tmp#12##0" = add i64 %"x##0", 8 + %"tmp#13##0" = inttoptr i64 %"tmp#12##0" to ptr + %"t##0" = load i64, ptr %"tmp#13##0" + %"tmp#14##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#8##0" = ptrtoint ptr %"tmp#14##0" to i64 + %"tmp#15##0" = inttoptr i64 %"tmp#8##0" to ptr + store i64 %"h##0", ptr %"tmp#15##0" + store i64 %"tmp#8##0", ptr %"tmp#10##0" + %"tmp#16##0" = add i64 %"tmp#8##0", 8 + %"tmp#17##0" = inttoptr i64 %"tmp#16##0" to ptr + musttail call fastcc void @"generic_list.append<0>"(i64 %"t##0", i64 %"y##0", ptr %"tmp#17##0") + ret void +if.else.0: + store i64 %"y##0", ptr %"tmp#10##0" + ret void } - -define external fastcc {i64, i1} @"generic_list.car<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"#rec##0" to i64* - %2 = load i64, i64* %1 - %3 = insertvalue {i64, i1} undef, i64 %2, 0 - %4 = insertvalue {i64, i1} %3, i1 1, 1 - ret {i64, i1} %4 -if.else: - %5 = insertvalue {i64, i1} undef, i64 undef, 0 - %6 = insertvalue {i64, i1} %5, i1 0, 1 - ret {i64, i1} %6 +define external fastcc {i64, i1} @"generic_list.car<0>"(i64 %"#rec##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + %"tmp#3##0" = insertvalue {i64, i1} undef, i64 %"tmp#2##0", 0 + %"tmp#4##0" = insertvalue {i64, i1} %"tmp#3##0", i1 1, 1 + ret {i64, i1} %"tmp#4##0" +if.else.0: + %"tmp#5##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#6##0" = insertvalue {i64, i1} %"tmp#5##0", i1 0, 1 + ret {i64, i1} %"tmp#6##0" } - -define external fastcc {i64, i1} @"generic_list.car<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = trunc i64 16 to i32 - %2 = tail call ccc i8* @wybe_malloc(i32 %1) - %3 = ptrtoint i8* %2 to i64 - %4 = inttoptr i64 %3 to i8* - %5 = inttoptr i64 %"#rec##0" to i8* - %6 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %4, i8* %5, i32 %6, i1 0) - %7 = inttoptr i64 %3 to i64* - store i64 %"#field##0", i64* %7 - %8 = insertvalue {i64, i1} undef, i64 %3, 0 - %9 = insertvalue {i64, i1} %8, i1 1, 1 - ret {i64, i1} %9 -if.else: - %10 = insertvalue {i64, i1} undef, i64 0, 0 - %11 = insertvalue {i64, i1} %10, i1 0, 1 - ret {i64, i1} %11 +define external fastcc {i64, i1} @"generic_list.car<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#2##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#2##0", ptr %"tmp#1##0", i64 16, i1 0) + %"tmp#3##0" = ptrtoint ptr %"tmp#2##0" to i64 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 %"#field##0", ptr %"tmp#4##0" + %"tmp#5##0" = insertvalue {i64, i1} undef, i64 %"tmp#3##0", 0 + %"tmp#6##0" = insertvalue {i64, i1} %"tmp#5##0", i1 1, 1 + ret {i64, i1} %"tmp#6##0" +if.else.0: + %"tmp#7##0" = insertvalue {i64, i1} undef, i64 0, 0 + %"tmp#8##0" = insertvalue {i64, i1} %"tmp#7##0", i1 0, 1 + ret {i64, i1} %"tmp#8##0" } - -define external fastcc {i64, i1} @"generic_list.cdr<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = add i64 %"#rec##0", 8 - %2 = inttoptr i64 %1 to i64* - %3 = load i64, i64* %2 - %4 = insertvalue {i64, i1} undef, i64 %3, 0 - %5 = insertvalue {i64, i1} %4, i1 1, 1 - ret {i64, i1} %5 -if.else: - %6 = insertvalue {i64, i1} undef, i64 undef, 0 - %7 = insertvalue {i64, i1} %6, i1 0, 1 - ret {i64, i1} %7 +define external fastcc {i64, i1} @"generic_list.cdr<0>"(i64 %"#rec##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = add i64 %"#rec##0", 8 + %"tmp#2##0" = inttoptr i64 %"tmp#1##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#2##0" + %"tmp#4##0" = insertvalue {i64, i1} undef, i64 %"tmp#3##0", 0 + %"tmp#5##0" = insertvalue {i64, i1} %"tmp#4##0", i1 1, 1 + ret {i64, i1} %"tmp#5##0" +if.else.0: + %"tmp#6##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#7##0" = insertvalue {i64, i1} %"tmp#6##0", i1 0, 1 + ret {i64, i1} %"tmp#7##0" } - -define external fastcc {i64, i1} @"generic_list.cdr<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = trunc i64 16 to i32 - %2 = tail call ccc i8* @wybe_malloc(i32 %1) - %3 = ptrtoint i8* %2 to i64 - %4 = inttoptr i64 %3 to i8* - %5 = inttoptr i64 %"#rec##0" to i8* - %6 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %4, i8* %5, i32 %6, i1 0) - %7 = add i64 %3, 8 - %8 = inttoptr i64 %7 to i64* - store i64 %"#field##0", i64* %8 - %9 = insertvalue {i64, i1} undef, i64 %3, 0 - %10 = insertvalue {i64, i1} %9, i1 1, 1 - ret {i64, i1} %10 -if.else: - %11 = insertvalue {i64, i1} undef, i64 0, 0 - %12 = insertvalue {i64, i1} %11, i1 0, 1 - ret {i64, i1} %12 +define external fastcc {i64, i1} @"generic_list.cdr<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#2##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#2##0", ptr %"tmp#1##0", i64 16, i1 0) + %"tmp#3##0" = ptrtoint ptr %"tmp#2##0" to i64 + %"tmp#4##0" = add i64 %"tmp#3##0", 8 + %"tmp#5##0" = inttoptr i64 %"tmp#4##0" to ptr + store i64 %"#field##0", ptr %"tmp#5##0" + %"tmp#6##0" = insertvalue {i64, i1} undef, i64 %"tmp#3##0", 0 + %"tmp#7##0" = insertvalue {i64, i1} %"tmp#6##0", i1 1, 1 + ret {i64, i1} %"tmp#7##0" +if.else.0: + %"tmp#8##0" = insertvalue {i64, i1} undef, i64 0, 0 + %"tmp#9##0" = insertvalue {i64, i1} %"tmp#8##0", i1 0, 1 + ret {i64, i1} %"tmp#9##0" } - -define external fastcc i64 @"generic_list.cons<0>"(i64 %"car##0", i64 %"cdr##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"car##0", i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"cdr##0", i64* %5 - ret i64 %2 +define external fastcc i64 @"generic_list.cons<0>"(i64 %"car##0", i64 %"cdr##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 16) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"car##0", ptr %"tmp#1##0" + %"tmp#2##0" = add i64 %"#rec##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"cdr##0", ptr %"tmp#3##0" + ret i64 %"#rec##0" } - -define external fastcc {i64, i64, i1} @"generic_list.cons<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#result##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"#result##0" to i64* - %2 = load i64, i64* %1 - %3 = add i64 %"#result##0", 8 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = insertvalue {i64, i64, i1} undef, i64 %2, 0 - %7 = insertvalue {i64, i64, i1} %6, i64 %5, 1 - %8 = insertvalue {i64, i64, i1} %7, i1 1, 2 - ret {i64, i64, i1} %8 -if.else: - %9 = insertvalue {i64, i64, i1} undef, i64 undef, 0 - %10 = insertvalue {i64, i64, i1} %9, i64 undef, 1 - %11 = insertvalue {i64, i64, i1} %10, i1 0, 2 - ret {i64, i64, i1} %11 +define external fastcc {i64, i64, i1} @"generic_list.cons<1>"(i64 %"#result##0") { + %"tmp#0##0" = icmp ne i64 %"#result##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = inttoptr i64 %"#result##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + %"tmp#3##0" = add i64 %"#result##0", 8 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#4##0" + %"tmp#6##0" = insertvalue {i64, i64, i1} undef, i64 %"tmp#2##0", 0 + %"tmp#7##0" = insertvalue {i64, i64, i1} %"tmp#6##0", i64 %"tmp#5##0", 1 + %"tmp#8##0" = insertvalue {i64, i64, i1} %"tmp#7##0", i1 1, 2 + ret {i64, i64, i1} %"tmp#8##0" +if.else.0: + %"tmp#9##0" = insertvalue {i64, i64, i1} undef, i64 undef, 0 + %"tmp#10##0" = insertvalue {i64, i64, i1} %"tmp#9##0", i64 undef, 1 + %"tmp#11##0" = insertvalue {i64, i64, i1} %"tmp#10##0", i1 0, 2 + ret {i64, i64, i1} %"tmp#11##0" } - -define external fastcc i64 @"generic_list.length<0>"(i64 %"x##0") alwaysinline { -entry: - %0 = tail call fastcc i64 @"generic_list.length1<0>"(i64 %"x##0", i64 0) - ret i64 %0 +define external fastcc i64 @"generic_list.length<0>"(i64 %"x##0") { + %"tmp#1##0" = tail call fastcc i64 @"generic_list.length1<0>"(i64 %"x##0", i64 0) + ret i64 %"tmp#1##0" } - -define external fastcc i64 @"generic_list.length1<0>"(i64 %"x##0", i64 %"acc##0") { -entry: - %0 = icmp ne i64 %"x##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = add i64 %"x##0", 8 - %2 = inttoptr i64 %1 to i64* - %3 = load i64, i64* %2 - %4 = add i64 %"acc##0", 1 - %5 = musttail call fastcc i64 @"generic_list.length1<0>"(i64 %3, i64 %4) - ret i64 %5 -if.else: - ret i64 %"acc##0" +define external fastcc i64 @"generic_list.length1<0>"(i64 %"x##0", i64 %"acc##0") { + %"tmp#5##0" = icmp ne i64 %"x##0", 0 + br i1 %"tmp#5##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#8##0" = add i64 %"x##0", 8 + %"tmp#9##0" = inttoptr i64 %"tmp#8##0" to ptr + %"t##0" = load i64, ptr %"tmp#9##0" + %"tmp#2##0" = add i64 %"acc##0", 1 + %"tmp#10##0" = tail call fastcc i64 @"generic_list.length1<0>"(i64 %"t##0", i64 %"tmp#2##0") + ret i64 %"tmp#10##0" +if.else.0: + ret i64 %"acc##0" } - -define external fastcc i64 @"generic_list.nil<0>"() alwaysinline { -entry: - ret i64 0 +define external fastcc i64 @"generic_list.nil<0>"() { + ret i64 0 } + -------------------------------------------------- Module generic_use representation : (not a type) @@ -399,7 +374,7 @@ module top-level code > public {semipure} (0 calls) proc concat > public (3 calls) -0: generic_use.concat<0>[410bae77d3] +0: generic_use.concat<0> concat(l1##0:generic_list(T) <{}; {}; {0}>, l2##0:generic_list(T) <{}; {}; {1}>, outByReference #result##0:generic_list(T) <{}; {}; {0, 1}>)<{}; {}; {}>: AliasPairs: [(#result##0,l2##0)] InterestingCallProperties: [InterestingUnaliased 0] @@ -466,7 +441,7 @@ iota(n##0:wybe.int, ?#result##0:generic_list(wybe.int))<{}; {}; {}>: proc nrev > public (2 calls) -0: generic_use.nrev<0>[410bae77d3] +0: generic_use.nrev<0> nrev(lst##0:generic_list(T) <{}; {}; {0}>, ?#result##0:generic_list(T) <{}; {}; {0}>)<{}; {}; {}>: AliasPairs: [] InterestingCallProperties: [InterestingUnaliased 0] @@ -564,7 +539,7 @@ reverse(lst##0:generic_list(T) <{}; {}; {0}>, ?#result##0:generic_list(T) <{}; { proc reverse1 > public (2 calls) -0: generic_use.reverse1<0>[410bae77d3] +0: generic_use.reverse1<0> reverse1(lst##0:generic_list(T) <{}; {}; {0}>, suffix##0:generic_list(T) <{}; {}; {1}>, ?#result##0:generic_list(T) <{}; {}; {0, 1}>)<{}; {}; {}>: AliasPairs: [(#result##0,suffix##0)] InterestingCallProperties: [InterestingUnaliased 0] @@ -596,278 +571,235 @@ reverse1(lst##0:generic_list(T) <{}; {}; {0}>, suffix##0:generic_list(T) <{}; {} LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'generic_use' - - - - -@generic_use.1 = constant {i64, i64} { i64 2, i64 ptrtoint ([?? x i8]* @generic_use.0 to i64) } - - -@generic_use.0 = constant [?? x i8] c", \00" - - -declare external ccc void @putchar(i8) - - -declare external ccc void @print_int(i64) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"generic_use.<0>"() { -entry: - %0 = tail call fastcc i64 @"generic_use.fromto1<0>"(i64 1, i64 5, i64 0) - %1 = tail call fastcc i64 @"generic_use.fromto1<0>"(i64 6, i64 10, i64 0) - tail call fastcc void @"generic_use.print<0>"(i64 %0) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"generic_use.print<0>"(i64 %1) - tail call ccc void @putchar(i8 10) - %2 = alloca i64 - call fastcc void @"generic_use.concat<0>"(i64 %0, i64 %1, i64* %2) - %3 = load i64, i64* %2 - tail call fastcc void @"generic_use.print<0>"(i64 %3) - tail call ccc void @putchar(i8 10) - %4 = tail call fastcc i64 @"generic_use.reverse1<0>[410bae77d3]"(i64 %0, i64 0) - tail call fastcc void @"generic_use.print<0>"(i64 %4) - tail call ccc void @putchar(i8 10) - %5 = tail call fastcc i64 @"generic_use.nrev<0>[410bae77d3]"(i64 %1) - tail call fastcc void @"generic_use.print<0>"(i64 %5) - tail call ccc void @putchar(i8 10) - ret void +source_filename = "!ROOT!/final-dump/generic_use.wybe" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c", \00", align 8 +@"string#1" = private unnamed_addr constant {i64, i64} { i64 2, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 + +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"generic_use.<0>"() { + %"tmp#0##0" = tail call fastcc i64 @"generic_use.fromto1<0>"(i64 1, i64 5, i64 0) + %"tmp#1##0" = tail call fastcc i64 @"generic_use.fromto1<0>"(i64 6, i64 10, i64 0) + tail call fastcc void @"generic_use.print<0>"(i64 %"tmp#0##0") + call ccc void @putchar(i8 10) + tail call fastcc void @"generic_use.print<0>"(i64 %"tmp#1##0") + call ccc void @putchar(i8 10) + %"tmp#24##0" = alloca i8, i64 8, align 8 + call fastcc void @"generic_use.concat<0>"(i64 %"tmp#0##0", i64 %"tmp#1##0", ptr %"tmp#24##0") + %"tmp#2##0" = load i64, ptr %"tmp#24##0" + call fastcc void @"generic_use.print<0>"(i64 %"tmp#2##0") + call ccc void @putchar(i8 10) + %"tmp#3##0" = call fastcc i64 @"generic_use.reverse1<0>[410bae77d3]"(i64 %"tmp#0##0", i64 0) + call fastcc void @"generic_use.print<0>"(i64 %"tmp#3##0") + call ccc void @putchar(i8 10) + %"tmp#4##0" = call fastcc i64 @"generic_use.nrev<0>[410bae77d3]"(i64 %"tmp#1##0") + call fastcc void @"generic_use.print<0>"(i64 %"tmp#4##0") + call ccc void @putchar(i8 10) + ret void } - -define external fastcc void @"generic_use.concat<0>"(i64 %"l1##0", i64 %"l2##0", i64* %"#result##0") { -entry: - %0 = icmp ne i64 %"l1##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"l1##0" to i64* - %2 = load i64, i64* %1 - %3 = add i64 %"l1##0", 8 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = trunc i64 16 to i32 - %7 = tail call ccc i8* @wybe_malloc(i32 %6) - %8 = ptrtoint i8* %7 to i64 - %9 = inttoptr i64 %8 to i64* - store i64 %2, i64* %9 - %10 = add i64 %8, 8 - %11 = inttoptr i64 %10 to i64* - store i64 %8, i64* %"#result##0" - musttail call fastcc void @"generic_use.concat<0>"(i64 %5, i64 %"l2##0", i64* %11) - ret void -if.else: - store i64 %"l2##0", i64* %"#result##0" - ret void +define external fastcc void @"generic_use.concat<0>"(i64 %"l1##0", i64 %"l2##0", ptr %"tmp#10##0") { + %"tmp#5##0" = icmp ne i64 %"l1##0", 0 + br i1 %"tmp#5##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#11##0" = inttoptr i64 %"l1##0" to ptr + %"h##0" = load i64, ptr %"tmp#11##0" + %"tmp#12##0" = add i64 %"l1##0", 8 + %"tmp#13##0" = inttoptr i64 %"tmp#12##0" to ptr + %"t##0" = load i64, ptr %"tmp#13##0" + %"tmp#14##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#8##0" = ptrtoint ptr %"tmp#14##0" to i64 + %"tmp#15##0" = inttoptr i64 %"tmp#8##0" to ptr + store i64 %"h##0", ptr %"tmp#15##0" + store i64 %"tmp#8##0", ptr %"tmp#10##0" + %"tmp#16##0" = add i64 %"tmp#8##0", 8 + %"tmp#17##0" = inttoptr i64 %"tmp#16##0" to ptr + musttail call fastcc void @"generic_use.concat<0>"(i64 %"t##0", i64 %"l2##0", ptr %"tmp#17##0") + ret void +if.else.0: + store i64 %"l2##0", ptr %"tmp#10##0" + ret void } - -define external fastcc void @"generic_use.concat<0>[410bae77d3]"(i64 %"l1##0", i64 %"l2##0", i64* %"#result##0") { -entry: - %0 = icmp ne i64 %"l1##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = add i64 %"l1##0", 8 - %2 = inttoptr i64 %1 to i64* - %3 = load i64, i64* %2 - %4 = add i64 %"l1##0", 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"l1##0", i64* %"#result##0" - musttail call fastcc void @"generic_use.concat<0>[410bae77d3]"(i64 %3, i64 %"l2##0", i64* %5) - ret void -if.else: - store i64 %"l2##0", i64* %"#result##0" - ret void +define external fastcc void @"generic_use.concat<0>[410bae77d3]"(i64 %"l1##0", i64 %"l2##0", ptr %"tmp#10##0") { + %"tmp#5##0" = icmp ne i64 %"l1##0", 0 + br i1 %"tmp#5##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#11##0" = add i64 %"l1##0", 8 + %"tmp#12##0" = inttoptr i64 %"tmp#11##0" to ptr + %"t##0" = load i64, ptr %"tmp#12##0" + store i64 %"l1##0", ptr %"tmp#10##0" + %"tmp#13##0" = add i64 %"l1##0", 8 + %"tmp#14##0" = inttoptr i64 %"tmp#13##0" to ptr + musttail call fastcc void @"generic_use.concat<0>[410bae77d3]"(i64 %"t##0", i64 %"l2##0", ptr %"tmp#14##0") + ret void +if.else.0: + store i64 %"l2##0", ptr %"tmp#10##0" + ret void } - -define external fastcc i64 @"generic_use.fromto<0>"(i64 %"lo##0", i64 %"hi##0") alwaysinline { -entry: - %0 = tail call fastcc i64 @"generic_use.fromto1<0>"(i64 %"lo##0", i64 %"hi##0", i64 0) - ret i64 %0 +define external fastcc i64 @"generic_use.fromto<0>"(i64 %"lo##0", i64 %"hi##0") { + %"tmp#2##0" = tail call fastcc i64 @"generic_use.fromto1<0>"(i64 %"lo##0", i64 %"hi##0", i64 0) + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"generic_use.fromto1<0>"(i64 %"lo##0", i64 %"hi##0", i64 %"sofar##0") { -entry: - %0 = icmp sge i64 %"hi##0", %"lo##0" - br i1 %0, label %if.then, label %if.else -if.then: - %1 = sub i64 %"hi##0", 1 - %2 = trunc i64 16 to i32 - %3 = tail call ccc i8* @wybe_malloc(i32 %2) - %4 = ptrtoint i8* %3 to i64 - %5 = inttoptr i64 %4 to i64* - store i64 %"hi##0", i64* %5 - %6 = add i64 %4, 8 - %7 = inttoptr i64 %6 to i64* - store i64 %"sofar##0", i64* %7 - %8 = musttail call fastcc i64 @"generic_use.fromto1<0>"(i64 %"lo##0", i64 %1, i64 %4) - ret i64 %8 -if.else: - ret i64 %"sofar##0" +define external fastcc i64 @"generic_use.fromto1<0>"(i64 %"lo##0", i64 %"hi##0", i64 %"sofar##0") { + %"tmp#4##0" = icmp sge i64 %"hi##0", %"lo##0" + br i1 %"tmp#4##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = sub i64 %"hi##0", 1 + %"tmp#13##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#11##0" = ptrtoint ptr %"tmp#13##0" to i64 + %"tmp#14##0" = inttoptr i64 %"tmp#11##0" to ptr + store i64 %"hi##0", ptr %"tmp#14##0" + %"tmp#15##0" = add i64 %"tmp#11##0", 8 + %"tmp#16##0" = inttoptr i64 %"tmp#15##0" to ptr + store i64 %"sofar##0", ptr %"tmp#16##0" + %"tmp#17##0" = tail call fastcc i64 @"generic_use.fromto1<0>"(i64 %"lo##0", i64 %"tmp#2##0", i64 %"tmp#11##0") + ret i64 %"tmp#17##0" +if.else.0: + ret i64 %"sofar##0" } - -define external fastcc i64 @"generic_use.iota<0>"(i64 %"n##0") alwaysinline { -entry: - %0 = tail call fastcc i64 @"generic_use.fromto1<0>"(i64 1, i64 %"n##0", i64 0) - ret i64 %0 +define external fastcc i64 @"generic_use.iota<0>"(i64 %"n##0") { + %"tmp#3##0" = tail call fastcc i64 @"generic_use.fromto1<0>"(i64 1, i64 %"n##0", i64 0) + ret i64 %"tmp#3##0" } - -define external fastcc i64 @"generic_use.nrev<0>"(i64 %"lst##0") { -entry: - %0 = icmp ne i64 %"lst##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"lst##0" to i64* - %2 = load i64, i64* %1 - %3 = add i64 %"lst##0", 8 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = tail call fastcc i64 @"generic_use.nrev<0>"(i64 %5) - %7 = trunc i64 16 to i32 - %8 = tail call ccc i8* @wybe_malloc(i32 %7) - %9 = ptrtoint i8* %8 to i64 - %10 = inttoptr i64 %9 to i64* - store i64 %2, i64* %10 - %11 = add i64 %9, 8 - %12 = inttoptr i64 %11 to i64* - store i64 0, i64* %12 - %13 = alloca i64 - call fastcc void @"generic_use.concat<0>[410bae77d3]"(i64 %6, i64 %9, i64* %13) - %14 = load i64, i64* %13 - ret i64 %14 -if.else: - ret i64 0 +define external fastcc i64 @"generic_use.nrev<0>"(i64 %"lst##0") { + %"tmp#8##0" = icmp ne i64 %"lst##0", 0 + br i1 %"tmp#8##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#13##0" = inttoptr i64 %"lst##0" to ptr + %"h##0" = load i64, ptr %"tmp#13##0" + %"tmp#14##0" = add i64 %"lst##0", 8 + %"tmp#15##0" = inttoptr i64 %"tmp#14##0" to ptr + %"t##0" = load i64, ptr %"tmp#15##0" + %"tmp#2##0" = tail call fastcc i64 @"generic_use.nrev<0>"(i64 %"t##0") + %"tmp#16##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#11##0" = ptrtoint ptr %"tmp#16##0" to i64 + %"tmp#17##0" = inttoptr i64 %"tmp#11##0" to ptr + store i64 %"h##0", ptr %"tmp#17##0" + %"tmp#18##0" = add i64 %"tmp#11##0", 8 + %"tmp#19##0" = inttoptr i64 %"tmp#18##0" to ptr + store i64 0, ptr %"tmp#19##0" + %"tmp#20##0" = alloca i8, i64 8, align 8 + call fastcc void @"generic_use.concat<0>[410bae77d3]"(i64 %"tmp#2##0", i64 %"tmp#11##0", ptr %"tmp#20##0") + %"tmp#21##0" = load i64, ptr %"tmp#20##0" + ret i64 %"tmp#21##0" +if.else.0: + ret i64 0 } - -define external fastcc i64 @"generic_use.nrev<0>[410bae77d3]"(i64 %"lst##0") { -entry: - %0 = icmp ne i64 %"lst##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = add i64 %"lst##0", 8 - %2 = inttoptr i64 %1 to i64* - %3 = load i64, i64* %2 - %4 = tail call fastcc i64 @"generic_use.nrev<0>[410bae77d3]"(i64 %3) - %5 = add i64 %"lst##0", 8 - %6 = inttoptr i64 %5 to i64* - store i64 0, i64* %6 - %7 = alloca i64 - call fastcc void @"generic_use.concat<0>[410bae77d3]"(i64 %4, i64 %"lst##0", i64* %7) - %8 = load i64, i64* %7 - ret i64 %8 -if.else: - ret i64 0 +define external fastcc i64 @"generic_use.nrev<0>[410bae77d3]"(i64 %"lst##0") { + %"tmp#8##0" = icmp ne i64 %"lst##0", 0 + br i1 %"tmp#8##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#13##0" = add i64 %"lst##0", 8 + %"tmp#14##0" = inttoptr i64 %"tmp#13##0" to ptr + %"t##0" = load i64, ptr %"tmp#14##0" + %"tmp#2##0" = tail call fastcc i64 @"generic_use.nrev<0>[410bae77d3]"(i64 %"t##0") + %"tmp#15##0" = add i64 %"lst##0", 8 + %"tmp#16##0" = inttoptr i64 %"tmp#15##0" to ptr + store i64 0, ptr %"tmp#16##0" + %"tmp#17##0" = alloca i8, i64 8, align 8 + call fastcc void @"generic_use.concat<0>[410bae77d3]"(i64 %"tmp#2##0", i64 %"lst##0", ptr %"tmp#17##0") + %"tmp#18##0" = load i64, ptr %"tmp#17##0" + ret i64 %"tmp#18##0" +if.else.0: + ret i64 0 } - -define external fastcc void @"generic_use.print<0>"(i64 %"lst##0") { -entry: - tail call ccc void @putchar(i8 91) - %0 = icmp ne i64 %"lst##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"lst##0" to i64* - %2 = load i64, i64* %1 - %3 = add i64 %"lst##0", 8 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - tail call ccc void @print_int(i64 %2) - tail call fastcc void @"generic_use.print_tail<0>"(i64 %5) - tail call ccc void @putchar(i8 93) - ret void -if.else: - tail call ccc void @putchar(i8 93) - ret void +define external fastcc void @"generic_use.print<0>"(i64 %"lst##0") { + call ccc void @putchar(i8 91) + %"tmp#5##0" = icmp ne i64 %"lst##0", 0 + br i1 %"tmp#5##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#15##0" = inttoptr i64 %"lst##0" to ptr + %"h##0" = load i64, ptr %"tmp#15##0" + %"tmp#16##0" = add i64 %"lst##0", 8 + %"tmp#17##0" = inttoptr i64 %"tmp#16##0" to ptr + %"t##0" = load i64, ptr %"tmp#17##0" + call ccc void @print_int(i64 %"h##0") + tail call fastcc void @"generic_use.print_tail<0>"(i64 %"t##0") + call ccc void @putchar(i8 93) + ret void +if.else.0: + call ccc void @putchar(i8 93) + ret void } - -define external fastcc void @"generic_use.print_tail<0>"(i64 %"lst##0") { -entry: - %0 = icmp ne i64 %"lst##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"lst##0" to i64* - %2 = load i64, i64* %1 - %3 = add i64 %"lst##0", 8 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @generic_use.1, i32 0, i32 0) to i64)) - tail call ccc void @print_int(i64 %2) - musttail call fastcc void @"generic_use.print_tail<0>"(i64 %5) - ret void -if.else: - ret void +define external fastcc void @"generic_use.print_tail<0>"(i64 %"lst##0") { + %"tmp#2##0" = icmp ne i64 %"lst##0", 0 + br i1 %"tmp#2##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#6##0" = inttoptr i64 %"lst##0" to ptr + %"h##0" = load i64, ptr %"tmp#6##0" + %"tmp#7##0" = add i64 %"lst##0", 8 + %"tmp#8##0" = inttoptr i64 %"tmp#7##0" to ptr + %"t##0" = load i64, ptr %"tmp#8##0" + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#1" to i64 )) + call ccc void @print_int(i64 %"h##0") + tail call fastcc void @"generic_use.print_tail<0>"(i64 %"t##0") + ret void +if.else.0: + ret void } - -define external fastcc void @"generic_use.println<0>"(i64 %"lst##0") alwaysinline { -entry: - tail call fastcc void @"generic_use.print<0>"(i64 %"lst##0") - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"generic_use.println<0>"(i64 %"lst##0") { + tail call fastcc void @"generic_use.print<0>"(i64 %"lst##0") + call ccc void @putchar(i8 10) + ret void } - -define external fastcc i64 @"generic_use.reverse<0>"(i64 %"lst##0") alwaysinline { -entry: - %0 = tail call fastcc i64 @"generic_use.reverse1<0>"(i64 %"lst##0", i64 0) - ret i64 %0 +define external fastcc i64 @"generic_use.reverse<0>"(i64 %"lst##0") { + %"tmp#2##0" = tail call fastcc i64 @"generic_use.reverse1<0>"(i64 %"lst##0", i64 0) + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"generic_use.reverse1<0>"(i64 %"lst##0", i64 %"suffix##0") { -entry: - %0 = icmp ne i64 %"lst##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"lst##0" to i64* - %2 = load i64, i64* %1 - %3 = add i64 %"lst##0", 8 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = trunc i64 16 to i32 - %7 = tail call ccc i8* @wybe_malloc(i32 %6) - %8 = ptrtoint i8* %7 to i64 - %9 = inttoptr i64 %8 to i64* - store i64 %2, i64* %9 - %10 = add i64 %8, 8 - %11 = inttoptr i64 %10 to i64* - store i64 %"suffix##0", i64* %11 - %12 = musttail call fastcc i64 @"generic_use.reverse1<0>"(i64 %5, i64 %8) - ret i64 %12 -if.else: - ret i64 %"suffix##0" +define external fastcc i64 @"generic_use.reverse1<0>"(i64 %"lst##0", i64 %"suffix##0") { + %"tmp#5##0" = icmp ne i64 %"lst##0", 0 + br i1 %"tmp#5##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#10##0" = inttoptr i64 %"lst##0" to ptr + %"h##0" = load i64, ptr %"tmp#10##0" + %"tmp#11##0" = add i64 %"lst##0", 8 + %"tmp#12##0" = inttoptr i64 %"tmp#11##0" to ptr + %"t##0" = load i64, ptr %"tmp#12##0" + %"tmp#13##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#8##0" = ptrtoint ptr %"tmp#13##0" to i64 + %"tmp#14##0" = inttoptr i64 %"tmp#8##0" to ptr + store i64 %"h##0", ptr %"tmp#14##0" + %"tmp#15##0" = add i64 %"tmp#8##0", 8 + %"tmp#16##0" = inttoptr i64 %"tmp#15##0" to ptr + store i64 %"suffix##0", ptr %"tmp#16##0" + %"tmp#17##0" = tail call fastcc i64 @"generic_use.reverse1<0>"(i64 %"t##0", i64 %"tmp#8##0") + ret i64 %"tmp#17##0" +if.else.0: + ret i64 %"suffix##0" } - -define external fastcc i64 @"generic_use.reverse1<0>[410bae77d3]"(i64 %"lst##0", i64 %"suffix##0") { -entry: - %0 = icmp ne i64 %"lst##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = add i64 %"lst##0", 8 - %2 = inttoptr i64 %1 to i64* - %3 = load i64, i64* %2 - %4 = add i64 %"lst##0", 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"suffix##0", i64* %5 - %6 = musttail call fastcc i64 @"generic_use.reverse1<0>[410bae77d3]"(i64 %3, i64 %"lst##0") - ret i64 %6 -if.else: - ret i64 %"suffix##0" +define external fastcc i64 @"generic_use.reverse1<0>[410bae77d3]"(i64 %"lst##0", i64 %"suffix##0") { + %"tmp#5##0" = icmp ne i64 %"lst##0", 0 + br i1 %"tmp#5##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#10##0" = add i64 %"lst##0", 8 + %"tmp#11##0" = inttoptr i64 %"tmp#10##0" to ptr + %"t##0" = load i64, ptr %"tmp#11##0" + %"tmp#12##0" = add i64 %"lst##0", 8 + %"tmp#13##0" = inttoptr i64 %"tmp#12##0" to ptr + store i64 %"suffix##0", ptr %"tmp#13##0" + %"tmp#14##0" = tail call fastcc i64 @"generic_use.reverse1<0>[410bae77d3]"(i64 %"t##0", i64 %"lst##0") + ret i64 %"tmp#14##0" +if.else.0: + ret i64 %"suffix##0" } diff --git a/test-cases/final-dump/global_flow_inference.exp b/test-cases/final-dump/global_flow_inference.exp index f0004a38f..ef837ab8c 100644 --- a/test-cases/final-dump/global_flow_inference.exp +++ b/test-cases/final-dump/global_flow_inference.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module global_flow_inference representation : (not a type) public submods : @@ -168,173 +171,132 @@ still_only_in(b##0:wybe.bool, ?x##0:wybe.int)<{<>}; { LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'global_flow_inference' +source_filename = "!ROOT!/final-dump/global_flow_inference.wybe" +target triple ???? - - - -@"resource#global_flow_inference.res" = global i64 undef - - -declare external ccc i8* @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) +@"resource#global_flow_inference.res" = global i64 undef -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"global_flow_inference.higher_order_branch<0>"(i1 %"b##0", i64 %"f##0") noinline { -entry: - br i1 %"b##0", label %if.then, label %if.else -if.then: - %0 = inttoptr i64 %"f##0" to i64* - %1 = load i64, i64* %0 - %2 = inttoptr i64 %1 to void (i64)* - tail call fastcc void %2(i64 %"f##0") - ret void -if.else: - ret void +define external fastcc void @"global_flow_inference.higher_order_branch<0>"(i1 %"b##0", i64 %"f##0") { + br i1 %"b##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = inttoptr i64 %"f##0" to ptr + %"tmp#0##0" = load ptr, ptr %"tmp#1##0" + tail call fastcc void %"tmp#0##0"(i64 %"f##0") + ret void +if.else.0: + ret void } - -define external fastcc void @"global_flow_inference.higher_order_branch_no_use<0>"(i1 %"b##0", i64 %"f##0") noinline { -entry: - br i1 %"b##0", label %if.then, label %if.else -if.then: - %0 = inttoptr i64 %"f##0" to i64* - %1 = load i64, i64* %0 - %2 = inttoptr i64 %1 to void (i64)* - tail call fastcc void %2(i64 %"f##0") - ret void -if.else: - ret void +define external fastcc void @"global_flow_inference.higher_order_branch_no_use<0>"(i1 %"b##0", i64 %"f##0") { + br i1 %"b##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = inttoptr i64 %"f##0" to ptr + %"tmp#0##0" = load ptr, ptr %"tmp#1##0" + tail call fastcc void %"tmp#0##0"(i64 %"f##0") + ret void +if.else.0: + ret void } - -define external fastcc void @"global_flow_inference.higher_order_branch_use<0>"(i1 %"b##0", i64 %"f##0") noinline { -entry: - br i1 %"b##0", label %if.then, label %if.else -if.then: - %0 = inttoptr i64 %"f##0" to i64* - %1 = load i64, i64* %0 - %2 = inttoptr i64 %1 to void (i64)* - tail call fastcc void %2(i64 %"f##0") - ret void -if.else: - store i64 1, i64* @"resource#global_flow_inference.res" - ret void +define external fastcc void @"global_flow_inference.higher_order_branch_use<0>"(i1 %"b##0", i64 %"f##0") { + br i1 %"b##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = inttoptr i64 %"f##0" to ptr + %"tmp#0##0" = load ptr, ptr %"tmp#1##0" + tail call fastcc void %"tmp#0##0"(i64 %"f##0") + ret void +if.else.0: + store i64 1, ptr @"resource#global_flow_inference.res" + ret void } - -define external fastcc void @"global_flow_inference.higher_order_in<0>"(i64 %"f##0") noinline { -entry: - %0 = load i64, i64* @"resource#global_flow_inference.res" - %1 = inttoptr i64 %"f##0" to i64* - %2 = load i64, i64* %1 - %3 = inttoptr i64 %2 to void (i64, i64)* - tail call fastcc void %3(i64 %"f##0", i64 %0) - ret void +define external fastcc void @"global_flow_inference.higher_order_in<0>"(i64 %"f##0") { + %"res##0" = load i64, ptr @"resource#global_flow_inference.res" + %"tmp#1##0" = inttoptr i64 %"f##0" to ptr + %"tmp#0##0" = load ptr, ptr %"tmp#1##0" + tail call fastcc void %"tmp#0##0"(i64 %"f##0", i64 %"res##0") + ret void } - -define external fastcc void @"global_flow_inference.higher_order_inout<0>"(i64 %"f##0") noinline { -entry: - %0 = load i64, i64* @"resource#global_flow_inference.res" - %1 = inttoptr i64 %"f##0" to i64* - %2 = load i64, i64* %1 - %3 = inttoptr i64 %2 to void (i64, i64)* - tail call fastcc void %3(i64 %"f##0", i64 %0) - store i64 1, i64* @"resource#global_flow_inference.res" - ret void +define external fastcc void @"global_flow_inference.higher_order_inout<0>"(i64 %"f##0") { + %"res##0" = load i64, ptr @"resource#global_flow_inference.res" + %"tmp#1##0" = inttoptr i64 %"f##0" to ptr + %"tmp#0##0" = load ptr, ptr %"tmp#1##0" + tail call fastcc void %"tmp#0##0"(i64 %"f##0", i64 %"res##0") + store i64 1, ptr @"resource#global_flow_inference.res" + ret void } - -define external fastcc void @"global_flow_inference.higher_order_only_out<0>"(i64 %"f##0") noinline { -entry: - store i64 1, i64* @"resource#global_flow_inference.res" - %0 = inttoptr i64 %"f##0" to i64* - %1 = load i64, i64* %0 - %2 = inttoptr i64 %1 to void (i64, i64)* - tail call fastcc void %2(i64 %"f##0", i64 1) - ret void +define external fastcc void @"global_flow_inference.higher_order_only_out<0>"(i64 %"f##0") { + store i64 1, ptr @"resource#global_flow_inference.res" + %"tmp#1##0" = inttoptr i64 %"f##0" to ptr + %"tmp#0##0" = load ptr, ptr %"tmp#1##0" + tail call fastcc void %"tmp#0##0"(i64 %"f##0", i64 1) + ret void } - -define external fastcc void @"global_flow_inference.higher_order_out<0>"(i64 %"f##0") noinline { -entry: - %0 = inttoptr i64 %"f##0" to i64* - %1 = load i64, i64* %0 - %2 = inttoptr i64 %1 to i64 (i64)* - %3 = tail call fastcc i64 %2(i64 %"f##0") - store i64 %3, i64* @"resource#global_flow_inference.res" - ret void +define external fastcc void @"global_flow_inference.higher_order_out<0>"(i64 %"f##0") { + %"tmp#1##0" = inttoptr i64 %"f##0" to ptr + %"tmp#0##0" = load ptr, ptr %"tmp#1##0" + %"res##0" = tail call fastcc i64 %"tmp#0##0"(i64 %"f##0") + store i64 %"res##0", ptr @"resource#global_flow_inference.res" + ret void } - -define external fastcc void @"global_flow_inference.inout<0>"(i1 %"b##0") noinline { -entry: - br i1 %"b##0", label %if.then, label %if.else -if.then: - musttail call fastcc void @"global_flow_inference.only_out<0>"(i1 1) - ret void -if.else: - ret void +define external fastcc void @"global_flow_inference.inout<0>"(i1 %"b##0") { + br i1 %"b##0", label %if.then.0, label %if.else.0 +if.then.0: + tail call fastcc void @"global_flow_inference.only_out<0>"(i1 1) + ret void +if.else.0: + ret void } - -define external fastcc i64 @"global_flow_inference.only_in<0>"() noinline { -entry: - %0 = load i64, i64* @"resource#global_flow_inference.res" - ret i64 %0 +define external fastcc i64 @"global_flow_inference.only_in<0>"() { + %"tmp#0##0" = load i64, ptr @"resource#global_flow_inference.res" + ret i64 %"tmp#0##0" } - -define external fastcc void @"global_flow_inference.only_out<0>"(i1 %"b##0") noinline { -entry: - br i1 %"b##0", label %if.then, label %if.else -if.then: - store i64 2, i64* @"resource#global_flow_inference.res" - ret void -if.else: - store i64 3, i64* @"resource#global_flow_inference.res" - ret void +define external fastcc void @"global_flow_inference.only_out<0>"(i1 %"b##0") { + br i1 %"b##0", label %if.then.0, label %if.else.0 +if.then.0: + store i64 2, ptr @"resource#global_flow_inference.res" + ret void +if.else.0: + store i64 3, ptr @"resource#global_flow_inference.res" + ret void } - -define external fastcc void @"global_flow_inference.rec_out_only1<0>"() noinline { -entry: - musttail call fastcc void @"global_flow_inference.rec_out_only2<0>"() - ret void +define external fastcc void @"global_flow_inference.rec_out_only1<0>"() { + tail call fastcc void @"global_flow_inference.rec_out_only2<0>"() + ret void } - -define external fastcc void @"global_flow_inference.rec_out_only2<0>"() noinline { -entry: - musttail call fastcc void @"global_flow_inference.rec_out_only1<0>"() - ret void +define external fastcc void @"global_flow_inference.rec_out_only2<0>"() { + tail call fastcc void @"global_flow_inference.rec_out_only1<0>"() + ret void } - -define external fastcc void @"global_flow_inference.rec_out_only_notail1<0>"() noinline { -entry: - store i64 1, i64* @"resource#global_flow_inference.res" - ret void +define external fastcc void @"global_flow_inference.rec_out_only_notail1<0>"() { + store i64 1, ptr @"resource#global_flow_inference.res" + ret void } - -define external fastcc void @"global_flow_inference.rec_out_only_notail2<0>"() noinline { -entry: - store i64 1, i64* @"resource#global_flow_inference.res" - ret void +define external fastcc void @"global_flow_inference.rec_out_only_notail2<0>"() { + store i64 1, ptr @"resource#global_flow_inference.res" + ret void } - -define external fastcc i64 @"global_flow_inference.still_only_in<0>"(i1 %"b##0") noinline { -entry: - br i1 %"b##0", label %if.then, label %if.else -if.then: - ret i64 0 -if.else: - %0 = load i64, i64* @"resource#global_flow_inference.res" - ret i64 %0 +define external fastcc i64 @"global_flow_inference.still_only_in<0>"(i1 %"b##0") { + br i1 %"b##0", label %if.then.0, label %if.else.0 +if.then.0: + ret i64 0 +if.else.0: + %"tmp#0##0" = load i64, ptr @"resource#global_flow_inference.res" + ret i64 %"tmp#0##0" } diff --git a/test-cases/final-dump/higher_order_anon.exp b/test-cases/final-dump/higher_order_anon.exp index e1713848f..b1b8464c6 100644 --- a/test-cases/final-dump/higher_order_anon.exp +++ b/test-cases/final-dump/higher_order_anon.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module higher_order_anon representation : (not a type) public submods : @@ -157,169 +160,127 @@ proc #anon#9 > {inline} (1 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'higher_order_anon' +source_filename = "!ROOT!/final-dump/higher_order_anon.wybe" +target triple ???? - - - -@higher_order_anon.0 = constant [1 x i64] [i64 ptrtoint (i64 (i64, i64)* @"higher_order_anon.#anon#7#anon#1<1>" to i64)] - - -declare external ccc i8* @wybe_malloc(i32) - +@"closure#0" = private unnamed_addr constant {ptr} { ptr @"higher_order_anon.#anon#7#anon#1<1>" }, align 8 -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) - -define external fastcc void @"higher_order_anon.<0>"() alwaysinline { -entry: - ret void +define external fastcc void @"higher_order_anon.<0>"() { + ret void } - -define external fastcc i64 @"higher_order_anon.#anon#1<0>"(i64 %"anon#1#1##0") alwaysinline { -entry: - %0 = add i64 %"anon#1#1##0", 1 - ret i64 %0 +define external fastcc i64 @"higher_order_anon.#anon#1<0>"(i64 %"anon#1#1##0") { + %"tmp#8##0" = add i64 %"anon#1#1##0", 1 + ret i64 %"tmp#8##0" } - -define external fastcc i64 @"higher_order_anon.#anon#1<1>"(i64 %"#env##0", i64 %"anon#1#1##0") alwaysinline { -entry: - %0 = add i64 %"anon#1#1##0", 1 - ret i64 %0 +define external fastcc i64 @"higher_order_anon.#anon#1<1>"(i64 %"#env##0", i64 %"generic#anon#1#1##0") { + %"anon#1#2##0" = add i64 %"generic#anon#1#1##0", 1 + ret i64 %"anon#1#2##0" } - -define external fastcc i64 @"higher_order_anon.#anon#2<0>"(i64 %"anon#2#1##0") alwaysinline { -entry: - %0 = add i64 %"anon#2#1##0", 1 - ret i64 %0 +define external fastcc i64 @"higher_order_anon.#anon#2<0>"(i64 %"anon#2#1##0") { + %"tmp#8##0" = add i64 %"anon#2#1##0", 1 + ret i64 %"tmp#8##0" } - -define external fastcc i64 @"higher_order_anon.#anon#2<1>"(i64 %"#env##0", i64 %"anon#2#1##0") alwaysinline { -entry: - %0 = add i64 %"anon#2#1##0", 1 - ret i64 %0 +define external fastcc i64 @"higher_order_anon.#anon#2<1>"(i64 %"#env##0", i64 %"generic#anon#2#1##0") { + %"anon#2#2##0" = add i64 %"generic#anon#2#1##0", 1 + ret i64 %"anon#2#2##0" } - -define external fastcc i64 @"higher_order_anon.#anon#3<0>"(i64 %"anon#3#2##0") alwaysinline { -entry: - ret i64 %"anon#3#2##0" +define external fastcc i64 @"higher_order_anon.#anon#3<0>"(i64 %"anon#3#2##0") { + ret i64 %"anon#3#2##0" } - -define external fastcc i64 @"higher_order_anon.#anon#3<1>"(i64 %"#env##0", i64 %"anon#3#1##0", i64 %"anon#3#2##0") alwaysinline { -entry: - ret i64 %"anon#3#2##0" +define external fastcc i64 @"higher_order_anon.#anon#3<1>"(i64 %"#env##0", i64 %"generic#anon#3#1##0", i64 %"generic#anon#3#2##0") { + ret i64 %"generic#anon#3#2##0" } - -define external fastcc i64 @"higher_order_anon.#anon#4<0>"(i64 %"anon#4#2##0") alwaysinline { -entry: - ret i64 %"anon#4#2##0" +define external fastcc i64 @"higher_order_anon.#anon#4<0>"(i64 %"anon#4#2##0") { + ret i64 %"anon#4#2##0" } - -define external fastcc i64 @"higher_order_anon.#anon#4<1>"(i64 %"#env##0", i64 %"anon#4#1##0", i64 %"anon#4#2##0") alwaysinline { -entry: - ret i64 %"anon#4#2##0" +define external fastcc i64 @"higher_order_anon.#anon#4<1>"(i64 %"#env##0", i64 %"generic#anon#4#1##0", i64 %"generic#anon#4#2##0") { + ret i64 %"generic#anon#4#2##0" } - -define external fastcc i64 @"higher_order_anon.#anon#5<0>"(i64 %"anon#5#1##0") alwaysinline { -entry: - ret i64 %"anon#5#1##0" +define external fastcc i64 @"higher_order_anon.#anon#5<0>"(i64 %"anon#5#1##0") { + ret i64 %"anon#5#1##0" } - -define external fastcc i64 @"higher_order_anon.#anon#5<1>"(i64 %"#env##0", i64 %"anon#5#1##0") alwaysinline { -entry: - ret i64 %"anon#5#1##0" +define external fastcc i64 @"higher_order_anon.#anon#5<1>"(i64 %"#env##0", i64 %"generic#anon#5#1##0") { + %"anon#5#1##0" = bitcast i64 %"generic#anon#5#1##0" to i64 + %"tmp#1##0" = bitcast i64 %"anon#5#1##0" to i64 + ret i64 %"tmp#1##0" } - -define external fastcc i64 @"higher_order_anon.#anon#6<0>"(i64 %"anon#6#1##0") alwaysinline { -entry: - ret i64 %"anon#6#1##0" +define external fastcc i64 @"higher_order_anon.#anon#6<0>"(i64 %"anon#6#1##0") { + ret i64 %"anon#6#1##0" } - -define external fastcc i64 @"higher_order_anon.#anon#6<1>"(i64 %"#env##0", i64 %"anon#6#1##0") alwaysinline { -entry: - ret i64 %"anon#6#1##0" +define external fastcc i64 @"higher_order_anon.#anon#6<1>"(i64 %"#env##0", i64 %"generic#anon#6#1##0") { + %"anon#6#1##0" = bitcast i64 %"generic#anon#6#1##0" to i64 + %"tmp#1##0" = bitcast i64 %"anon#6#1##0" to i64 + ret i64 %"tmp#1##0" } - -define external fastcc i64 @"higher_order_anon.#anon#7<0>"(i64 %"id##0") alwaysinline { -entry: - %0 = inttoptr i64 %"id##0" to i64* - %1 = load i64, i64* %0 - %2 = inttoptr i64 %1 to i64 (i64, i64)* - %3 = tail call fastcc i64 %2(i64 %"id##0", i64 ptrtoint (i64* getelementptr inbounds ([1 x i64], [1 x i64]* @higher_order_anon.0, i32 0, i32 0) to i64)) - ret i64 %3 +define external fastcc i64 @"higher_order_anon.#anon#7<0>"(i64 %"id##0") { + %"tmp#7##0" = inttoptr i64 %"id##0" to ptr + %"tmp#6##0" = load ptr, ptr %"tmp#7##0" + %"tmp#8##0" = tail call fastcc i64 %"tmp#6##0"(i64 %"id##0", ptr @"closure#0") + ret i64 %"tmp#8##0" } - -define external fastcc i64 @"higher_order_anon.#anon#7<1>"(i64 %"#env##0") alwaysinline { -entry: - %0 = add i64 %"#env##0", 8 - %1 = inttoptr i64 %0 to i64* - %2 = load i64, i64* %1 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %4 to i64 (i64, i64)* - %6 = tail call fastcc i64 %5(i64 %2, i64 ptrtoint (i64* getelementptr inbounds ([1 x i64], [1 x i64]* @higher_order_anon.0, i32 0, i32 0) to i64)) - ret i64 %6 +define external fastcc i64 @"higher_order_anon.#anon#7<1>"(i64 %"#env##0") { + %"tmp#1##0" = add i64 %"#env##0", 8 + %"tmp#2##0" = inttoptr i64 %"tmp#1##0" to ptr + %"generic#id##0" = load i64, ptr %"tmp#2##0" + %"id##0" = bitcast i64 %"generic#id##0" to i64 + %"tmp#4##0" = inttoptr i64 %"id##0" to ptr + %"tmp#3##0" = load ptr, ptr %"tmp#4##0" + %"anon#7#1##0" = tail call fastcc i64 %"tmp#3##0"(i64 %"id##0", ptr @"closure#0") + %"tmp#5##0" = bitcast i64 %"anon#7#1##0" to i64 + ret i64 %"tmp#5##0" } - -define external fastcc i64 @"higher_order_anon.#anon#7#anon#1<0>"(i64 %"anon#8#1##0") alwaysinline { -entry: - %0 = add i64 %"anon#8#1##0", 1 - ret i64 %0 +define external fastcc i64 @"higher_order_anon.#anon#7#anon#1<0>"(i64 %"anon#8#1##0") { + %"tmp#8##0" = add i64 %"anon#8#1##0", 1 + ret i64 %"tmp#8##0" } - -define external fastcc i64 @"higher_order_anon.#anon#7#anon#1<1>"(i64 %"#env##0", i64 %"anon#8#1##0") alwaysinline { -entry: - %0 = add i64 %"anon#8#1##0", 1 - ret i64 %0 +define external fastcc i64 @"higher_order_anon.#anon#7#anon#1<1>"(i64 %"#env##0", i64 %"generic#anon#8#1##0") { + %"anon#8#2##0" = add i64 %"generic#anon#8#1##0", 1 + ret i64 %"anon#8#2##0" } - -define external fastcc double @"higher_order_anon.#anon#8<0>"(double %"anon#9#1##0", double %"anon#9#3##0") alwaysinline { -entry: - %0 = fadd double %"anon#9#1##0", %"anon#9#3##0" - ret double %0 +define external fastcc double @"higher_order_anon.#anon#8<0>"(double %"anon#9#1##0", double %"anon#9#3##0") { + %"tmp#8##0" = fadd double %"anon#9#1##0", %"anon#9#3##0" + ret double %"tmp#8##0" } - -define external fastcc i64 @"higher_order_anon.#anon#8<1>"(i64 %"#env##0", i64 %"anon#9#1##0", i64 %"anon#9#2##0", i64 %"anon#9#3##0") alwaysinline { -entry: - %0 = bitcast i64 %"anon#9#1##0" to double - %1 = bitcast i64 %"anon#9#3##0" to double - %2 = fadd double %0, %1 - %3 = bitcast double %2 to i64 - ret i64 %3 +define external fastcc i64 @"higher_order_anon.#anon#8<1>"(i64 %"#env##0", i64 %"generic#anon#9#1##0", i64 %"generic#anon#9#2##0", i64 %"generic#anon#9#3##0") { + %"anon#9#1##0" = bitcast i64 %"generic#anon#9#1##0" to double + %"anon#9#3##0" = bitcast i64 %"generic#anon#9#3##0" to double + %"anon#9#4##0" = fadd double %"anon#9#1##0", %"anon#9#3##0" + %"tmp#3##0" = bitcast double %"anon#9#4##0" to i64 + ret i64 %"tmp#3##0" } - -define external fastcc double @"higher_order_anon.#anon#9<0>"(double %"anon#10#1##0", double %"anon#10#3##0") alwaysinline { -entry: - %0 = fadd double %"anon#10#1##0", %"anon#10#3##0" - ret double %0 +define external fastcc double @"higher_order_anon.#anon#9<0>"(double %"anon#10#1##0", double %"anon#10#3##0") { + %"tmp#8##0" = fadd double %"anon#10#1##0", %"anon#10#3##0" + ret double %"tmp#8##0" } - -define external fastcc i64 @"higher_order_anon.#anon#9<1>"(i64 %"#env##0", i64 %"anon#10#1##0", i64 %"anon#10#2##0", i64 %"anon#10#3##0") alwaysinline { -entry: - %0 = bitcast i64 %"anon#10#1##0" to double - %1 = bitcast i64 %"anon#10#3##0" to double - %2 = fadd double %0, %1 - %3 = bitcast double %2 to i64 - ret i64 %3 +define external fastcc i64 @"higher_order_anon.#anon#9<1>"(i64 %"#env##0", i64 %"generic#anon#10#1##0", i64 %"generic#anon#10#2##0", i64 %"generic#anon#10#3##0") { + %"anon#10#1##0" = bitcast i64 %"generic#anon#10#1##0" to double + %"anon#10#3##0" = bitcast i64 %"generic#anon#10#3##0" to double + %"anon#10#4##0" = fadd double %"anon#10#1##0", %"anon#10#3##0" + %"tmp#3##0" = bitcast double %"anon#10#4##0" to i64 + ret i64 %"tmp#3##0" } diff --git a/test-cases/final-dump/higher_order_append.exp b/test-cases/final-dump/higher_order_append.exp index 13c55412f..668407b28 100644 --- a/test-cases/final-dump/higher_order_append.exp +++ b/test-cases/final-dump/higher_order_append.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module higher_order_append representation : (not a type) public submods : @@ -111,184 +114,147 @@ print_list_of_ints#closure#1(x##0:wybe.int)<{<>}; {<>}; LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'higher_order_append' - - - - -@higher_order_append.0 = constant [1 x i64] [i64 ptrtoint (void (i64, i64)* @"higher_order_append.#closure#1<0>" to i64)] - - -@higher_order_append.1 = constant [1 x i64] [i64 ptrtoint (void (i64, i64)* @"higher_order_append.print_list_of_ints#closure#1<0>" to i64)] - - -declare external ccc void @print_int(i64) - - -declare external fastcc void @"wybe.list.print<0>"(i64, i64) - - -declare external ccc void @putchar(i8) - - -declare external fastcc void @"wybe.list.map<1>"(i64, i64, i64*) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"higher_order_append.<0>"() { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 1, i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 0, i64* %5 - %6 = trunc i64 16 to i32 - %7 = tail call ccc i8* @wybe_malloc(i32 %6) - %8 = ptrtoint i8* %7 to i64 - %9 = inttoptr i64 %8 to i64* - store i64 2, i64* %9 - %10 = add i64 %8, 8 - %11 = inttoptr i64 %10 to i64* - store i64 0, i64* %11 - %12 = trunc i64 16 to i32 - %13 = tail call ccc i8* @wybe_malloc(i32 %12) - %14 = ptrtoint i8* %13 to i64 - %15 = inttoptr i64 %14 to i64* - store i64 3, i64* %15 - %16 = add i64 %14, 8 - %17 = inttoptr i64 %16 to i64* - store i64 0, i64* %17 - %18 = trunc i64 16 to i32 - %19 = tail call ccc i8* @wybe_malloc(i32 %18) - %20 = ptrtoint i8* %19 to i64 - %21 = inttoptr i64 %20 to i64* - store i64 %14, i64* %21 - %22 = add i64 %20, 8 - %23 = inttoptr i64 %22 to i64* - store i64 0, i64* %23 - %24 = trunc i64 16 to i32 - %25 = tail call ccc i8* @wybe_malloc(i32 %24) - %26 = ptrtoint i8* %25 to i64 - %27 = inttoptr i64 %26 to i64* - store i64 %8, i64* %27 - %28 = add i64 %26, 8 - %29 = inttoptr i64 %28 to i64* - store i64 %20, i64* %29 - %30 = trunc i64 16 to i32 - %31 = tail call ccc i8* @wybe_malloc(i32 %30) - %32 = ptrtoint i8* %31 to i64 - %33 = inttoptr i64 %32 to i64* - store i64 %2, i64* %33 - %34 = add i64 %32, 8 - %35 = inttoptr i64 %34 to i64* - store i64 %26, i64* %35 - %36 = trunc i64 16 to i32 - %37 = tail call ccc i8* @wybe_malloc(i32 %36) - %38 = ptrtoint i8* %37 to i64 - %39 = inttoptr i64 %38 to i64* - store i64 6, i64* %39 - %40 = add i64 %38, 8 - %41 = inttoptr i64 %40 to i64* - store i64 0, i64* %41 - %42 = trunc i64 16 to i32 - %43 = tail call ccc i8* @wybe_malloc(i32 %42) - %44 = ptrtoint i8* %43 to i64 - %45 = inttoptr i64 %44 to i64* - store i64 4, i64* %45 - %46 = add i64 %44, 8 - %47 = inttoptr i64 %46 to i64* - store i64 %38, i64* %47 - %48 = trunc i64 16 to i32 - %49 = tail call ccc i8* @wybe_malloc(i32 %48) - %50 = ptrtoint i8* %49 to i64 - %51 = inttoptr i64 %50 to i64* - %52 = getelementptr i64, i64* %51, i64 0 - store i64 ptrtoint (i64 (i64, i64)* @"higher_order_append.#anon#1<1>" to i64), i64* %52 - %53 = getelementptr i64, i64* %51, i64 1 - store i64 %44, i64* %53 - %54 = alloca i64 - call fastcc void @"wybe.list.map<1>"(i64 %50, i64 %32, i64* %54) - %55 = load i64, i64* %54 - tail call fastcc void @"wybe.list.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ([1 x i64], [1 x i64]* @higher_order_append.0, i32 0, i32 0) to i64), i64 %32) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"wybe.list.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ([1 x i64], [1 x i64]* @higher_order_append.0, i32 0, i32 0) to i64), i64 %55) - tail call ccc void @putchar(i8 10) - ret void +source_filename = "!ROOT!/final-dump/higher_order_append.wybe" +target triple ???? + +@"closure#0" = private unnamed_addr constant {ptr} { ptr @"higher_order_append.#closure#1<0>" }, align 8 +@"closure#1" = private unnamed_addr constant {ptr} { ptr @"higher_order_append.print_list_of_ints#closure#1<0>" }, align 8 + +declare external fastcc void @"wybe.list.map<1>"(i64, i64, ptr) +declare external fastcc void @"wybe.list.print<0>"(i64, i64) +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"higher_order_append.<0>"() { + %"tmp#55##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#17##0" = ptrtoint ptr %"tmp#55##0" to i64 + %"tmp#56##0" = inttoptr i64 %"tmp#17##0" to ptr + store i64 1, ptr %"tmp#56##0" + %"tmp#57##0" = add i64 %"tmp#17##0", 8 + %"tmp#58##0" = inttoptr i64 %"tmp#57##0" to ptr + store i64 0, ptr %"tmp#58##0" + %"tmp#59##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#21##0" = ptrtoint ptr %"tmp#59##0" to i64 + %"tmp#60##0" = inttoptr i64 %"tmp#21##0" to ptr + store i64 2, ptr %"tmp#60##0" + %"tmp#61##0" = add i64 %"tmp#21##0", 8 + %"tmp#62##0" = inttoptr i64 %"tmp#61##0" to ptr + store i64 0, ptr %"tmp#62##0" + %"tmp#63##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#25##0" = ptrtoint ptr %"tmp#63##0" to i64 + %"tmp#64##0" = inttoptr i64 %"tmp#25##0" to ptr + store i64 3, ptr %"tmp#64##0" + %"tmp#65##0" = add i64 %"tmp#25##0", 8 + %"tmp#66##0" = inttoptr i64 %"tmp#65##0" to ptr + store i64 0, ptr %"tmp#66##0" + %"tmp#67##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#29##0" = ptrtoint ptr %"tmp#67##0" to i64 + %"tmp#68##0" = inttoptr i64 %"tmp#29##0" to ptr + store i64 %"tmp#25##0", ptr %"tmp#68##0" + %"tmp#69##0" = add i64 %"tmp#29##0", 8 + %"tmp#70##0" = inttoptr i64 %"tmp#69##0" to ptr + store i64 0, ptr %"tmp#70##0" + %"tmp#71##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#33##0" = ptrtoint ptr %"tmp#71##0" to i64 + %"tmp#72##0" = inttoptr i64 %"tmp#33##0" to ptr + store i64 %"tmp#21##0", ptr %"tmp#72##0" + %"tmp#73##0" = add i64 %"tmp#33##0", 8 + %"tmp#74##0" = inttoptr i64 %"tmp#73##0" to ptr + store i64 %"tmp#29##0", ptr %"tmp#74##0" + %"tmp#75##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#37##0" = ptrtoint ptr %"tmp#75##0" to i64 + %"tmp#76##0" = inttoptr i64 %"tmp#37##0" to ptr + store i64 %"tmp#17##0", ptr %"tmp#76##0" + %"tmp#77##0" = add i64 %"tmp#37##0", 8 + %"tmp#78##0" = inttoptr i64 %"tmp#77##0" to ptr + store i64 %"tmp#33##0", ptr %"tmp#78##0" + %"tmp#79##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#41##0" = ptrtoint ptr %"tmp#79##0" to i64 + %"tmp#80##0" = inttoptr i64 %"tmp#41##0" to ptr + store i64 6, ptr %"tmp#80##0" + %"tmp#81##0" = add i64 %"tmp#41##0", 8 + %"tmp#82##0" = inttoptr i64 %"tmp#81##0" to ptr + store i64 0, ptr %"tmp#82##0" + %"tmp#83##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#45##0" = ptrtoint ptr %"tmp#83##0" to i64 + %"tmp#84##0" = inttoptr i64 %"tmp#45##0" to ptr + store i64 4, ptr %"tmp#84##0" + %"tmp#85##0" = add i64 %"tmp#45##0", 8 + %"tmp#86##0" = inttoptr i64 %"tmp#85##0" to ptr + store i64 %"tmp#41##0", ptr %"tmp#86##0" + %"tmp#87##0" = alloca i8, i64 8, align 8 + %"tmp#89##0" = call ccc ptr @wybe_malloc(i32 16) + store ptr @"higher_order_append.#anon#1<1>", ptr %"tmp#89##0" + %"tmp#90##0" = ptrtoint ptr %"tmp#89##0" to i64 + %"tmp#91##0" = add i64 %"tmp#90##0", 8 + %"tmp#92##0" = inttoptr i64 %"tmp#91##0" to ptr + store ptr @"higher_order_append.#anon#1<1>", ptr %"tmp#92##0" + %"tmp#88##0" = ptrtoint ptr %"tmp#89##0" to i64 + call fastcc void @"wybe.list.map<1>"(i64 %"tmp#88##0", i64 %"tmp#37##0", ptr %"tmp#87##0") + %"y##0" = load i64, ptr %"tmp#87##0" + call fastcc void @"wybe.list.print<0>"(i64 ptrtoint( ptr @"closure#0" to i64 ), i64 %"tmp#37##0") + call ccc void @putchar(i8 10) + call fastcc void @"wybe.list.print<0>"(i64 ptrtoint( ptr @"closure#0" to i64 ), i64 %"y##0") + call ccc void @putchar(i8 10) + ret void } - -define external fastcc i64 @"higher_order_append.#anon#1<0>"(i64 %"cons##0", i64 %"anon#1#1##0") alwaysinline { -entry: - %0 = alloca i64 - call fastcc void @"higher_order_append.append<0>"(i64 %"anon#1#1##0", i64 %"cons##0", i64* %0) - %1 = load i64, i64* %0 - ret i64 %1 +define external fastcc i64 @"higher_order_append.#anon#1<0>"(i64 %"cons##0", i64 %"anon#1#1##0") { + %"tmp#15##0" = alloca i8, i64 8, align 8 + call fastcc void @"higher_order_append.append<0>"(i64 %"anon#1#1##0", i64 %"cons##0", ptr %"tmp#15##0") + %"tmp#16##0" = load i64, ptr %"tmp#15##0" + ret i64 %"tmp#16##0" } - -define external fastcc i64 @"higher_order_append.#anon#1<1>"(i64 %"#env##0", i64 %"anon#1#1##0") alwaysinline { -entry: - %0 = add i64 %"#env##0", 8 - %1 = inttoptr i64 %0 to i64* - %2 = load i64, i64* %1 - %3 = alloca i64 - call fastcc void @"higher_order_append.append<0>"(i64 %"anon#1#1##0", i64 %2, i64* %3) - %4 = load i64, i64* %3 - ret i64 %4 +define external fastcc i64 @"higher_order_append.#anon#1<1>"(i64 %"#env##0", i64 %"generic#anon#1#1##0") { + %"tmp#2##0" = add i64 %"#env##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"generic#cons##0" = load i64, ptr %"tmp#3##0" + %"tmp#4##0" = alloca i8, i64 8, align 8 + call fastcc void @"higher_order_append.append<0>"(i64 %"generic#anon#1#1##0", i64 %"generic#cons##0", ptr %"tmp#4##0") + %"anon#1#2##0" = load i64, ptr %"tmp#4##0" + ret i64 %"anon#1#2##0" } - -define external fastcc void @"higher_order_append.#closure#1<0>"(i64 %"#env##0", i64 %"l##0") alwaysinline { -entry: - musttail call fastcc void @"wybe.list.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ([1 x i64], [1 x i64]* @higher_order_append.1, i32 0, i32 0) to i64), i64 %"l##0") - ret void +define external fastcc void @"higher_order_append.#closure#1<0>"(i64 %"#env##0", i64 %"generic#l##0") { + tail call fastcc void @"wybe.list.print<0>"(i64 ptrtoint( ptr @"closure#1" to i64 ), i64 %"generic#l##0") + ret void } - -define external fastcc void @"higher_order_append.append<0>"(i64 %"front##0", i64 %"back##0", i64* %"result##0") { -entry: - %0 = icmp ne i64 %"front##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"front##0" to i64* - %2 = load i64, i64* %1 - %3 = add i64 %"front##0", 8 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = trunc i64 16 to i32 - %7 = tail call ccc i8* @wybe_malloc(i32 %6) - %8 = ptrtoint i8* %7 to i64 - %9 = inttoptr i64 %8 to i64* - store i64 %2, i64* %9 - %10 = add i64 %8, 8 - %11 = inttoptr i64 %10 to i64* - store i64 %8, i64* %"result##0" - musttail call fastcc void @"higher_order_append.append<0>"(i64 %5, i64 %"back##0", i64* %11) - ret void -if.else: - store i64 %"back##0", i64* %"result##0" - ret void +define external fastcc void @"higher_order_append.append<0>"(i64 %"front##0", i64 %"back##0", ptr %"tmp#8##0") { + %"tmp#3##0" = icmp ne i64 %"front##0", 0 + br i1 %"tmp#3##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#9##0" = inttoptr i64 %"front##0" to ptr + %"h##0" = load i64, ptr %"tmp#9##0" + %"tmp#10##0" = add i64 %"front##0", 8 + %"tmp#11##0" = inttoptr i64 %"tmp#10##0" to ptr + %"t##0" = load i64, ptr %"tmp#11##0" + %"tmp#12##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#6##0" = ptrtoint ptr %"tmp#12##0" to i64 + %"tmp#13##0" = inttoptr i64 %"tmp#6##0" to ptr + store i64 %"h##0", ptr %"tmp#13##0" + store i64 %"tmp#6##0", ptr %"tmp#8##0" + %"tmp#14##0" = add i64 %"tmp#6##0", 8 + %"tmp#15##0" = inttoptr i64 %"tmp#14##0" to ptr + musttail call fastcc void @"higher_order_append.append<0>"(i64 %"t##0", i64 %"back##0", ptr %"tmp#15##0") + ret void +if.else.0: + store i64 %"back##0", ptr %"tmp#8##0" + ret void } - -define external fastcc void @"higher_order_append.print_list_of_ints<0>"(i64 %"l##0") alwaysinline { -entry: - tail call fastcc void @"wybe.list.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ([1 x i64], [1 x i64]* @higher_order_append.1, i32 0, i32 0) to i64), i64 %"l##0") - ret void +define external fastcc void @"higher_order_append.print_list_of_ints<0>"(i64 %"l##0") { + tail call fastcc void @"wybe.list.print<0>"(i64 ptrtoint( ptr @"closure#1" to i64 ), i64 %"l##0") + ret void } - -define external fastcc void @"higher_order_append.print_list_of_ints#closure#1<0>"(i64 %"#env##0", i64 %"x##0") alwaysinline { -entry: - tail call ccc void @print_int(i64 %"x##0") - ret void +define external fastcc void @"higher_order_append.print_list_of_ints#closure#1<0>"(i64 %"#env##0", i64 %"generic#x##0") { + call ccc void @print_int(i64 %"generic#x##0") + ret void } diff --git a/test-cases/final-dump/higher_order_impure.exp b/test-cases/final-dump/higher_order_impure.exp index 9a7612f42..22b748734 100644 --- a/test-cases/final-dump/higher_order_impure.exp +++ b/test-cases/final-dump/higher_order_impure.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module higher_order_impure representation : (not a type) public submods : @@ -44,50 +47,35 @@ measure(func##0:{impure}(), ?seconds_elapsed##0:wybe.float)<{}; {}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'higher_order_impure' - - - - -declare external ccc void @putchar(i8) - - -declare external ccc void @print_float(double) +source_filename = "!ROOT!/final-dump/higher_order_impure.wybe" +target triple ???? -declare external ccc i8* @wybe_malloc(i32) +declare external ccc void @print_float(double) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"higher_order_impure.<0>"() alwaysinline { -entry: - tail call fastcc void @"higher_order_impure.#anon#1<0>"() - tail call ccc void @print_float(double 3.000000e0) - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"higher_order_impure.<0>"() { + tail call fastcc void @"higher_order_impure.#anon#1<0>"() + call ccc void @print_float(double 3.0) + call ccc void @putchar(i8 10) + ret void } - -define external fastcc void @"higher_order_impure.#anon#1<0>"() alwaysinline { -entry: - ret void +define external fastcc void @"higher_order_impure.#anon#1<0>"() { + ret void } - -define external fastcc void @"higher_order_impure.#anon#1<1>"(i64 %"#env##0") alwaysinline { -entry: - ret void +define external fastcc void @"higher_order_impure.#anon#1<1>"(i64 %"#env##0") { + ret void } - -define external fastcc double @"higher_order_impure.measure<0>"(i64 %"func##0") alwaysinline { -entry: - %0 = inttoptr i64 %"func##0" to i64* - %1 = load i64, i64* %0 - %2 = inttoptr i64 %1 to void (i64)* - tail call fastcc void %2(i64 %"func##0") - ret double 3.000000e0 +define external fastcc double @"higher_order_impure.measure<0>"(i64 %"func##0") { + %"tmp#1##0" = inttoptr i64 %"func##0" to ptr + %"tmp#0##0" = load ptr, ptr %"tmp#1##0" + tail call fastcc void %"tmp#0##0"(i64 %"func##0") + ret double 3.0 } diff --git a/test-cases/final-dump/higher_order_inline.exp b/test-cases/final-dump/higher_order_inline.exp index c1c6e4f38..5691f43f1 100644 --- a/test-cases/final-dump/higher_order_inline.exp +++ b/test-cases/final-dump/higher_order_inline.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module higher_order_inline representation : (not a type) public submods : @@ -29,33 +32,23 @@ proc #closure#1 > {inline} (1 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'higher_order_inline' +source_filename = "!ROOT!/final-dump/higher_order_inline.wybe" +target triple ???? - - - -declare external ccc void @putchar(i8) - - -declare external ccc void @print_int(i64) +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"higher_order_inline.<0>"() alwaysinline { -entry: - tail call ccc void @print_int(i64 1) - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"higher_order_inline.<0>"() { + call ccc void @print_int(i64 1) + call ccc void @putchar(i8 10) + ret void } - -define external fastcc i64 @"higher_order_inline.#closure#1<0>"(i64 %"#env##0", i64 %"a##0") alwaysinline { -entry: - ret i64 %"a##0" +define external fastcc i64 @"higher_order_inline.#closure#1<0>"(i64 %"#env##0", i64 %"generic#a##0") { + ret i64 %"generic#a##0" } diff --git a/test-cases/final-dump/higher_order_loop.exp b/test-cases/final-dump/higher_order_loop.exp index 5a775d0a0..9f338c5fd 100644 --- a/test-cases/final-dump/higher_order_loop.exp +++ b/test-cases/final-dump/higher_order_loop.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module higher_order_loop representation : (not a type) public submods : @@ -62,84 +65,64 @@ proc #cont#1 > {semipure} (2 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'higher_order_loop' - - - - -@higher_order_loop.1 = constant [1 x i64] [i64 ptrtoint (void (i64, i64)* @"higher_order_loop.#closure#1<0>" to i64)] - - -@higher_order_loop.0 = constant [1 x i64] [i64 ptrtoint (void (i64, i64)* @"higher_order_loop.#closure#2<0>" to i64)] - - -declare external ccc void @print_int(i64) - - -declare external ccc void @putchar(i8) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"higher_order_loop.<0>"() { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 ptrtoint (i64* getelementptr inbounds ([1 x i64], [1 x i64]* @higher_order_loop.0, i32 0, i32 0) to i64), i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 0, i64* %5 - %6 = trunc i64 16 to i32 - %7 = tail call ccc i8* @wybe_malloc(i32 %6) - %8 = ptrtoint i8* %7 to i64 - %9 = inttoptr i64 %8 to i64* - store i64 ptrtoint (i64* getelementptr inbounds ([1 x i64], [1 x i64]* @higher_order_loop.1, i32 0, i32 0) to i64), i64* %9 - %10 = add i64 %8, 8 - %11 = inttoptr i64 %10 to i64* - store i64 %2, i64* %11 - tail call fastcc void @"higher_order_loop.#cont#1<0>"(i64 %8) - ret void +source_filename = "!ROOT!/final-dump/higher_order_loop.wybe" +target triple ???? + +@"closure#0" = private unnamed_addr constant {ptr} { ptr @"higher_order_loop.#closure#1<0>" }, align 8 +@"closure#1" = private unnamed_addr constant {ptr} { ptr @"higher_order_loop.#closure#2<0>" }, align 8 + +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"higher_order_loop.<0>"() { + %"tmp#16##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#10##0" = ptrtoint ptr %"tmp#16##0" to i64 + %"tmp#17##0" = inttoptr i64 %"tmp#10##0" to ptr + store ptr @"closure#1", ptr %"tmp#17##0" + %"tmp#18##0" = add i64 %"tmp#10##0", 8 + %"tmp#19##0" = inttoptr i64 %"tmp#18##0" to ptr + store i64 0, ptr %"tmp#19##0" + %"tmp#20##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#14##0" = ptrtoint ptr %"tmp#20##0" to i64 + %"tmp#21##0" = inttoptr i64 %"tmp#14##0" to ptr + store ptr @"closure#0", ptr %"tmp#21##0" + %"tmp#22##0" = add i64 %"tmp#14##0", 8 + %"tmp#23##0" = inttoptr i64 %"tmp#22##0" to ptr + store i64 %"tmp#10##0", ptr %"tmp#23##0" + tail call fastcc void @"higher_order_loop.#cont#1<0>"(i64 %"tmp#14##0") + ret void } - -define external fastcc void @"higher_order_loop.#closure#1<0>"(i64 %"#env##0", i64 %"x##0") alwaysinline { -entry: - tail call ccc void @print_int(i64 %"x##0") - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"higher_order_loop.#closure#1<0>"(i64 %"#env##0", i64 %"generic#x##0") { + call ccc void @print_int(i64 %"generic#x##0") + call ccc void @putchar(i8 10) + ret void } - -define external fastcc void @"higher_order_loop.#closure#2<0>"(i64 %"#env##0", i64 %"x##0") alwaysinline { -entry: - tail call ccc void @print_int(i64 %"x##0") - ret void +define external fastcc void @"higher_order_loop.#closure#2<0>"(i64 %"#env##0", i64 %"generic#x##0") { + call ccc void @print_int(i64 %"generic#x##0") + ret void } - -define external fastcc void @"higher_order_loop.#cont#1<0>"(i64 %"tmp#5##0") { -entry: - %0 = icmp ne i64 %"tmp#5##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"tmp#5##0" to i64* - %2 = load i64, i64* %1 - %3 = add i64 %"tmp#5##0", 8 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = inttoptr i64 %2 to i64* - %7 = load i64, i64* %6 - %8 = inttoptr i64 %7 to void (i64, i64)* - tail call fastcc void %8(i64 %2, i64 10) - musttail call fastcc void @"higher_order_loop.#cont#1<0>"(i64 %5) - ret void -if.else: - ret void +define external fastcc void @"higher_order_loop.#cont#1<0>"(i64 %"tmp#5##0") { + %"tmp#9##0" = icmp ne i64 %"tmp#5##0", 0 + br i1 %"tmp#9##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#10##0" = inttoptr i64 %"tmp#5##0" to ptr + %"f##0" = load i64, ptr %"tmp#10##0" + %"tmp#11##0" = add i64 %"tmp#5##0", 8 + %"tmp#12##0" = inttoptr i64 %"tmp#11##0" to ptr + %"tmp#5##1" = load i64, ptr %"tmp#12##0" + %"tmp#14##0" = inttoptr i64 %"f##0" to ptr + %"tmp#13##0" = load ptr, ptr %"tmp#14##0" + tail call fastcc void %"tmp#13##0"(i64 %"f##0", i64 10) + tail call fastcc void @"higher_order_loop.#cont#1<0>"(i64 %"tmp#5##1") + ret void +if.else.0: + ret void } diff --git a/test-cases/final-dump/higher_order_phantom.exp b/test-cases/final-dump/higher_order_phantom.exp index 4dc78544e..995cf94a1 100644 --- a/test-cases/final-dump/higher_order_phantom.exp +++ b/test-cases/final-dump/higher_order_phantom.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module higher_order_phantom representation : (not a type) public submods : @@ -34,39 +37,29 @@ c(f##0:(wybe.phantom, ?X) <{}; {}; {0}>, x##0:wybe.phantom, ?#result##0:X <{}; { LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'higher_order_phantom' +source_filename = "!ROOT!/final-dump/higher_order_phantom.wybe" +target triple ???? - - - -declare external ccc i8* @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"higher_order_phantom.a<0>"(i64 %"f##0") alwaysinline { -entry: - ret void +define external fastcc void @"higher_order_phantom.a<0>"(i64 %"f##0") { + ret void } - -define external fastcc void @"higher_order_phantom.b<0>"(i64 %"f##0") alwaysinline { -entry: - %0 = inttoptr i64 %"f##0" to i64* - %1 = load i64, i64* %0 - %2 = inttoptr i64 %1 to i64 (i64, i64)* - %3 = tail call fastcc i64 %2(i64 %"f##0", i64 undef) - ret void +define external fastcc void @"higher_order_phantom.b<0>"(i64 %"f##0") { + %"tmp#1##0" = inttoptr i64 %"f##0" to ptr + %"tmp#0##0" = load ptr, ptr %"tmp#1##0" + tail call fastcc void %"tmp#0##0"(i64 %"f##0") + ret void } - -define external fastcc i64 @"higher_order_phantom.c<0>"(i64 %"f##0") alwaysinline { -entry: - %0 = inttoptr i64 %"f##0" to i64* - %1 = load i64, i64* %0 - %2 = inttoptr i64 %1 to i64 (i64, i64)* - %3 = tail call fastcc i64 %2(i64 %"f##0", i64 undef) - ret i64 %3 +define external fastcc i64 @"higher_order_phantom.c<0>"(i64 %"f##0") { + %"tmp#2##0" = inttoptr i64 %"f##0" to ptr + %"tmp#1##0" = load ptr, ptr %"tmp#2##0" + %"tmp#3##0" = tail call fastcc i64 %"tmp#1##0"(i64 %"f##0") + ret i64 %"tmp#3##0" } diff --git a/test-cases/final-dump/higher_order_refs.exp b/test-cases/final-dump/higher_order_refs.exp index beecbc1a0..b00938cf2 100644 --- a/test-cases/final-dump/higher_order_refs.exp +++ b/test-cases/final-dump/higher_order_refs.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module higher_order_refs representation : (not a type) public submods : @@ -125,159 +128,113 @@ app(f##0:(I, ?J) <{}; {}; {0}>, i##0:I <{}; {}; {1}>, ?#result##0:J <{}; {}; {0, LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'higher_order_refs' - - - - -@higher_order_refs.0 = constant [1 x i64] [i64 ptrtoint (i64 (i64, i64)* @"higher_order_refs.#anon#1<1>" to i64)] - - -@higher_order_refs.1 = constant [1 x i64] [i64 ptrtoint (i64 (i64, i64)* @"higher_order_refs.#anon#2<1>" to i64)] - - -@higher_order_refs.2 = constant [2 x i64] [i64 ptrtoint (i64 (i64, i64)* @"higher_order_refs.#anon#3<1>" to i64), i64 bitcast (double 5.000000e-1 to i64)] - - -@higher_order_refs.3 = constant [1 x i64] [i64 ptrtoint (i64 (i64, i64)* @"higher_order_refs.#closure#1<0>" to i64)] - - -@higher_order_refs.4 = constant [1 x i64] [i64 ptrtoint (i64 (i64, i64)* @"higher_order_refs.#closure#2<0>" to i64)] - - -@higher_order_refs.5 = constant [1 x i64] [i64 ptrtoint (i64 (i64, i64)* @"higher_order_refs.#closure#3<0>" to i64)] - - -declare external ccc void @putchar(i8) - - -declare external ccc void @print_int(i64) - - -declare external ccc void @print_float(double) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"higher_order_refs.<0>"() { -entry: - %0 = tail call fastcc i64 @"higher_order_refs.app<0>"(i64 ptrtoint (i64* getelementptr inbounds ([1 x i64], [1 x i64]* @higher_order_refs.0, i32 0, i32 0) to i64), i64 bitcast (double 1.000000e0 to i64)) - %1 = bitcast i64 %0 to double - tail call ccc void @print_float(double %1) - tail call ccc void @putchar(i8 10) - %2 = tail call fastcc i64 @"higher_order_refs.app<0>"(i64 ptrtoint (i64* getelementptr inbounds ([1 x i64], [1 x i64]* @higher_order_refs.1, i32 0, i32 0) to i64), i64 bitcast (double 1.000000e0 to i64)) - %3 = bitcast i64 %2 to double - tail call ccc void @print_float(double %3) - tail call ccc void @putchar(i8 10) - %4 = tail call fastcc i64 @"higher_order_refs.app<0>"(i64 ptrtoint (i64* getelementptr inbounds ([2 x i64], [2 x i64]* @higher_order_refs.2, i32 0, i32 0) to i64), i64 bitcast (double 1.000000e0 to i64)) - %5 = bitcast i64 %4 to double - tail call ccc void @print_float(double %5) - tail call ccc void @putchar(i8 10) - %6 = tail call fastcc i64 @"higher_order_refs.app<0>"(i64 ptrtoint (i64* getelementptr inbounds ([1 x i64], [1 x i64]* @higher_order_refs.3, i32 0, i32 0) to i64), i64 bitcast (double 1.000000e0 to i64)) - %7 = bitcast i64 %6 to double - tail call ccc void @print_float(double %7) - tail call ccc void @putchar(i8 10) - %8 = tail call fastcc i64 @"higher_order_refs.app<0>"(i64 ptrtoint (i64* getelementptr inbounds ([1 x i64], [1 x i64]* @higher_order_refs.4, i32 0, i32 0) to i64), i64 1) - tail call ccc void @print_int(i64 %8) - tail call ccc void @putchar(i8 10) - %9 = tail call fastcc i64 @"higher_order_refs.app<0>"(i64 ptrtoint (i64* getelementptr inbounds ([1 x i64], [1 x i64]* @higher_order_refs.5, i32 0, i32 0) to i64), i64 1) - tail call ccc void @print_int(i64 %9) - tail call ccc void @putchar(i8 10) - ret void +source_filename = "!ROOT!/final-dump/higher_order_refs.wybe" +target triple ???? + +@"closure#0" = private unnamed_addr constant {ptr} { ptr @"higher_order_refs.#anon#1<1>" }, align 8 +@"closure#1" = private unnamed_addr constant {ptr} { ptr @"higher_order_refs.#anon#2<1>" }, align 8 +@"closure#2" = private unnamed_addr constant {ptr, double} { ptr @"higher_order_refs.#anon#3<1>", double 0.5 }, align 8 +@"closure#3" = private unnamed_addr constant {ptr} { ptr @"higher_order_refs.#closure#1<0>" }, align 8 +@"closure#4" = private unnamed_addr constant {ptr} { ptr @"higher_order_refs.#closure#2<0>" }, align 8 +@"closure#5" = private unnamed_addr constant {ptr, i64} { ptr @"higher_order_refs.#closure#3<0>", i64 undef }, align 8 + +declare external ccc void @print_float(double) +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"higher_order_refs.<0>"() { + %"tmp#34##0" = tail call fastcc i64 @"higher_order_refs.app<0>"(i64 ptrtoint( ptr @"closure#0" to i64 ), i64 bitcast( double 1.0 to i64 )) + %"tmp#0##0" = bitcast i64 %"tmp#34##0" to double + call ccc void @print_float(double %"tmp#0##0") + call ccc void @putchar(i8 10) + %"tmp#35##0" = tail call fastcc i64 @"higher_order_refs.app<0>"(i64 ptrtoint( ptr @"closure#1" to i64 ), i64 bitcast( double 1.0 to i64 )) + %"tmp#1##0" = bitcast i64 %"tmp#35##0" to double + call ccc void @print_float(double %"tmp#1##0") + call ccc void @putchar(i8 10) + %"tmp#36##0" = tail call fastcc i64 @"higher_order_refs.app<0>"(i64 ptrtoint( ptr @"closure#2" to i64 ), i64 bitcast( double 1.0 to i64 )) + %"tmp#3##0" = bitcast i64 %"tmp#36##0" to double + call ccc void @print_float(double %"tmp#3##0") + call ccc void @putchar(i8 10) + %"tmp#37##0" = tail call fastcc i64 @"higher_order_refs.app<0>"(i64 ptrtoint( ptr @"closure#3" to i64 ), i64 bitcast( double 1.0 to i64 )) + %"tmp#5##0" = bitcast i64 %"tmp#37##0" to double + call ccc void @print_float(double %"tmp#5##0") + call ccc void @putchar(i8 10) + %"tmp#6##0" = tail call fastcc i64 @"higher_order_refs.app<0>"(i64 ptrtoint( ptr @"closure#4" to i64 ), i64 1) + call ccc void @print_int(i64 %"tmp#6##0") + call ccc void @putchar(i8 10) + %"tmp#8##0" = tail call fastcc i64 @"higher_order_refs.app<0>"(i64 ptrtoint( ptr @"closure#5" to i64 ), i64 1) + call ccc void @print_int(i64 %"tmp#8##0") + call ccc void @putchar(i8 10) + ret void } - -define external fastcc double @"higher_order_refs.#anon#1<0>"(double %"anon#1#1##0") alwaysinline { -entry: - ret double %"anon#1#1##0" +define external fastcc double @"higher_order_refs.#anon#1<0>"(double %"anon#1#1##0") { + ret double %"anon#1#1##0" } - -define external fastcc i64 @"higher_order_refs.#anon#1<1>"(i64 %"#env##0", i64 %"anon#1#1##0") alwaysinline { -entry: - %0 = bitcast i64 %"anon#1#1##0" to double - %1 = bitcast double %0 to i64 - ret i64 %1 +define external fastcc i64 @"higher_order_refs.#anon#1<1>"(i64 %"#env##0", i64 %"generic#anon#1#1##0") { + %"anon#1#1##0" = bitcast i64 %"generic#anon#1#1##0" to double + %"tmp#1##0" = bitcast double %"anon#1#1##0" to i64 + ret i64 %"tmp#1##0" } - -define external fastcc double @"higher_order_refs.#anon#2<0>"(double %"anon#2#1##0") alwaysinline { -entry: - ret double %"anon#2#1##0" +define external fastcc double @"higher_order_refs.#anon#2<0>"(double %"anon#2#1##0") { + ret double %"anon#2#1##0" } - -define external fastcc i64 @"higher_order_refs.#anon#2<1>"(i64 %"#env##0", i64 %"anon#2#1##0") alwaysinline { -entry: - %0 = bitcast i64 %"anon#2#1##0" to double - %1 = bitcast double %0 to i64 - ret i64 %1 +define external fastcc i64 @"higher_order_refs.#anon#2<1>"(i64 %"#env##0", i64 %"generic#anon#2#1##0") { + %"anon#2#1##0" = bitcast i64 %"generic#anon#2#1##0" to double + %"tmp#1##0" = bitcast double %"anon#2#1##0" to i64 + ret i64 %"tmp#1##0" } - -define external fastcc double @"higher_order_refs.#anon#3<0>"(double %"y##0", double %"anon#3#1##0") alwaysinline { -entry: - %0 = fsub double %"anon#3#1##0", %"y##0" - ret double %0 +define external fastcc double @"higher_order_refs.#anon#3<0>"(double %"y##0", double %"anon#3#1##0") { + %"tmp#12##0" = fsub double %"anon#3#1##0", %"y##0" + ret double %"tmp#12##0" } - -define external fastcc i64 @"higher_order_refs.#anon#3<1>"(i64 %"#env##0", i64 %"anon#3#1##0") alwaysinline { -entry: - %0 = add i64 %"#env##0", 8 - %1 = inttoptr i64 %0 to double* - %2 = load double, double* %1 - %3 = bitcast i64 %"anon#3#1##0" to double - %4 = fsub double %3, %2 - %5 = bitcast double %4 to i64 - ret i64 %5 +define external fastcc i64 @"higher_order_refs.#anon#3<1>"(i64 %"#env##0", i64 %"generic#anon#3#1##0") { + %"tmp#2##0" = add i64 %"#env##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"generic#y##0" = load i64, ptr %"tmp#3##0" + %"anon#3#1##0" = bitcast i64 %"generic#anon#3#1##0" to double + %"y##0" = bitcast i64 %"generic#y##0" to double + %"anon#3#2##0" = fsub double %"anon#3#1##0", %"y##0" + %"tmp#4##0" = bitcast double %"anon#3#2##0" to i64 + ret i64 %"tmp#4##0" } - -define external fastcc i64 @"higher_order_refs.#closure#1<0>"(i64 %"#env##0", i64 %"a##0") alwaysinline { -entry: - ret i64 %"a##0" +define external fastcc i64 @"higher_order_refs.#closure#1<0>"(i64 %"#env##0", i64 %"generic#a##0") { + ret i64 %"generic#a##0" } - -define external fastcc i64 @"higher_order_refs.#closure#2<0>"(i64 %"#env##0", i64 %"i##0") alwaysinline { -entry: - %0 = add i64 %"i##0", 1 - ret i64 %0 +define external fastcc i64 @"higher_order_refs.#closure#2<0>"(i64 %"#env##0", i64 %"generic#i##0") { + %"#result##0" = add i64 %"generic#i##0", 1 + ret i64 %"#result##0" } - -define external fastcc i64 @"higher_order_refs.#closure#3<0>"(i64 %"#env##0", i64 %"y##0") alwaysinline { -entry: - %0 = add i64 %"y##0", 10 - ret i64 %0 +define external fastcc i64 @"higher_order_refs.#closure#3<0>"(i64 %"#env##0", i64 %"generic#y##0") { + %"#result##0" = add i64 %"generic#y##0", 10 + ret i64 %"#result##0" } - -define external fastcc i64 @"higher_order_refs.add_one<0>"(i64 %"i##0") alwaysinline { -entry: - %0 = add i64 %"i##0", 1 - ret i64 %0 +define external fastcc i64 @"higher_order_refs.add_one<0>"(i64 %"i##0") { + %"tmp#3##0" = add i64 %"i##0", 1 + ret i64 %"tmp#3##0" } - -define external fastcc double @"higher_order_refs.add_one<1>"(double %"f##0") alwaysinline { -entry: - %0 = fadd double %"f##0", 1.000000e0 - ret double %0 +define external fastcc double @"higher_order_refs.add_one<1>"(double %"f##0") { + %"tmp#3##0" = fadd double %"f##0", 1.0 + ret double %"tmp#3##0" } - -define external fastcc i64 @"higher_order_refs.app<0>"(i64 %"f##0", i64 %"i##0") noinline { -entry: - %0 = inttoptr i64 %"f##0" to i64* - %1 = load i64, i64* %0 - %2 = inttoptr i64 %1 to i64 (i64, i64)* - %3 = tail call fastcc i64 %2(i64 %"f##0", i64 %"i##0") - ret i64 %3 +define external fastcc i64 @"higher_order_refs.app<0>"(i64 %"f##0", i64 %"i##0") { + %"tmp#2##0" = inttoptr i64 %"f##0" to ptr + %"tmp#1##0" = load ptr, ptr %"tmp#2##0" + %"tmp#3##0" = tail call fastcc i64 %"tmp#1##0"(i64 %"f##0", i64 %"i##0") + ret i64 %"tmp#3##0" } diff --git a/test-cases/final-dump/higher_order_resources.exp b/test-cases/final-dump/higher_order_resources.exp index c7e5f21ad..e4c86c936 100644 --- a/test-cases/final-dump/higher_order_resources.exp +++ b/test-cases/final-dump/higher_order_resources.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module higher_order_resources representation : (not a type) public submods : @@ -164,291 +167,229 @@ take_max(i##0:wybe.int)<{<>}; {< \00" - - -@higher_order_resources.0 = constant [1 x i64] [i64 ptrtoint (void (i64, i64)* @"higher_order_resources.#anon#1<1>" to i64)] - - -@higher_order_resources.4 = constant [1 x i64] [i64 ptrtoint (void (i64, i64)* @"higher_order_resources.#anon#2#closure#1<0>" to i64)] - - -@higher_order_resources.3 = constant [1 x i64] [i64 ptrtoint (void (i64, i64)* @"higher_order_resources.#anon#2<1>" to i64)] - - -declare external fastcc i64 @"wybe.int.max<0>"(i64, i64) - - -declare external fastcc i64 @"wybe.list.length1<0>"(i64, i64) - - -declare external ccc void @putchar(i8) - - -declare external ccc void @print_int(i64) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external fastcc void @"wybe.list.map#cont#1<0>"(i64, i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"higher_order_resources.<0>"() { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 3, i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 0, i64* %5 - %6 = trunc i64 16 to i32 - %7 = tail call ccc i8* @wybe_malloc(i32 %6) - %8 = ptrtoint i8* %7 to i64 - %9 = inttoptr i64 %8 to i64* - store i64 2, i64* %9 - %10 = add i64 %8, 8 - %11 = inttoptr i64 %10 to i64* - store i64 %2, i64* %11 - %12 = trunc i64 16 to i32 - %13 = tail call ccc i8* @wybe_malloc(i32 %12) - %14 = ptrtoint i8* %13 to i64 - %15 = inttoptr i64 %14 to i64* - store i64 1, i64* %15 - %16 = add i64 %14, 8 - %17 = inttoptr i64 %16 to i64* - store i64 %8, i64* %17 - %18 = trunc i64 16 to i32 - %19 = tail call ccc i8* @wybe_malloc(i32 %18) - %20 = ptrtoint i8* %19 to i64 - %21 = inttoptr i64 %20 to i64* - store i64 1, i64* %21 - %22 = add i64 %20, 8 - %23 = inttoptr i64 %22 to i64* - store i64 0, i64* %23 - %24 = trunc i64 16 to i32 - %25 = tail call ccc i8* @wybe_malloc(i32 %24) - %26 = ptrtoint i8* %25 to i64 - %27 = inttoptr i64 %26 to i64* - store i64 5, i64* %27 - %28 = add i64 %26, 8 - %29 = inttoptr i64 %28 to i64* - store i64 %20, i64* %29 - %30 = trunc i64 16 to i32 - %31 = tail call ccc i8* @wybe_malloc(i32 %30) - %32 = ptrtoint i8* %31 to i64 - %33 = inttoptr i64 %32 to i64* - store i64 %26, i64* %33 - %34 = add i64 %32, 8 - %35 = inttoptr i64 %34 to i64* - store i64 0, i64* %35 - %36 = trunc i64 16 to i32 - %37 = tail call ccc i8* @wybe_malloc(i32 %36) - %38 = ptrtoint i8* %37 to i64 - %39 = inttoptr i64 %38 to i64* - store i64 %14, i64* %39 - %40 = add i64 %38, 8 - %41 = inttoptr i64 %40 to i64* - store i64 %32, i64* %41 - %42 = load i64, i64* @"resource#higher_order_resources.maximum" - store i64 -1000, i64* @"resource#higher_order_resources.maximum" - tail call fastcc void @"wybe.list.map#cont#1<0>"(i64 ptrtoint (i64* getelementptr inbounds ([1 x i64], [1 x i64]* @higher_order_resources.0, i32 0, i32 0) to i64), i64 %38) - %43 = load i64, i64* @"resource#higher_order_resources.maximum" - tail call ccc void @print_int(i64 %43) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @higher_order_resources.2, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - %44 = trunc i64 16 to i32 - %45 = tail call ccc i8* @wybe_malloc(i32 %44) - %46 = ptrtoint i8* %45 to i64 - %47 = inttoptr i64 %46 to i64* - store i64 3, i64* %47 - %48 = add i64 %46, 8 - %49 = inttoptr i64 %48 to i64* - store i64 0, i64* %49 - %50 = trunc i64 16 to i32 - %51 = tail call ccc i8* @wybe_malloc(i32 %50) - %52 = ptrtoint i8* %51 to i64 - %53 = inttoptr i64 %52 to i64* - store i64 2, i64* %53 - %54 = add i64 %52, 8 - %55 = inttoptr i64 %54 to i64* - store i64 %46, i64* %55 - %56 = trunc i64 16 to i32 - %57 = tail call ccc i8* @wybe_malloc(i32 %56) - %58 = ptrtoint i8* %57 to i64 - %59 = inttoptr i64 %58 to i64* - store i64 1, i64* %59 - %60 = add i64 %58, 8 - %61 = inttoptr i64 %60 to i64* - store i64 %52, i64* %61 - %62 = trunc i64 16 to i32 - %63 = tail call ccc i8* @wybe_malloc(i32 %62) - %64 = ptrtoint i8* %63 to i64 - %65 = inttoptr i64 %64 to i64* - store i64 2, i64* %65 - %66 = add i64 %64, 8 - %67 = inttoptr i64 %66 to i64* - store i64 0, i64* %67 - %68 = trunc i64 16 to i32 - %69 = tail call ccc i8* @wybe_malloc(i32 %68) - %70 = ptrtoint i8* %69 to i64 - %71 = inttoptr i64 %70 to i64* - store i64 1, i64* %71 - %72 = add i64 %70, 8 - %73 = inttoptr i64 %72 to i64* - store i64 %64, i64* %73 - %74 = trunc i64 16 to i32 - %75 = tail call ccc i8* @wybe_malloc(i32 %74) - %76 = ptrtoint i8* %75 to i64 - %77 = inttoptr i64 %76 to i64* - store i64 2, i64* %77 - %78 = add i64 %76, 8 - %79 = inttoptr i64 %78 to i64* - store i64 %70, i64* %79 - %80 = trunc i64 16 to i32 - %81 = tail call ccc i8* @wybe_malloc(i32 %80) - %82 = ptrtoint i8* %81 to i64 - %83 = inttoptr i64 %82 to i64* - store i64 1, i64* %83 - %84 = add i64 %82, 8 - %85 = inttoptr i64 %84 to i64* - store i64 %76, i64* %85 - %86 = trunc i64 16 to i32 - %87 = tail call ccc i8* @wybe_malloc(i32 %86) - %88 = ptrtoint i8* %87 to i64 - %89 = inttoptr i64 %88 to i64* - store i64 1, i64* %89 - %90 = add i64 %88, 8 - %91 = inttoptr i64 %90 to i64* - store i64 0, i64* %91 - %92 = trunc i64 16 to i32 - %93 = tail call ccc i8* @wybe_malloc(i32 %92) - %94 = ptrtoint i8* %93 to i64 - %95 = inttoptr i64 %94 to i64* - store i64 5, i64* %95 - %96 = add i64 %94, 8 - %97 = inttoptr i64 %96 to i64* - store i64 %88, i64* %97 - %98 = trunc i64 16 to i32 - %99 = tail call ccc i8* @wybe_malloc(i32 %98) - %100 = ptrtoint i8* %99 to i64 - %101 = inttoptr i64 %100 to i64* - store i64 %94, i64* %101 - %102 = add i64 %100, 8 - %103 = inttoptr i64 %102 to i64* - store i64 0, i64* %103 - %104 = trunc i64 16 to i32 - %105 = tail call ccc i8* @wybe_malloc(i32 %104) - %106 = ptrtoint i8* %105 to i64 - %107 = inttoptr i64 %106 to i64* - store i64 %82, i64* %107 - %108 = add i64 %106, 8 - %109 = inttoptr i64 %108 to i64* - store i64 %100, i64* %109 - %110 = trunc i64 16 to i32 - %111 = tail call ccc i8* @wybe_malloc(i32 %110) - %112 = ptrtoint i8* %111 to i64 - %113 = inttoptr i64 %112 to i64* - store i64 %58, i64* %113 - %114 = add i64 %112, 8 - %115 = inttoptr i64 %114 to i64* - store i64 %106, i64* %115 - store i64 -1000, i64* @"resource#higher_order_resources.maximum" - tail call fastcc void @"wybe.list.map#cont#1<0>"(i64 ptrtoint (i64* getelementptr inbounds ([1 x i64], [1 x i64]* @higher_order_resources.3, i32 0, i32 0) to i64), i64 %112) - %116 = load i64, i64* @"resource#higher_order_resources.maximum" - tail call ccc void @print_int(i64 %116) - tail call ccc void @putchar(i8 10) - store i64 %42, i64* @"resource#higher_order_resources.maximum" - ret void +source_filename = "!ROOT!/final-dump/higher_order_resources.wybe" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c"*****\00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c"> \00", align 8 +@"string#2" = private unnamed_addr constant {i64, i64} { i64 5, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +@"string#3" = private unnamed_addr constant {i64, i64} { i64 2, i64 ptrtoint( ptr @"cstring#1" to i64 ) }, align 8 +@"closure#4" = private unnamed_addr constant {ptr} { ptr @"higher_order_resources.#anon#1<1>" }, align 8 +@"closure#5" = private unnamed_addr constant {ptr} { ptr @"higher_order_resources.#anon#2<1>" }, align 8 +@"closure#6" = private unnamed_addr constant {ptr} { ptr @"higher_order_resources.#anon#2#closure#1<0>" }, align 8 + +declare external fastcc i64 @"wybe.int.max<0>"(i64, i64) +declare external fastcc i64 @"wybe.list.length1<0>"(i64, i64) +declare external fastcc void @"wybe.list.map#cont#1<0>"(i64, i64) +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) +@"resource#higher_order_resources.maximum" = global i64 undef + +define external fastcc void @"higher_order_resources.<0>"() { + %"tmp#124##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#35##0" = ptrtoint ptr %"tmp#124##0" to i64 + %"tmp#125##0" = inttoptr i64 %"tmp#35##0" to ptr + store i64 3, ptr %"tmp#125##0" + %"tmp#126##0" = add i64 %"tmp#35##0", 8 + %"tmp#127##0" = inttoptr i64 %"tmp#126##0" to ptr + store i64 0, ptr %"tmp#127##0" + %"tmp#128##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#39##0" = ptrtoint ptr %"tmp#128##0" to i64 + %"tmp#129##0" = inttoptr i64 %"tmp#39##0" to ptr + store i64 2, ptr %"tmp#129##0" + %"tmp#130##0" = add i64 %"tmp#39##0", 8 + %"tmp#131##0" = inttoptr i64 %"tmp#130##0" to ptr + store i64 %"tmp#35##0", ptr %"tmp#131##0" + %"tmp#132##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#43##0" = ptrtoint ptr %"tmp#132##0" to i64 + %"tmp#133##0" = inttoptr i64 %"tmp#43##0" to ptr + store i64 1, ptr %"tmp#133##0" + %"tmp#134##0" = add i64 %"tmp#43##0", 8 + %"tmp#135##0" = inttoptr i64 %"tmp#134##0" to ptr + store i64 %"tmp#39##0", ptr %"tmp#135##0" + %"tmp#136##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#47##0" = ptrtoint ptr %"tmp#136##0" to i64 + %"tmp#137##0" = inttoptr i64 %"tmp#47##0" to ptr + store i64 1, ptr %"tmp#137##0" + %"tmp#138##0" = add i64 %"tmp#47##0", 8 + %"tmp#139##0" = inttoptr i64 %"tmp#138##0" to ptr + store i64 0, ptr %"tmp#139##0" + %"tmp#140##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#51##0" = ptrtoint ptr %"tmp#140##0" to i64 + %"tmp#141##0" = inttoptr i64 %"tmp#51##0" to ptr + store i64 5, ptr %"tmp#141##0" + %"tmp#142##0" = add i64 %"tmp#51##0", 8 + %"tmp#143##0" = inttoptr i64 %"tmp#142##0" to ptr + store i64 %"tmp#47##0", ptr %"tmp#143##0" + %"tmp#144##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#55##0" = ptrtoint ptr %"tmp#144##0" to i64 + %"tmp#145##0" = inttoptr i64 %"tmp#55##0" to ptr + store i64 %"tmp#51##0", ptr %"tmp#145##0" + %"tmp#146##0" = add i64 %"tmp#55##0", 8 + %"tmp#147##0" = inttoptr i64 %"tmp#146##0" to ptr + store i64 0, ptr %"tmp#147##0" + %"tmp#148##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#59##0" = ptrtoint ptr %"tmp#148##0" to i64 + %"tmp#149##0" = inttoptr i64 %"tmp#59##0" to ptr + store i64 %"tmp#43##0", ptr %"tmp#149##0" + %"tmp#150##0" = add i64 %"tmp#59##0", 8 + %"tmp#151##0" = inttoptr i64 %"tmp#150##0" to ptr + store i64 %"tmp#55##0", ptr %"tmp#151##0" + %"tmp#29##0" = load i64, ptr @"resource#higher_order_resources.maximum" + store i64 -1000, ptr @"resource#higher_order_resources.maximum" + tail call fastcc void @"wybe.list.map#cont#1<0>"(i64 ptrtoint( ptr @"closure#4" to i64 ), i64 %"tmp#59##0") + %"maximum##1" = load i64, ptr @"resource#higher_order_resources.maximum" + call ccc void @print_int(i64 %"maximum##1") + call ccc void @putchar(i8 10) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#2" to i64 )) + call ccc void @putchar(i8 10) + %"tmp#152##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#72##0" = ptrtoint ptr %"tmp#152##0" to i64 + %"tmp#153##0" = inttoptr i64 %"tmp#72##0" to ptr + store i64 3, ptr %"tmp#153##0" + %"tmp#154##0" = add i64 %"tmp#72##0", 8 + %"tmp#155##0" = inttoptr i64 %"tmp#154##0" to ptr + store i64 0, ptr %"tmp#155##0" + %"tmp#156##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#76##0" = ptrtoint ptr %"tmp#156##0" to i64 + %"tmp#157##0" = inttoptr i64 %"tmp#76##0" to ptr + store i64 2, ptr %"tmp#157##0" + %"tmp#158##0" = add i64 %"tmp#76##0", 8 + %"tmp#159##0" = inttoptr i64 %"tmp#158##0" to ptr + store i64 %"tmp#72##0", ptr %"tmp#159##0" + %"tmp#160##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#80##0" = ptrtoint ptr %"tmp#160##0" to i64 + %"tmp#161##0" = inttoptr i64 %"tmp#80##0" to ptr + store i64 1, ptr %"tmp#161##0" + %"tmp#162##0" = add i64 %"tmp#80##0", 8 + %"tmp#163##0" = inttoptr i64 %"tmp#162##0" to ptr + store i64 %"tmp#76##0", ptr %"tmp#163##0" + %"tmp#164##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#84##0" = ptrtoint ptr %"tmp#164##0" to i64 + %"tmp#165##0" = inttoptr i64 %"tmp#84##0" to ptr + store i64 2, ptr %"tmp#165##0" + %"tmp#166##0" = add i64 %"tmp#84##0", 8 + %"tmp#167##0" = inttoptr i64 %"tmp#166##0" to ptr + store i64 0, ptr %"tmp#167##0" + %"tmp#168##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#88##0" = ptrtoint ptr %"tmp#168##0" to i64 + %"tmp#169##0" = inttoptr i64 %"tmp#88##0" to ptr + store i64 1, ptr %"tmp#169##0" + %"tmp#170##0" = add i64 %"tmp#88##0", 8 + %"tmp#171##0" = inttoptr i64 %"tmp#170##0" to ptr + store i64 %"tmp#84##0", ptr %"tmp#171##0" + %"tmp#172##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#92##0" = ptrtoint ptr %"tmp#172##0" to i64 + %"tmp#173##0" = inttoptr i64 %"tmp#92##0" to ptr + store i64 2, ptr %"tmp#173##0" + %"tmp#174##0" = add i64 %"tmp#92##0", 8 + %"tmp#175##0" = inttoptr i64 %"tmp#174##0" to ptr + store i64 %"tmp#88##0", ptr %"tmp#175##0" + %"tmp#176##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#96##0" = ptrtoint ptr %"tmp#176##0" to i64 + %"tmp#177##0" = inttoptr i64 %"tmp#96##0" to ptr + store i64 1, ptr %"tmp#177##0" + %"tmp#178##0" = add i64 %"tmp#96##0", 8 + %"tmp#179##0" = inttoptr i64 %"tmp#178##0" to ptr + store i64 %"tmp#92##0", ptr %"tmp#179##0" + %"tmp#180##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#100##0" = ptrtoint ptr %"tmp#180##0" to i64 + %"tmp#181##0" = inttoptr i64 %"tmp#100##0" to ptr + store i64 1, ptr %"tmp#181##0" + %"tmp#182##0" = add i64 %"tmp#100##0", 8 + %"tmp#183##0" = inttoptr i64 %"tmp#182##0" to ptr + store i64 0, ptr %"tmp#183##0" + %"tmp#184##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#104##0" = ptrtoint ptr %"tmp#184##0" to i64 + %"tmp#185##0" = inttoptr i64 %"tmp#104##0" to ptr + store i64 5, ptr %"tmp#185##0" + %"tmp#186##0" = add i64 %"tmp#104##0", 8 + %"tmp#187##0" = inttoptr i64 %"tmp#186##0" to ptr + store i64 %"tmp#100##0", ptr %"tmp#187##0" + %"tmp#188##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#108##0" = ptrtoint ptr %"tmp#188##0" to i64 + %"tmp#189##0" = inttoptr i64 %"tmp#108##0" to ptr + store i64 %"tmp#104##0", ptr %"tmp#189##0" + %"tmp#190##0" = add i64 %"tmp#108##0", 8 + %"tmp#191##0" = inttoptr i64 %"tmp#190##0" to ptr + store i64 0, ptr %"tmp#191##0" + %"tmp#192##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#112##0" = ptrtoint ptr %"tmp#192##0" to i64 + %"tmp#193##0" = inttoptr i64 %"tmp#112##0" to ptr + store i64 %"tmp#96##0", ptr %"tmp#193##0" + %"tmp#194##0" = add i64 %"tmp#112##0", 8 + %"tmp#195##0" = inttoptr i64 %"tmp#194##0" to ptr + store i64 %"tmp#108##0", ptr %"tmp#195##0" + %"tmp#196##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#116##0" = ptrtoint ptr %"tmp#196##0" to i64 + %"tmp#197##0" = inttoptr i64 %"tmp#116##0" to ptr + store i64 %"tmp#80##0", ptr %"tmp#197##0" + %"tmp#198##0" = add i64 %"tmp#116##0", 8 + %"tmp#199##0" = inttoptr i64 %"tmp#198##0" to ptr + store i64 %"tmp#112##0", ptr %"tmp#199##0" + store i64 -1000, ptr @"resource#higher_order_resources.maximum" + tail call fastcc void @"wybe.list.map#cont#1<0>"(i64 ptrtoint( ptr @"closure#5" to i64 ), i64 %"tmp#116##0") + %"maximum##3" = load i64, ptr @"resource#higher_order_resources.maximum" + call ccc void @print_int(i64 %"maximum##3") + call ccc void @putchar(i8 10) + store i64 %"tmp#29##0", ptr @"resource#higher_order_resources.maximum" + ret void } - -define external fastcc void @"higher_order_resources.#anon#1<0>"(i64 %"anon#1#1##0") alwaysinline { -entry: - %0 = tail call fastcc i64 @"wybe.list.length1<0>"(i64 %"anon#1#1##0", i64 0) - musttail call fastcc void @"higher_order_resources.take_max<0>"(i64 %0) - ret void +define external fastcc void @"higher_order_resources.#anon#1<0>"(i64 %"anon#1#1##0") { + %"tmp#10##0" = tail call fastcc i64 @"wybe.list.length1<0>"(i64 %"anon#1#1##0", i64 0) + tail call fastcc void @"higher_order_resources.take_max<0>"(i64 %"tmp#10##0") + ret void } - -define external fastcc void @"higher_order_resources.#anon#1<1>"(i64 %"#env##0", i64 %"anon#1#1##0") alwaysinline { -entry: - %0 = tail call fastcc i64 @"wybe.list.length1<0>"(i64 %"anon#1#1##0", i64 0) - tail call fastcc void @"higher_order_resources.take_max<0>"(i64 %0) - ret void +define external fastcc void @"higher_order_resources.#anon#1<1>"(i64 %"#env##0", i64 %"generic#anon#1#1##0") { + %"tmp#1##0" = tail call fastcc i64 @"wybe.list.length1<0>"(i64 %"generic#anon#1#1##0", i64 0) + tail call fastcc void @"higher_order_resources.take_max<0>"(i64 %"tmp#1##0") + ret void } - -define external fastcc void @"higher_order_resources.#anon#2<0>"(i64 %"anon#2#1##0") alwaysinline { -entry: - %0 = load i64, i64* @"resource#higher_order_resources.maximum" - store i64 -1000, i64* @"resource#higher_order_resources.maximum" - tail call fastcc void @"wybe.list.map#cont#1<0>"(i64 ptrtoint (i64* getelementptr inbounds ([1 x i64], [1 x i64]* @higher_order_resources.4, i32 0, i32 0) to i64), i64 %"anon#2#1##0") - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @higher_order_resources.6, i32 0, i32 0) to i64)) - %1 = load i64, i64* @"resource#higher_order_resources.maximum" - tail call ccc void @print_int(i64 %1) - tail call ccc void @putchar(i8 10) - store i64 %0, i64* @"resource#higher_order_resources.maximum" - %2 = tail call fastcc i64 @"wybe.list.length1<0>"(i64 %"anon#2#1##0", i64 0) - musttail call fastcc void @"higher_order_resources.take_max<0>"(i64 %2) - ret void +define external fastcc void @"higher_order_resources.#anon#2<0>"(i64 %"anon#2#1##0") { + %"tmp#32##0" = load i64, ptr @"resource#higher_order_resources.maximum" + store i64 -1000, ptr @"resource#higher_order_resources.maximum" + tail call fastcc void @"wybe.list.map#cont#1<0>"(i64 ptrtoint( ptr @"closure#6" to i64 ), i64 %"anon#2#1##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#3" to i64 )) + %"maximum##2" = load i64, ptr @"resource#higher_order_resources.maximum" + call ccc void @print_int(i64 %"maximum##2") + call ccc void @putchar(i8 10) + store i64 %"tmp#32##0", ptr @"resource#higher_order_resources.maximum" + %"tmp#28##0" = tail call fastcc i64 @"wybe.list.length1<0>"(i64 %"anon#2#1##0", i64 0) + tail call fastcc void @"higher_order_resources.take_max<0>"(i64 %"tmp#28##0") + ret void } - -define external fastcc void @"higher_order_resources.#anon#2<1>"(i64 %"#env##0", i64 %"anon#2#1##0") alwaysinline { -entry: - %0 = load i64, i64* @"resource#higher_order_resources.maximum" - store i64 -1000, i64* @"resource#higher_order_resources.maximum" - tail call fastcc void @"wybe.list.map#cont#1<0>"(i64 ptrtoint (i64* getelementptr inbounds ([1 x i64], [1 x i64]* @higher_order_resources.4, i32 0, i32 0) to i64), i64 %"anon#2#1##0") - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @higher_order_resources.6, i32 0, i32 0) to i64)) - %1 = load i64, i64* @"resource#higher_order_resources.maximum" - tail call ccc void @print_int(i64 %1) - tail call ccc void @putchar(i8 10) - store i64 %0, i64* @"resource#higher_order_resources.maximum" - %2 = tail call fastcc i64 @"wybe.list.length1<0>"(i64 %"anon#2#1##0", i64 0) - tail call fastcc void @"higher_order_resources.take_max<0>"(i64 %2) - ret void +define external fastcc void @"higher_order_resources.#anon#2<1>"(i64 %"#env##0", i64 %"generic#anon#2#1##0") { + %"tmp#1##0" = load i64, ptr @"resource#higher_order_resources.maximum" + store i64 -1000, ptr @"resource#higher_order_resources.maximum" + tail call fastcc void @"wybe.list.map#cont#1<0>"(i64 ptrtoint( ptr @"closure#6" to i64 ), i64 %"generic#anon#2#1##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#3" to i64 )) + %"tmp#2##0" = load i64, ptr @"resource#higher_order_resources.maximum" + call ccc void @print_int(i64 %"tmp#2##0") + call ccc void @putchar(i8 10) + store i64 %"tmp#1##0", ptr @"resource#higher_order_resources.maximum" + %"tmp#6##0" = tail call fastcc i64 @"wybe.list.length1<0>"(i64 %"generic#anon#2#1##0", i64 0) + tail call fastcc void @"higher_order_resources.take_max<0>"(i64 %"tmp#6##0") + ret void } - -define external fastcc void @"higher_order_resources.#anon#2#closure#1<0>"(i64 %"#env##0", i64 %"i##0") alwaysinline { -entry: - tail call fastcc void @"higher_order_resources.take_max<0>"(i64 %"i##0") - ret void +define external fastcc void @"higher_order_resources.#anon#2#closure#1<0>"(i64 %"#env##0", i64 %"generic#i##0") { + tail call fastcc void @"higher_order_resources.take_max<0>"(i64 %"generic#i##0") + ret void } - -define external fastcc void @"higher_order_resources.take_max<0>"(i64 %"i##0") { -entry: - %0 = load i64, i64* @"resource#higher_order_resources.maximum" - %1 = tail call fastcc i64 @"wybe.int.max<0>"(i64 %"i##0", i64 %0) - store i64 %1, i64* @"resource#higher_order_resources.maximum" - ret void +define external fastcc void @"higher_order_resources.take_max<0>"(i64 %"i##0") { + %"maximum##0" = load i64, ptr @"resource#higher_order_resources.maximum" + %"tmp#0##0" = tail call fastcc i64 @"wybe.int.max<0>"(i64 %"i##0", i64 %"maximum##0") + store i64 %"tmp#0##0", ptr @"resource#higher_order_resources.maximum" + ret void } diff --git a/test-cases/final-dump/higher_order_sort.exp b/test-cases/final-dump/higher_order_sort.exp index c8fb72584..fb16eb3e6 100644 --- a/test-cases/final-dump/higher_order_sort.exp +++ b/test-cases/final-dump/higher_order_sort.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module higher_order_sort representation : (not a type) public submods : @@ -67,92 +70,80 @@ sort#cont#1(<=##0:(X, X, ?wybe.bool) <{}; {}; {0}>, sorted##0:wybe.list(X) <{}; LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'higher_order_sort' - - - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"higher_order_sort.insert<0>"(i64 %"<=##0", i64 %"x##0", i64 %"xs##0", i64* %"xs##1") { -entry: - %0 = icmp ne i64 %"xs##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"xs##0" to i64* - %2 = load i64, i64* %1 - %3 = add i64 %"xs##0", 8 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = inttoptr i64 %"<=##0" to i64* - %7 = load i64, i64* %6 - %8 = inttoptr i64 %7 to i64 (i64, i64, i64)* - %9 = tail call fastcc i64 %8(i64 %"<=##0", i64 %"x##0", i64 %2) - %10 = trunc i64 %9 to i1 - br i1 %10, label %if.then1, label %if.else1 -if.else: - %23 = trunc i64 16 to i32 - %24 = tail call ccc i8* @wybe_malloc(i32 %23) - %25 = ptrtoint i8* %24 to i64 - %26 = inttoptr i64 %25 to i64* - store i64 %"x##0", i64* %26 - %27 = add i64 %25, 8 - %28 = inttoptr i64 %27 to i64* - store i64 0, i64* %28 - store i64 %25, i64* %"xs##1" - ret void -if.then1: - %11 = trunc i64 16 to i32 - %12 = tail call ccc i8* @wybe_malloc(i32 %11) - %13 = ptrtoint i8* %12 to i64 - %14 = inttoptr i64 %13 to i64* - store i64 %"x##0", i64* %14 - %15 = add i64 %13, 8 - %16 = inttoptr i64 %15 to i64* - store i64 %"xs##0", i64* %16 - store i64 %13, i64* %"xs##1" - ret void -if.else1: - %17 = trunc i64 16 to i32 - %18 = tail call ccc i8* @wybe_malloc(i32 %17) - %19 = ptrtoint i8* %18 to i64 - %20 = inttoptr i64 %19 to i64* - store i64 %2, i64* %20 - %21 = add i64 %19, 8 - %22 = inttoptr i64 %21 to i64* - store i64 %19, i64* %"xs##1" - musttail call fastcc void @"higher_order_sort.insert<0>"(i64 %"<=##0", i64 %"x##0", i64 %5, i64* %22) - ret void +source_filename = "!ROOT!/final-dump/higher_order_sort.wybe" +target triple ???? + + +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"higher_order_sort.insert<0>"(i64 %"<=##0", i64 %"x##0", i64 %"xs##0", ptr %"tmp#20##0") { + %"tmp#7##0" = icmp ne i64 %"xs##0", 0 + br i1 %"tmp#7##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#21##0" = inttoptr i64 %"xs##0" to ptr + %"head##0" = load i64, ptr %"tmp#21##0" + %"tmp#22##0" = add i64 %"xs##0", 8 + %"tmp#23##0" = inttoptr i64 %"tmp#22##0" to ptr + %"rest##0" = load i64, ptr %"tmp#23##0" + %"tmp#25##0" = inttoptr i64 %"<=##0" to ptr + %"tmp#24##0" = load ptr, ptr %"tmp#25##0" + %"tmp#4##0" = tail call fastcc i1 %"tmp#24##0"(i64 %"<=##0", i64 %"x##0", i64 %"head##0") + br i1 %"tmp#4##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#26##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#18##0" = ptrtoint ptr %"tmp#26##0" to i64 + %"tmp#27##0" = inttoptr i64 %"tmp#18##0" to ptr + store i64 %"x##0", ptr %"tmp#27##0" + store i64 %"tmp#18##0", ptr %"tmp#20##0" + %"tmp#28##0" = add i64 %"tmp#18##0", 8 + %"tmp#29##0" = inttoptr i64 %"tmp#28##0" to ptr + store i64 %"xs##0", ptr %"tmp#29##0" + ret void +if.else.1: + %"tmp#30##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#14##0" = ptrtoint ptr %"tmp#30##0" to i64 + %"tmp#31##0" = inttoptr i64 %"tmp#14##0" to ptr + store i64 %"head##0", ptr %"tmp#31##0" + store i64 %"tmp#14##0", ptr %"tmp#20##0" + %"tmp#32##0" = add i64 %"tmp#14##0", 8 + %"tmp#33##0" = inttoptr i64 %"tmp#32##0" to ptr + musttail call fastcc void @"higher_order_sort.insert<0>"(i64 %"<=##0", i64 %"x##0", i64 %"rest##0", ptr %"tmp#33##0") + ret void +if.else.0: + %"tmp#34##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#10##0" = ptrtoint ptr %"tmp#34##0" to i64 + %"tmp#35##0" = inttoptr i64 %"tmp#10##0" to ptr + store i64 %"x##0", ptr %"tmp#35##0" + store i64 %"tmp#10##0", ptr %"tmp#20##0" + %"tmp#36##0" = add i64 %"tmp#10##0", 8 + %"tmp#37##0" = inttoptr i64 %"tmp#36##0" to ptr + store i64 0, ptr %"tmp#37##0" + ret void } - -define external fastcc i64 @"higher_order_sort.sort<0>"(i64 %"<=##0", i64 %"xs##0") alwaysinline { -entry: - %0 = tail call fastcc i64 @"higher_order_sort.sort#cont#1<0>"(i64 %"<=##0", i64 0, i64 %"xs##0") - ret i64 %0 +define external fastcc i64 @"higher_order_sort.sort<0>"(i64 %"<=##0", i64 %"xs##0") { + %"tmp#4##0" = tail call fastcc i64 @"higher_order_sort.sort#cont#1<0>"(i64 %"<=##0", i64 0, i64 %"xs##0") + ret i64 %"tmp#4##0" } - -define external fastcc i64 @"higher_order_sort.sort#cont#1<0>"(i64 %"<=##0", i64 %"sorted##0", i64 %"tmp#1##0") { -entry: - %0 = icmp ne i64 %"tmp#1##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"tmp#1##0" to i64* - %2 = load i64, i64* %1 - %3 = add i64 %"tmp#1##0", 8 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = alloca i64 - call fastcc void @"higher_order_sort.insert<0>"(i64 %"<=##0", i64 %2, i64 %"sorted##0", i64* %6) - %7 = load i64, i64* %6 - %8 = musttail call fastcc i64 @"higher_order_sort.sort#cont#1<0>"(i64 %"<=##0", i64 %7, i64 %5) - ret i64 %8 -if.else: - ret i64 %"sorted##0" +define external fastcc i64 @"higher_order_sort.sort#cont#1<0>"(i64 %"<=##0", i64 %"sorted##0", i64 %"tmp#1##0") { + %"tmp#5##0" = icmp ne i64 %"tmp#1##0", 0 + br i1 %"tmp#5##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#6##0" = inttoptr i64 %"tmp#1##0" to ptr + %"x##0" = load i64, ptr %"tmp#6##0" + %"tmp#7##0" = add i64 %"tmp#1##0", 8 + %"tmp#8##0" = inttoptr i64 %"tmp#7##0" to ptr + %"tmp#1##1" = load i64, ptr %"tmp#8##0" + %"tmp#9##0" = alloca i8, i64 8, align 8 + call fastcc void @"higher_order_sort.insert<0>"(i64 %"<=##0", i64 %"x##0", i64 %"sorted##0", ptr %"tmp#9##0") + %"sorted##1" = load i64, ptr %"tmp#9##0" + %"tmp#10##0" = call fastcc i64 @"higher_order_sort.sort#cont#1<0>"(i64 %"<=##0", i64 %"sorted##1", i64 %"tmp#1##1") + ret i64 %"tmp#10##0" +if.else.0: + ret i64 %"sorted##0" } diff --git a/test-cases/final-dump/higher_order_tests.exp b/test-cases/final-dump/higher_order_tests.exp index fe01d0148..51f61a489 100644 --- a/test-cases/final-dump/higher_order_tests.exp +++ b/test-cases/final-dump/higher_order_tests.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module higher_order_tests representation : (not a type) public submods : @@ -208,249 +211,175 @@ do_test2(f##0:(I, ?wybe.bool) <{}; {}; {0}>, i##0:I <{}; {}; {1}>, ?#success##0: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'higher_order_tests' - - - - -@higher_order_tests.4 = constant {i64, i64} { i64 1, i64 ptrtoint ([?? x i8]* @higher_order_tests.3 to i64) } - - -@higher_order_tests.8 = constant {i64, i64} { i64 1, i64 ptrtoint ([?? x i8]* @higher_order_tests.7 to i64) } - - -@higher_order_tests.1 = constant {i64, i64} { i64 2, i64 ptrtoint ([?? x i8]* @higher_order_tests.0 to i64) } - - -@higher_order_tests.6 = constant {i64, i64} { i64 2, i64 ptrtoint ([?? x i8]* @higher_order_tests.5 to i64) } - - -@higher_order_tests.10 = constant {i64, i64} { i64 6, i64 ptrtoint ([?? x i8]* @higher_order_tests.9 to i64) } - - -@higher_order_tests.0 = constant [?? x i8] c"*1\00" - - -@higher_order_tests.5 = constant [?? x i8] c"*2\00" - - -@higher_order_tests.9 = constant [?? x i8] c"------\00" - - -@higher_order_tests.3 = constant [?? x i8] c"1\00" - - -@higher_order_tests.7 = constant [?? x i8] c"2\00" - - -@higher_order_tests.2 = constant [1 x i64] [i64 ptrtoint (i64 (i64, i64)* @"higher_order_tests.#anon#1<1>" to i64)] - - -@higher_order_tests.11 = constant [1 x i64] [i64 ptrtoint (i64 (i64, i64)* @"higher_order_tests.#anon#2<1>" to i64)] - - -declare external ccc void @putchar(i8) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"higher_order_tests.<0>"() { -entry: - %0 = tail call fastcc i1 @"higher_order_tests.#anon#1<0>"() - br i1 %0, label %if.then, label %if.else -if.then: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @higher_order_tests.1, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"higher_order_tests.#cont#1<0>"(i64 ptrtoint (i64* getelementptr inbounds ([1 x i64], [1 x i64]* @higher_order_tests.2, i32 0, i32 0) to i64)) - ret void -if.else: - tail call fastcc void @"higher_order_tests.#cont#1<0>"(i64 ptrtoint (i64* getelementptr inbounds ([1 x i64], [1 x i64]* @higher_order_tests.2, i32 0, i32 0) to i64)) - ret void +source_filename = "!ROOT!/final-dump/higher_order_tests.wybe" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c"*1\00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c"*2\00", align 8 +@"cstring#2" = private unnamed_addr constant [ ?? x i8 ] c"------\00", align 8 +@"cstring#3" = private unnamed_addr constant [ ?? x i8 ] c"1\00", align 8 +@"cstring#4" = private unnamed_addr constant [ ?? x i8 ] c"2\00", align 8 +@"string#5" = private unnamed_addr constant {i64, i64} { i64 2, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +@"string#6" = private unnamed_addr constant {i64, i64} { i64 2, i64 ptrtoint( ptr @"cstring#1" to i64 ) }, align 8 +@"string#7" = private unnamed_addr constant {i64, i64} { i64 6, i64 ptrtoint( ptr @"cstring#2" to i64 ) }, align 8 +@"string#8" = private unnamed_addr constant {i64, i64} { i64 1, i64 ptrtoint( ptr @"cstring#3" to i64 ) }, align 8 +@"string#9" = private unnamed_addr constant {i64, i64} { i64 1, i64 ptrtoint( ptr @"cstring#4" to i64 ) }, align 8 +@"closure#10" = private unnamed_addr constant {ptr} { ptr @"higher_order_tests.#anon#1<1>" }, align 8 +@"closure#11" = private unnamed_addr constant {ptr} { ptr @"higher_order_tests.#anon#2<1>" }, align 8 + +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"higher_order_tests.<0>"() { + %"tmp#8##0" = tail call fastcc i1 @"higher_order_tests.#anon#1<0>"() + br i1 %"tmp#8##0", label %if.then.0, label %if.else.0 +if.then.0: + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#5" to i64 )) + call ccc void @putchar(i8 10) + tail call fastcc void @"higher_order_tests.#cont#1<0>"(i64 ptrtoint( ptr @"closure#10" to i64 )) + ret void +if.else.0: + tail call fastcc void @"higher_order_tests.#cont#1<0>"(i64 ptrtoint( ptr @"closure#10" to i64 )) + ret void } - -define external fastcc i1 @"higher_order_tests.#anon#1<0>"() alwaysinline { -entry: - ret i1 1 +define external fastcc i1 @"higher_order_tests.#anon#1<0>"() { + ret i1 1 } - -define external fastcc i64 @"higher_order_tests.#anon#1<1>"(i64 %"#env##0", i64 %"anon#1#1##0") alwaysinline { -entry: - %0 = zext i1 1 to i64 - ret i64 %0 +define external fastcc i64 @"higher_order_tests.#anon#1<1>"(i64 %"#env##0", i64 %"generic#anon#1#1##0") { + %"tmp#1##0" = zext i1 1 to i64 + ret i64 %"tmp#1##0" } - -define external fastcc i1 @"higher_order_tests.#anon#2<0>"(i64 %"anon#2#1##0") alwaysinline { -entry: - %0 = icmp eq i64 %"anon#2#1##0", 1 - ret i1 %0 +define external fastcc i1 @"higher_order_tests.#anon#2<0>"(i64 %"anon#2#1##0") { + %"tmp#4##0" = icmp eq i64 %"anon#2#1##0", 1 + ret i1 %"tmp#4##0" } - -define external fastcc i64 @"higher_order_tests.#anon#2<1>"(i64 %"#env##0", i64 %"anon#2#1##0") alwaysinline { -entry: - %0 = icmp eq i64 %"anon#2#1##0", 1 - %1 = zext i1 %0 to i64 - ret i64 %1 +define external fastcc i64 @"higher_order_tests.#anon#2<1>"(i64 %"#env##0", i64 %"generic#anon#2#1##0") { + %"#success##0" = icmp eq i64 %"generic#anon#2#1##0", 1 + %"tmp#1##0" = zext i1 %"#success##0" to i64 + ret i64 %"tmp#1##0" } - -define external fastcc void @"higher_order_tests.#cont#1<0>"(i64 %"t##0") { -entry: - %0 = inttoptr i64 %"t##0" to i64* - %1 = load i64, i64* %0 - %2 = inttoptr i64 %1 to i64 (i64, i64)* - %3 = tail call fastcc i64 %2(i64 %"t##0", i64 1) - %4 = trunc i64 %3 to i1 - br i1 %4, label %if.then, label %if.else -if.then: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @higher_order_tests.4, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - musttail call fastcc void @"higher_order_tests.#cont#2<0>"(i64 %"t##0") - ret void -if.else: - musttail call fastcc void @"higher_order_tests.#cont#2<0>"(i64 %"t##0") - ret void +define external fastcc void @"higher_order_tests.#cont#1<0>"(i64 %"t##0") { + %"tmp#14##0" = inttoptr i64 %"t##0" to ptr + %"tmp#13##0" = load ptr, ptr %"tmp#14##0" + %"tmp#7##0" = tail call fastcc i1 %"tmp#13##0"(i64 %"t##0", i64 1) + br i1 %"tmp#7##0", label %if.then.0, label %if.else.0 +if.then.0: + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#8" to i64 )) + call ccc void @putchar(i8 10) + tail call fastcc void @"higher_order_tests.#cont#2<0>"(i64 %"t##0") + ret void +if.else.0: + tail call fastcc void @"higher_order_tests.#cont#2<0>"(i64 %"t##0") + ret void } - -define external fastcc void @"higher_order_tests.#cont#2<0>"(i64 %"t##0") { -entry: - %0 = inttoptr i64 %"t##0" to i64* - %1 = load i64, i64* %0 - %2 = inttoptr i64 %1 to i64 (i64, i64)* - %3 = tail call fastcc i64 %2(i64 %"t##0", i64 2) - %4 = trunc i64 %3 to i1 - br i1 %4, label %if.then, label %if.else -if.then: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @higher_order_tests.6, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - musttail call fastcc void @"higher_order_tests.#cont#3<0>"(i64 %"t##0") - ret void -if.else: - musttail call fastcc void @"higher_order_tests.#cont#3<0>"(i64 %"t##0") - ret void +define external fastcc void @"higher_order_tests.#cont#2<0>"(i64 %"t##0") { + %"tmp#13##0" = inttoptr i64 %"t##0" to ptr + %"tmp#12##0" = load ptr, ptr %"tmp#13##0" + %"tmp#6##0" = tail call fastcc i1 %"tmp#12##0"(i64 %"t##0", i64 2) + br i1 %"tmp#6##0", label %if.then.0, label %if.else.0 +if.then.0: + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#6" to i64 )) + call ccc void @putchar(i8 10) + tail call fastcc void @"higher_order_tests.#cont#3<0>"(i64 %"t##0") + ret void +if.else.0: + tail call fastcc void @"higher_order_tests.#cont#3<0>"(i64 %"t##0") + ret void } - -define external fastcc void @"higher_order_tests.#cont#3<0>"(i64 %"t##0") { -entry: - %0 = inttoptr i64 %"t##0" to i64* - %1 = load i64, i64* %0 - %2 = inttoptr i64 %1 to i64 (i64, i64)* - %3 = tail call fastcc i64 %2(i64 %"t##0", i64 2) - %4 = trunc i64 %3 to i1 - br i1 %4, label %if.then, label %if.else -if.then: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @higher_order_tests.8, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"higher_order_tests.#cont#4<0>"() - ret void -if.else: - tail call fastcc void @"higher_order_tests.#cont#4<0>"() - ret void +define external fastcc void @"higher_order_tests.#cont#3<0>"(i64 %"t##0") { + %"tmp#12##0" = inttoptr i64 %"t##0" to ptr + %"tmp#11##0" = load ptr, ptr %"tmp#12##0" + %"tmp#5##0" = tail call fastcc i1 %"tmp#11##0"(i64 %"t##0", i64 2) + br i1 %"tmp#5##0", label %if.then.0, label %if.else.0 +if.then.0: + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#9" to i64 )) + call ccc void @putchar(i8 10) + tail call fastcc void @"higher_order_tests.#cont#4<0>"() + ret void +if.else.0: + tail call fastcc void @"higher_order_tests.#cont#4<0>"() + ret void } - -define external fastcc void @"higher_order_tests.#cont#4<0>"() { -entry: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @higher_order_tests.10, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - %0 = tail call fastcc i1 @"higher_order_tests.#anon#2<0>"(i64 1) - br i1 %0, label %if.then, label %if.else -if.then: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @higher_order_tests.1, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"higher_order_tests.#cont#5<0>"(i64 ptrtoint (i64* getelementptr inbounds ([1 x i64], [1 x i64]* @higher_order_tests.11, i32 0, i32 0) to i64)) - ret void -if.else: - tail call fastcc void @"higher_order_tests.#cont#5<0>"(i64 ptrtoint (i64* getelementptr inbounds ([1 x i64], [1 x i64]* @higher_order_tests.11, i32 0, i32 0) to i64)) - ret void +define external fastcc void @"higher_order_tests.#cont#4<0>"() { + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#7" to i64 )) + call ccc void @putchar(i8 10) + %"tmp#4##0" = tail call fastcc i1 @"higher_order_tests.#anon#2<0>"(i64 1) + br i1 %"tmp#4##0", label %if.then.0, label %if.else.0 +if.then.0: + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#5" to i64 )) + call ccc void @putchar(i8 10) + tail call fastcc void @"higher_order_tests.#cont#5<0>"(i64 ptrtoint( ptr @"closure#11" to i64 )) + ret void +if.else.0: + tail call fastcc void @"higher_order_tests.#cont#5<0>"(i64 ptrtoint( ptr @"closure#11" to i64 )) + ret void } - -define external fastcc void @"higher_order_tests.#cont#5<0>"(i64 %"t##0") { -entry: - %0 = inttoptr i64 %"t##0" to i64* - %1 = load i64, i64* %0 - %2 = inttoptr i64 %1 to i64 (i64, i64)* - %3 = tail call fastcc i64 %2(i64 %"t##0", i64 1) - %4 = trunc i64 %3 to i1 - br i1 %4, label %if.then, label %if.else -if.then: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @higher_order_tests.4, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - musttail call fastcc void @"higher_order_tests.#cont#6<0>"(i64 %"t##0") - ret void -if.else: - musttail call fastcc void @"higher_order_tests.#cont#6<0>"(i64 %"t##0") - ret void +define external fastcc void @"higher_order_tests.#cont#5<0>"(i64 %"t##0") { + %"tmp#10##0" = inttoptr i64 %"t##0" to ptr + %"tmp#9##0" = load ptr, ptr %"tmp#10##0" + %"tmp#3##0" = tail call fastcc i1 %"tmp#9##0"(i64 %"t##0", i64 1) + br i1 %"tmp#3##0", label %if.then.0, label %if.else.0 +if.then.0: + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#8" to i64 )) + call ccc void @putchar(i8 10) + tail call fastcc void @"higher_order_tests.#cont#6<0>"(i64 %"t##0") + ret void +if.else.0: + tail call fastcc void @"higher_order_tests.#cont#6<0>"(i64 %"t##0") + ret void } - -define external fastcc void @"higher_order_tests.#cont#6<0>"(i64 %"t##0") { -entry: - %0 = inttoptr i64 %"t##0" to i64* - %1 = load i64, i64* %0 - %2 = inttoptr i64 %1 to i64 (i64, i64)* - %3 = tail call fastcc i64 %2(i64 %"t##0", i64 2) - %4 = trunc i64 %3 to i1 - br i1 %4, label %if.then, label %if.else -if.then: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @higher_order_tests.6, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - musttail call fastcc void @"higher_order_tests.#cont#7<0>"(i64 %"t##0") - ret void -if.else: - musttail call fastcc void @"higher_order_tests.#cont#7<0>"(i64 %"t##0") - ret void +define external fastcc void @"higher_order_tests.#cont#6<0>"(i64 %"t##0") { + %"tmp#9##0" = inttoptr i64 %"t##0" to ptr + %"tmp#8##0" = load ptr, ptr %"tmp#9##0" + %"tmp#2##0" = tail call fastcc i1 %"tmp#8##0"(i64 %"t##0", i64 2) + br i1 %"tmp#2##0", label %if.then.0, label %if.else.0 +if.then.0: + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#6" to i64 )) + call ccc void @putchar(i8 10) + tail call fastcc void @"higher_order_tests.#cont#7<0>"(i64 %"t##0") + ret void +if.else.0: + tail call fastcc void @"higher_order_tests.#cont#7<0>"(i64 %"t##0") + ret void } - -define external fastcc void @"higher_order_tests.#cont#7<0>"(i64 %"t##0") { -entry: - %0 = inttoptr i64 %"t##0" to i64* - %1 = load i64, i64* %0 - %2 = inttoptr i64 %1 to i64 (i64, i64)* - %3 = tail call fastcc i64 %2(i64 %"t##0", i64 2) - %4 = trunc i64 %3 to i1 - br i1 %4, label %if.then, label %if.else -if.then: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @higher_order_tests.8, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - ret void -if.else: - ret void +define external fastcc void @"higher_order_tests.#cont#7<0>"(i64 %"t##0") { + %"tmp#8##0" = inttoptr i64 %"t##0" to ptr + %"tmp#7##0" = load ptr, ptr %"tmp#8##0" + %"tmp#1##0" = tail call fastcc i1 %"tmp#7##0"(i64 %"t##0", i64 2) + br i1 %"tmp#1##0", label %if.then.0, label %if.else.0 +if.then.0: + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#9" to i64 )) + call ccc void @putchar(i8 10) + ret void +if.else.0: + ret void } - -define external fastcc i1 @"higher_order_tests.do_test<0>"(i64 %"f##0", i64 %"i##0") alwaysinline { -entry: - %0 = inttoptr i64 %"f##0" to i64* - %1 = load i64, i64* %0 - %2 = inttoptr i64 %1 to i64 (i64, i64)* - %3 = tail call fastcc i64 %2(i64 %"f##0", i64 %"i##0") - %4 = trunc i64 %3 to i1 - ret i1 %4 +define external fastcc i1 @"higher_order_tests.do_test<0>"(i64 %"f##0", i64 %"i##0") { + %"tmp#2##0" = inttoptr i64 %"f##0" to ptr + %"tmp#1##0" = load ptr, ptr %"tmp#2##0" + %"tmp#3##0" = tail call fastcc i1 %"tmp#1##0"(i64 %"f##0", i64 %"i##0") + ret i1 %"tmp#3##0" } - -define external fastcc i1 @"higher_order_tests.do_test2<0>"(i64 %"f##0", i64 %"i##0") alwaysinline { -entry: - %0 = inttoptr i64 %"f##0" to i64* - %1 = load i64, i64* %0 - %2 = inttoptr i64 %1 to i64 (i64, i64)* - %3 = tail call fastcc i64 %2(i64 %"f##0", i64 %"i##0") - %4 = trunc i64 %3 to i1 - ret i1 %4 +define external fastcc i1 @"higher_order_tests.do_test2<0>"(i64 %"f##0", i64 %"i##0") { + %"tmp#2##0" = inttoptr i64 %"f##0" to ptr + %"tmp#1##0" = load ptr, ptr %"tmp#2##0" + %"tmp#3##0" = tail call fastcc i1 %"tmp#1##0"(i64 %"f##0", i64 %"i##0") + ret i1 %"tmp#3##0" } diff --git a/test-cases/final-dump/hypot.exp b/test-cases/final-dump/hypot.exp index 0f5e9b7db..9da1f6ed1 100644 --- a/test-cases/final-dump/hypot.exp +++ b/test-cases/final-dump/hypot.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module hypot representation : (not a type) public submods : @@ -124,226 +127,130 @@ hypot(s1##0:wybe.float, s2##0:wybe.float, ?#result##0:wybe.float)<{}; {}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'hypot' - - - - -@hypot.7 = constant {i64, i64} { i64 3, i64 ptrtoint ([?? x i8]* @hypot.6 to i64) } - - -@hypot.5 = constant {i64, i64} { i64 4, i64 ptrtoint ([?? x i8]* @hypot.4 to i64) } - - -@hypot.17 = constant {i64, i64} { i64 8, i64 ptrtoint ([?? x i8]* @hypot.16 to i64) } - - -@hypot.11 = constant {i64, i64} { i64 10, i64 ptrtoint ([?? x i8]* @hypot.10 to i64) } - - -@hypot.3 = constant {i64, i64} { i64 10, i64 ptrtoint ([?? x i8]* @hypot.2 to i64) } - - -@hypot.9 = constant {i64, i64} { i64 10, i64 ptrtoint ([?? x i8]* @hypot.8 to i64) } - - -@hypot.25 = constant {i64, i64} { i64 11, i64 ptrtoint ([?? x i8]* @hypot.24 to i64) } - - -@hypot.23 = constant {i64, i64} { i64 12, i64 ptrtoint ([?? x i8]* @hypot.22 to i64) } - - -@hypot.27 = constant {i64, i64} { i64 12, i64 ptrtoint ([?? x i8]* @hypot.26 to i64) } - - -@hypot.1 = constant {i64, i64} { i64 13, i64 ptrtoint ([?? x i8]* @hypot.0 to i64) } - - -@hypot.29 = constant {i64, i64} { i64 13, i64 ptrtoint ([?? x i8]* @hypot.28 to i64) } - - -@hypot.19 = constant {i64, i64} { i64 16, i64 ptrtoint ([?? x i8]* @hypot.18 to i64) } - - -@hypot.21 = constant {i64, i64} { i64 16, i64 ptrtoint ([?? x i8]* @hypot.20 to i64) } - - -@hypot.13 = constant {i64, i64} { i64 18, i64 ptrtoint ([?? x i8]* @hypot.12 to i64) } - - -@hypot.15 = constant {i64, i64} { i64 18, i64 ptrtoint ([?? x i8]* @hypot.14 to i64) } - - -@hypot.6 = constant [?? x i8] c" = \00" - - -@hypot.2 = constant [?? x i8] c"area(5) = \00" - - -@hypot.20 = constant [?? x i8] c"base 2 log(e) = \00" - - -@hypot.24 = constant [?? x i8] c"ceil(pi) = \00" - - -@hypot.18 = constant [?? x i8] c"common log(e) = \00" - - -@hypot.14 = constant [?? x i8] c"cos(30 degrees) = \00" - - -@hypot.10 = constant [?? x i8] c"cos(30) = \00" - - -@hypot.4 = constant [?? x i8] c"e = \00" - - -@hypot.22 = constant [?? x i8] c"floor(pi) = \00" - - -@hypot.0 = constant [?? x i8] c"hypot(3,4) = \00" - - -@hypot.28 = constant [?? x i8] c"iround(pi) = \00" - - -@hypot.16 = constant [?? x i8] c"ln(e) = \00" - - -@hypot.26 = constant [?? x i8] c"round(pi) = \00" - - -@hypot.12 = constant [?? x i8] c"sin(30 degrees) = \00" - - -@hypot.8 = constant [?? x i8] c"sin(30) = \00" - - -declare external ccc double @llvm.sqrt.f64(double) - - -declare external ccc void @putchar(i8) - - -declare external ccc void @print_int(i64) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc void @print_float(double) - - -declare external ccc double @llvm.round.f64(double) - - -declare external ccc double @llvm.ceil.f64(double) - - -declare external ccc double @llvm.floor.f64(double) - - -declare external ccc double @llvm.log2.f64(double) - - -declare external ccc double @llvm.log10.f64(double) - - -declare external ccc double @llvm.log.f64(double) - - -declare external ccc double @llvm.cos.f64(double) - - -declare external ccc double @llvm.sin.f64(double) - - -declare external ccc double @llvm.exp.f64(double) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"hypot.<0>"() { -entry: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @hypot.1, i32 0, i32 0) to i64)) - %0 = tail call ccc double @llvm.sqrt.f64(double 2.500000e1) - tail call ccc void @print_float(double %0) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @hypot.3, i32 0, i32 0) to i64)) - tail call ccc void @print_float(double 7.853982e1) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @hypot.5, i32 0, i32 0) to i64)) - tail call ccc void @print_float(double 2.718282e0) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @hypot.7, i32 0, i32 0) to i64)) - %1 = tail call ccc double @llvm.exp.f64(double 1.000000e0) - tail call ccc void @print_float(double %1) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @hypot.9, i32 0, i32 0) to i64)) - %2 = tail call ccc double @llvm.sin.f64(double 3.000000e1) - tail call ccc void @print_float(double %2) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @hypot.11, i32 0, i32 0) to i64)) - %3 = tail call ccc double @llvm.cos.f64(double 3.000000e1) - tail call ccc void @print_float(double %3) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @hypot.13, i32 0, i32 0) to i64)) - %4 = tail call ccc double @llvm.sin.f64(double 5.235988e-1) - tail call ccc void @print_float(double %4) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @hypot.15, i32 0, i32 0) to i64)) - %5 = tail call ccc double @llvm.cos.f64(double 5.235988e-1) - tail call ccc void @print_float(double %5) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @hypot.17, i32 0, i32 0) to i64)) - %6 = tail call ccc double @llvm.log.f64(double 2.718282e0) - tail call ccc void @print_float(double %6) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @hypot.19, i32 0, i32 0) to i64)) - %7 = tail call ccc double @llvm.log10.f64(double 2.718282e0) - tail call ccc void @print_float(double %7) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @hypot.21, i32 0, i32 0) to i64)) - %8 = tail call ccc double @llvm.log2.f64(double 2.718282e0) - tail call ccc void @print_float(double %8) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @hypot.23, i32 0, i32 0) to i64)) - %9 = tail call ccc double @llvm.floor.f64(double 3.141593e0) - tail call ccc void @print_float(double %9) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @hypot.25, i32 0, i32 0) to i64)) - %10 = tail call ccc double @llvm.ceil.f64(double 3.141593e0) - tail call ccc void @print_float(double %10) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @hypot.27, i32 0, i32 0) to i64)) - %11 = tail call ccc double @llvm.round.f64(double 3.141593e0) - tail call ccc void @print_float(double %11) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @hypot.29, i32 0, i32 0) to i64)) - %12 = fptosi double %11 to i64 - tail call ccc void @print_int(i64 %12) - tail call ccc void @putchar(i8 10) - ret void +source_filename = "!ROOT!/final-dump/hypot.wybe" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c" = \00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c"area(5) = \00", align 8 +@"cstring#2" = private unnamed_addr constant [ ?? x i8 ] c"base 2 log(e) = \00", align 8 +@"cstring#3" = private unnamed_addr constant [ ?? x i8 ] c"ceil(pi) = \00", align 8 +@"cstring#4" = private unnamed_addr constant [ ?? x i8 ] c"common log(e) = \00", align 8 +@"cstring#5" = private unnamed_addr constant [ ?? x i8 ] c"cos(30 degrees) = \00", align 8 +@"cstring#6" = private unnamed_addr constant [ ?? x i8 ] c"cos(30) = \00", align 8 +@"cstring#7" = private unnamed_addr constant [ ?? x i8 ] c"e = \00", align 8 +@"cstring#8" = private unnamed_addr constant [ ?? x i8 ] c"floor(pi) = \00", align 8 +@"cstring#9" = private unnamed_addr constant [ ?? x i8 ] c"hypot(3,4) = \00", align 8 +@"cstring#10" = private unnamed_addr constant [ ?? x i8 ] c"iround(pi) = \00", align 8 +@"cstring#11" = private unnamed_addr constant [ ?? x i8 ] c"ln(e) = \00", align 8 +@"cstring#12" = private unnamed_addr constant [ ?? x i8 ] c"round(pi) = \00", align 8 +@"cstring#13" = private unnamed_addr constant [ ?? x i8 ] c"sin(30 degrees) = \00", align 8 +@"cstring#14" = private unnamed_addr constant [ ?? x i8 ] c"sin(30) = \00", align 8 +@"string#15" = private unnamed_addr constant {i64, i64} { i64 3, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +@"string#16" = private unnamed_addr constant {i64, i64} { i64 10, i64 ptrtoint( ptr @"cstring#1" to i64 ) }, align 8 +@"string#17" = private unnamed_addr constant {i64, i64} { i64 16, i64 ptrtoint( ptr @"cstring#2" to i64 ) }, align 8 +@"string#18" = private unnamed_addr constant {i64, i64} { i64 11, i64 ptrtoint( ptr @"cstring#3" to i64 ) }, align 8 +@"string#19" = private unnamed_addr constant {i64, i64} { i64 16, i64 ptrtoint( ptr @"cstring#4" to i64 ) }, align 8 +@"string#20" = private unnamed_addr constant {i64, i64} { i64 18, i64 ptrtoint( ptr @"cstring#5" to i64 ) }, align 8 +@"string#21" = private unnamed_addr constant {i64, i64} { i64 10, i64 ptrtoint( ptr @"cstring#6" to i64 ) }, align 8 +@"string#22" = private unnamed_addr constant {i64, i64} { i64 4, i64 ptrtoint( ptr @"cstring#7" to i64 ) }, align 8 +@"string#23" = private unnamed_addr constant {i64, i64} { i64 12, i64 ptrtoint( ptr @"cstring#8" to i64 ) }, align 8 +@"string#24" = private unnamed_addr constant {i64, i64} { i64 13, i64 ptrtoint( ptr @"cstring#9" to i64 ) }, align 8 +@"string#25" = private unnamed_addr constant {i64, i64} { i64 13, i64 ptrtoint( ptr @"cstring#10" to i64 ) }, align 8 +@"string#26" = private unnamed_addr constant {i64, i64} { i64 8, i64 ptrtoint( ptr @"cstring#11" to i64 ) }, align 8 +@"string#27" = private unnamed_addr constant {i64, i64} { i64 12, i64 ptrtoint( ptr @"cstring#12" to i64 ) }, align 8 +@"string#28" = private unnamed_addr constant {i64, i64} { i64 18, i64 ptrtoint( ptr @"cstring#13" to i64 ) }, align 8 +@"string#29" = private unnamed_addr constant {i64, i64} { i64 10, i64 ptrtoint( ptr @"cstring#14" to i64 ) }, align 8 + +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc double @llvm.ceil.f64(double) +declare external ccc double @llvm.cos.f64(double) +declare external ccc double @llvm.exp.f64(double) +declare external ccc double @llvm.floor.f64(double) +declare external ccc double @llvm.log.f64(double) +declare external ccc double @llvm.log10.f64(double) +declare external ccc double @llvm.log2.f64(double) +declare external ccc double @llvm.round.f64(double) +declare external ccc double @llvm.sin.f64(double) +declare external ccc double @llvm.sqrt.f64(double) +declare external ccc void @print_float(double) +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"hypot.<0>"() { + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#24" to i64 )) + %"tmp#0##0" = call ccc double @llvm.sqrt.f64(double 25.0) + call ccc void @print_float(double %"tmp#0##0") + call ccc void @putchar(i8 10) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#16" to i64 )) + call ccc void @print_float(double 78.53981633974483) + call ccc void @putchar(i8 10) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#22" to i64 )) + call ccc void @print_float(double 2.7182818284590455) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#15" to i64 )) + %"tmp#3##0" = call ccc double @llvm.exp.f64(double 1.0) + call ccc void @print_float(double %"tmp#3##0") + call ccc void @putchar(i8 10) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#29" to i64 )) + %"tmp#4##0" = call ccc double @llvm.sin.f64(double 30.0) + call ccc void @print_float(double %"tmp#4##0") + call ccc void @putchar(i8 10) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#21" to i64 )) + %"tmp#5##0" = call ccc double @llvm.cos.f64(double 30.0) + call ccc void @print_float(double %"tmp#5##0") + call ccc void @putchar(i8 10) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#28" to i64 )) + %"tmp#6##0" = call ccc double @llvm.sin.f64(double 0.5235987755982988) + call ccc void @print_float(double %"tmp#6##0") + call ccc void @putchar(i8 10) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#20" to i64 )) + %"tmp#10##0" = call ccc double @llvm.cos.f64(double 0.5235987755982988) + call ccc void @print_float(double %"tmp#10##0") + call ccc void @putchar(i8 10) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#26" to i64 )) + %"tmp#14##0" = call ccc double @llvm.log.f64(double 2.7182818284590455) + call ccc void @print_float(double %"tmp#14##0") + call ccc void @putchar(i8 10) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#19" to i64 )) + %"tmp#16##0" = call ccc double @llvm.log10.f64(double 2.7182818284590455) + call ccc void @print_float(double %"tmp#16##0") + call ccc void @putchar(i8 10) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#17" to i64 )) + %"tmp#18##0" = call ccc double @llvm.log2.f64(double 2.7182818284590455) + call ccc void @print_float(double %"tmp#18##0") + call ccc void @putchar(i8 10) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#23" to i64 )) + %"tmp#20##0" = call ccc double @llvm.floor.f64(double 3.141592653589793) + call ccc void @print_float(double %"tmp#20##0") + call ccc void @putchar(i8 10) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#18" to i64 )) + %"tmp#22##0" = call ccc double @llvm.ceil.f64(double 3.141592653589793) + call ccc void @print_float(double %"tmp#22##0") + call ccc void @putchar(i8 10) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#27" to i64 )) + %"tmp#24##0" = call ccc double @llvm.round.f64(double 3.141592653589793) + call ccc void @print_float(double %"tmp#24##0") + call ccc void @putchar(i8 10) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#25" to i64 )) + %"tmp#26##0" = fptosi double %"tmp#24##0" to i64 + call ccc void @print_int(i64 %"tmp#26##0") + call ccc void @putchar(i8 10) + ret void } - -define external fastcc double @"hypot.area<0>"(double %"r##0") alwaysinline { -entry: - %0 = fmul double %"r##0", %"r##0" - %1 = fmul double 3.141593e0, %0 - ret double %1 +define external fastcc double @"hypot.area<0>"(double %"r##0") { + %"tmp#2##0" = fmul double %"r##0", %"r##0" + %"tmp#6##0" = fmul double 3.141592653589793, %"tmp#2##0" + ret double %"tmp#6##0" } - -define external fastcc double @"hypot.hypot<0>"(double %"s1##0", double %"s2##0") alwaysinline { -entry: - %0 = fmul double %"s1##0", %"s1##0" - %1 = fmul double %"s2##0", %"s2##0" - %2 = fadd double %0, %1 - %3 = tail call ccc double @llvm.sqrt.f64(double %2) - ret double %3 +define external fastcc double @"hypot.hypot<0>"(double %"s1##0", double %"s2##0") { + %"tmp#2##0" = fmul double %"s1##0", %"s1##0" + %"tmp#3##0" = fmul double %"s2##0", %"s2##0" + %"tmp#1##0" = fadd double %"tmp#2##0", %"tmp#3##0" + %"tmp#9##0" = call ccc double @llvm.sqrt.f64(double %"tmp#1##0") + ret double %"tmp#9##0" } diff --git a/test-cases/final-dump/import.exp b/test-cases/final-dump/import.exp index 9fc7db27d..3d09d1997 100644 --- a/test-cases/final-dump/import.exp +++ b/test-cases/final-dump/import.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module import representation : (not a type) public submods : @@ -47,75 +50,61 @@ distance(p1##0:position.position, p2##0:position.position, ?#result##0:wybe.int) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'import' - - - - -declare external ccc i64 @isqrt(i64) - - -declare external ccc i64 @ipow(i64, i64) - - -declare external ccc void @putchar(i8) - - -declare external ccc void @print_int(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"import.<0>"() { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 0, i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 20, i64* %5 - %6 = trunc i64 16 to i32 - %7 = tail call ccc i8* @wybe_malloc(i32 %6) - %8 = ptrtoint i8* %7 to i64 - %9 = inttoptr i64 %8 to i64* - store i64 0, i64* %9 - %10 = add i64 %8, 8 - %11 = inttoptr i64 %10 to i64* - store i64 0, i64* %11 - %12 = tail call fastcc i64 @"import.distance<0>"(i64 %2, i64 %8) - tail call ccc void @print_int(i64 %12) - tail call ccc void @putchar(i8 10) - ret void +source_filename = "!ROOT!/final-dump/import.wybe" +target triple ???? + + +declare external ccc i64 @ipow(i64, i64) +declare external ccc i64 @isqrt(i64) +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"import.<0>"() { + %"tmp#15##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#5##0" = ptrtoint ptr %"tmp#15##0" to i64 + %"tmp#16##0" = inttoptr i64 %"tmp#5##0" to ptr + store i64 0, ptr %"tmp#16##0" + %"tmp#17##0" = add i64 %"tmp#5##0", 8 + %"tmp#18##0" = inttoptr i64 %"tmp#17##0" to ptr + store i64 20, ptr %"tmp#18##0" + %"tmp#19##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#9##0" = ptrtoint ptr %"tmp#19##0" to i64 + %"tmp#20##0" = inttoptr i64 %"tmp#9##0" to ptr + store i64 0, ptr %"tmp#20##0" + %"tmp#21##0" = add i64 %"tmp#9##0", 8 + %"tmp#22##0" = inttoptr i64 %"tmp#21##0" to ptr + store i64 0, ptr %"tmp#22##0" + %"tmp#0##0" = tail call fastcc i64 @"import.distance<0>"(i64 %"tmp#5##0", i64 %"tmp#9##0") + call ccc void @print_int(i64 %"tmp#0##0") + call ccc void @putchar(i8 10) + ret void } - -define external fastcc i64 @"import.distance<0>"(i64 %"p1##0", i64 %"p2##0") { -entry: - %0 = inttoptr i64 %"p2##0" to i64* - %1 = load i64, i64* %0 - %2 = inttoptr i64 %"p1##0" to i64* - %3 = load i64, i64* %2 - %4 = sub i64 %1, %3 - %5 = tail call ccc i64 @ipow(i64 %4, i64 2) - %6 = add i64 %"p2##0", 8 - %7 = inttoptr i64 %6 to i64* - %8 = load i64, i64* %7 - %9 = add i64 %"p1##0", 8 - %10 = inttoptr i64 %9 to i64* - %11 = load i64, i64* %10 - %12 = sub i64 %8, %11 - %13 = tail call ccc i64 @ipow(i64 %12, i64 2) - %14 = add i64 %5, %13 - %15 = tail call ccc i64 @isqrt(i64 %14) - ret i64 %15 +define external fastcc i64 @"import.distance<0>"(i64 %"p1##0", i64 %"p2##0") { + %"tmp#25##0" = inttoptr i64 %"p2##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#25##0" + %"tmp#26##0" = inttoptr i64 %"p1##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#26##0" + %"tmp#3##0" = sub i64 %"tmp#4##0", %"tmp#5##0" + %"tmp#2##0" = call ccc i64 @ipow(i64 %"tmp#3##0", i64 2) + %"tmp#27##0" = add i64 %"p2##0", 8 + %"tmp#28##0" = inttoptr i64 %"tmp#27##0" to ptr + %"tmp#8##0" = load i64, ptr %"tmp#28##0" + %"tmp#29##0" = add i64 %"p1##0", 8 + %"tmp#30##0" = inttoptr i64 %"tmp#29##0" to ptr + %"tmp#9##0" = load i64, ptr %"tmp#30##0" + %"tmp#7##0" = sub i64 %"tmp#8##0", %"tmp#9##0" + %"tmp#6##0" = call ccc i64 @ipow(i64 %"tmp#7##0", i64 2) + %"tmp#1##0" = add i64 %"tmp#2##0", %"tmp#6##0" + %"tmp#31##0" = call ccc i64 @isqrt(i64 %"tmp#1##0") + ret i64 %"tmp#31##0" } + -------------------------------------------------- Module position representation : (not a type) @@ -158,63 +147,42 @@ printPosition(pos##0:position.position)<{<>}; {<>}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'position' - - - - -@position.3 = constant {i64, i64} { i64 1, i64 ptrtoint ([?? x i8]* @position.2 to i64) } - - -@position.5 = constant {i64, i64} { i64 1, i64 ptrtoint ([?? x i8]* @position.4 to i64) } - - -@position.1 = constant {i64, i64} { i64 2, i64 ptrtoint ([?? x i8]* @position.0 to i64) } - - -@position.0 = constant [?? x i8] c" (\00" - - -@position.4 = constant [?? x i8] c")\00" - - -@position.2 = constant [?? x i8] c",\00" - - -declare external ccc void @putchar(i8) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc void @print_int(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"position.printPosition<0>"(i64 %"pos##0") { -entry: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @position.1, i32 0, i32 0) to i64)) - %0 = inttoptr i64 %"pos##0" to i64* - %1 = load i64, i64* %0 - tail call ccc void @print_int(i64 %1) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @position.3, i32 0, i32 0) to i64)) - %2 = add i64 %"pos##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - tail call ccc void @print_int(i64 %4) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @position.5, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - ret void +source_filename = "!ROOT!/final-dump/position.wybe" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c" (\00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c")\00", align 8 +@"cstring#2" = private unnamed_addr constant [ ?? x i8 ] c",\00", align 8 +@"string#3" = private unnamed_addr constant {i64, i64} { i64 2, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +@"string#4" = private unnamed_addr constant {i64, i64} { i64 1, i64 ptrtoint( ptr @"cstring#1" to i64 ) }, align 8 +@"string#5" = private unnamed_addr constant {i64, i64} { i64 1, i64 ptrtoint( ptr @"cstring#2" to i64 ) }, align 8 + +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"position.printPosition<0>"(i64 %"pos##0") { + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#3" to i64 )) + %"tmp#13##0" = inttoptr i64 %"pos##0" to ptr + %"tmp#0##0" = load i64, ptr %"tmp#13##0" + call ccc void @print_int(i64 %"tmp#0##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#5" to i64 )) + %"tmp#14##0" = add i64 %"pos##0", 8 + %"tmp#15##0" = inttoptr i64 %"tmp#14##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#15##0" + call ccc void @print_int(i64 %"tmp#1##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#4" to i64 )) + call ccc void @putchar(i8 10) + ret void } + -------------------------------------------------- Module position.position - representation : address + representation : pointer public submods : public resources: public procs : position.position.=<0> @@ -316,134 +284,110 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'position.position' - - - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i1 @"position.position.=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %"#right##0" to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = icmp eq i64 %1, %6 - br i1 %10, label %if.then, label %if.else -if.then: - %11 = icmp eq i64 %4, %9 - ret i1 %11 -if.else: - ret i1 0 +source_filename = "!ROOT!/final-dump/position.wybe" +target triple ???? + + +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc i1 @"position.position.=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#9##0" = inttoptr i64 %"#left##0" to ptr + %"#left#x##0" = load i64, ptr %"tmp#9##0" + %"tmp#10##0" = add i64 %"#left##0", 8 + %"tmp#11##0" = inttoptr i64 %"tmp#10##0" to ptr + %"#left#y##0" = load i64, ptr %"tmp#11##0" + %"tmp#12##0" = inttoptr i64 %"#right##0" to ptr + %"#right#x##0" = load i64, ptr %"tmp#12##0" + %"tmp#13##0" = add i64 %"#right##0", 8 + %"tmp#14##0" = inttoptr i64 %"tmp#13##0" to ptr + %"#right#y##0" = load i64, ptr %"tmp#14##0" + %"tmp#1##0" = icmp eq i64 %"#left#x##0", %"#right#x##0" + br i1 %"tmp#1##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#15##0" = icmp eq i64 %"#left#y##0", %"#right#y##0" + ret i1 %"tmp#15##0" +if.else.0: + ret i1 0 } - -define external fastcc i64 @"position.position.position<0>"(i64 %"x##0", i64 %"y##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"x##0", i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"y##0", i64* %5 - ret i64 %2 +define external fastcc i64 @"position.position.position<0>"(i64 %"x##0", i64 %"y##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 16) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"x##0", ptr %"tmp#1##0" + %"tmp#2##0" = add i64 %"#rec##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"y##0", ptr %"tmp#3##0" + ret i64 %"#rec##0" } - -define external fastcc {i64, i64} @"position.position.position<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#result##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#result##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = insertvalue {i64, i64} undef, i64 %1, 0 - %6 = insertvalue {i64, i64} %5, i64 %4, 1 - ret {i64, i64} %6 +define external fastcc {i64, i64} @"position.position.position<1>"(i64 %"#result##0") { + %"tmp#0##0" = inttoptr i64 %"#result##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + %"tmp#2##0" = add i64 %"#result##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#3##0" + %"tmp#5##0" = insertvalue {i64, i64} undef, i64 %"tmp#1##0", 0 + %"tmp#6##0" = insertvalue {i64, i64} %"tmp#5##0", i64 %"tmp#4##0", 1 + ret {i64, i64} %"tmp#6##0" } - -define external fastcc i64 @"position.position.x<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#rec##0" to i64* - %1 = load i64, i64* %0 - ret i64 %1 +define external fastcc i64 @"position.position.x<0>"(i64 %"#rec##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + ret i64 %"tmp#1##0" } - -define external fastcc i64 @"position.position.x<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = inttoptr i64 %2 to i64* - store i64 %"#field##0", i64* %6 - ret i64 %2 +define external fastcc i64 @"position.position.x<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"#field##0", ptr %"tmp#3##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"position.position.y<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = add i64 %"#rec##0", 8 - %1 = inttoptr i64 %0 to i64* - %2 = load i64, i64* %1 - ret i64 %2 +define external fastcc i64 @"position.position.y<0>"(i64 %"#rec##0") { + %"tmp#0##0" = add i64 %"#rec##0", 8 + %"tmp#1##0" = inttoptr i64 %"tmp#0##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"position.position.y<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = add i64 %2, 8 - %7 = inttoptr i64 %6 to i64* - store i64 %"#field##0", i64* %7 - ret i64 %2 +define external fastcc i64 @"position.position.y<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = add i64 %"tmp#2##0", 8 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 %"#field##0", ptr %"tmp#4##0" + ret i64 %"tmp#2##0" } - -define external fastcc i1 @"position.position.~=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %"#right##0" to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = icmp eq i64 %1, %6 - br i1 %10, label %if.then, label %if.else -if.then: - %11 = icmp eq i64 %4, %9 - %12 = xor i1 %11, 1 - ret i1 %12 -if.else: - %13 = xor i1 0, 1 - ret i1 %13 +define external fastcc i1 @"position.position.~=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#8##0" = inttoptr i64 %"#left##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#8##0" + %"tmp#9##0" = add i64 %"#left##0", 8 + %"tmp#10##0" = inttoptr i64 %"tmp#9##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#10##0" + %"tmp#11##0" = inttoptr i64 %"#right##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#11##0" + %"tmp#12##0" = add i64 %"#right##0", 8 + %"tmp#13##0" = inttoptr i64 %"tmp#12##0" to ptr + %"tmp#6##0" = load i64, ptr %"tmp#13##0" + %"tmp#7##0" = icmp eq i64 %"tmp#3##0", %"tmp#5##0" + br i1 %"tmp#7##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#0##0" = icmp eq i64 %"tmp#4##0", %"tmp#6##0" + %"tmp#14##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#14##0" +if.else.0: + %"tmp#15##0" = xor i1 0, 1 + ret i1 %"tmp#15##0" } diff --git a/test-cases/final-dump/import_in_sub_mod_lib.exp b/test-cases/final-dump/import_in_sub_mod_lib.exp index 210f116dc..bb875c539 100644 --- a/test-cases/final-dump/import_in_sub_mod_lib.exp +++ b/test-cases/final-dump/import_in_sub_mod_lib.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module import_in_sub_mod_lib representation : (not a type) public submods : @@ -21,27 +24,19 @@ foo(v##0:wybe.int)<{<>}; {<>}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'import_in_sub_mod_lib' +source_filename = "!ROOT!/final-dump/import_in_sub_mod_lib.wybe" +target triple ???? - - - -declare external ccc void @putchar(i8) - - -declare external ccc void @print_int(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -define external fastcc void @"import_in_sub_mod_lib.foo<0>"(i64 %"v##0") alwaysinline { -entry: - tail call ccc void @print_int(i64 %"v##0") - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"import_in_sub_mod_lib.foo<0>"(i64 %"v##0") { + call ccc void @print_int(i64 %"v##0") + call ccc void @putchar(i8 10) + ret void } diff --git a/test-cases/final-dump/import_in_sub_mod_main.exp b/test-cases/final-dump/import_in_sub_mod_main.exp index c763d19bc..7646186de 100644 --- a/test-cases/final-dump/import_in_sub_mod_main.exp +++ b/test-cases/final-dump/import_in_sub_mod_main.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module import_in_sub_mod_lib representation : (not a type) public submods : @@ -21,30 +24,23 @@ foo(v##0:wybe.int)<{<>}; {<>}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'import_in_sub_mod_lib' - - - - -declare external ccc void @putchar(i8) - - -declare external ccc void @print_int(i64) +source_filename = "!ROOT!/final-dump/import_in_sub_mod_lib.wybe" +target triple ???? -declare external ccc i8* @wybe_malloc(i32) +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"import_in_sub_mod_lib.foo<0>"(i64 %"v##0") alwaysinline { -entry: - tail call ccc void @print_int(i64 %"v##0") - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"import_in_sub_mod_lib.foo<0>"(i64 %"v##0") { + call ccc void @print_int(i64 %"v##0") + call ccc void @putchar(i8 10) + ret void } + -------------------------------------------------- Module import_in_sub_mod_main representation : (not a type) @@ -69,30 +65,23 @@ module top-level code > public {inline,semipure} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'import_in_sub_mod_main' - - - - -declare external ccc void @putchar(i8) +source_filename = "!ROOT!/final-dump/import_in_sub_mod_main.wybe" +target triple ???? -declare external ccc void @print_int(i64) +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"import_in_sub_mod_main.<0>"() alwaysinline { -entry: - tail call ccc void @print_int(i64 10) - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"import_in_sub_mod_main.<0>"() { + call ccc void @print_int(i64 10) + call ccc void @putchar(i8 10) + ret void } + -------------------------------------------------- Module import_in_sub_mod_main.sub representation : (not a type) @@ -117,27 +106,19 @@ bar(v##0:wybe.int)<{<>}; {<>}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'import_in_sub_mod_main.sub' +source_filename = "!ROOT!/final-dump/import_in_sub_mod_main.wybe" +target triple ???? - - - -declare external ccc void @putchar(i8) - - -declare external ccc void @print_int(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -define external fastcc void @"import_in_sub_mod_main.sub.bar<0>"(i64 %"v##0") alwaysinline { -entry: - tail call ccc void @print_int(i64 %"v##0") - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"import_in_sub_mod_main.sub.bar<0>"(i64 %"v##0") { + call ccc void @print_int(i64 %"v##0") + call ccc void @putchar(i8 10) + ret void } diff --git a/test-cases/final-dump/importer.exp b/test-cases/final-dump/importer.exp index 710d5278e..a11f7380b 100644 --- a/test-cases/final-dump/importer.exp +++ b/test-cases/final-dump/importer.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module exporter representation : (not a type) public submods : @@ -27,36 +30,27 @@ three(?n##0:wybe.int)<{<>}; {}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'exporter' - - - - -@"resource#exporter.res" = global i64 undef +source_filename = "!ROOT!/final-dump/exporter.wybe" +target triple ???? -declare external ccc i64 @ipow(i64, i64) +declare external ccc i64 @ipow(i64, i64) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) +@"resource#exporter.res" = global i64 undef - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i64 @"exporter.fn<0>"(i64 %"i##0") alwaysinline { -entry: - %0 = tail call ccc i64 @ipow(i64 2, i64 %"i##0") - ret i64 %0 +define external fastcc i64 @"exporter.fn<0>"(i64 %"i##0") { + %"tmp#3##0" = call ccc i64 @ipow(i64 2, i64 %"i##0") + ret i64 %"tmp#3##0" } - -define external fastcc i64 @"exporter.three<0>"() alwaysinline { -entry: - %0 = load i64, i64* @"resource#exporter.res" - ret i64 %0 +define external fastcc i64 @"exporter.three<0>"() { + %"tmp#1##0" = load i64, ptr @"resource#exporter.res" + ret i64 %"tmp#1##0" } + -------------------------------------------------- Module importer representation : (not a type) @@ -103,76 +97,49 @@ my_three(?n##0:wybe.int)<{<>}; {}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'importer' - - - - -@"resource#exporter.res" = external global i64 - - -@importer.3 = constant {i64, i64} { i64 2, i64 ptrtoint ([?? x i8]* @importer.2 to i64) } - - -@importer.1 = constant {i64, i64} { i64 3, i64 ptrtoint ([?? x i8]* @importer.0 to i64) } - - -@importer.0 = constant [?? x i8] c" = \00" - - -@importer.2 = constant [?? x i8] c"2^\00" - - -declare external ccc void @putchar(i8) - - -declare external fastcc void @"wybe.string.print<0>[410bae77d3]"(i64) - - -declare external fastcc i64 @"wybe.string.,,<0>"(i64, i64) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external fastcc i64 @"wybe.int.fmt<2>"(i64, i64, i8) - - -declare external ccc i64 @ipow(i64, i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"importer.<0>"() { -entry: - %0 = load i64, i64* @"resource#exporter.res" - %1 = tail call ccc i64 @ipow(i64 2, i64 %0) - %2 = tail call fastcc i64 @"wybe.int.fmt<2>"(i64 %0, i64 0, i8 32) - %3 = tail call fastcc i64 @"wybe.int.fmt<2>"(i64 %1, i64 0, i8 32) - %4 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @importer.1, i32 0, i32 0) to i64), i64 %3) - %5 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 %2, i64 %4) - %6 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @importer.3, i32 0, i32 0) to i64), i64 %5) - tail call fastcc void @"wybe.string.print<0>"(i64 %6) - tail call ccc void @putchar(i8 10) - %7 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @importer.1, i32 0, i32 0) to i64), i64 %3) - %8 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 %2, i64 %7) - %9 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @importer.3, i32 0, i32 0) to i64), i64 %8) - tail call fastcc void @"wybe.string.print<0>[410bae77d3]"(i64 %9) - tail call ccc void @putchar(i8 10) - ret void +source_filename = "!ROOT!/final-dump/importer.wybe" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c" = \00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c"2^\00", align 8 +@"string#2" = private unnamed_addr constant {i64, i64} { i64 3, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +@"string#3" = private unnamed_addr constant {i64, i64} { i64 2, i64 ptrtoint( ptr @"cstring#1" to i64 ) }, align 8 + +@"resource#exporter.res" = external global i64 +declare external fastcc i64 @"wybe.int.fmt<2>"(i64, i64, i8) +declare external fastcc i64 @"wybe.string.,,<0>"(i64, i64) +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external fastcc void @"wybe.string.print<0>[410bae77d3]"(i64) +declare external ccc i64 @ipow(i64, i64) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"importer.<0>"() { + %"tmp#19##0" = load i64, ptr @"resource#exporter.res" + %"tmp#20##0" = call ccc i64 @ipow(i64 2, i64 %"tmp#19##0") + %"tmp#3##0" = tail call fastcc i64 @"wybe.int.fmt<2>"(i64 %"tmp#19##0", i64 0, i8 32) + %"tmp#5##0" = tail call fastcc i64 @"wybe.int.fmt<2>"(i64 %"tmp#20##0", i64 0, i8 32) + %"tmp#4##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint( ptr @"string#2" to i64 ), i64 %"tmp#5##0") + %"tmp#2##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 %"tmp#3##0", i64 %"tmp#4##0") + %"tmp#1##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint( ptr @"string#3" to i64 ), i64 %"tmp#2##0") + tail call fastcc void @"wybe.string.print<0>"(i64 %"tmp#1##0") + call ccc void @putchar(i8 10) + %"tmp#10##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint( ptr @"string#2" to i64 ), i64 %"tmp#5##0") + %"tmp#8##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 %"tmp#3##0", i64 %"tmp#10##0") + %"tmp#7##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint( ptr @"string#3" to i64 ), i64 %"tmp#8##0") + tail call fastcc void @"wybe.string.print<0>[410bae77d3]"(i64 %"tmp#7##0") + call ccc void @putchar(i8 10) + ret void } - -define external fastcc i64 @"importer.my_three<0>"() alwaysinline { -entry: - %0 = load i64, i64* @"resource#exporter.res" - ret i64 %0 +define external fastcc i64 @"importer.my_three<0>"() { + %"tmp#1##0" = load i64, ptr @"resource#exporter.res" + ret i64 %"tmp#1##0" } + -------------------------------------------------- Module pub_importer representation : (not a type) @@ -188,13 +155,11 @@ entry: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'pub_importer' - - - - -declare external ccc i8* @wybe_malloc(i32) +source_filename = "!ROOT!/final-dump/pub_importer.wybe" +target triple ???? -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) diff --git a/test-cases/final-dump/imports.exp b/test-cases/final-dump/imports.exp index ac24d1699..eb0e908b4 100644 --- a/test-cases/final-dump/imports.exp +++ b/test-cases/final-dump/imports.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module imports representation : (not a type) public submods : mod5 -> mod5 @@ -21,16 +24,15 @@ AFTER EVERYTHING: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'imports' +source_filename = "!ROOT!/final-dump/imports.wybe" +target triple ???? - +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) -------------------------------------------------- Module mod1 representation : (not a type) @@ -44,16 +46,15 @@ declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'mod1' - - +source_filename = "!ROOT!/final-dump/mod1.wybe" +target triple ???? -declare external ccc i8* @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) -------------------------------------------------- Module mod2 representation : (not a type) @@ -67,16 +68,15 @@ declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'mod2' +source_filename = "!ROOT!/final-dump/mod2.wybe" +target triple ???? - - - -declare external ccc i8* @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) -------------------------------------------------- Module mod3 representation : (not a type) @@ -90,16 +90,15 @@ declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'mod3' +source_filename = "!ROOT!/final-dump/mod3.wybe" +target triple ???? - - - -declare external ccc i8* @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) -------------------------------------------------- Module mod4 representation : (not a type) @@ -113,16 +112,15 @@ declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'mod4' +source_filename = "!ROOT!/final-dump/mod4.wybe" +target triple ???? - +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) -------------------------------------------------- Module mod5 representation : (not a type) @@ -136,16 +134,15 @@ declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'mod5' - - +source_filename = "!ROOT!/final-dump/mod5.wybe" +target triple ???? -declare external ccc i8* @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) -------------------------------------------------- Module mod6 representation : (not a type) @@ -159,16 +156,15 @@ declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'mod6' +source_filename = "!ROOT!/final-dump/mod6.wybe" +target triple ???? - - - -declare external ccc i8* @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) -------------------------------------------------- Module mod7 representation : (not a type) @@ -182,16 +178,15 @@ declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'mod7' +source_filename = "!ROOT!/final-dump/mod7.wybe" +target triple ???? - +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) -------------------------------------------------- Module mod8 representation : (not a type) @@ -205,13 +200,11 @@ declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'mod8' - - - - -declare external ccc i8* @wybe_malloc(i32) +source_filename = "!ROOT!/final-dump/mod8.wybe" +target triple ???? -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) diff --git a/test-cases/final-dump/inequality.exp b/test-cases/final-dump/inequality.exp index 4e2122961..362b9ad18 100644 --- a/test-cases/final-dump/inequality.exp +++ b/test-cases/final-dump/inequality.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module inequality representation : (not a type) public submods : @@ -25,29 +28,21 @@ module top-level code > public {semipure} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'inequality' +source_filename = "!ROOT!/final-dump/inequality.wybe" +target triple ???? - - - -declare external ccc void @putchar(i8) - - -declare external fastcc void @"wybe.bool.print<0>"(i1) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) +declare external fastcc void @"wybe.bool.print<0>"(i1) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -define external fastcc void @"inequality.<0>"() { -entry: - tail call fastcc void @"wybe.bool.print<0>"(i1 1) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"wybe.bool.print<0>"(i1 0) - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"inequality.<0>"() { + tail call fastcc void @"wybe.bool.print<0>"(i1 1) + call ccc void @putchar(i8 10) + tail call fastcc void @"wybe.bool.print<0>"(i1 0) + call ccc void @putchar(i8 10) + ret void } diff --git a/test-cases/final-dump/inline_decl.exp b/test-cases/final-dump/inline_decl.exp index 2e721121e..04e9e690f 100644 --- a/test-cases/final-dump/inline_decl.exp +++ b/test-cases/final-dump/inline_decl.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module inline_decl representation : (not a type) public submods : @@ -66,61 +69,51 @@ long()<{<>}; {<>}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'inline_decl' - - - - -declare external ccc void @putchar(i8) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"inline_decl.<0>"() { -entry: - tail call ccc void @putchar(i8 104) - tail call ccc void @putchar(i8 101) - tail call ccc void @putchar(i8 108) - tail call ccc void @putchar(i8 108) - tail call ccc void @putchar(i8 111) - tail call ccc void @putchar(i8 32) - tail call ccc void @putchar(i8 119) - tail call ccc void @putchar(i8 111) - tail call ccc void @putchar(i8 114) - tail call ccc void @putchar(i8 108) - tail call ccc void @putchar(i8 100) - tail call ccc void @putchar(i8 33) - musttail call fastcc void @"inline_decl.finish<0>"() - ret void +source_filename = "!ROOT!/final-dump/inline_decl.wybe" +target triple ???? + + +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"inline_decl.<0>"() { + call ccc void @putchar(i8 104) + call ccc void @putchar(i8 101) + call ccc void @putchar(i8 108) + call ccc void @putchar(i8 108) + call ccc void @putchar(i8 111) + call ccc void @putchar(i8 32) + call ccc void @putchar(i8 119) + call ccc void @putchar(i8 111) + call ccc void @putchar(i8 114) + call ccc void @putchar(i8 108) + call ccc void @putchar(i8 100) + call ccc void @putchar(i8 33) + tail call fastcc void @"inline_decl.finish<0>"() + ret void } - -define external fastcc void @"inline_decl.finish<0>"() noinline { -entry: - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"inline_decl.finish<0>"() { + call ccc void @putchar(i8 10) + ret void } - -define external fastcc void @"inline_decl.long<0>"() alwaysinline { -entry: - tail call ccc void @putchar(i8 104) - tail call ccc void @putchar(i8 101) - tail call ccc void @putchar(i8 108) - tail call ccc void @putchar(i8 108) - tail call ccc void @putchar(i8 111) - tail call ccc void @putchar(i8 32) - tail call ccc void @putchar(i8 119) - tail call ccc void @putchar(i8 111) - tail call ccc void @putchar(i8 114) - tail call ccc void @putchar(i8 108) - tail call ccc void @putchar(i8 100) - tail call ccc void @putchar(i8 33) - musttail call fastcc void @"inline_decl.finish<0>"() - ret void +define external fastcc void @"inline_decl.long<0>"() { + call ccc void @putchar(i8 104) + call ccc void @putchar(i8 101) + call ccc void @putchar(i8 108) + call ccc void @putchar(i8 108) + call ccc void @putchar(i8 111) + call ccc void @putchar(i8 32) + call ccc void @putchar(i8 119) + call ccc void @putchar(i8 111) + call ccc void @putchar(i8 114) + call ccc void @putchar(i8 108) + call ccc void @putchar(i8 100) + call ccc void @putchar(i8 33) + tail call fastcc void @"inline_decl.finish<0>"() + ret void } diff --git a/test-cases/final-dump/inline_pos.exp b/test-cases/final-dump/inline_pos.exp index 09ed2fc67..59c57e65b 100644 --- a/test-cases/final-dump/inline_pos.exp +++ b/test-cases/final-dump/inline_pos.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module command_line representation : (not a type) public submods : @@ -44,68 +47,45 @@ set_exit_code(code##0:wybe.int)<{}; {<>}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'command_line' - - - - -@"resource#command_line.argc" = global i64 undef - - -@"resource#command_line.arguments" = global i64 undef - - -@"resource#command_line.argv" = global i64 undef - - -@"resource#command_line.command" = global i64 undef - - -@"resource#command_line.exit_code" = global i64 undef - - -@command_line.1 = constant [?? x i8] c"Erroneous program argument vector\00" - - -@command_line.0 = constant [?? x i8] c"command_line:18:15\00" - - -declare external ccc void @error_exit(i64, i64) - - -declare external fastcc {i64, i64, i1} @"wybe.array.[|]<0>"(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"command_line.<0>"() { -entry: - %0 = load i64, i64* @"resource#command_line.arguments" - %1 = tail call fastcc {i64, i64, i1} @"wybe.array.[|]<0>"(i64 %0) - %2 = extractvalue {i64, i64, i1} %1, 0 - %3 = extractvalue {i64, i64, i1} %1, 1 - %4 = extractvalue {i64, i64, i1} %1, 2 - br i1 %4, label %if.then, label %if.else -if.then: - store i64 %3, i64* @"resource#command_line.arguments" - store i64 %2, i64* @"resource#command_line.command" - ret void -if.else: - tail call ccc void @error_exit(i64 ptrtoint (i8* getelementptr inbounds ([?? x i8], [?? x i8]* @command_line.0, i32 0, i32 0) to i64), i64 ptrtoint (i8* getelementptr inbounds ([?? x i8], [?? x i8]* @command_line.1, i32 0, i32 0) to i64)) - ret void +source_filename = "!ROOT!/../wybelibs/command_line.o" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c"Erroneous program argument vector\00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c"command_line:18:15\00", align 8 + +declare external fastcc {i64, i64, i1} @"wybe.array.[|]<0>"(i64) +declare external ccc void @error_exit(i64, i64) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) +@"resource#command_line.argc" = global i64 undef +@"resource#command_line.arguments" = global i64 undef +@"resource#command_line.argv" = global i64 undef +@"resource#command_line.command" = global i64 undef +@"resource#command_line.exit_code" = global i64 undef + +define external fastcc void @"command_line.<0>"() { + %"arguments##0" = load i64, ptr @"resource#command_line.arguments" + %"tmp#11##0" = tail call fastcc {i64, i64, i1} @"wybe.array.[|]<0>"(i64 %"arguments##0") + %"command##1" = extractvalue {i64, i64, i1}%"tmp#11##0", 0 + %"arguments##2" = extractvalue {i64, i64, i1}%"tmp#11##0", 1 + %"tmp#8##0" = extractvalue {i64, i64, i1}%"tmp#11##0", 2 + br i1 %"tmp#8##0", label %if.then.0, label %if.else.0 +if.then.0: + store i64 %"arguments##2", ptr @"resource#command_line.arguments" + store i64 %"command##1", ptr @"resource#command_line.command" + ret void +if.else.0: + call ccc void @error_exit(i64 ptrtoint( ptr @"cstring#1" to i64 ), i64 ptrtoint( ptr @"cstring#0" to i64 )) + ret void } - -define external fastcc void @"command_line.set_exit_code<0>"(i64 %"code##0") alwaysinline { -entry: - store i64 %"code##0", i64* @"resource#command_line.exit_code" - ret void +define external fastcc void @"command_line.set_exit_code<0>"(i64 %"code##0") { + store i64 %"code##0", ptr @"resource#command_line.exit_code" + ret void } + -------------------------------------------------- Module inline_pos representation : (not a type) @@ -143,55 +123,35 @@ myincr(x##0:wybe.int, ?x##1:wybe.int)<{}; {}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'inline_pos' - - - - -@"resource#command_line.arguments" = external global i64 - - -@inline_pos.1 = constant {i64, i64} { i64 4, i64 ptrtoint ([?? x i8]* @inline_pos.0 to i64) } - - -@inline_pos.0 = constant [?? x i8] c"v = \00" - - -declare external ccc void @putchar(i8) - - -declare external fastcc void @"wybe.string.print<0>[410bae77d3]"(i64) - - -declare external fastcc i64 @"wybe.string.,,<0>"(i64, i64) - - -declare external fastcc i64 @"wybe.int.fmt<2>"(i64, i64, i8) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"inline_pos.<0>"() { -entry: - %0 = load i64, i64* @"resource#command_line.arguments" - %1 = inttoptr i64 %0 to i64* - %2 = load i64, i64* %1 - %3 = add i64 %2, 1 - %4 = tail call fastcc i64 @"wybe.int.fmt<2>"(i64 %3, i64 0, i8 32) - %5 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @inline_pos.1, i32 0, i32 0) to i64), i64 %4) - tail call fastcc void @"wybe.string.print<0>[410bae77d3]"(i64 %5) - tail call ccc void @putchar(i8 10) - ret void +source_filename = "!ROOT!/final-dump/inline_pos.wybe" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c"v = \00", align 8 +@"string#1" = private unnamed_addr constant {i64, i64} { i64 4, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 + +@"resource#command_line.arguments" = external global i64 +declare external fastcc i64 @"wybe.int.fmt<2>"(i64, i64, i8) +declare external fastcc i64 @"wybe.string.,,<0>"(i64, i64) +declare external fastcc void @"wybe.string.print<0>[410bae77d3]"(i64) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"inline_pos.<0>"() { + %"arguments##0" = load i64, ptr @"resource#command_line.arguments" + %"tmp#9##0" = inttoptr i64 %"arguments##0" to ptr + %"tmp#0##0" = load i64, ptr %"tmp#9##0" + %"v##1" = add i64 %"tmp#0##0", 1 + %"tmp#2##0" = tail call fastcc i64 @"wybe.int.fmt<2>"(i64 %"v##1", i64 0, i8 32) + %"tmp#1##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint( ptr @"string#1" to i64 ), i64 %"tmp#2##0") + tail call fastcc void @"wybe.string.print<0>[410bae77d3]"(i64 %"tmp#1##0") + call ccc void @putchar(i8 10) + ret void } - -define external fastcc i64 @"inline_pos.myincr<0>"(i64 %"x##0") alwaysinline { -entry: - %0 = add i64 %"x##0", 1 - ret i64 %0 +define external fastcc i64 @"inline_pos.myincr<0>"(i64 %"x##0") { + %"tmp#3##0" = add i64 %"x##0", 1 + ret i64 %"tmp#3##0" } diff --git a/test-cases/final-dump/inline_rename.exp b/test-cases/final-dump/inline_rename.exp index 7bf79999d..f577db2d1 100644 --- a/test-cases/final-dump/inline_rename.exp +++ b/test-cases/final-dump/inline_rename.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module inline_rename representation : (not a type) public submods : @@ -44,45 +47,33 @@ foo(?bar##0:wybe.int)<{<>}; {<>}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'inline_rename' +source_filename = "!ROOT!/final-dump/inline_rename.wybe" +target triple ???? - - - -declare external ccc void @putchar(i8) - - -declare external ccc void @print_int(i64) +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"inline_rename.<0>"() { -entry: - %0 = tail call fastcc i64 @"inline_rename.eq<0>"(i64 0) - tail call ccc void @print_int(i64 %0) - tail call ccc void @putchar(i8 10) - tail call ccc void @print_int(i64 %0) - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"inline_rename.<0>"() { + %"b##0" = tail call fastcc i64 @"inline_rename.eq<0>"(i64 0) + call ccc void @print_int(i64 %"b##0") + call ccc void @putchar(i8 10) + call ccc void @print_int(i64 %"b##0") + call ccc void @putchar(i8 10) + ret void } - -define external fastcc i64 @"inline_rename.eq<0>"(i64 %"x##0") noinline { -entry: - ret i64 %"x##0" +define external fastcc i64 @"inline_rename.eq<0>"(i64 %"x##0") { + ret i64 %"x##0" } - -define external fastcc i64 @"inline_rename.foo<0>"() alwaysinline { -entry: - %0 = tail call fastcc i64 @"inline_rename.eq<0>"(i64 0) - tail call ccc void @print_int(i64 %0) - tail call ccc void @putchar(i8 10) - ret i64 %0 +define external fastcc i64 @"inline_rename.foo<0>"() { + %"tmp#4##0" = tail call fastcc i64 @"inline_rename.eq<0>"(i64 0) + call ccc void @print_int(i64 %"tmp#4##0") + call ccc void @putchar(i8 10) + ret i64 %"tmp#4##0" } diff --git a/test-cases/final-dump/int_list.exp b/test-cases/final-dump/int_list.exp index 5ac11a480..7473e0451 100644 --- a/test-cases/final-dump/int_list.exp +++ b/test-cases/final-dump/int_list.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module int_list representation : (not a type) public submods : int_list -> int_list.int_list @@ -74,84 +77,71 @@ println(x##0:int_list.int_list)<{<>}; {<>}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'int_list' - - - - -declare external ccc void @putchar(i8) - - -declare external ccc void @print_int(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"int_list.<0>"() { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 3, i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 0, i64* %5 - %6 = trunc i64 16 to i32 - %7 = tail call ccc i8* @wybe_malloc(i32 %6) - %8 = ptrtoint i8* %7 to i64 - %9 = inttoptr i64 %8 to i64* - store i64 2, i64* %9 - %10 = add i64 %8, 8 - %11 = inttoptr i64 %10 to i64* - store i64 %2, i64* %11 - %12 = trunc i64 16 to i32 - %13 = tail call ccc i8* @wybe_malloc(i32 %12) - %14 = ptrtoint i8* %13 to i64 - %15 = inttoptr i64 %14 to i64* - store i64 1, i64* %15 - %16 = add i64 %14, 8 - %17 = inttoptr i64 %16 to i64* - store i64 %8, i64* %17 - tail call fastcc void @"int_list.print<0>"(i64 %14) - tail call ccc void @putchar(i8 10) - ret void +source_filename = "!ROOT!/final-dump/int_list.wybe" +target triple ???? + + +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"int_list.<0>"() { + %"tmp#22##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#6##0" = ptrtoint ptr %"tmp#22##0" to i64 + %"tmp#23##0" = inttoptr i64 %"tmp#6##0" to ptr + store i64 3, ptr %"tmp#23##0" + %"tmp#24##0" = add i64 %"tmp#6##0", 8 + %"tmp#25##0" = inttoptr i64 %"tmp#24##0" to ptr + store i64 0, ptr %"tmp#25##0" + %"tmp#26##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#11##0" = ptrtoint ptr %"tmp#26##0" to i64 + %"tmp#27##0" = inttoptr i64 %"tmp#11##0" to ptr + store i64 2, ptr %"tmp#27##0" + %"tmp#28##0" = add i64 %"tmp#11##0", 8 + %"tmp#29##0" = inttoptr i64 %"tmp#28##0" to ptr + store i64 %"tmp#6##0", ptr %"tmp#29##0" + %"tmp#30##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#16##0" = ptrtoint ptr %"tmp#30##0" to i64 + %"tmp#31##0" = inttoptr i64 %"tmp#16##0" to ptr + store i64 1, ptr %"tmp#31##0" + %"tmp#32##0" = add i64 %"tmp#16##0", 8 + %"tmp#33##0" = inttoptr i64 %"tmp#32##0" to ptr + store i64 %"tmp#11##0", ptr %"tmp#33##0" + tail call fastcc void @"int_list.print<0>"(i64 %"tmp#16##0") + call ccc void @putchar(i8 10) + ret void } - -define external fastcc void @"int_list.print<0>"(i64 %"x##0") { -entry: - %0 = icmp ne i64 %"x##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"x##0" to i64* - %2 = load i64, i64* %1 - %3 = add i64 %"x##0", 8 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - tail call ccc void @print_int(i64 %2) - tail call ccc void @putchar(i8 32) - musttail call fastcc void @"int_list.print<0>"(i64 %5) - ret void -if.else: - ret void +define external fastcc void @"int_list.print<0>"(i64 %"x##0") { + %"tmp#2##0" = icmp ne i64 %"x##0", 0 + br i1 %"tmp#2##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#9##0" = inttoptr i64 %"x##0" to ptr + %"h##0" = load i64, ptr %"tmp#9##0" + %"tmp#10##0" = add i64 %"x##0", 8 + %"tmp#11##0" = inttoptr i64 %"tmp#10##0" to ptr + %"t##0" = load i64, ptr %"tmp#11##0" + call ccc void @print_int(i64 %"h##0") + call ccc void @putchar(i8 32) + tail call fastcc void @"int_list.print<0>"(i64 %"t##0") + ret void +if.else.0: + ret void } - -define external fastcc void @"int_list.println<0>"(i64 %"x##0") alwaysinline { -entry: - tail call fastcc void @"int_list.print<0>"(i64 %"x##0") - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"int_list.println<0>"(i64 %"x##0") { + tail call fastcc void @"int_list.print<0>"(i64 %"x##0") + call ccc void @putchar(i8 10) + ret void } + -------------------------------------------------- Module int_list.int_list - representation : address + representation : pointer public submods : public resources: public procs : int_list.int_list.=<0> @@ -310,180 +300,154 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'int_list.int_list' - - - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i1 @"int_list.int_list.=<0>"(i64 %"#left##0", i64 %"#right##0") { -entry: - %0 = icmp ne i64 %"#left##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"#left##0" to i64* - %2 = load i64, i64* %1 - %3 = add i64 %"#left##0", 8 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = icmp ne i64 %"#right##0", 0 - br i1 %6, label %if.then1, label %if.else1 -if.else: - %14 = icmp eq i64 %"#right##0", 0 - ret i1 %14 -if.then1: - %7 = inttoptr i64 %"#right##0" to i64* - %8 = load i64, i64* %7 - %9 = add i64 %"#right##0", 8 - %10 = inttoptr i64 %9 to i64* - %11 = load i64, i64* %10 - %12 = icmp eq i64 %2, %8 - br i1 %12, label %if.then2, label %if.else2 -if.else1: - ret i1 0 -if.then2: - %13 = musttail call fastcc i1 @"int_list.int_list.=<0>"(i64 %5, i64 %11) - ret i1 %13 -if.else2: - ret i1 0 +source_filename = "!ROOT!/final-dump/int_list.wybe" +target triple ???? + + +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc i1 @"int_list.int_list.=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#0##0" = icmp ne i64 %"#left##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#12##0" = inttoptr i64 %"#left##0" to ptr + %"#left#head##0" = load i64, ptr %"tmp#12##0" + %"tmp#13##0" = add i64 %"#left##0", 8 + %"tmp#14##0" = inttoptr i64 %"tmp#13##0" to ptr + %"#left#tail##0" = load i64, ptr %"tmp#14##0" + %"tmp#9##0" = icmp ne i64 %"#right##0", 0 + br i1 %"tmp#9##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#15##0" = inttoptr i64 %"#right##0" to ptr + %"#right#head##0" = load i64, ptr %"tmp#15##0" + %"tmp#16##0" = add i64 %"#right##0", 8 + %"tmp#17##0" = inttoptr i64 %"tmp#16##0" to ptr + %"#right#tail##0" = load i64, ptr %"tmp#17##0" + %"tmp#4##0" = icmp eq i64 %"#left#head##0", %"#right#head##0" + br i1 %"tmp#4##0", label %if.then.2, label %if.else.2 +if.then.2: + %"tmp#18##0" = tail call fastcc i1 @"int_list.int_list.=<0>"(i64 %"#left#tail##0", i64 %"#right#tail##0") + ret i1 %"tmp#18##0" +if.else.2: + ret i1 0 +if.else.1: + ret i1 0 +if.else.0: + %"tmp#19##0" = icmp eq i64 %"#right##0", 0 + ret i1 %"tmp#19##0" } - -define external fastcc i64 @"int_list.int_list.cons<0>"(i64 %"head##0", i64 %"tail##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"head##0", i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"tail##0", i64* %5 - ret i64 %2 +define external fastcc i64 @"int_list.int_list.cons<0>"(i64 %"head##0", i64 %"tail##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 16) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"head##0", ptr %"tmp#1##0" + %"tmp#2##0" = add i64 %"#rec##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"tail##0", ptr %"tmp#3##0" + ret i64 %"#rec##0" } - -define external fastcc {i64, i64, i1} @"int_list.int_list.cons<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#result##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"#result##0" to i64* - %2 = load i64, i64* %1 - %3 = add i64 %"#result##0", 8 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = insertvalue {i64, i64, i1} undef, i64 %2, 0 - %7 = insertvalue {i64, i64, i1} %6, i64 %5, 1 - %8 = insertvalue {i64, i64, i1} %7, i1 1, 2 - ret {i64, i64, i1} %8 -if.else: - %9 = insertvalue {i64, i64, i1} undef, i64 undef, 0 - %10 = insertvalue {i64, i64, i1} %9, i64 undef, 1 - %11 = insertvalue {i64, i64, i1} %10, i1 0, 2 - ret {i64, i64, i1} %11 +define external fastcc {i64, i64, i1} @"int_list.int_list.cons<1>"(i64 %"#result##0") { + %"tmp#0##0" = icmp ne i64 %"#result##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = inttoptr i64 %"#result##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + %"tmp#3##0" = add i64 %"#result##0", 8 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#4##0" + %"tmp#6##0" = insertvalue {i64, i64, i1} undef, i64 %"tmp#2##0", 0 + %"tmp#7##0" = insertvalue {i64, i64, i1} %"tmp#6##0", i64 %"tmp#5##0", 1 + %"tmp#8##0" = insertvalue {i64, i64, i1} %"tmp#7##0", i1 1, 2 + ret {i64, i64, i1} %"tmp#8##0" +if.else.0: + %"tmp#9##0" = insertvalue {i64, i64, i1} undef, i64 undef, 0 + %"tmp#10##0" = insertvalue {i64, i64, i1} %"tmp#9##0", i64 undef, 1 + %"tmp#11##0" = insertvalue {i64, i64, i1} %"tmp#10##0", i1 0, 2 + ret {i64, i64, i1} %"tmp#11##0" } - -define external fastcc {i64, i1} @"int_list.int_list.head<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"#rec##0" to i64* - %2 = load i64, i64* %1 - %3 = insertvalue {i64, i1} undef, i64 %2, 0 - %4 = insertvalue {i64, i1} %3, i1 1, 1 - ret {i64, i1} %4 -if.else: - %5 = insertvalue {i64, i1} undef, i64 undef, 0 - %6 = insertvalue {i64, i1} %5, i1 0, 1 - ret {i64, i1} %6 +define external fastcc {i64, i1} @"int_list.int_list.head<0>"(i64 %"#rec##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + %"tmp#3##0" = insertvalue {i64, i1} undef, i64 %"tmp#2##0", 0 + %"tmp#4##0" = insertvalue {i64, i1} %"tmp#3##0", i1 1, 1 + ret {i64, i1} %"tmp#4##0" +if.else.0: + %"tmp#5##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#6##0" = insertvalue {i64, i1} %"tmp#5##0", i1 0, 1 + ret {i64, i1} %"tmp#6##0" } - -define external fastcc {i64, i1} @"int_list.int_list.head<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = trunc i64 16 to i32 - %2 = tail call ccc i8* @wybe_malloc(i32 %1) - %3 = ptrtoint i8* %2 to i64 - %4 = inttoptr i64 %3 to i8* - %5 = inttoptr i64 %"#rec##0" to i8* - %6 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %4, i8* %5, i32 %6, i1 0) - %7 = inttoptr i64 %3 to i64* - store i64 %"#field##0", i64* %7 - %8 = insertvalue {i64, i1} undef, i64 %3, 0 - %9 = insertvalue {i64, i1} %8, i1 1, 1 - ret {i64, i1} %9 -if.else: - %10 = insertvalue {i64, i1} undef, i64 0, 0 - %11 = insertvalue {i64, i1} %10, i1 0, 1 - ret {i64, i1} %11 +define external fastcc {i64, i1} @"int_list.int_list.head<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#2##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#2##0", ptr %"tmp#1##0", i64 16, i1 0) + %"tmp#3##0" = ptrtoint ptr %"tmp#2##0" to i64 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 %"#field##0", ptr %"tmp#4##0" + %"tmp#5##0" = insertvalue {i64, i1} undef, i64 %"tmp#3##0", 0 + %"tmp#6##0" = insertvalue {i64, i1} %"tmp#5##0", i1 1, 1 + ret {i64, i1} %"tmp#6##0" +if.else.0: + %"tmp#7##0" = insertvalue {i64, i1} undef, i64 0, 0 + %"tmp#8##0" = insertvalue {i64, i1} %"tmp#7##0", i1 0, 1 + ret {i64, i1} %"tmp#8##0" } - -define external fastcc i64 @"int_list.int_list.nil<0>"() alwaysinline { -entry: - ret i64 0 +define external fastcc i64 @"int_list.int_list.nil<0>"() { + ret i64 0 } - -define external fastcc {i64, i1} @"int_list.int_list.tail<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = add i64 %"#rec##0", 8 - %2 = inttoptr i64 %1 to i64* - %3 = load i64, i64* %2 - %4 = insertvalue {i64, i1} undef, i64 %3, 0 - %5 = insertvalue {i64, i1} %4, i1 1, 1 - ret {i64, i1} %5 -if.else: - %6 = insertvalue {i64, i1} undef, i64 undef, 0 - %7 = insertvalue {i64, i1} %6, i1 0, 1 - ret {i64, i1} %7 +define external fastcc {i64, i1} @"int_list.int_list.tail<0>"(i64 %"#rec##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = add i64 %"#rec##0", 8 + %"tmp#2##0" = inttoptr i64 %"tmp#1##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#2##0" + %"tmp#4##0" = insertvalue {i64, i1} undef, i64 %"tmp#3##0", 0 + %"tmp#5##0" = insertvalue {i64, i1} %"tmp#4##0", i1 1, 1 + ret {i64, i1} %"tmp#5##0" +if.else.0: + %"tmp#6##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#7##0" = insertvalue {i64, i1} %"tmp#6##0", i1 0, 1 + ret {i64, i1} %"tmp#7##0" } - -define external fastcc {i64, i1} @"int_list.int_list.tail<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = trunc i64 16 to i32 - %2 = tail call ccc i8* @wybe_malloc(i32 %1) - %3 = ptrtoint i8* %2 to i64 - %4 = inttoptr i64 %3 to i8* - %5 = inttoptr i64 %"#rec##0" to i8* - %6 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %4, i8* %5, i32 %6, i1 0) - %7 = add i64 %3, 8 - %8 = inttoptr i64 %7 to i64* - store i64 %"#field##0", i64* %8 - %9 = insertvalue {i64, i1} undef, i64 %3, 0 - %10 = insertvalue {i64, i1} %9, i1 1, 1 - ret {i64, i1} %10 -if.else: - %11 = insertvalue {i64, i1} undef, i64 0, 0 - %12 = insertvalue {i64, i1} %11, i1 0, 1 - ret {i64, i1} %12 +define external fastcc {i64, i1} @"int_list.int_list.tail<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#2##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#2##0", ptr %"tmp#1##0", i64 16, i1 0) + %"tmp#3##0" = ptrtoint ptr %"tmp#2##0" to i64 + %"tmp#4##0" = add i64 %"tmp#3##0", 8 + %"tmp#5##0" = inttoptr i64 %"tmp#4##0" to ptr + store i64 %"#field##0", ptr %"tmp#5##0" + %"tmp#6##0" = insertvalue {i64, i1} undef, i64 %"tmp#3##0", 0 + %"tmp#7##0" = insertvalue {i64, i1} %"tmp#6##0", i1 1, 1 + ret {i64, i1} %"tmp#7##0" +if.else.0: + %"tmp#8##0" = insertvalue {i64, i1} undef, i64 0, 0 + %"tmp#9##0" = insertvalue {i64, i1} %"tmp#8##0", i1 0, 1 + ret {i64, i1} %"tmp#9##0" } - -define external fastcc i1 @"int_list.int_list.~=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = tail call fastcc i1 @"int_list.int_list.=<0>"(i64 %"#left##0", i64 %"#right##0") - %1 = xor i1 %0, 1 - ret i1 %1 +define external fastcc i1 @"int_list.int_list.~=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#0##0" = tail call fastcc i1 @"int_list.int_list.=<0>"(i64 %"#left##0", i64 %"#right##0") + %"tmp#1##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#1##0" } diff --git a/test-cases/final-dump/int_sequence.exp b/test-cases/final-dump/int_sequence.exp index ef487aa33..1c159db81 100644 --- a/test-cases/final-dump/int_sequence.exp +++ b/test-cases/final-dump/int_sequence.exp @@ -1,7 +1,10 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module int_sequence - representation : address + representation : pointer public submods : public resources: public procs : int_sequence.<0> @@ -31,7 +34,7 @@ module top-level code > public {semipure} (0 calls) proc #cont#1 > {semipure} (2 calls) -0: int_sequence.#cont#1<0>[410bae77d3] +0: int_sequence.#cont#1<0> #cont#1(tmp#0##0:int_sequence)<{<>}; {<>}; {}>: AliasPairs: [] InterestingCallProperties: [InterestingUnaliased 0] @@ -98,7 +101,7 @@ proc = > public {inline} (1 calls) proc [|] > public (3 calls) -0: int_sequence.[|]<0>[785a827a1b] +0: int_sequence.[|]<0> [|](?head##0:wybe.int, ?tail##0:int_sequence, seq##0:int_sequence, ?#success##0:wybe.bool)<{}; {}; {}>: AliasPairs: [] InterestingCallProperties: [InterestingUnaliased 2] @@ -188,248 +191,208 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'int_sequence' - - - - -declare external ccc void @putchar(i8) - - -declare external ccc void @print_int(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"int_sequence.<0>"() { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 1, i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 10, i64* %5 - tail call fastcc void @"int_sequence.#cont#1<0>[410bae77d3]"(i64 %2) - ret void +source_filename = "!ROOT!/final-dump/int_sequence.wybe" +target triple ???? + + +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"int_sequence.<0>"() { + %"tmp#8##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#6##0" = ptrtoint ptr %"tmp#8##0" to i64 + %"tmp#9##0" = inttoptr i64 %"tmp#6##0" to ptr + store i64 1, ptr %"tmp#9##0" + %"tmp#10##0" = add i64 %"tmp#6##0", 8 + %"tmp#11##0" = inttoptr i64 %"tmp#10##0" to ptr + store i64 10, ptr %"tmp#11##0" + tail call fastcc void @"int_sequence.#cont#1<0>[410bae77d3]"(i64 %"tmp#6##0") + ret void } - -define external fastcc void @"int_sequence.#cont#1<0>"(i64 %"tmp#0##0") { -entry: - %0 = tail call fastcc {i64, i64, i1} @"int_sequence.[|]<0>"(i64 %"tmp#0##0") - %1 = extractvalue {i64, i64, i1} %0, 0 - %2 = extractvalue {i64, i64, i1} %0, 1 - %3 = extractvalue {i64, i64, i1} %0, 2 - br i1 %3, label %if.then, label %if.else -if.then: - tail call ccc void @print_int(i64 %1) - tail call ccc void @putchar(i8 10) - musttail call fastcc void @"int_sequence.#cont#1<0>[410bae77d3]"(i64 %2) - ret void -if.else: - ret void +define external fastcc void @"int_sequence.#cont#1<0>"(i64 %"tmp#0##0") { + %"tmp#8##0" = tail call fastcc {i64, i64, i1} @"int_sequence.[|]<0>"(i64 %"tmp#0##0") + %"i##0" = extractvalue {i64, i64, i1}%"tmp#8##0", 0 + %"tmp#0##1" = extractvalue {i64, i64, i1}%"tmp#8##0", 1 + %"tmp#3##0" = extractvalue {i64, i64, i1}%"tmp#8##0", 2 + br i1 %"tmp#3##0", label %if.then.0, label %if.else.0 +if.then.0: + call ccc void @print_int(i64 %"i##0") + call ccc void @putchar(i8 10) + tail call fastcc void @"int_sequence.#cont#1<0>[410bae77d3]"(i64 %"tmp#0##1") + ret void +if.else.0: + ret void } - -define external fastcc void @"int_sequence.#cont#1<0>[410bae77d3]"(i64 %"tmp#0##0") { -entry: - %0 = tail call fastcc {i64, i64, i1} @"int_sequence.[|]<0>[785a827a1b]"(i64 %"tmp#0##0") - %1 = extractvalue {i64, i64, i1} %0, 0 - %2 = extractvalue {i64, i64, i1} %0, 1 - %3 = extractvalue {i64, i64, i1} %0, 2 - br i1 %3, label %if.then, label %if.else -if.then: - tail call ccc void @print_int(i64 %1) - tail call ccc void @putchar(i8 10) - musttail call fastcc void @"int_sequence.#cont#1<0>[410bae77d3]"(i64 %2) - ret void -if.else: - ret void +define external fastcc void @"int_sequence.#cont#1<0>[410bae77d3]"(i64 %"tmp#0##0") { + %"tmp#8##0" = tail call fastcc {i64, i64, i1} @"int_sequence.[|]<0>[785a827a1b]"(i64 %"tmp#0##0") + %"i##0" = extractvalue {i64, i64, i1}%"tmp#8##0", 0 + %"tmp#0##1" = extractvalue {i64, i64, i1}%"tmp#8##0", 1 + %"tmp#3##0" = extractvalue {i64, i64, i1}%"tmp#8##0", 2 + br i1 %"tmp#3##0", label %if.then.0, label %if.else.0 +if.then.0: + call ccc void @print_int(i64 %"i##0") + call ccc void @putchar(i8 10) + tail call fastcc void @"int_sequence.#cont#1<0>[410bae77d3]"(i64 %"tmp#0##1") + ret void +if.else.0: + ret void } - -define external fastcc i64 @"int_sequence...<0>"(i64 %"lower##0", i64 %"upper##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"lower##0", i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"upper##0", i64* %5 - ret i64 %2 +define external fastcc i64 @"int_sequence...<0>"(i64 %"lower##0", i64 %"upper##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 16) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"lower##0", ptr %"tmp#1##0" + %"tmp#2##0" = add i64 %"#rec##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"upper##0", ptr %"tmp#3##0" + ret i64 %"#rec##0" } - -define external fastcc {i64, i64} @"int_sequence...<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#result##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#result##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = insertvalue {i64, i64} undef, i64 %1, 0 - %6 = insertvalue {i64, i64} %5, i64 %4, 1 - ret {i64, i64} %6 +define external fastcc {i64, i64} @"int_sequence...<1>"(i64 %"#result##0") { + %"tmp#0##0" = inttoptr i64 %"#result##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + %"tmp#2##0" = add i64 %"#result##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#3##0" + %"tmp#5##0" = insertvalue {i64, i64} undef, i64 %"tmp#1##0", 0 + %"tmp#6##0" = insertvalue {i64, i64} %"tmp#5##0", i64 %"tmp#4##0", 1 + ret {i64, i64} %"tmp#6##0" } - -define external fastcc i1 @"int_sequence.=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %"#right##0" to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = icmp eq i64 %1, %6 - br i1 %10, label %if.then, label %if.else -if.then: - %11 = icmp eq i64 %4, %9 - ret i1 %11 -if.else: - ret i1 0 +define external fastcc i1 @"int_sequence.=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#9##0" = inttoptr i64 %"#left##0" to ptr + %"#left#lower##0" = load i64, ptr %"tmp#9##0" + %"tmp#10##0" = add i64 %"#left##0", 8 + %"tmp#11##0" = inttoptr i64 %"tmp#10##0" to ptr + %"#left#upper##0" = load i64, ptr %"tmp#11##0" + %"tmp#12##0" = inttoptr i64 %"#right##0" to ptr + %"#right#lower##0" = load i64, ptr %"tmp#12##0" + %"tmp#13##0" = add i64 %"#right##0", 8 + %"tmp#14##0" = inttoptr i64 %"tmp#13##0" to ptr + %"#right#upper##0" = load i64, ptr %"tmp#14##0" + %"tmp#1##0" = icmp eq i64 %"#left#lower##0", %"#right#lower##0" + br i1 %"tmp#1##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#15##0" = icmp eq i64 %"#left#upper##0", %"#right#upper##0" + ret i1 %"tmp#15##0" +if.else.0: + ret i1 0 } - -define external fastcc {i64, i64, i1} @"int_sequence.[|]<0>"(i64 %"seq##0") { -entry: - %0 = inttoptr i64 %"seq##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"seq##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = icmp sle i64 %1, %4 - br i1 %5, label %if.then, label %if.else -if.then: - %6 = add i64 %1, 1 - %7 = trunc i64 16 to i32 - %8 = tail call ccc i8* @wybe_malloc(i32 %7) - %9 = ptrtoint i8* %8 to i64 - %10 = inttoptr i64 %9 to i64* - store i64 %6, i64* %10 - %11 = add i64 %9, 8 - %12 = inttoptr i64 %11 to i64* - store i64 %4, i64* %12 - %13 = insertvalue {i64, i64, i1} undef, i64 %1, 0 - %14 = insertvalue {i64, i64, i1} %13, i64 %9, 1 - %15 = insertvalue {i64, i64, i1} %14, i1 1, 2 - ret {i64, i64, i1} %15 -if.else: - %16 = insertvalue {i64, i64, i1} undef, i64 undef, 0 - %17 = insertvalue {i64, i64, i1} %16, i64 undef, 1 - %18 = insertvalue {i64, i64, i1} %17, i1 0, 2 - ret {i64, i64, i1} %18 +define external fastcc {i64, i64, i1} @"int_sequence.[|]<0>"(i64 %"seq##0") { + %"tmp#21##0" = inttoptr i64 %"seq##0" to ptr + %"tmp#0##0" = load i64, ptr %"tmp#21##0" + %"tmp#22##0" = add i64 %"seq##0", 8 + %"tmp#23##0" = inttoptr i64 %"tmp#22##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#23##0" + %"tmp#7##0" = icmp sle i64 %"tmp#0##0", %"tmp#1##0" + br i1 %"tmp#7##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#4##0" = add i64 %"tmp#0##0", 1 + %"tmp#24##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#19##0" = ptrtoint ptr %"tmp#24##0" to i64 + %"tmp#25##0" = inttoptr i64 %"tmp#19##0" to ptr + store i64 %"tmp#4##0", ptr %"tmp#25##0" + %"tmp#26##0" = add i64 %"tmp#19##0", 8 + %"tmp#27##0" = inttoptr i64 %"tmp#26##0" to ptr + store i64 %"tmp#1##0", ptr %"tmp#27##0" + %"tmp#28##0" = insertvalue {i64, i64, i1} undef, i64 %"tmp#0##0", 0 + %"tmp#29##0" = insertvalue {i64, i64, i1} %"tmp#28##0", i64 %"tmp#19##0", 1 + %"tmp#30##0" = insertvalue {i64, i64, i1} %"tmp#29##0", i1 1, 2 + ret {i64, i64, i1} %"tmp#30##0" +if.else.0: + %"tmp#31##0" = insertvalue {i64, i64, i1} undef, i64 undef, 0 + %"tmp#32##0" = insertvalue {i64, i64, i1} %"tmp#31##0", i64 undef, 1 + %"tmp#33##0" = insertvalue {i64, i64, i1} %"tmp#32##0", i1 0, 2 + ret {i64, i64, i1} %"tmp#33##0" } - -define external fastcc {i64, i64, i1} @"int_sequence.[|]<0>[785a827a1b]"(i64 %"seq##0") { -entry: - %0 = inttoptr i64 %"seq##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"seq##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = icmp sle i64 %1, %4 - br i1 %5, label %if.then, label %if.else -if.then: - %6 = add i64 %1, 1 - %7 = inttoptr i64 %"seq##0" to i64* - store i64 %6, i64* %7 - %8 = add i64 %"seq##0", 8 - %9 = inttoptr i64 %8 to i64* - store i64 %4, i64* %9 - %10 = insertvalue {i64, i64, i1} undef, i64 %1, 0 - %11 = insertvalue {i64, i64, i1} %10, i64 %"seq##0", 1 - %12 = insertvalue {i64, i64, i1} %11, i1 1, 2 - ret {i64, i64, i1} %12 -if.else: - %13 = insertvalue {i64, i64, i1} undef, i64 undef, 0 - %14 = insertvalue {i64, i64, i1} %13, i64 undef, 1 - %15 = insertvalue {i64, i64, i1} %14, i1 0, 2 - ret {i64, i64, i1} %15 +define external fastcc {i64, i64, i1} @"int_sequence.[|]<0>[785a827a1b]"(i64 %"seq##0") { + %"tmp#21##0" = inttoptr i64 %"seq##0" to ptr + %"tmp#0##0" = load i64, ptr %"tmp#21##0" + %"tmp#22##0" = add i64 %"seq##0", 8 + %"tmp#23##0" = inttoptr i64 %"tmp#22##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#23##0" + %"tmp#7##0" = icmp sle i64 %"tmp#0##0", %"tmp#1##0" + br i1 %"tmp#7##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#4##0" = add i64 %"tmp#0##0", 1 + %"tmp#24##0" = inttoptr i64 %"seq##0" to ptr + store i64 %"tmp#4##0", ptr %"tmp#24##0" + %"tmp#25##0" = add i64 %"seq##0", 8 + %"tmp#26##0" = inttoptr i64 %"tmp#25##0" to ptr + store i64 %"tmp#1##0", ptr %"tmp#26##0" + %"tmp#27##0" = insertvalue {i64, i64, i1} undef, i64 %"tmp#0##0", 0 + %"tmp#28##0" = insertvalue {i64, i64, i1} %"tmp#27##0", i64 %"seq##0", 1 + %"tmp#29##0" = insertvalue {i64, i64, i1} %"tmp#28##0", i1 1, 2 + ret {i64, i64, i1} %"tmp#29##0" +if.else.0: + %"tmp#30##0" = insertvalue {i64, i64, i1} undef, i64 undef, 0 + %"tmp#31##0" = insertvalue {i64, i64, i1} %"tmp#30##0", i64 undef, 1 + %"tmp#32##0" = insertvalue {i64, i64, i1} %"tmp#31##0", i1 0, 2 + ret {i64, i64, i1} %"tmp#32##0" } - -define external fastcc i64 @"int_sequence.lower<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#rec##0" to i64* - %1 = load i64, i64* %0 - ret i64 %1 +define external fastcc i64 @"int_sequence.lower<0>"(i64 %"#rec##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + ret i64 %"tmp#1##0" } - -define external fastcc i64 @"int_sequence.lower<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = inttoptr i64 %2 to i64* - store i64 %"#field##0", i64* %6 - ret i64 %2 +define external fastcc i64 @"int_sequence.lower<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"#field##0", ptr %"tmp#3##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"int_sequence.upper<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = add i64 %"#rec##0", 8 - %1 = inttoptr i64 %0 to i64* - %2 = load i64, i64* %1 - ret i64 %2 +define external fastcc i64 @"int_sequence.upper<0>"(i64 %"#rec##0") { + %"tmp#0##0" = add i64 %"#rec##0", 8 + %"tmp#1##0" = inttoptr i64 %"tmp#0##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"int_sequence.upper<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = add i64 %2, 8 - %7 = inttoptr i64 %6 to i64* - store i64 %"#field##0", i64* %7 - ret i64 %2 +define external fastcc i64 @"int_sequence.upper<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = add i64 %"tmp#2##0", 8 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 %"#field##0", ptr %"tmp#4##0" + ret i64 %"tmp#2##0" } - -define external fastcc i1 @"int_sequence.~=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %"#right##0" to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = icmp eq i64 %1, %6 - br i1 %10, label %if.then, label %if.else -if.then: - %11 = icmp eq i64 %4, %9 - %12 = xor i1 %11, 1 - ret i1 %12 -if.else: - %13 = xor i1 0, 1 - ret i1 %13 +define external fastcc i1 @"int_sequence.~=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#8##0" = inttoptr i64 %"#left##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#8##0" + %"tmp#9##0" = add i64 %"#left##0", 8 + %"tmp#10##0" = inttoptr i64 %"tmp#9##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#10##0" + %"tmp#11##0" = inttoptr i64 %"#right##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#11##0" + %"tmp#12##0" = add i64 %"#right##0", 8 + %"tmp#13##0" = inttoptr i64 %"tmp#12##0" to ptr + %"tmp#6##0" = load i64, ptr %"tmp#13##0" + %"tmp#7##0" = icmp eq i64 %"tmp#3##0", %"tmp#5##0" + br i1 %"tmp#7##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#0##0" = icmp eq i64 %"tmp#4##0", %"tmp#6##0" + %"tmp#14##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#14##0" +if.else.0: + %"tmp#15##0" = xor i1 0, 1 + ret i1 %"tmp#15##0" } diff --git a/test-cases/final-dump/io.exp b/test-cases/final-dump/io.exp index 6c8d8be16..50582bde3 100644 --- a/test-cases/final-dump/io.exp +++ b/test-cases/final-dump/io.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module io representation : (not a type) public submods : @@ -48,45 +51,33 @@ myprint_b(x##0:wybe.int, ?y##0:wybe.int)<{<>}; {<>}; {}> LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'io' +source_filename = "!ROOT!/final-dump/io.wybe" +target triple ???? - - - -declare external ccc void @putchar(i8) - - -declare external ccc void @print_int(i64) +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"io.<0>"() { -entry: - tail call ccc void @print_int(i64 100) - tail call ccc void @putchar(i8 10) - tail call ccc void @print_int(i64 200) - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"io.<0>"() { + call ccc void @print_int(i64 100) + call ccc void @putchar(i8 10) + call ccc void @print_int(i64 200) + call ccc void @putchar(i8 10) + ret void } - -define external fastcc void @"io.myprint_a<0>"(i64 %"x##0") alwaysinline { -entry: - tail call ccc void @print_int(i64 %"x##0") - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"io.myprint_a<0>"(i64 %"x##0") { + call ccc void @print_int(i64 %"x##0") + call ccc void @putchar(i8 10) + ret void } - -define external fastcc i64 @"io.myprint_b<0>"(i64 %"x##0") alwaysinline { -entry: - tail call ccc void @print_int(i64 %"x##0") - tail call ccc void @putchar(i8 10) - ret i64 200 +define external fastcc i64 @"io.myprint_b<0>"(i64 %"x##0") { + call ccc void @print_int(i64 %"x##0") + call ccc void @putchar(i8 10) + ret i64 200 } diff --git a/test-cases/final-dump/io_flow_ok.exp b/test-cases/final-dump/io_flow_ok.exp index ff548d55c..3887d59cf 100644 --- a/test-cases/final-dump/io_flow_ok.exp +++ b/test-cases/final-dump/io_flow_ok.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module io_flow_ok representation : (not a type) public submods : @@ -62,72 +65,48 @@ unknown(?#success##0:wybe.bool)<{}; {}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'io_flow_ok' - - - - -@io_flow_ok.3 = constant {i64, i64} { i64 2, i64 ptrtoint ([?? x i8]* @io_flow_ok.2 to i64) } - - -@io_flow_ok.5 = constant {i64, i64} { i64 11, i64 ptrtoint ([?? x i8]* @io_flow_ok.4 to i64) } - - -@io_flow_ok.1 = constant {i64, i64} { i64 12, i64 ptrtoint ([?? x i8]* @io_flow_ok.0 to i64) } - - -@io_flow_ok.2 = constant [?? x i8] c"OK\00" - - -@io_flow_ok.4 = constant [?? x i8] c"That's odd!\00" - - -@io_flow_ok.0 = constant [?? x i8] c"hello world!\00" - - -declare external ccc void @putchar(i8) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"io_flow_ok.<0>"() { -entry: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @io_flow_ok.1, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - %0 = tail call fastcc i1 @"io_flow_ok.unknown<0>"() - br i1 %0, label %if.then, label %if.else -if.then: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @io_flow_ok.3, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @io_flow_ok.1, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - ret void -if.else: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @io_flow_ok.5, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @io_flow_ok.1, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - ret void +source_filename = "!ROOT!/final-dump/io_flow_ok.wybe" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c"OK\00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c"That's odd!\00", align 8 +@"cstring#2" = private unnamed_addr constant [ ?? x i8 ] c"hello world!\00", align 8 +@"string#3" = private unnamed_addr constant {i64, i64} { i64 2, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +@"string#4" = private unnamed_addr constant {i64, i64} { i64 11, i64 ptrtoint( ptr @"cstring#1" to i64 ) }, align 8 +@"string#5" = private unnamed_addr constant {i64, i64} { i64 12, i64 ptrtoint( ptr @"cstring#2" to i64 ) }, align 8 + +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"io_flow_ok.<0>"() { + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#5" to i64 )) + call ccc void @putchar(i8 10) + %"tmp#0##0" = tail call fastcc i1 @"io_flow_ok.unknown<0>"() + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#3" to i64 )) + call ccc void @putchar(i8 10) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#5" to i64 )) + call ccc void @putchar(i8 10) + ret void +if.else.0: + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#4" to i64 )) + call ccc void @putchar(i8 10) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#5" to i64 )) + call ccc void @putchar(i8 10) + ret void } - -define external fastcc void @"io_flow_ok.aok<0>"() alwaysinline { -entry: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @io_flow_ok.1, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"io_flow_ok.aok<0>"() { + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#5" to i64 )) + call ccc void @putchar(i8 10) + ret void } - -define external fastcc i1 @"io_flow_ok.unknown<0>"() noinline { -entry: - ret i1 1 +define external fastcc i1 @"io_flow_ok.unknown<0>"() { + ret i1 1 } diff --git a/test-cases/final-dump/list_loop.exp b/test-cases/final-dump/list_loop.exp index 974080ddf..de57ede89 100644 --- a/test-cases/final-dump/list_loop.exp +++ b/test-cases/final-dump/list_loop.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module list_loop representation : (not a type) public submods : intlist -> list_loop.intlist @@ -113,134 +116,107 @@ proc #cont#4 > {inline,semipure} (1 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'list_loop' - - - - -@list_loop.3 = constant {i64, i64} { i64 1, i64 ptrtoint ([?? x i8]* @list_loop.2 to i64) } - - -@list_loop.1 = constant {i64, i64} { i64 4, i64 ptrtoint ([?? x i8]* @list_loop.0 to i64) } - - -@list_loop.2 = constant [?? x i8] c" \00" - - -@list_loop.0 = constant [?? x i8] c" \00" - - -declare external ccc void @putchar(i8) - - -declare external ccc void @print_int(i64) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"list_loop.<0>"() { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 3, i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 0, i64* %5 - %6 = trunc i64 16 to i32 - %7 = tail call ccc i8* @wybe_malloc(i32 %6) - %8 = ptrtoint i8* %7 to i64 - %9 = inttoptr i64 %8 to i64* - store i64 2, i64* %9 - %10 = add i64 %8, 8 - %11 = inttoptr i64 %10 to i64* - store i64 %2, i64* %11 - %12 = trunc i64 16 to i32 - %13 = tail call ccc i8* @wybe_malloc(i32 %12) - %14 = ptrtoint i8* %13 to i64 - %15 = inttoptr i64 %14 to i64* - store i64 1, i64* %15 - %16 = add i64 %14, 8 - %17 = inttoptr i64 %16 to i64* - store i64 %8, i64* %17 - tail call fastcc void @"list_loop.#cont#1<0>"(i64 %14, i64 %14) - ret void +source_filename = "!ROOT!/final-dump/list_loop.wybe" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c" \00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c" \00", align 8 +@"string#2" = private unnamed_addr constant {i64, i64} { i64 1, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +@"string#3" = private unnamed_addr constant {i64, i64} { i64 4, i64 ptrtoint( ptr @"cstring#1" to i64 ) }, align 8 + +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"list_loop.<0>"() { + %"tmp#23##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#10##0" = ptrtoint ptr %"tmp#23##0" to i64 + %"tmp#24##0" = inttoptr i64 %"tmp#10##0" to ptr + store i64 3, ptr %"tmp#24##0" + %"tmp#25##0" = add i64 %"tmp#10##0", 8 + %"tmp#26##0" = inttoptr i64 %"tmp#25##0" to ptr + store i64 0, ptr %"tmp#26##0" + %"tmp#27##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#15##0" = ptrtoint ptr %"tmp#27##0" to i64 + %"tmp#28##0" = inttoptr i64 %"tmp#15##0" to ptr + store i64 2, ptr %"tmp#28##0" + %"tmp#29##0" = add i64 %"tmp#15##0", 8 + %"tmp#30##0" = inttoptr i64 %"tmp#29##0" to ptr + store i64 %"tmp#10##0", ptr %"tmp#30##0" + %"tmp#31##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#20##0" = ptrtoint ptr %"tmp#31##0" to i64 + %"tmp#32##0" = inttoptr i64 %"tmp#20##0" to ptr + store i64 1, ptr %"tmp#32##0" + %"tmp#33##0" = add i64 %"tmp#20##0", 8 + %"tmp#34##0" = inttoptr i64 %"tmp#33##0" to ptr + store i64 %"tmp#15##0", ptr %"tmp#34##0" + tail call fastcc void @"list_loop.#cont#1<0>"(i64 %"tmp#20##0", i64 %"tmp#20##0") + ret void } - -define external fastcc void @"list_loop.#cont#1<0>"(i64 %"l##0", i64 %"x##0") { -entry: - %0 = icmp ne i64 %"l##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"l##0" to i64* - %2 = load i64, i64* %1 - %3 = add i64 %"l##0", 8 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - tail call ccc void @print_int(i64 %2) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"list_loop.#cont#3<0>"(i64 %2, i64 %5, i64 %"x##0", i64 %"x##0") - ret void -if.else: - ret void +define external fastcc void @"list_loop.#cont#1<0>"(i64 %"l##0", i64 %"x##0") { + %"tmp#9##0" = icmp ne i64 %"l##0", 0 + br i1 %"tmp#9##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#16##0" = inttoptr i64 %"l##0" to ptr + %"h##0" = load i64, ptr %"tmp#16##0" + %"tmp#17##0" = add i64 %"l##0", 8 + %"tmp#18##0" = inttoptr i64 %"tmp#17##0" to ptr + %"l##1" = load i64, ptr %"tmp#18##0" + call ccc void @print_int(i64 %"h##0") + call ccc void @putchar(i8 10) + tail call fastcc void @"list_loop.#cont#3<0>"(i64 %"h##0", i64 %"l##1", i64 %"x##0", i64 %"x##0") + ret void +if.else.0: + ret void } - -define external fastcc void @"list_loop.#cont#2<0>"(i64 %"h##0", i64 %"l##0", i64 %"x##0") alwaysinline { -entry: - tail call ccc void @print_int(i64 %"h##0") - tail call ccc void @putchar(i8 10) - tail call fastcc void @"list_loop.#cont#3<0>"(i64 %"h##0", i64 %"l##0", i64 %"x##0", i64 %"x##0") - ret void +define external fastcc void @"list_loop.#cont#2<0>"(i64 %"h##0", i64 %"l##0", i64 %"x##0") { + call ccc void @print_int(i64 %"h##0") + call ccc void @putchar(i8 10) + tail call fastcc void @"list_loop.#cont#3<0>"(i64 %"h##0", i64 %"l##0", i64 %"x##0", i64 %"x##0") + ret void } - -define external fastcc void @"list_loop.#cont#3<0>"(i64 %"h##0", i64 %"l##0", i64 %"l2##0", i64 %"x##0") { -entry: - %0 = icmp ne i64 %"l2##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"l2##0" to i64* - %2 = load i64, i64* %1 - %3 = add i64 %"l2##0", 8 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @list_loop.1, i32 0, i32 0) to i64)) - tail call ccc void @print_int(i64 %"h##0") - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @list_loop.3, i32 0, i32 0) to i64)) - tail call ccc void @print_int(i64 %2) - tail call ccc void @putchar(i8 10) - musttail call fastcc void @"list_loop.#cont#3<0>"(i64 %"h##0", i64 %"l##0", i64 %5, i64 %"x##0") - ret void -if.else: - tail call fastcc void @"list_loop.#cont#1<0>"(i64 %"l##0", i64 %"x##0") - ret void +define external fastcc void @"list_loop.#cont#3<0>"(i64 %"h##0", i64 %"l##0", i64 %"l2##0", i64 %"x##0") { + %"tmp#8##0" = icmp ne i64 %"l2##0", 0 + br i1 %"tmp#8##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#19##0" = inttoptr i64 %"l2##0" to ptr + %"h2##0" = load i64, ptr %"tmp#19##0" + %"tmp#20##0" = add i64 %"l2##0", 8 + %"tmp#21##0" = inttoptr i64 %"tmp#20##0" to ptr + %"l2##1" = load i64, ptr %"tmp#21##0" + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#3" to i64 )) + call ccc void @print_int(i64 %"h##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#2" to i64 )) + call ccc void @print_int(i64 %"h2##0") + call ccc void @putchar(i8 10) + tail call fastcc void @"list_loop.#cont#3<0>"(i64 %"h##0", i64 %"l##0", i64 %"l2##1", i64 %"x##0") + ret void +if.else.0: + tail call fastcc void @"list_loop.#cont#1<0>"(i64 %"l##0", i64 %"x##0") + ret void } - -define external fastcc void @"list_loop.#cont#4<0>"(i64 %"h##0", i64 %"h2##0", i64 %"l##0", i64 %"l2##0", i64 %"x##0") alwaysinline { -entry: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @list_loop.1, i32 0, i32 0) to i64)) - tail call ccc void @print_int(i64 %"h##0") - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @list_loop.3, i32 0, i32 0) to i64)) - tail call ccc void @print_int(i64 %"h2##0") - tail call ccc void @putchar(i8 10) - tail call fastcc void @"list_loop.#cont#3<0>"(i64 %"h##0", i64 %"l##0", i64 %"l2##0", i64 %"x##0") - ret void +define external fastcc void @"list_loop.#cont#4<0>"(i64 %"h##0", i64 %"h2##0", i64 %"l##0", i64 %"l2##0", i64 %"x##0") { + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#3" to i64 )) + call ccc void @print_int(i64 %"h##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#2" to i64 )) + call ccc void @print_int(i64 %"h2##0") + call ccc void @putchar(i8 10) + tail call fastcc void @"list_loop.#cont#3<0>"(i64 %"h##0", i64 %"l##0", i64 %"l2##0", i64 %"x##0") + ret void } + -------------------------------------------------- Module list_loop.intlist - representation : address + representation : pointer public submods : public resources: public procs : list_loop.intlist.=<0> @@ -399,180 +375,154 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'list_loop.intlist' - - - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i1 @"list_loop.intlist.=<0>"(i64 %"#left##0", i64 %"#right##0") { -entry: - %0 = icmp ne i64 %"#left##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"#left##0" to i64* - %2 = load i64, i64* %1 - %3 = add i64 %"#left##0", 8 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = icmp ne i64 %"#right##0", 0 - br i1 %6, label %if.then1, label %if.else1 -if.else: - %14 = icmp eq i64 %"#right##0", 0 - ret i1 %14 -if.then1: - %7 = inttoptr i64 %"#right##0" to i64* - %8 = load i64, i64* %7 - %9 = add i64 %"#right##0", 8 - %10 = inttoptr i64 %9 to i64* - %11 = load i64, i64* %10 - %12 = icmp eq i64 %2, %8 - br i1 %12, label %if.then2, label %if.else2 -if.else1: - ret i1 0 -if.then2: - %13 = musttail call fastcc i1 @"list_loop.intlist.=<0>"(i64 %5, i64 %11) - ret i1 %13 -if.else2: - ret i1 0 +source_filename = "!ROOT!/final-dump/list_loop.wybe" +target triple ???? + + +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc i1 @"list_loop.intlist.=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#0##0" = icmp ne i64 %"#left##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#12##0" = inttoptr i64 %"#left##0" to ptr + %"#left#head##0" = load i64, ptr %"tmp#12##0" + %"tmp#13##0" = add i64 %"#left##0", 8 + %"tmp#14##0" = inttoptr i64 %"tmp#13##0" to ptr + %"#left#tail##0" = load i64, ptr %"tmp#14##0" + %"tmp#9##0" = icmp ne i64 %"#right##0", 0 + br i1 %"tmp#9##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#15##0" = inttoptr i64 %"#right##0" to ptr + %"#right#head##0" = load i64, ptr %"tmp#15##0" + %"tmp#16##0" = add i64 %"#right##0", 8 + %"tmp#17##0" = inttoptr i64 %"tmp#16##0" to ptr + %"#right#tail##0" = load i64, ptr %"tmp#17##0" + %"tmp#4##0" = icmp eq i64 %"#left#head##0", %"#right#head##0" + br i1 %"tmp#4##0", label %if.then.2, label %if.else.2 +if.then.2: + %"tmp#18##0" = tail call fastcc i1 @"list_loop.intlist.=<0>"(i64 %"#left#tail##0", i64 %"#right#tail##0") + ret i1 %"tmp#18##0" +if.else.2: + ret i1 0 +if.else.1: + ret i1 0 +if.else.0: + %"tmp#19##0" = icmp eq i64 %"#right##0", 0 + ret i1 %"tmp#19##0" } - -define external fastcc i64 @"list_loop.intlist.cons<0>"(i64 %"head##0", i64 %"tail##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"head##0", i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"tail##0", i64* %5 - ret i64 %2 +define external fastcc i64 @"list_loop.intlist.cons<0>"(i64 %"head##0", i64 %"tail##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 16) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"head##0", ptr %"tmp#1##0" + %"tmp#2##0" = add i64 %"#rec##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"tail##0", ptr %"tmp#3##0" + ret i64 %"#rec##0" } - -define external fastcc {i64, i64, i1} @"list_loop.intlist.cons<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#result##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"#result##0" to i64* - %2 = load i64, i64* %1 - %3 = add i64 %"#result##0", 8 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = insertvalue {i64, i64, i1} undef, i64 %2, 0 - %7 = insertvalue {i64, i64, i1} %6, i64 %5, 1 - %8 = insertvalue {i64, i64, i1} %7, i1 1, 2 - ret {i64, i64, i1} %8 -if.else: - %9 = insertvalue {i64, i64, i1} undef, i64 undef, 0 - %10 = insertvalue {i64, i64, i1} %9, i64 undef, 1 - %11 = insertvalue {i64, i64, i1} %10, i1 0, 2 - ret {i64, i64, i1} %11 +define external fastcc {i64, i64, i1} @"list_loop.intlist.cons<1>"(i64 %"#result##0") { + %"tmp#0##0" = icmp ne i64 %"#result##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = inttoptr i64 %"#result##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + %"tmp#3##0" = add i64 %"#result##0", 8 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#4##0" + %"tmp#6##0" = insertvalue {i64, i64, i1} undef, i64 %"tmp#2##0", 0 + %"tmp#7##0" = insertvalue {i64, i64, i1} %"tmp#6##0", i64 %"tmp#5##0", 1 + %"tmp#8##0" = insertvalue {i64, i64, i1} %"tmp#7##0", i1 1, 2 + ret {i64, i64, i1} %"tmp#8##0" +if.else.0: + %"tmp#9##0" = insertvalue {i64, i64, i1} undef, i64 undef, 0 + %"tmp#10##0" = insertvalue {i64, i64, i1} %"tmp#9##0", i64 undef, 1 + %"tmp#11##0" = insertvalue {i64, i64, i1} %"tmp#10##0", i1 0, 2 + ret {i64, i64, i1} %"tmp#11##0" } - -define external fastcc {i64, i1} @"list_loop.intlist.head<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"#rec##0" to i64* - %2 = load i64, i64* %1 - %3 = insertvalue {i64, i1} undef, i64 %2, 0 - %4 = insertvalue {i64, i1} %3, i1 1, 1 - ret {i64, i1} %4 -if.else: - %5 = insertvalue {i64, i1} undef, i64 undef, 0 - %6 = insertvalue {i64, i1} %5, i1 0, 1 - ret {i64, i1} %6 +define external fastcc {i64, i1} @"list_loop.intlist.head<0>"(i64 %"#rec##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + %"tmp#3##0" = insertvalue {i64, i1} undef, i64 %"tmp#2##0", 0 + %"tmp#4##0" = insertvalue {i64, i1} %"tmp#3##0", i1 1, 1 + ret {i64, i1} %"tmp#4##0" +if.else.0: + %"tmp#5##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#6##0" = insertvalue {i64, i1} %"tmp#5##0", i1 0, 1 + ret {i64, i1} %"tmp#6##0" } - -define external fastcc {i64, i1} @"list_loop.intlist.head<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = trunc i64 16 to i32 - %2 = tail call ccc i8* @wybe_malloc(i32 %1) - %3 = ptrtoint i8* %2 to i64 - %4 = inttoptr i64 %3 to i8* - %5 = inttoptr i64 %"#rec##0" to i8* - %6 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %4, i8* %5, i32 %6, i1 0) - %7 = inttoptr i64 %3 to i64* - store i64 %"#field##0", i64* %7 - %8 = insertvalue {i64, i1} undef, i64 %3, 0 - %9 = insertvalue {i64, i1} %8, i1 1, 1 - ret {i64, i1} %9 -if.else: - %10 = insertvalue {i64, i1} undef, i64 0, 0 - %11 = insertvalue {i64, i1} %10, i1 0, 1 - ret {i64, i1} %11 +define external fastcc {i64, i1} @"list_loop.intlist.head<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#2##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#2##0", ptr %"tmp#1##0", i64 16, i1 0) + %"tmp#3##0" = ptrtoint ptr %"tmp#2##0" to i64 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 %"#field##0", ptr %"tmp#4##0" + %"tmp#5##0" = insertvalue {i64, i1} undef, i64 %"tmp#3##0", 0 + %"tmp#6##0" = insertvalue {i64, i1} %"tmp#5##0", i1 1, 1 + ret {i64, i1} %"tmp#6##0" +if.else.0: + %"tmp#7##0" = insertvalue {i64, i1} undef, i64 0, 0 + %"tmp#8##0" = insertvalue {i64, i1} %"tmp#7##0", i1 0, 1 + ret {i64, i1} %"tmp#8##0" } - -define external fastcc i64 @"list_loop.intlist.nil<0>"() alwaysinline { -entry: - ret i64 0 +define external fastcc i64 @"list_loop.intlist.nil<0>"() { + ret i64 0 } - -define external fastcc {i64, i1} @"list_loop.intlist.tail<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = add i64 %"#rec##0", 8 - %2 = inttoptr i64 %1 to i64* - %3 = load i64, i64* %2 - %4 = insertvalue {i64, i1} undef, i64 %3, 0 - %5 = insertvalue {i64, i1} %4, i1 1, 1 - ret {i64, i1} %5 -if.else: - %6 = insertvalue {i64, i1} undef, i64 undef, 0 - %7 = insertvalue {i64, i1} %6, i1 0, 1 - ret {i64, i1} %7 +define external fastcc {i64, i1} @"list_loop.intlist.tail<0>"(i64 %"#rec##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = add i64 %"#rec##0", 8 + %"tmp#2##0" = inttoptr i64 %"tmp#1##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#2##0" + %"tmp#4##0" = insertvalue {i64, i1} undef, i64 %"tmp#3##0", 0 + %"tmp#5##0" = insertvalue {i64, i1} %"tmp#4##0", i1 1, 1 + ret {i64, i1} %"tmp#5##0" +if.else.0: + %"tmp#6##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#7##0" = insertvalue {i64, i1} %"tmp#6##0", i1 0, 1 + ret {i64, i1} %"tmp#7##0" } - -define external fastcc {i64, i1} @"list_loop.intlist.tail<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = trunc i64 16 to i32 - %2 = tail call ccc i8* @wybe_malloc(i32 %1) - %3 = ptrtoint i8* %2 to i64 - %4 = inttoptr i64 %3 to i8* - %5 = inttoptr i64 %"#rec##0" to i8* - %6 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %4, i8* %5, i32 %6, i1 0) - %7 = add i64 %3, 8 - %8 = inttoptr i64 %7 to i64* - store i64 %"#field##0", i64* %8 - %9 = insertvalue {i64, i1} undef, i64 %3, 0 - %10 = insertvalue {i64, i1} %9, i1 1, 1 - ret {i64, i1} %10 -if.else: - %11 = insertvalue {i64, i1} undef, i64 0, 0 - %12 = insertvalue {i64, i1} %11, i1 0, 1 - ret {i64, i1} %12 +define external fastcc {i64, i1} @"list_loop.intlist.tail<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#2##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#2##0", ptr %"tmp#1##0", i64 16, i1 0) + %"tmp#3##0" = ptrtoint ptr %"tmp#2##0" to i64 + %"tmp#4##0" = add i64 %"tmp#3##0", 8 + %"tmp#5##0" = inttoptr i64 %"tmp#4##0" to ptr + store i64 %"#field##0", ptr %"tmp#5##0" + %"tmp#6##0" = insertvalue {i64, i1} undef, i64 %"tmp#3##0", 0 + %"tmp#7##0" = insertvalue {i64, i1} %"tmp#6##0", i1 1, 1 + ret {i64, i1} %"tmp#7##0" +if.else.0: + %"tmp#8##0" = insertvalue {i64, i1} undef, i64 0, 0 + %"tmp#9##0" = insertvalue {i64, i1} %"tmp#8##0", i1 0, 1 + ret {i64, i1} %"tmp#9##0" } - -define external fastcc i1 @"list_loop.intlist.~=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = tail call fastcc i1 @"list_loop.intlist.=<0>"(i64 %"#left##0", i64 %"#right##0") - %1 = xor i1 %0, 1 - ret i1 %1 +define external fastcc i1 @"list_loop.intlist.~=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#0##0" = tail call fastcc i1 @"list_loop.intlist.=<0>"(i64 %"#left##0", i64 %"#right##0") + %"tmp#1##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#1##0" } diff --git a/test-cases/final-dump/list_this.exp b/test-cases/final-dump/list_this.exp index 38d7815b0..5b5ce36e0 100644 --- a/test-cases/final-dump/list_this.exp +++ b/test-cases/final-dump/list_this.exp @@ -1,7 +1,10 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module list_this(T) - representation : address + representation : pointer public submods : public resources: public procs : list_this.append<0> @@ -163,188 +166,159 @@ nil(?#result##0:list_this(T))<{}; {}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'list_this' - - - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"list_this.append<0>"(i64 %"x##0", i64 %"y##0", i64* %"#result##0") { -entry: - %0 = icmp ne i64 %"x##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"x##0" to i64* - %2 = load i64, i64* %1 - %3 = add i64 %"x##0", 8 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = trunc i64 16 to i32 - %7 = tail call ccc i8* @wybe_malloc(i32 %6) - %8 = ptrtoint i8* %7 to i64 - %9 = inttoptr i64 %8 to i64* - store i64 %2, i64* %9 - %10 = add i64 %8, 8 - %11 = inttoptr i64 %10 to i64* - store i64 %8, i64* %"#result##0" - musttail call fastcc void @"list_this.append<0>"(i64 %5, i64 %"y##0", i64* %11) - ret void -if.else: - store i64 %"y##0", i64* %"#result##0" - ret void +source_filename = "!ROOT!/final-dump/list_this.wybe" +target triple ???? + + +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"list_this.append<0>"(i64 %"x##0", i64 %"y##0", ptr %"tmp#10##0") { + %"tmp#5##0" = icmp ne i64 %"x##0", 0 + br i1 %"tmp#5##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#11##0" = inttoptr i64 %"x##0" to ptr + %"h##0" = load i64, ptr %"tmp#11##0" + %"tmp#12##0" = add i64 %"x##0", 8 + %"tmp#13##0" = inttoptr i64 %"tmp#12##0" to ptr + %"t##0" = load i64, ptr %"tmp#13##0" + %"tmp#14##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#8##0" = ptrtoint ptr %"tmp#14##0" to i64 + %"tmp#15##0" = inttoptr i64 %"tmp#8##0" to ptr + store i64 %"h##0", ptr %"tmp#15##0" + store i64 %"tmp#8##0", ptr %"tmp#10##0" + %"tmp#16##0" = add i64 %"tmp#8##0", 8 + %"tmp#17##0" = inttoptr i64 %"tmp#16##0" to ptr + musttail call fastcc void @"list_this.append<0>"(i64 %"t##0", i64 %"y##0", ptr %"tmp#17##0") + ret void +if.else.0: + store i64 %"y##0", ptr %"tmp#10##0" + ret void } - -define external fastcc {i64, i1} @"list_this.car<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"#rec##0" to i64* - %2 = load i64, i64* %1 - %3 = insertvalue {i64, i1} undef, i64 %2, 0 - %4 = insertvalue {i64, i1} %3, i1 1, 1 - ret {i64, i1} %4 -if.else: - %5 = insertvalue {i64, i1} undef, i64 undef, 0 - %6 = insertvalue {i64, i1} %5, i1 0, 1 - ret {i64, i1} %6 +define external fastcc {i64, i1} @"list_this.car<0>"(i64 %"#rec##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + %"tmp#3##0" = insertvalue {i64, i1} undef, i64 %"tmp#2##0", 0 + %"tmp#4##0" = insertvalue {i64, i1} %"tmp#3##0", i1 1, 1 + ret {i64, i1} %"tmp#4##0" +if.else.0: + %"tmp#5##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#6##0" = insertvalue {i64, i1} %"tmp#5##0", i1 0, 1 + ret {i64, i1} %"tmp#6##0" } - -define external fastcc {i64, i1} @"list_this.car<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = trunc i64 16 to i32 - %2 = tail call ccc i8* @wybe_malloc(i32 %1) - %3 = ptrtoint i8* %2 to i64 - %4 = inttoptr i64 %3 to i8* - %5 = inttoptr i64 %"#rec##0" to i8* - %6 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %4, i8* %5, i32 %6, i1 0) - %7 = inttoptr i64 %3 to i64* - store i64 %"#field##0", i64* %7 - %8 = insertvalue {i64, i1} undef, i64 %3, 0 - %9 = insertvalue {i64, i1} %8, i1 1, 1 - ret {i64, i1} %9 -if.else: - %10 = insertvalue {i64, i1} undef, i64 0, 0 - %11 = insertvalue {i64, i1} %10, i1 0, 1 - ret {i64, i1} %11 +define external fastcc {i64, i1} @"list_this.car<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#2##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#2##0", ptr %"tmp#1##0", i64 16, i1 0) + %"tmp#3##0" = ptrtoint ptr %"tmp#2##0" to i64 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 %"#field##0", ptr %"tmp#4##0" + %"tmp#5##0" = insertvalue {i64, i1} undef, i64 %"tmp#3##0", 0 + %"tmp#6##0" = insertvalue {i64, i1} %"tmp#5##0", i1 1, 1 + ret {i64, i1} %"tmp#6##0" +if.else.0: + %"tmp#7##0" = insertvalue {i64, i1} undef, i64 0, 0 + %"tmp#8##0" = insertvalue {i64, i1} %"tmp#7##0", i1 0, 1 + ret {i64, i1} %"tmp#8##0" } - -define external fastcc {i64, i1} @"list_this.cdr<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = add i64 %"#rec##0", 8 - %2 = inttoptr i64 %1 to i64* - %3 = load i64, i64* %2 - %4 = insertvalue {i64, i1} undef, i64 %3, 0 - %5 = insertvalue {i64, i1} %4, i1 1, 1 - ret {i64, i1} %5 -if.else: - %6 = insertvalue {i64, i1} undef, i64 undef, 0 - %7 = insertvalue {i64, i1} %6, i1 0, 1 - ret {i64, i1} %7 +define external fastcc {i64, i1} @"list_this.cdr<0>"(i64 %"#rec##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = add i64 %"#rec##0", 8 + %"tmp#2##0" = inttoptr i64 %"tmp#1##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#2##0" + %"tmp#4##0" = insertvalue {i64, i1} undef, i64 %"tmp#3##0", 0 + %"tmp#5##0" = insertvalue {i64, i1} %"tmp#4##0", i1 1, 1 + ret {i64, i1} %"tmp#5##0" +if.else.0: + %"tmp#6##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#7##0" = insertvalue {i64, i1} %"tmp#6##0", i1 0, 1 + ret {i64, i1} %"tmp#7##0" } - -define external fastcc {i64, i1} @"list_this.cdr<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = trunc i64 16 to i32 - %2 = tail call ccc i8* @wybe_malloc(i32 %1) - %3 = ptrtoint i8* %2 to i64 - %4 = inttoptr i64 %3 to i8* - %5 = inttoptr i64 %"#rec##0" to i8* - %6 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %4, i8* %5, i32 %6, i1 0) - %7 = add i64 %3, 8 - %8 = inttoptr i64 %7 to i64* - store i64 %"#field##0", i64* %8 - %9 = insertvalue {i64, i1} undef, i64 %3, 0 - %10 = insertvalue {i64, i1} %9, i1 1, 1 - ret {i64, i1} %10 -if.else: - %11 = insertvalue {i64, i1} undef, i64 0, 0 - %12 = insertvalue {i64, i1} %11, i1 0, 1 - ret {i64, i1} %12 +define external fastcc {i64, i1} @"list_this.cdr<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#2##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#2##0", ptr %"tmp#1##0", i64 16, i1 0) + %"tmp#3##0" = ptrtoint ptr %"tmp#2##0" to i64 + %"tmp#4##0" = add i64 %"tmp#3##0", 8 + %"tmp#5##0" = inttoptr i64 %"tmp#4##0" to ptr + store i64 %"#field##0", ptr %"tmp#5##0" + %"tmp#6##0" = insertvalue {i64, i1} undef, i64 %"tmp#3##0", 0 + %"tmp#7##0" = insertvalue {i64, i1} %"tmp#6##0", i1 1, 1 + ret {i64, i1} %"tmp#7##0" +if.else.0: + %"tmp#8##0" = insertvalue {i64, i1} undef, i64 0, 0 + %"tmp#9##0" = insertvalue {i64, i1} %"tmp#8##0", i1 0, 1 + ret {i64, i1} %"tmp#9##0" } - -define external fastcc i64 @"list_this.cons<0>"(i64 %"car##0", i64 %"cdr##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"car##0", i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"cdr##0", i64* %5 - ret i64 %2 +define external fastcc i64 @"list_this.cons<0>"(i64 %"car##0", i64 %"cdr##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 16) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"car##0", ptr %"tmp#1##0" + %"tmp#2##0" = add i64 %"#rec##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"cdr##0", ptr %"tmp#3##0" + ret i64 %"#rec##0" } - -define external fastcc {i64, i64, i1} @"list_this.cons<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#result##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"#result##0" to i64* - %2 = load i64, i64* %1 - %3 = add i64 %"#result##0", 8 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = insertvalue {i64, i64, i1} undef, i64 %2, 0 - %7 = insertvalue {i64, i64, i1} %6, i64 %5, 1 - %8 = insertvalue {i64, i64, i1} %7, i1 1, 2 - ret {i64, i64, i1} %8 -if.else: - %9 = insertvalue {i64, i64, i1} undef, i64 undef, 0 - %10 = insertvalue {i64, i64, i1} %9, i64 undef, 1 - %11 = insertvalue {i64, i64, i1} %10, i1 0, 2 - ret {i64, i64, i1} %11 +define external fastcc {i64, i64, i1} @"list_this.cons<1>"(i64 %"#result##0") { + %"tmp#0##0" = icmp ne i64 %"#result##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = inttoptr i64 %"#result##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + %"tmp#3##0" = add i64 %"#result##0", 8 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#4##0" + %"tmp#6##0" = insertvalue {i64, i64, i1} undef, i64 %"tmp#2##0", 0 + %"tmp#7##0" = insertvalue {i64, i64, i1} %"tmp#6##0", i64 %"tmp#5##0", 1 + %"tmp#8##0" = insertvalue {i64, i64, i1} %"tmp#7##0", i1 1, 2 + ret {i64, i64, i1} %"tmp#8##0" +if.else.0: + %"tmp#9##0" = insertvalue {i64, i64, i1} undef, i64 undef, 0 + %"tmp#10##0" = insertvalue {i64, i64, i1} %"tmp#9##0", i64 undef, 1 + %"tmp#11##0" = insertvalue {i64, i64, i1} %"tmp#10##0", i1 0, 2 + ret {i64, i64, i1} %"tmp#11##0" } - -define external fastcc i64 @"list_this.length<0>"(i64 %"x##0") alwaysinline { -entry: - %0 = tail call fastcc i64 @"list_this.length1<0>"(i64 %"x##0", i64 0) - ret i64 %0 +define external fastcc i64 @"list_this.length<0>"(i64 %"x##0") { + %"tmp#1##0" = tail call fastcc i64 @"list_this.length1<0>"(i64 %"x##0", i64 0) + ret i64 %"tmp#1##0" } - -define external fastcc i64 @"list_this.length1<0>"(i64 %"x##0", i64 %"acc##0") { -entry: - %0 = icmp ne i64 %"x##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = add i64 %"x##0", 8 - %2 = inttoptr i64 %1 to i64* - %3 = load i64, i64* %2 - %4 = add i64 %"acc##0", 1 - %5 = musttail call fastcc i64 @"list_this.length1<0>"(i64 %3, i64 %4) - ret i64 %5 -if.else: - ret i64 %"acc##0" +define external fastcc i64 @"list_this.length1<0>"(i64 %"x##0", i64 %"acc##0") { + %"tmp#5##0" = icmp ne i64 %"x##0", 0 + br i1 %"tmp#5##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#8##0" = add i64 %"x##0", 8 + %"tmp#9##0" = inttoptr i64 %"tmp#8##0" to ptr + %"t##0" = load i64, ptr %"tmp#9##0" + %"tmp#2##0" = add i64 %"acc##0", 1 + %"tmp#10##0" = tail call fastcc i64 @"list_this.length1<0>"(i64 %"t##0", i64 %"tmp#2##0") + ret i64 %"tmp#10##0" +if.else.0: + ret i64 %"acc##0" } - -define external fastcc i64 @"list_this.nil<0>"() alwaysinline { -entry: - ret i64 0 +define external fastcc i64 @"list_this.nil<0>"() { + ret i64 0 } diff --git a/test-cases/final-dump/loop_bug.exp b/test-cases/final-dump/loop_bug.exp index 1417de22e..1041420b0 100644 --- a/test-cases/final-dump/loop_bug.exp +++ b/test-cases/final-dump/loop_bug.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module loop_bug representation : (not a type) public submods : int_list -> loop_bug.int_list @@ -58,9 +61,9 @@ print#cont#1([h##0:wybe.int], t##0:loop_bug.int_list)<{<>}; {<(", ":wybe.string)<{<>}; {<>}; {}> #3 @loop_bug:nn:nn - foreign lpvm load(<>:wybe.phantom, ?%tmp#7##0:wybe.phantom) @loop_bug:nn:nn - foreign c print_int(~h##1:wybe.int, ~tmp#7##0:wybe.phantom, ?tmp#8##0:wybe.phantom) @loop_bug:nn:nn - foreign lpvm store(~%tmp#8##0:wybe.phantom, <>:wybe.phantom) @loop_bug:nn:nn + foreign lpvm load(<>:wybe.phantom, ?%tmp#10##0:wybe.phantom) @loop_bug:nn:nn + foreign c print_int(~h##1:wybe.int, ~tmp#10##0:wybe.phantom, ?tmp#11##0:wybe.phantom) @loop_bug:nn:nn + foreign lpvm store(~%tmp#11##0:wybe.phantom, <>:wybe.phantom) @loop_bug:nn:nn loop_bug.print#cont#1<0>(_:wybe.int, ~t##1:loop_bug.int_list)<{<>}; {<>}; {}> #4 @loop_bug:nn:nn @@ -78,83 +81,66 @@ print#cont#2(h##0:wybe.int, t##0:loop_bug.int_list)<{<>}; {<"(i64) - - -declare external ccc void @putchar(i8) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"loop_bug.print<0>"(i64 %"lst##0") { -entry: - tail call ccc void @putchar(i8 91) - %0 = icmp ne i64 %"lst##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"lst##0" to i64* - %2 = load i64, i64* %1 - %3 = add i64 %"lst##0", 8 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - tail call ccc void @print_int(i64 %2) - musttail call fastcc void @"loop_bug.print#cont#1<0>"(i64 %5) - ret void -if.else: - tail call ccc void @putchar(i8 93) - ret void +source_filename = "!ROOT!/final-dump/loop_bug.wybe" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c", \00", align 8 +@"string#1" = private unnamed_addr constant {i64, i64} { i64 2, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 + +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"loop_bug.print<0>"(i64 %"lst##0") { + call ccc void @putchar(i8 91) + %"tmp#8##0" = icmp ne i64 %"lst##0", 0 + br i1 %"tmp#8##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#15##0" = inttoptr i64 %"lst##0" to ptr + %"h##0" = load i64, ptr %"tmp#15##0" + %"tmp#16##0" = add i64 %"lst##0", 8 + %"tmp#17##0" = inttoptr i64 %"tmp#16##0" to ptr + %"t##0" = load i64, ptr %"tmp#17##0" + call ccc void @print_int(i64 %"h##0") + tail call fastcc void @"loop_bug.print#cont#1<0>"(i64 %"t##0") + ret void +if.else.0: + call ccc void @putchar(i8 93) + ret void } - -define external fastcc void @"loop_bug.print#cont#1<0>"(i64 %"t##0") { -entry: - %0 = icmp ne i64 %"t##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"t##0" to i64* - %2 = load i64, i64* %1 - %3 = add i64 %"t##0", 8 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @loop_bug.1, i32 0, i32 0) to i64)) - tail call ccc void @print_int(i64 %2) - musttail call fastcc void @"loop_bug.print#cont#1<0>"(i64 %5) - ret void -if.else: - tail call ccc void @putchar(i8 93) - ret void +define external fastcc void @"loop_bug.print#cont#1<0>"(i64 %"t##0") { + %"tmp#4##0" = icmp ne i64 %"t##0", 0 + br i1 %"tmp#4##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#12##0" = inttoptr i64 %"t##0" to ptr + %"h##1" = load i64, ptr %"tmp#12##0" + %"tmp#13##0" = add i64 %"t##0", 8 + %"tmp#14##0" = inttoptr i64 %"tmp#13##0" to ptr + %"t##1" = load i64, ptr %"tmp#14##0" + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#1" to i64 )) + call ccc void @print_int(i64 %"h##1") + tail call fastcc void @"loop_bug.print#cont#1<0>"(i64 %"t##1") + ret void +if.else.0: + call ccc void @putchar(i8 93) + ret void } - -define external fastcc void @"loop_bug.print#cont#2<0>"(i64 %"h##0", i64 %"t##0") alwaysinline { -entry: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @loop_bug.1, i32 0, i32 0) to i64)) - tail call ccc void @print_int(i64 %"h##0") - tail call fastcc void @"loop_bug.print#cont#1<0>"(i64 %"t##0") - ret void +define external fastcc void @"loop_bug.print#cont#2<0>"(i64 %"h##0", i64 %"t##0") { + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#1" to i64 )) + call ccc void @print_int(i64 %"h##0") + tail call fastcc void @"loop_bug.print#cont#1<0>"(i64 %"t##0") + ret void } + -------------------------------------------------- Module loop_bug.int_list - representation : address + representation : pointer public submods : public resources: public procs : loop_bug.int_list.=<0> @@ -313,180 +299,154 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'loop_bug.int_list' - - - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i1 @"loop_bug.int_list.=<0>"(i64 %"#left##0", i64 %"#right##0") { -entry: - %0 = icmp ne i64 %"#left##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"#left##0" to i64* - %2 = load i64, i64* %1 - %3 = add i64 %"#left##0", 8 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = icmp ne i64 %"#right##0", 0 - br i1 %6, label %if.then1, label %if.else1 -if.else: - %14 = icmp eq i64 %"#right##0", 0 - ret i1 %14 -if.then1: - %7 = inttoptr i64 %"#right##0" to i64* - %8 = load i64, i64* %7 - %9 = add i64 %"#right##0", 8 - %10 = inttoptr i64 %9 to i64* - %11 = load i64, i64* %10 - %12 = icmp eq i64 %2, %8 - br i1 %12, label %if.then2, label %if.else2 -if.else1: - ret i1 0 -if.then2: - %13 = musttail call fastcc i1 @"loop_bug.int_list.=<0>"(i64 %5, i64 %11) - ret i1 %13 -if.else2: - ret i1 0 +source_filename = "!ROOT!/final-dump/loop_bug.wybe" +target triple ???? + + +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc i1 @"loop_bug.int_list.=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#0##0" = icmp ne i64 %"#left##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#12##0" = inttoptr i64 %"#left##0" to ptr + %"#left#head##0" = load i64, ptr %"tmp#12##0" + %"tmp#13##0" = add i64 %"#left##0", 8 + %"tmp#14##0" = inttoptr i64 %"tmp#13##0" to ptr + %"#left#tail##0" = load i64, ptr %"tmp#14##0" + %"tmp#9##0" = icmp ne i64 %"#right##0", 0 + br i1 %"tmp#9##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#15##0" = inttoptr i64 %"#right##0" to ptr + %"#right#head##0" = load i64, ptr %"tmp#15##0" + %"tmp#16##0" = add i64 %"#right##0", 8 + %"tmp#17##0" = inttoptr i64 %"tmp#16##0" to ptr + %"#right#tail##0" = load i64, ptr %"tmp#17##0" + %"tmp#4##0" = icmp eq i64 %"#left#head##0", %"#right#head##0" + br i1 %"tmp#4##0", label %if.then.2, label %if.else.2 +if.then.2: + %"tmp#18##0" = tail call fastcc i1 @"loop_bug.int_list.=<0>"(i64 %"#left#tail##0", i64 %"#right#tail##0") + ret i1 %"tmp#18##0" +if.else.2: + ret i1 0 +if.else.1: + ret i1 0 +if.else.0: + %"tmp#19##0" = icmp eq i64 %"#right##0", 0 + ret i1 %"tmp#19##0" } - -define external fastcc i64 @"loop_bug.int_list.cons<0>"(i64 %"head##0", i64 %"tail##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"head##0", i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"tail##0", i64* %5 - ret i64 %2 +define external fastcc i64 @"loop_bug.int_list.cons<0>"(i64 %"head##0", i64 %"tail##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 16) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"head##0", ptr %"tmp#1##0" + %"tmp#2##0" = add i64 %"#rec##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"tail##0", ptr %"tmp#3##0" + ret i64 %"#rec##0" } - -define external fastcc {i64, i64, i1} @"loop_bug.int_list.cons<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#result##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"#result##0" to i64* - %2 = load i64, i64* %1 - %3 = add i64 %"#result##0", 8 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = insertvalue {i64, i64, i1} undef, i64 %2, 0 - %7 = insertvalue {i64, i64, i1} %6, i64 %5, 1 - %8 = insertvalue {i64, i64, i1} %7, i1 1, 2 - ret {i64, i64, i1} %8 -if.else: - %9 = insertvalue {i64, i64, i1} undef, i64 undef, 0 - %10 = insertvalue {i64, i64, i1} %9, i64 undef, 1 - %11 = insertvalue {i64, i64, i1} %10, i1 0, 2 - ret {i64, i64, i1} %11 +define external fastcc {i64, i64, i1} @"loop_bug.int_list.cons<1>"(i64 %"#result##0") { + %"tmp#0##0" = icmp ne i64 %"#result##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = inttoptr i64 %"#result##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + %"tmp#3##0" = add i64 %"#result##0", 8 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#4##0" + %"tmp#6##0" = insertvalue {i64, i64, i1} undef, i64 %"tmp#2##0", 0 + %"tmp#7##0" = insertvalue {i64, i64, i1} %"tmp#6##0", i64 %"tmp#5##0", 1 + %"tmp#8##0" = insertvalue {i64, i64, i1} %"tmp#7##0", i1 1, 2 + ret {i64, i64, i1} %"tmp#8##0" +if.else.0: + %"tmp#9##0" = insertvalue {i64, i64, i1} undef, i64 undef, 0 + %"tmp#10##0" = insertvalue {i64, i64, i1} %"tmp#9##0", i64 undef, 1 + %"tmp#11##0" = insertvalue {i64, i64, i1} %"tmp#10##0", i1 0, 2 + ret {i64, i64, i1} %"tmp#11##0" } - -define external fastcc {i64, i1} @"loop_bug.int_list.head<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"#rec##0" to i64* - %2 = load i64, i64* %1 - %3 = insertvalue {i64, i1} undef, i64 %2, 0 - %4 = insertvalue {i64, i1} %3, i1 1, 1 - ret {i64, i1} %4 -if.else: - %5 = insertvalue {i64, i1} undef, i64 undef, 0 - %6 = insertvalue {i64, i1} %5, i1 0, 1 - ret {i64, i1} %6 +define external fastcc {i64, i1} @"loop_bug.int_list.head<0>"(i64 %"#rec##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + %"tmp#3##0" = insertvalue {i64, i1} undef, i64 %"tmp#2##0", 0 + %"tmp#4##0" = insertvalue {i64, i1} %"tmp#3##0", i1 1, 1 + ret {i64, i1} %"tmp#4##0" +if.else.0: + %"tmp#5##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#6##0" = insertvalue {i64, i1} %"tmp#5##0", i1 0, 1 + ret {i64, i1} %"tmp#6##0" } - -define external fastcc {i64, i1} @"loop_bug.int_list.head<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = trunc i64 16 to i32 - %2 = tail call ccc i8* @wybe_malloc(i32 %1) - %3 = ptrtoint i8* %2 to i64 - %4 = inttoptr i64 %3 to i8* - %5 = inttoptr i64 %"#rec##0" to i8* - %6 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %4, i8* %5, i32 %6, i1 0) - %7 = inttoptr i64 %3 to i64* - store i64 %"#field##0", i64* %7 - %8 = insertvalue {i64, i1} undef, i64 %3, 0 - %9 = insertvalue {i64, i1} %8, i1 1, 1 - ret {i64, i1} %9 -if.else: - %10 = insertvalue {i64, i1} undef, i64 0, 0 - %11 = insertvalue {i64, i1} %10, i1 0, 1 - ret {i64, i1} %11 +define external fastcc {i64, i1} @"loop_bug.int_list.head<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#2##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#2##0", ptr %"tmp#1##0", i64 16, i1 0) + %"tmp#3##0" = ptrtoint ptr %"tmp#2##0" to i64 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 %"#field##0", ptr %"tmp#4##0" + %"tmp#5##0" = insertvalue {i64, i1} undef, i64 %"tmp#3##0", 0 + %"tmp#6##0" = insertvalue {i64, i1} %"tmp#5##0", i1 1, 1 + ret {i64, i1} %"tmp#6##0" +if.else.0: + %"tmp#7##0" = insertvalue {i64, i1} undef, i64 0, 0 + %"tmp#8##0" = insertvalue {i64, i1} %"tmp#7##0", i1 0, 1 + ret {i64, i1} %"tmp#8##0" } - -define external fastcc i64 @"loop_bug.int_list.nil<0>"() alwaysinline { -entry: - ret i64 0 +define external fastcc i64 @"loop_bug.int_list.nil<0>"() { + ret i64 0 } - -define external fastcc {i64, i1} @"loop_bug.int_list.tail<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = add i64 %"#rec##0", 8 - %2 = inttoptr i64 %1 to i64* - %3 = load i64, i64* %2 - %4 = insertvalue {i64, i1} undef, i64 %3, 0 - %5 = insertvalue {i64, i1} %4, i1 1, 1 - ret {i64, i1} %5 -if.else: - %6 = insertvalue {i64, i1} undef, i64 undef, 0 - %7 = insertvalue {i64, i1} %6, i1 0, 1 - ret {i64, i1} %7 +define external fastcc {i64, i1} @"loop_bug.int_list.tail<0>"(i64 %"#rec##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = add i64 %"#rec##0", 8 + %"tmp#2##0" = inttoptr i64 %"tmp#1##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#2##0" + %"tmp#4##0" = insertvalue {i64, i1} undef, i64 %"tmp#3##0", 0 + %"tmp#5##0" = insertvalue {i64, i1} %"tmp#4##0", i1 1, 1 + ret {i64, i1} %"tmp#5##0" +if.else.0: + %"tmp#6##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#7##0" = insertvalue {i64, i1} %"tmp#6##0", i1 0, 1 + ret {i64, i1} %"tmp#7##0" } - -define external fastcc {i64, i1} @"loop_bug.int_list.tail<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = trunc i64 16 to i32 - %2 = tail call ccc i8* @wybe_malloc(i32 %1) - %3 = ptrtoint i8* %2 to i64 - %4 = inttoptr i64 %3 to i8* - %5 = inttoptr i64 %"#rec##0" to i8* - %6 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %4, i8* %5, i32 %6, i1 0) - %7 = add i64 %3, 8 - %8 = inttoptr i64 %7 to i64* - store i64 %"#field##0", i64* %8 - %9 = insertvalue {i64, i1} undef, i64 %3, 0 - %10 = insertvalue {i64, i1} %9, i1 1, 1 - ret {i64, i1} %10 -if.else: - %11 = insertvalue {i64, i1} undef, i64 0, 0 - %12 = insertvalue {i64, i1} %11, i1 0, 1 - ret {i64, i1} %12 +define external fastcc {i64, i1} @"loop_bug.int_list.tail<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#2##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#2##0", ptr %"tmp#1##0", i64 16, i1 0) + %"tmp#3##0" = ptrtoint ptr %"tmp#2##0" to i64 + %"tmp#4##0" = add i64 %"tmp#3##0", 8 + %"tmp#5##0" = inttoptr i64 %"tmp#4##0" to ptr + store i64 %"#field##0", ptr %"tmp#5##0" + %"tmp#6##0" = insertvalue {i64, i1} undef, i64 %"tmp#3##0", 0 + %"tmp#7##0" = insertvalue {i64, i1} %"tmp#6##0", i1 1, 1 + ret {i64, i1} %"tmp#7##0" +if.else.0: + %"tmp#8##0" = insertvalue {i64, i1} undef, i64 0, 0 + %"tmp#9##0" = insertvalue {i64, i1} %"tmp#8##0", i1 0, 1 + ret {i64, i1} %"tmp#9##0" } - -define external fastcc i1 @"loop_bug.int_list.~=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = tail call fastcc i1 @"loop_bug.int_list.=<0>"(i64 %"#left##0", i64 %"#right##0") - %1 = xor i1 %0, 1 - ret i1 %1 +define external fastcc i1 @"loop_bug.int_list.~=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#0##0" = tail call fastcc i1 @"loop_bug.int_list.=<0>"(i64 %"#left##0", i64 %"#right##0") + %"tmp#1##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#1##0" } diff --git a/test-cases/final-dump/loop_terminators.exp b/test-cases/final-dump/loop_terminators.exp index 57ea8b727..090d9b9f3 100644 --- a/test-cases/final-dump/loop_terminators.exp +++ b/test-cases/final-dump/loop_terminators.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module loop_terminators representation : (not a type) public submods : @@ -70,80 +73,52 @@ loop3#cont#1()<{}; {}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'loop_terminators' +source_filename = "!ROOT!/final-dump/loop_terminators.wybe" +target triple ???? - - - -@loop_terminators.1 = constant {i64, i64} { i64 3, i64 ptrtoint ([?? x i8]* @loop_terminators.0 to i64) } - - -@loop_terminators.0 = constant [?? x i8] c"lol\00" - - -@loop_terminators.2 = constant [?? x i8] c"loop_terminators:14:11\00" - - -declare external ccc void @error_exit(i64, i64) - - -declare external fastcc i64 @"wybe.string.c_string<0>"(i64) +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c"lol\00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c"loop_terminators:14:11\00", align 8 +@"string#2" = private unnamed_addr constant {i64, i64} { i64 3, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +declare external fastcc i64 @"wybe.string.c_string<0>"(i64) +declare external ccc void @error_exit(i64, i64) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"loop_terminators.loop0<0>"() alwaysinline { -entry: - ret void +define external fastcc void @"loop_terminators.loop0<0>"() { + ret void } - -define external fastcc void @"loop_terminators.loop0#cont#1<0>"() alwaysinline { -entry: - ret void +define external fastcc void @"loop_terminators.loop0#cont#1<0>"() { + ret void } - -define external fastcc void @"loop_terminators.loop1<0>"() alwaysinline { -entry: - ret void +define external fastcc void @"loop_terminators.loop1<0>"() { + ret void } - -define external fastcc void @"loop_terminators.loop1#cont#1<0>"() alwaysinline { -entry: - ret void +define external fastcc void @"loop_terminators.loop1#cont#1<0>"() { + ret void } - -define external fastcc void @"loop_terminators.loop2<0>"() alwaysinline { -entry: - ret void +define external fastcc void @"loop_terminators.loop2<0>"() { + ret void } - -define external fastcc void @"loop_terminators.loop2#cont#1<0>"() alwaysinline { -entry: - ret void +define external fastcc void @"loop_terminators.loop2#cont#1<0>"() { + ret void } - -define external fastcc void @"loop_terminators.loop3<0>"() alwaysinline { -entry: - %0 = tail call fastcc i64 @"wybe.string.c_string<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @loop_terminators.1, i32 0, i32 0) to i64)) - tail call ccc void @error_exit(i64 ptrtoint (i8* getelementptr inbounds ([?? x i8], [?? x i8]* @loop_terminators.2, i32 0, i32 0) to i64), i64 %0) - ret void +define external fastcc void @"loop_terminators.loop3<0>"() { + %"tmp#0##0" = tail call fastcc i64 @"wybe.string.c_string<0>"(i64 ptrtoint( ptr @"string#2" to i64 )) + call ccc void @error_exit(i64 ptrtoint( ptr @"cstring#1" to i64 ), i64 %"tmp#0##0") + ret void } - -define external fastcc void @"loop_terminators.loop3#cont#1<0>"() alwaysinline { -entry: - %0 = tail call fastcc i64 @"wybe.string.c_string<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @loop_terminators.1, i32 0, i32 0) to i64)) - tail call ccc void @error_exit(i64 ptrtoint (i8* getelementptr inbounds ([?? x i8], [?? x i8]* @loop_terminators.2, i32 0, i32 0) to i64), i64 %0) - ret void +define external fastcc void @"loop_terminators.loop3#cont#1<0>"() { + %"tmp#2##0" = tail call fastcc i64 @"wybe.string.c_string<0>"(i64 ptrtoint( ptr @"string#2" to i64 )) + call ccc void @error_exit(i64 ptrtoint( ptr @"cstring#1" to i64 ), i64 %"tmp#2##0") + ret void } diff --git a/test-cases/final-dump/main_hello.exp b/test-cases/final-dump/main_hello.exp index 4833cb4de..315079ce8 100644 --- a/test-cases/final-dump/main_hello.exp +++ b/test-cases/final-dump/main_hello.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module command_line representation : (not a type) public submods : @@ -44,68 +47,45 @@ set_exit_code(code##0:wybe.int)<{}; {<>}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'command_line' - - - - -@"resource#command_line.argc" = global i64 undef - - -@"resource#command_line.arguments" = global i64 undef - - -@"resource#command_line.argv" = global i64 undef - - -@"resource#command_line.command" = global i64 undef - - -@"resource#command_line.exit_code" = global i64 undef - - -@command_line.1 = constant [?? x i8] c"Erroneous program argument vector\00" - - -@command_line.0 = constant [?? x i8] c"command_line:18:15\00" - - -declare external ccc void @error_exit(i64, i64) - - -declare external fastcc {i64, i64, i1} @"wybe.array.[|]<0>"(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"command_line.<0>"() { -entry: - %0 = load i64, i64* @"resource#command_line.arguments" - %1 = tail call fastcc {i64, i64, i1} @"wybe.array.[|]<0>"(i64 %0) - %2 = extractvalue {i64, i64, i1} %1, 0 - %3 = extractvalue {i64, i64, i1} %1, 1 - %4 = extractvalue {i64, i64, i1} %1, 2 - br i1 %4, label %if.then, label %if.else -if.then: - store i64 %3, i64* @"resource#command_line.arguments" - store i64 %2, i64* @"resource#command_line.command" - ret void -if.else: - tail call ccc void @error_exit(i64 ptrtoint (i8* getelementptr inbounds ([?? x i8], [?? x i8]* @command_line.0, i32 0, i32 0) to i64), i64 ptrtoint (i8* getelementptr inbounds ([?? x i8], [?? x i8]* @command_line.1, i32 0, i32 0) to i64)) - ret void +source_filename = "!ROOT!/../wybelibs/command_line.o" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c"Erroneous program argument vector\00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c"command_line:18:15\00", align 8 + +declare external fastcc {i64, i64, i1} @"wybe.array.[|]<0>"(i64) +declare external ccc void @error_exit(i64, i64) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) +@"resource#command_line.argc" = global i64 undef +@"resource#command_line.arguments" = global i64 undef +@"resource#command_line.argv" = global i64 undef +@"resource#command_line.command" = global i64 undef +@"resource#command_line.exit_code" = global i64 undef + +define external fastcc void @"command_line.<0>"() { + %"arguments##0" = load i64, ptr @"resource#command_line.arguments" + %"tmp#11##0" = tail call fastcc {i64, i64, i1} @"wybe.array.[|]<0>"(i64 %"arguments##0") + %"command##1" = extractvalue {i64, i64, i1}%"tmp#11##0", 0 + %"arguments##2" = extractvalue {i64, i64, i1}%"tmp#11##0", 1 + %"tmp#8##0" = extractvalue {i64, i64, i1}%"tmp#11##0", 2 + br i1 %"tmp#8##0", label %if.then.0, label %if.else.0 +if.then.0: + store i64 %"arguments##2", ptr @"resource#command_line.arguments" + store i64 %"command##1", ptr @"resource#command_line.command" + ret void +if.else.0: + call ccc void @error_exit(i64 ptrtoint( ptr @"cstring#1" to i64 ), i64 ptrtoint( ptr @"cstring#0" to i64 )) + ret void } - -define external fastcc void @"command_line.set_exit_code<0>"(i64 %"code##0") alwaysinline { -entry: - store i64 %"code##0", i64* @"resource#command_line.exit_code" - ret void +define external fastcc void @"command_line.set_exit_code<0>"(i64 %"code##0") { + store i64 %"code##0", ptr @"resource#command_line.exit_code" + ret void } + -------------------------------------------------- Module main_hello representation : (not a type) @@ -137,55 +117,33 @@ module top-level code > public {semipure} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'main_hello' - - - - -@"resource#command_line.arguments" = external global i64 - - -@"resource#command_line.exit_code" = external global i64 - - -@main_hello.1 = constant {i64, i64} { i64 13, i64 ptrtoint ([?? x i8]* @main_hello.0 to i64) } - - -@main_hello.3 = constant {i64, i64} { i64 25, i64 ptrtoint ([?? x i8]* @main_hello.2 to i64) } - - -@main_hello.2 = constant [?? x i8] c" command line argument(s)\00" - - -@main_hello.0 = constant [?? x i8] c"hello, world!\00" - - -declare external ccc void @putchar(i8) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc void @print_int(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"main_hello.<0>"() { -entry: - store i64 42, i64* @"resource#command_line.exit_code" - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @main_hello.1, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - %0 = load i64, i64* @"resource#command_line.arguments" - %1 = inttoptr i64 %0 to i64* - %2 = load i64, i64* %1 - tail call ccc void @print_int(i64 %2) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @main_hello.3, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - ret void +source_filename = "!ROOT!/final-dump/main_hello.wybe" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c" command line argument(s)\00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c"hello, world!\00", align 8 +@"string#2" = private unnamed_addr constant {i64, i64} { i64 25, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +@"string#3" = private unnamed_addr constant {i64, i64} { i64 13, i64 ptrtoint( ptr @"cstring#1" to i64 ) }, align 8 + +@"resource#command_line.arguments" = external global i64 +@"resource#command_line.exit_code" = external global i64 +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"main_hello.<0>"() { + store i64 42, ptr @"resource#command_line.exit_code" + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#3" to i64 )) + call ccc void @putchar(i8 10) + %"arguments##0" = load i64, ptr @"resource#command_line.arguments" + %"tmp#12##0" = inttoptr i64 %"arguments##0" to ptr + %"tmp#0##0" = load i64, ptr %"tmp#12##0" + call ccc void @print_int(i64 %"tmp#0##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#2" to i64 )) + call ccc void @putchar(i8 10) + ret void } diff --git a/test-cases/final-dump/main_hello2.exp b/test-cases/final-dump/main_hello2.exp index f3076cc24..781417e01 100644 --- a/test-cases/final-dump/main_hello2.exp +++ b/test-cases/final-dump/main_hello2.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module main_hello2 representation : (not a type) public submods : @@ -22,40 +25,24 @@ module top-level code > public {semipure} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'main_hello2' +source_filename = "!ROOT!/final-dump/main_hello2.wybe" +target triple ???? - - - -@main_hello2.3 = constant {i64, i64} { i64 6, i64 ptrtoint ([?? x i8]* @main_hello2.2 to i64) } - - -@main_hello2.1 = constant {i64, i64} { i64 7, i64 ptrtoint ([?? x i8]* @main_hello2.0 to i64) } - - -@main_hello2.0 = constant [?? x i8] c"hello, \00" - - -@main_hello2.2 = constant [?? x i8] c"world!\00" - - -declare external ccc void @putchar(i8) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c"hello, \00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c"world!\00", align 8 +@"string#2" = private unnamed_addr constant {i64, i64} { i64 7, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +@"string#3" = private unnamed_addr constant {i64, i64} { i64 6, i64 ptrtoint( ptr @"cstring#1" to i64 ) }, align 8 +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -define external fastcc void @"main_hello2.<0>"() { -entry: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @main_hello2.1, i32 0, i32 0) to i64)) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @main_hello2.3, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"main_hello2.<0>"() { + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#2" to i64 )) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#3" to i64 )) + call ccc void @putchar(i8 10) + ret void } diff --git a/test-cases/final-dump/mainless.exp b/test-cases/final-dump/mainless.exp index 9f2b99c87..9154b1bf8 100644 --- a/test-cases/final-dump/mainless.exp +++ b/test-cases/final-dump/mainless.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module mainless representation : (not a type) public submods : @@ -18,19 +21,15 @@ nothing_interesting(?#result##0:wybe.int)<{}; {}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'mainless' +source_filename = "!ROOT!/final-dump/mainless.wybe" +target triple ???? - - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -define external fastcc i64 @"mainless.nothing_interesting<0>"() alwaysinline { -entry: - ret i64 7 +define external fastcc i64 @"mainless.nothing_interesting<0>"() { + ret i64 7 } diff --git a/test-cases/final-dump/mixed_fields.exp b/test-cases/final-dump/mixed_fields.exp index 352a60568..9a2505bc7 100644 --- a/test-cases/final-dump/mixed_fields.exp +++ b/test-cases/final-dump/mixed_fields.exp @@ -1,7 +1,10 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module mixed_fields - representation : address + representation : pointer public submods : public resources: public procs : mixed_fields.<0> @@ -244,361 +247,298 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'mixed_fields' - - - - -declare external ccc void @putchar(i8) - - -declare external ccc void @print_int(i64) - - -declare external fastcc void @"wybe.bool.print<0>"(i1) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"mixed_fields.<0>"() { -entry: - %0 = trunc i64 32 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - store i8 97, i8* %3 - %4 = add i64 %2, 1 - %5 = inttoptr i64 %4 to i1* - store i1 1, i1* %5 - %6 = add i64 %2, 2 - %7 = inttoptr i64 %6 to i8* - store i8 65, i8* %7 - %8 = add i64 %2, 8 - %9 = inttoptr i64 %8 to i64* - store i64 3, i64* %9 - %10 = add i64 %2, 16 - %11 = inttoptr i64 %10 to i64* - store i64 42, i64* %11 - %12 = add i64 %2, 24 - %13 = inttoptr i64 %12 to i64* - store i64 17, i64* %13 - tail call fastcc void @"mixed_fields.printit<0>"(i64 %2) - ret void +source_filename = "!ROOT!/final-dump/mixed_fields.wybe" +target triple ???? + + +declare external fastcc void @"wybe.bool.print<0>"(i1) +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"mixed_fields.<0>"() { + %"tmp#14##0" = call ccc ptr @wybe_malloc(i32 32) + %"tmp#8##0" = ptrtoint ptr %"tmp#14##0" to i64 + %"tmp#15##0" = inttoptr i64 %"tmp#8##0" to ptr + store i8 97, ptr %"tmp#15##0" + %"tmp#16##0" = add i64 %"tmp#8##0", 1 + %"tmp#17##0" = inttoptr i64 %"tmp#16##0" to ptr + store i1 1, ptr %"tmp#17##0" + %"tmp#18##0" = add i64 %"tmp#8##0", 2 + %"tmp#19##0" = inttoptr i64 %"tmp#18##0" to ptr + store i8 65, ptr %"tmp#19##0" + %"tmp#20##0" = add i64 %"tmp#8##0", 8 + %"tmp#21##0" = inttoptr i64 %"tmp#20##0" to ptr + store i64 3, ptr %"tmp#21##0" + %"tmp#22##0" = add i64 %"tmp#8##0", 16 + %"tmp#23##0" = inttoptr i64 %"tmp#22##0" to ptr + store i64 42, ptr %"tmp#23##0" + %"tmp#24##0" = add i64 %"tmp#8##0", 24 + %"tmp#25##0" = inttoptr i64 %"tmp#24##0" to ptr + store i64 17, ptr %"tmp#25##0" + tail call fastcc void @"mixed_fields.printit<0>"(i64 %"tmp#8##0") + ret void } - -define external fastcc i1 @"mixed_fields.=<0>"(i64 %"#left##0", i64 %"#right##0") { -entry: - %0 = inttoptr i64 %"#left##0" to i8* - %1 = load i8, i8* %0 - %2 = add i64 %"#left##0", 1 - %3 = inttoptr i64 %2 to i1* - %4 = load i1, i1* %3 - %5 = add i64 %"#left##0", 2 - %6 = inttoptr i64 %5 to i8* - %7 = load i8, i8* %6 - %8 = add i64 %"#left##0", 8 - %9 = inttoptr i64 %8 to i64* - %10 = load i64, i64* %9 - %11 = add i64 %"#left##0", 16 - %12 = inttoptr i64 %11 to i64* - %13 = load i64, i64* %12 - %14 = add i64 %"#left##0", 24 - %15 = inttoptr i64 %14 to i64* - %16 = load i64, i64* %15 - %17 = inttoptr i64 %"#right##0" to i8* - %18 = load i8, i8* %17 - %19 = add i64 %"#right##0", 1 - %20 = inttoptr i64 %19 to i1* - %21 = load i1, i1* %20 - %22 = add i64 %"#right##0", 2 - %23 = inttoptr i64 %22 to i8* - %24 = load i8, i8* %23 - %25 = add i64 %"#right##0", 8 - %26 = inttoptr i64 %25 to i64* - %27 = load i64, i64* %26 - %28 = add i64 %"#right##0", 16 - %29 = inttoptr i64 %28 to i64* - %30 = load i64, i64* %29 - %31 = add i64 %"#right##0", 24 - %32 = inttoptr i64 %31 to i64* - %33 = load i64, i64* %32 - %34 = icmp eq i64 %10, %27 - br i1 %34, label %if.then, label %if.else -if.then: - %35 = icmp eq i8 %1, %18 - br i1 %35, label %if.then1, label %if.else1 -if.else: - ret i1 0 -if.then1: - %36 = icmp eq i64 %13, %30 - br i1 %36, label %if.then2, label %if.else2 -if.else1: - ret i1 0 -if.then2: - %37 = icmp eq i1 %4, %21 - br i1 %37, label %if.then3, label %if.else3 -if.else2: - ret i1 0 -if.then3: - %38 = icmp eq i64 %16, %33 - br i1 %38, label %if.then4, label %if.else4 -if.else3: - ret i1 0 -if.then4: - %39 = icmp eq i8 %7, %24 - ret i1 %39 -if.else4: - ret i1 0 +define external fastcc i1 @"mixed_fields.=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#21##0" = inttoptr i64 %"#left##0" to ptr + %"#left#f2##0" = load i8, ptr %"tmp#21##0" + %"tmp#22##0" = add i64 %"#left##0", 1 + %"tmp#23##0" = inttoptr i64 %"tmp#22##0" to ptr + %"#left#f4##0" = load i1, ptr %"tmp#23##0" + %"tmp#24##0" = add i64 %"#left##0", 2 + %"tmp#25##0" = inttoptr i64 %"tmp#24##0" to ptr + %"#left#f6##0" = load i8, ptr %"tmp#25##0" + %"tmp#26##0" = add i64 %"#left##0", 8 + %"tmp#27##0" = inttoptr i64 %"tmp#26##0" to ptr + %"#left#f1##0" = load i64, ptr %"tmp#27##0" + %"tmp#28##0" = add i64 %"#left##0", 16 + %"tmp#29##0" = inttoptr i64 %"tmp#28##0" to ptr + %"#left#f3##0" = load i64, ptr %"tmp#29##0" + %"tmp#30##0" = add i64 %"#left##0", 24 + %"tmp#31##0" = inttoptr i64 %"tmp#30##0" to ptr + %"#left#f5##0" = load i64, ptr %"tmp#31##0" + %"tmp#32##0" = inttoptr i64 %"#right##0" to ptr + %"#right#f2##0" = load i8, ptr %"tmp#32##0" + %"tmp#33##0" = add i64 %"#right##0", 1 + %"tmp#34##0" = inttoptr i64 %"tmp#33##0" to ptr + %"#right#f4##0" = load i1, ptr %"tmp#34##0" + %"tmp#35##0" = add i64 %"#right##0", 2 + %"tmp#36##0" = inttoptr i64 %"tmp#35##0" to ptr + %"#right#f6##0" = load i8, ptr %"tmp#36##0" + %"tmp#37##0" = add i64 %"#right##0", 8 + %"tmp#38##0" = inttoptr i64 %"tmp#37##0" to ptr + %"#right#f1##0" = load i64, ptr %"tmp#38##0" + %"tmp#39##0" = add i64 %"#right##0", 16 + %"tmp#40##0" = inttoptr i64 %"tmp#39##0" to ptr + %"#right#f3##0" = load i64, ptr %"tmp#40##0" + %"tmp#41##0" = add i64 %"#right##0", 24 + %"tmp#42##0" = inttoptr i64 %"tmp#41##0" to ptr + %"#right#f5##0" = load i64, ptr %"tmp#42##0" + %"tmp#1##0" = icmp eq i64 %"#left#f1##0", %"#right#f1##0" + br i1 %"tmp#1##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = icmp eq i8 %"#left#f2##0", %"#right#f2##0" + br i1 %"tmp#2##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#3##0" = icmp eq i64 %"#left#f3##0", %"#right#f3##0" + br i1 %"tmp#3##0", label %if.then.2, label %if.else.2 +if.then.2: + %"tmp#4##0" = icmp eq i1 %"#left#f4##0", %"#right#f4##0" + br i1 %"tmp#4##0", label %if.then.3, label %if.else.3 +if.then.3: + %"tmp#5##0" = icmp eq i64 %"#left#f5##0", %"#right#f5##0" + br i1 %"tmp#5##0", label %if.then.4, label %if.else.4 +if.then.4: + %"tmp#43##0" = icmp eq i8 %"#left#f6##0", %"#right#f6##0" + ret i1 %"tmp#43##0" +if.else.4: + ret i1 0 +if.else.3: + ret i1 0 +if.else.2: + ret i1 0 +if.else.1: + ret i1 0 +if.else.0: + ret i1 0 } - -define external fastcc i64 @"mixed_fields.f1<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = add i64 %"#rec##0", 8 - %1 = inttoptr i64 %0 to i64* - %2 = load i64, i64* %1 - ret i64 %2 +define external fastcc i64 @"mixed_fields.f1<0>"(i64 %"#rec##0") { + %"tmp#0##0" = add i64 %"#rec##0", 8 + %"tmp#1##0" = inttoptr i64 %"tmp#0##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"mixed_fields.f1<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 32 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 32 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = add i64 %2, 8 - %7 = inttoptr i64 %6 to i64* - store i64 %"#field##0", i64* %7 - ret i64 %2 +define external fastcc i64 @"mixed_fields.f1<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 32) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 32, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = add i64 %"tmp#2##0", 8 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 %"#field##0", ptr %"tmp#4##0" + ret i64 %"tmp#2##0" } - -define external fastcc i8 @"mixed_fields.f2<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#rec##0" to i8* - %1 = load i8, i8* %0 - ret i8 %1 +define external fastcc i8 @"mixed_fields.f2<0>"(i64 %"#rec##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = load i8, ptr %"tmp#0##0" + ret i8 %"tmp#1##0" } - -define external fastcc i64 @"mixed_fields.f2<1>"(i64 %"#rec##0", i8 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 32 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 32 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = inttoptr i64 %2 to i8* - store i8 %"#field##0", i8* %6 - ret i64 %2 +define external fastcc i64 @"mixed_fields.f2<1>"(i64 %"#rec##0", i8 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 32) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 32, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i8 %"#field##0", ptr %"tmp#3##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"mixed_fields.f3<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = add i64 %"#rec##0", 16 - %1 = inttoptr i64 %0 to i64* - %2 = load i64, i64* %1 - ret i64 %2 +define external fastcc i64 @"mixed_fields.f3<0>"(i64 %"#rec##0") { + %"tmp#0##0" = add i64 %"#rec##0", 16 + %"tmp#1##0" = inttoptr i64 %"tmp#0##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"mixed_fields.f3<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 32 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 32 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = add i64 %2, 16 - %7 = inttoptr i64 %6 to i64* - store i64 %"#field##0", i64* %7 - ret i64 %2 +define external fastcc i64 @"mixed_fields.f3<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 32) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 32, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = add i64 %"tmp#2##0", 16 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 %"#field##0", ptr %"tmp#4##0" + ret i64 %"tmp#2##0" } - -define external fastcc i1 @"mixed_fields.f4<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = add i64 %"#rec##0", 1 - %1 = inttoptr i64 %0 to i1* - %2 = load i1, i1* %1 - ret i1 %2 +define external fastcc i1 @"mixed_fields.f4<0>"(i64 %"#rec##0") { + %"tmp#0##0" = add i64 %"#rec##0", 1 + %"tmp#1##0" = inttoptr i64 %"tmp#0##0" to ptr + %"tmp#2##0" = load i1, ptr %"tmp#1##0" + ret i1 %"tmp#2##0" } - -define external fastcc i64 @"mixed_fields.f4<1>"(i64 %"#rec##0", i1 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 32 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 32 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = add i64 %2, 1 - %7 = inttoptr i64 %6 to i1* - store i1 %"#field##0", i1* %7 - ret i64 %2 +define external fastcc i64 @"mixed_fields.f4<1>"(i64 %"#rec##0", i1 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 32) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 32, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = add i64 %"tmp#2##0", 1 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + store i1 %"#field##0", ptr %"tmp#4##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"mixed_fields.f5<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = add i64 %"#rec##0", 24 - %1 = inttoptr i64 %0 to i64* - %2 = load i64, i64* %1 - ret i64 %2 +define external fastcc i64 @"mixed_fields.f5<0>"(i64 %"#rec##0") { + %"tmp#0##0" = add i64 %"#rec##0", 24 + %"tmp#1##0" = inttoptr i64 %"tmp#0##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"mixed_fields.f5<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 32 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 32 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = add i64 %2, 24 - %7 = inttoptr i64 %6 to i64* - store i64 %"#field##0", i64* %7 - ret i64 %2 +define external fastcc i64 @"mixed_fields.f5<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 32) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 32, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = add i64 %"tmp#2##0", 24 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 %"#field##0", ptr %"tmp#4##0" + ret i64 %"tmp#2##0" } - -define external fastcc i8 @"mixed_fields.f6<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = add i64 %"#rec##0", 2 - %1 = inttoptr i64 %0 to i8* - %2 = load i8, i8* %1 - ret i8 %2 +define external fastcc i8 @"mixed_fields.f6<0>"(i64 %"#rec##0") { + %"tmp#0##0" = add i64 %"#rec##0", 2 + %"tmp#1##0" = inttoptr i64 %"tmp#0##0" to ptr + %"tmp#2##0" = load i8, ptr %"tmp#1##0" + ret i8 %"tmp#2##0" } - -define external fastcc i64 @"mixed_fields.f6<1>"(i64 %"#rec##0", i8 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 32 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 32 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = add i64 %2, 2 - %7 = inttoptr i64 %6 to i8* - store i8 %"#field##0", i8* %7 - ret i64 %2 +define external fastcc i64 @"mixed_fields.f6<1>"(i64 %"#rec##0", i8 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 32) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 32, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = add i64 %"tmp#2##0", 2 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + store i8 %"#field##0", ptr %"tmp#4##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"mixed_fields.mixed<0>"(i64 %"f1##0", i8 %"f2##0", i64 %"f3##0", i1 %"f4##0", i64 %"f5##0", i8 %"f6##0") alwaysinline { -entry: - %0 = trunc i64 32 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - store i8 %"f2##0", i8* %3 - %4 = add i64 %2, 1 - %5 = inttoptr i64 %4 to i1* - store i1 %"f4##0", i1* %5 - %6 = add i64 %2, 2 - %7 = inttoptr i64 %6 to i8* - store i8 %"f6##0", i8* %7 - %8 = add i64 %2, 8 - %9 = inttoptr i64 %8 to i64* - store i64 %"f1##0", i64* %9 - %10 = add i64 %2, 16 - %11 = inttoptr i64 %10 to i64* - store i64 %"f3##0", i64* %11 - %12 = add i64 %2, 24 - %13 = inttoptr i64 %12 to i64* - store i64 %"f5##0", i64* %13 - ret i64 %2 +define external fastcc i64 @"mixed_fields.mixed<0>"(i64 %"f1##0", i8 %"f2##0", i64 %"f3##0", i1 %"f4##0", i64 %"f5##0", i8 %"f6##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 32) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i8 %"f2##0", ptr %"tmp#1##0" + %"tmp#2##0" = add i64 %"#rec##0", 1 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i1 %"f4##0", ptr %"tmp#3##0" + %"tmp#4##0" = add i64 %"#rec##0", 2 + %"tmp#5##0" = inttoptr i64 %"tmp#4##0" to ptr + store i8 %"f6##0", ptr %"tmp#5##0" + %"tmp#6##0" = add i64 %"#rec##0", 8 + %"tmp#7##0" = inttoptr i64 %"tmp#6##0" to ptr + store i64 %"f1##0", ptr %"tmp#7##0" + %"tmp#8##0" = add i64 %"#rec##0", 16 + %"tmp#9##0" = inttoptr i64 %"tmp#8##0" to ptr + store i64 %"f3##0", ptr %"tmp#9##0" + %"tmp#10##0" = add i64 %"#rec##0", 24 + %"tmp#11##0" = inttoptr i64 %"tmp#10##0" to ptr + store i64 %"f5##0", ptr %"tmp#11##0" + ret i64 %"#rec##0" } - -define external fastcc {i64, i8, i64, i1, i64, i8} @"mixed_fields.mixed<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#result##0" to i8* - %1 = load i8, i8* %0 - %2 = add i64 %"#result##0", 1 - %3 = inttoptr i64 %2 to i1* - %4 = load i1, i1* %3 - %5 = add i64 %"#result##0", 2 - %6 = inttoptr i64 %5 to i8* - %7 = load i8, i8* %6 - %8 = add i64 %"#result##0", 8 - %9 = inttoptr i64 %8 to i64* - %10 = load i64, i64* %9 - %11 = add i64 %"#result##0", 16 - %12 = inttoptr i64 %11 to i64* - %13 = load i64, i64* %12 - %14 = add i64 %"#result##0", 24 - %15 = inttoptr i64 %14 to i64* - %16 = load i64, i64* %15 - %17 = insertvalue {i64, i8, i64, i1, i64, i8} undef, i64 %10, 0 - %18 = insertvalue {i64, i8, i64, i1, i64, i8} %17, i8 %1, 1 - %19 = insertvalue {i64, i8, i64, i1, i64, i8} %18, i64 %13, 2 - %20 = insertvalue {i64, i8, i64, i1, i64, i8} %19, i1 %4, 3 - %21 = insertvalue {i64, i8, i64, i1, i64, i8} %20, i64 %16, 4 - %22 = insertvalue {i64, i8, i64, i1, i64, i8} %21, i8 %7, 5 - ret {i64, i8, i64, i1, i64, i8} %22 +define external fastcc {i64, i8, i64, i1, i64, i8} @"mixed_fields.mixed<1>"(i64 %"#result##0") { + %"tmp#0##0" = inttoptr i64 %"#result##0" to ptr + %"tmp#1##0" = load i8, ptr %"tmp#0##0" + %"tmp#2##0" = add i64 %"#result##0", 1 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = load i1, ptr %"tmp#3##0" + %"tmp#5##0" = add i64 %"#result##0", 2 + %"tmp#6##0" = inttoptr i64 %"tmp#5##0" to ptr + %"tmp#7##0" = load i8, ptr %"tmp#6##0" + %"tmp#8##0" = add i64 %"#result##0", 8 + %"tmp#9##0" = inttoptr i64 %"tmp#8##0" to ptr + %"tmp#10##0" = load i64, ptr %"tmp#9##0" + %"tmp#11##0" = add i64 %"#result##0", 16 + %"tmp#12##0" = inttoptr i64 %"tmp#11##0" to ptr + %"tmp#13##0" = load i64, ptr %"tmp#12##0" + %"tmp#14##0" = add i64 %"#result##0", 24 + %"tmp#15##0" = inttoptr i64 %"tmp#14##0" to ptr + %"tmp#16##0" = load i64, ptr %"tmp#15##0" + %"tmp#17##0" = insertvalue {i64, i8, i64, i1, i64, i8} undef, i64 %"tmp#10##0", 0 + %"tmp#18##0" = insertvalue {i64, i8, i64, i1, i64, i8} %"tmp#17##0", i8 %"tmp#1##0", 1 + %"tmp#19##0" = insertvalue {i64, i8, i64, i1, i64, i8} %"tmp#18##0", i64 %"tmp#13##0", 2 + %"tmp#20##0" = insertvalue {i64, i8, i64, i1, i64, i8} %"tmp#19##0", i1 %"tmp#4##0", 3 + %"tmp#21##0" = insertvalue {i64, i8, i64, i1, i64, i8} %"tmp#20##0", i64 %"tmp#16##0", 4 + %"tmp#22##0" = insertvalue {i64, i8, i64, i1, i64, i8} %"tmp#21##0", i8 %"tmp#7##0", 5 + ret {i64, i8, i64, i1, i64, i8} %"tmp#22##0" } - -define external fastcc void @"mixed_fields.printit<0>"(i64 %"ob##0") { -entry: - %0 = add i64 %"ob##0", 8 - %1 = inttoptr i64 %0 to i64* - %2 = load i64, i64* %1 - tail call ccc void @print_int(i64 %2) - tail call ccc void @putchar(i8 10) - %3 = inttoptr i64 %"ob##0" to i8* - %4 = load i8, i8* %3 - tail call ccc void @putchar(i8 %4) - tail call ccc void @putchar(i8 10) - %5 = add i64 %"ob##0", 16 - %6 = inttoptr i64 %5 to i64* - %7 = load i64, i64* %6 - tail call ccc void @print_int(i64 %7) - tail call ccc void @putchar(i8 10) - %8 = add i64 %"ob##0", 1 - %9 = inttoptr i64 %8 to i1* - %10 = load i1, i1* %9 - tail call fastcc void @"wybe.bool.print<0>"(i1 %10) - tail call ccc void @putchar(i8 10) - %11 = add i64 %"ob##0", 24 - %12 = inttoptr i64 %11 to i64* - %13 = load i64, i64* %12 - tail call ccc void @print_int(i64 %13) - tail call ccc void @putchar(i8 10) - %14 = add i64 %"ob##0", 2 - %15 = inttoptr i64 %14 to i8* - %16 = load i8, i8* %15 - tail call ccc void @putchar(i8 %16) - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"mixed_fields.printit<0>"(i64 %"ob##0") { + %"tmp#35##0" = add i64 %"ob##0", 8 + %"tmp#36##0" = inttoptr i64 %"tmp#35##0" to ptr + %"tmp#0##0" = load i64, ptr %"tmp#36##0" + call ccc void @print_int(i64 %"tmp#0##0") + call ccc void @putchar(i8 10) + %"tmp#37##0" = inttoptr i64 %"ob##0" to ptr + %"tmp#1##0" = load i8, ptr %"tmp#37##0" + call ccc void @putchar(i8 %"tmp#1##0") + call ccc void @putchar(i8 10) + %"tmp#38##0" = add i64 %"ob##0", 16 + %"tmp#39##0" = inttoptr i64 %"tmp#38##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#39##0" + call ccc void @print_int(i64 %"tmp#2##0") + call ccc void @putchar(i8 10) + %"tmp#40##0" = add i64 %"ob##0", 1 + %"tmp#41##0" = inttoptr i64 %"tmp#40##0" to ptr + %"tmp#3##0" = load i1, ptr %"tmp#41##0" + tail call fastcc void @"wybe.bool.print<0>"(i1 %"tmp#3##0") + call ccc void @putchar(i8 10) + %"tmp#42##0" = add i64 %"ob##0", 24 + %"tmp#43##0" = inttoptr i64 %"tmp#42##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#43##0" + call ccc void @print_int(i64 %"tmp#4##0") + call ccc void @putchar(i8 10) + %"tmp#44##0" = add i64 %"ob##0", 2 + %"tmp#45##0" = inttoptr i64 %"tmp#44##0" to ptr + %"tmp#5##0" = load i8, ptr %"tmp#45##0" + call ccc void @putchar(i8 %"tmp#5##0") + call ccc void @putchar(i8 10) + ret void } - -define external fastcc i1 @"mixed_fields.~=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = tail call fastcc i1 @"mixed_fields.=<0>"(i64 %"#left##0", i64 %"#right##0") - %1 = xor i1 %0, 1 - ret i1 %1 +define external fastcc i1 @"mixed_fields.~=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#0##0" = tail call fastcc i1 @"mixed_fields.=<0>"(i64 %"#left##0", i64 %"#right##0") + %"tmp#1##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#1##0" } diff --git a/test-cases/final-dump/mod1.exp b/test-cases/final-dump/mod1.exp index fbe237880..7310346dc 100644 --- a/test-cases/final-dump/mod1.exp +++ b/test-cases/final-dump/mod1.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module mod1 representation : (not a type) public submods : @@ -12,13 +15,11 @@ AFTER EVERYTHING: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'mod1' - - - - -declare external ccc i8* @wybe_malloc(i32) +source_filename = "!ROOT!/final-dump/mod1.wybe" +target triple ???? -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) diff --git a/test-cases/final-dump/mod2.exp b/test-cases/final-dump/mod2.exp index 09b81425a..07ec5807d 100644 --- a/test-cases/final-dump/mod2.exp +++ b/test-cases/final-dump/mod2.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module mod2 representation : (not a type) public submods : @@ -12,13 +15,11 @@ AFTER EVERYTHING: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'mod2' - - - - -declare external ccc i8* @wybe_malloc(i32) +source_filename = "!ROOT!/final-dump/mod2.wybe" +target triple ???? -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) diff --git a/test-cases/final-dump/mod3.exp b/test-cases/final-dump/mod3.exp index 0539415c7..cff41fa73 100644 --- a/test-cases/final-dump/mod3.exp +++ b/test-cases/final-dump/mod3.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module mod3 representation : (not a type) public submods : @@ -12,13 +15,11 @@ AFTER EVERYTHING: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'mod3' - - - - -declare external ccc i8* @wybe_malloc(i32) +source_filename = "!ROOT!/final-dump/mod3.wybe" +target triple ???? -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) diff --git a/test-cases/final-dump/mod4.exp b/test-cases/final-dump/mod4.exp index 4d375b53a..7bc6fe032 100644 --- a/test-cases/final-dump/mod4.exp +++ b/test-cases/final-dump/mod4.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module mod4 representation : (not a type) public submods : @@ -12,13 +15,11 @@ AFTER EVERYTHING: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'mod4' - - - - -declare external ccc i8* @wybe_malloc(i32) +source_filename = "!ROOT!/final-dump/mod4.wybe" +target triple ???? -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) diff --git a/test-cases/final-dump/mod5.exp b/test-cases/final-dump/mod5.exp index 538f2fbb6..cb3a2a682 100644 --- a/test-cases/final-dump/mod5.exp +++ b/test-cases/final-dump/mod5.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module mod5 representation : (not a type) public submods : @@ -12,13 +15,11 @@ AFTER EVERYTHING: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'mod5' - - - - -declare external ccc i8* @wybe_malloc(i32) +source_filename = "!ROOT!/final-dump/mod5.wybe" +target triple ???? -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) diff --git a/test-cases/final-dump/mod6.exp b/test-cases/final-dump/mod6.exp index 0660e8966..e31e996c3 100644 --- a/test-cases/final-dump/mod6.exp +++ b/test-cases/final-dump/mod6.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module mod6 representation : (not a type) public submods : @@ -12,13 +15,11 @@ AFTER EVERYTHING: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'mod6' - - - - -declare external ccc i8* @wybe_malloc(i32) +source_filename = "!ROOT!/final-dump/mod6.wybe" +target triple ???? -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) diff --git a/test-cases/final-dump/mod7.exp b/test-cases/final-dump/mod7.exp index 479ffe14c..afead05d3 100644 --- a/test-cases/final-dump/mod7.exp +++ b/test-cases/final-dump/mod7.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module mod7 representation : (not a type) public submods : @@ -12,13 +15,11 @@ AFTER EVERYTHING: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'mod7' - - - - -declare external ccc i8* @wybe_malloc(i32) +source_filename = "!ROOT!/final-dump/mod7.wybe" +target triple ???? -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) diff --git a/test-cases/final-dump/mod8.exp b/test-cases/final-dump/mod8.exp index d9bbf2701..ee7b9b3cb 100644 --- a/test-cases/final-dump/mod8.exp +++ b/test-cases/final-dump/mod8.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module mod8 representation : (not a type) public submods : @@ -12,13 +15,11 @@ AFTER EVERYTHING: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'mod8' - - - - -declare external ccc i8* @wybe_malloc(i32) +source_filename = "!ROOT!/final-dump/mod8.wybe" +target triple ???? -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) diff --git a/test-cases/final-dump/multi_out.exp b/test-cases/final-dump/multi_out.exp index 1b6789fa3..0db11eb18 100644 --- a/test-cases/final-dump/multi_out.exp +++ b/test-cases/final-dump/multi_out.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module multi_out representation : (not a type) public submods : @@ -28,28 +31,22 @@ onetwothree(?x##0:wybe.int, ?y##0:wybe.int, ?z##0:wybe.int)<{}; {}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'multi_out' +source_filename = "!ROOT!/final-dump/multi_out.wybe" +target triple ???? - - - -declare external ccc i8* @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"multi_out.<0>"() alwaysinline { -entry: - ret void +define external fastcc void @"multi_out.<0>"() { + ret void } - -define external fastcc {i64, i64, i64} @"multi_out.onetwothree<0>"() alwaysinline { -entry: - %0 = insertvalue {i64, i64, i64} undef, i64 1, 0 - %1 = insertvalue {i64, i64, i64} %0, i64 2, 1 - %2 = insertvalue {i64, i64, i64} %1, i64 3, 2 - ret {i64, i64, i64} %2 +define external fastcc {i64, i64, i64} @"multi_out.onetwothree<0>"() { + %"tmp#0##0" = insertvalue {i64, i64, i64} undef, i64 1, 0 + %"tmp#1##0" = insertvalue {i64, i64, i64} %"tmp#0##0", i64 2, 1 + %"tmp#2##0" = insertvalue {i64, i64, i64} %"tmp#1##0", i64 3, 2 + ret {i64, i64, i64} %"tmp#2##0" } diff --git a/test-cases/final-dump/multi_specz.exp b/test-cases/final-dump/multi_specz.exp index 7727f304e..28045483f 100644 --- a/test-cases/final-dump/multi_specz.exp +++ b/test-cases/final-dump/multi_specz.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module multi_specz representation : (not a type) public submods : @@ -124,186 +127,147 @@ modifyAndPrint(pos##0:position.position, v##0:wybe.int)<{<>}; {<"(i64) - - -declare external ccc void @putchar(i8) - - -declare external fastcc void @"wybe.string.print<0>"(i64) +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c"-------------\00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c"=============\00", align 8 +@"string#2" = private unnamed_addr constant {i64, i64} { i64 13, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +@"string#3" = private unnamed_addr constant {i64, i64} { i64 13, i64 ptrtoint( ptr @"cstring#1" to i64 ) }, align 8 +declare external fastcc void @"position.printPosition<0>"(i64) +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @putchar(i8) +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"multi_specz.<0>"() alwaysinline { -entry: - tail call fastcc void @"multi_specz.bar1<0>"() - musttail call fastcc void @"multi_specz.bar2<0>"() - ret void +define external fastcc void @"multi_specz.<0>"() { + tail call fastcc void @"multi_specz.bar1<0>"() + tail call fastcc void @"multi_specz.bar2<0>"() + ret void } - -define external fastcc void @"multi_specz.bar1<0>"() { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 0, i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 1, i64* %5 - %6 = trunc i64 16 to i32 - %7 = tail call ccc i8* @wybe_malloc(i32 %6) - %8 = ptrtoint i8* %7 to i64 - %9 = inttoptr i64 %8 to i64* - store i64 0, i64* %9 - %10 = add i64 %8, 8 - %11 = inttoptr i64 %10 to i64* - store i64 2, i64* %11 - %12 = trunc i64 16 to i32 - %13 = tail call ccc i8* @wybe_malloc(i32 %12) - %14 = ptrtoint i8* %13 to i64 - %15 = inttoptr i64 %14 to i64* - store i64 0, i64* %15 - %16 = add i64 %14, 8 - %17 = inttoptr i64 %16 to i64* - store i64 3, i64* %17 - %18 = trunc i64 16 to i32 - %19 = tail call ccc i8* @wybe_malloc(i32 %18) - %20 = ptrtoint i8* %19 to i64 - %21 = inttoptr i64 %20 to i64* - store i64 0, i64* %21 - %22 = add i64 %20, 8 - %23 = inttoptr i64 %22 to i64* - store i64 4, i64* %23 - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @multi_specz.1, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"multi_specz.foo<0>[7477e50a09]"(i64 %2, i64 %8, i64 %14, i64 %20) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @multi_specz.3, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"position.printPosition<0>"(i64 %14) - tail call fastcc void @"position.printPosition<0>"(i64 %20) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @multi_specz.1, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"multi_specz.bar1<0>"() { + %"tmp#29##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#6##0" = ptrtoint ptr %"tmp#29##0" to i64 + %"tmp#30##0" = inttoptr i64 %"tmp#6##0" to ptr + store i64 0, ptr %"tmp#30##0" + %"tmp#31##0" = add i64 %"tmp#6##0", 8 + %"tmp#32##0" = inttoptr i64 %"tmp#31##0" to ptr + store i64 1, ptr %"tmp#32##0" + %"tmp#33##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#10##0" = ptrtoint ptr %"tmp#33##0" to i64 + %"tmp#34##0" = inttoptr i64 %"tmp#10##0" to ptr + store i64 0, ptr %"tmp#34##0" + %"tmp#35##0" = add i64 %"tmp#10##0", 8 + %"tmp#36##0" = inttoptr i64 %"tmp#35##0" to ptr + store i64 2, ptr %"tmp#36##0" + %"tmp#37##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#14##0" = ptrtoint ptr %"tmp#37##0" to i64 + %"tmp#38##0" = inttoptr i64 %"tmp#14##0" to ptr + store i64 0, ptr %"tmp#38##0" + %"tmp#39##0" = add i64 %"tmp#14##0", 8 + %"tmp#40##0" = inttoptr i64 %"tmp#39##0" to ptr + store i64 3, ptr %"tmp#40##0" + %"tmp#41##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#18##0" = ptrtoint ptr %"tmp#41##0" to i64 + %"tmp#42##0" = inttoptr i64 %"tmp#18##0" to ptr + store i64 0, ptr %"tmp#42##0" + %"tmp#43##0" = add i64 %"tmp#18##0", 8 + %"tmp#44##0" = inttoptr i64 %"tmp#43##0" to ptr + store i64 4, ptr %"tmp#44##0" + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#3" to i64 )) + call ccc void @putchar(i8 10) + tail call fastcc void @"multi_specz.foo<0>[7477e50a09]"(i64 %"tmp#6##0", i64 %"tmp#10##0", i64 %"tmp#14##0", i64 %"tmp#18##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#2" to i64 )) + call ccc void @putchar(i8 10) + tail call fastcc void @"position.printPosition<0>"(i64 %"tmp#14##0") + tail call fastcc void @"position.printPosition<0>"(i64 %"tmp#18##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#3" to i64 )) + call ccc void @putchar(i8 10) + ret void } - -define external fastcc void @"multi_specz.bar2<0>"() { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 0, i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 1, i64* %5 - %6 = trunc i64 16 to i32 - %7 = tail call ccc i8* @wybe_malloc(i32 %6) - %8 = ptrtoint i8* %7 to i64 - %9 = inttoptr i64 %8 to i64* - store i64 0, i64* %9 - %10 = add i64 %8, 8 - %11 = inttoptr i64 %10 to i64* - store i64 2, i64* %11 - %12 = trunc i64 16 to i32 - %13 = tail call ccc i8* @wybe_malloc(i32 %12) - %14 = ptrtoint i8* %13 to i64 - %15 = inttoptr i64 %14 to i64* - store i64 0, i64* %15 - %16 = add i64 %14, 8 - %17 = inttoptr i64 %16 to i64* - store i64 3, i64* %17 - %18 = trunc i64 16 to i32 - %19 = tail call ccc i8* @wybe_malloc(i32 %18) - %20 = ptrtoint i8* %19 to i64 - %21 = inttoptr i64 %20 to i64* - store i64 0, i64* %21 - %22 = add i64 %20, 8 - %23 = inttoptr i64 %22 to i64* - store i64 4, i64* %23 - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @multi_specz.1, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"multi_specz.foo<0>"(i64 %2, i64 %8, i64 %14, i64 %20) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @multi_specz.3, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"position.printPosition<0>"(i64 %2) - tail call fastcc void @"position.printPosition<0>"(i64 %8) - tail call fastcc void @"position.printPosition<0>"(i64 %14) - tail call fastcc void @"position.printPosition<0>"(i64 %20) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @multi_specz.1, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"multi_specz.bar2<0>"() { + %"tmp#29##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#6##0" = ptrtoint ptr %"tmp#29##0" to i64 + %"tmp#30##0" = inttoptr i64 %"tmp#6##0" to ptr + store i64 0, ptr %"tmp#30##0" + %"tmp#31##0" = add i64 %"tmp#6##0", 8 + %"tmp#32##0" = inttoptr i64 %"tmp#31##0" to ptr + store i64 1, ptr %"tmp#32##0" + %"tmp#33##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#10##0" = ptrtoint ptr %"tmp#33##0" to i64 + %"tmp#34##0" = inttoptr i64 %"tmp#10##0" to ptr + store i64 0, ptr %"tmp#34##0" + %"tmp#35##0" = add i64 %"tmp#10##0", 8 + %"tmp#36##0" = inttoptr i64 %"tmp#35##0" to ptr + store i64 2, ptr %"tmp#36##0" + %"tmp#37##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#14##0" = ptrtoint ptr %"tmp#37##0" to i64 + %"tmp#38##0" = inttoptr i64 %"tmp#14##0" to ptr + store i64 0, ptr %"tmp#38##0" + %"tmp#39##0" = add i64 %"tmp#14##0", 8 + %"tmp#40##0" = inttoptr i64 %"tmp#39##0" to ptr + store i64 3, ptr %"tmp#40##0" + %"tmp#41##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#18##0" = ptrtoint ptr %"tmp#41##0" to i64 + %"tmp#42##0" = inttoptr i64 %"tmp#18##0" to ptr + store i64 0, ptr %"tmp#42##0" + %"tmp#43##0" = add i64 %"tmp#18##0", 8 + %"tmp#44##0" = inttoptr i64 %"tmp#43##0" to ptr + store i64 4, ptr %"tmp#44##0" + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#3" to i64 )) + call ccc void @putchar(i8 10) + tail call fastcc void @"multi_specz.foo<0>"(i64 %"tmp#6##0", i64 %"tmp#10##0", i64 %"tmp#14##0", i64 %"tmp#18##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#2" to i64 )) + call ccc void @putchar(i8 10) + tail call fastcc void @"position.printPosition<0>"(i64 %"tmp#6##0") + tail call fastcc void @"position.printPosition<0>"(i64 %"tmp#10##0") + tail call fastcc void @"position.printPosition<0>"(i64 %"tmp#14##0") + tail call fastcc void @"position.printPosition<0>"(i64 %"tmp#18##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#3" to i64 )) + call ccc void @putchar(i8 10) + ret void } - -define external fastcc void @"multi_specz.foo<0>"(i64 %"x1##0", i64 %"x2##0", i64 %"x3##0", i64 %"x4##0") { -entry: - tail call fastcc void @"multi_specz.modifyAndPrint<0>"(i64 %"x1##0", i64 111) - tail call fastcc void @"multi_specz.modifyAndPrint<0>"(i64 %"x2##0", i64 222) - tail call fastcc void @"multi_specz.modifyAndPrint<0>"(i64 %"x3##0", i64 333) - tail call fastcc void @"multi_specz.modifyAndPrint<0>"(i64 %"x4##0", i64 444) - ret void +define external fastcc void @"multi_specz.foo<0>"(i64 %"x1##0", i64 %"x2##0", i64 %"x3##0", i64 %"x4##0") { + tail call fastcc void @"multi_specz.modifyAndPrint<0>"(i64 %"x1##0", i64 111) + tail call fastcc void @"multi_specz.modifyAndPrint<0>"(i64 %"x2##0", i64 222) + tail call fastcc void @"multi_specz.modifyAndPrint<0>"(i64 %"x3##0", i64 333) + tail call fastcc void @"multi_specz.modifyAndPrint<0>"(i64 %"x4##0", i64 444) + ret void } - -define external fastcc void @"multi_specz.foo<0>[7477e50a09]"(i64 %"x1##0", i64 %"x2##0", i64 %"x3##0", i64 %"x4##0") { -entry: - tail call fastcc void @"multi_specz.modifyAndPrint<0>[410bae77d3]"(i64 %"x1##0", i64 111) - tail call fastcc void @"multi_specz.modifyAndPrint<0>[410bae77d3]"(i64 %"x2##0", i64 222) - tail call fastcc void @"multi_specz.modifyAndPrint<0>"(i64 %"x3##0", i64 333) - tail call fastcc void @"multi_specz.modifyAndPrint<0>"(i64 %"x4##0", i64 444) - ret void +define external fastcc void @"multi_specz.foo<0>[7477e50a09]"(i64 %"x1##0", i64 %"x2##0", i64 %"x3##0", i64 %"x4##0") { + tail call fastcc void @"multi_specz.modifyAndPrint<0>[410bae77d3]"(i64 %"x1##0", i64 111) + tail call fastcc void @"multi_specz.modifyAndPrint<0>[410bae77d3]"(i64 %"x2##0", i64 222) + tail call fastcc void @"multi_specz.modifyAndPrint<0>"(i64 %"x3##0", i64 333) + tail call fastcc void @"multi_specz.modifyAndPrint<0>"(i64 %"x4##0", i64 444) + ret void } - -define external fastcc void @"multi_specz.modifyAndPrint<0>"(i64 %"pos##0", i64 %"v##0") { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"pos##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = inttoptr i64 %2 to i64* - store i64 %"v##0", i64* %6 - tail call fastcc void @"position.printPosition<0>"(i64 %2) - ret void +define external fastcc void @"multi_specz.modifyAndPrint<0>"(i64 %"pos##0", i64 %"v##0") { + %"tmp#2##0" = inttoptr i64 %"pos##0" to ptr + %"tmp#3##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#3##0", ptr %"tmp#2##0", i64 16, i1 0) + %"tmp#4##0" = ptrtoint ptr %"tmp#3##0" to i64 + %"tmp#5##0" = inttoptr i64 %"tmp#4##0" to ptr + store i64 %"v##0", ptr %"tmp#5##0" + tail call fastcc void @"position.printPosition<0>"(i64 %"tmp#4##0") + ret void } - -define external fastcc void @"multi_specz.modifyAndPrint<0>[410bae77d3]"(i64 %"pos##0", i64 %"v##0") { -entry: - %0 = inttoptr i64 %"pos##0" to i64* - store i64 %"v##0", i64* %0 - tail call fastcc void @"position.printPosition<0>"(i64 %"pos##0") - ret void +define external fastcc void @"multi_specz.modifyAndPrint<0>[410bae77d3]"(i64 %"pos##0", i64 %"v##0") { + %"tmp#2##0" = inttoptr i64 %"pos##0" to ptr + store i64 %"v##0", ptr %"tmp#2##0" + tail call fastcc void @"position.printPosition<0>"(i64 %"pos##0") + ret void } + -------------------------------------------------- Module position representation : (not a type) @@ -346,63 +310,42 @@ printPosition(pos##0:position.position)<{<>}; {<>}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'position' - - - - -@position.3 = constant {i64, i64} { i64 1, i64 ptrtoint ([?? x i8]* @position.2 to i64) } - - -@position.5 = constant {i64, i64} { i64 1, i64 ptrtoint ([?? x i8]* @position.4 to i64) } - - -@position.1 = constant {i64, i64} { i64 2, i64 ptrtoint ([?? x i8]* @position.0 to i64) } - - -@position.0 = constant [?? x i8] c" (\00" - - -@position.4 = constant [?? x i8] c")\00" - - -@position.2 = constant [?? x i8] c",\00" - - -declare external ccc void @putchar(i8) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc void @print_int(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"position.printPosition<0>"(i64 %"pos##0") { -entry: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @position.1, i32 0, i32 0) to i64)) - %0 = inttoptr i64 %"pos##0" to i64* - %1 = load i64, i64* %0 - tail call ccc void @print_int(i64 %1) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @position.3, i32 0, i32 0) to i64)) - %2 = add i64 %"pos##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - tail call ccc void @print_int(i64 %4) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @position.5, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - ret void +source_filename = "!ROOT!/final-dump/position.wybe" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c" (\00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c")\00", align 8 +@"cstring#2" = private unnamed_addr constant [ ?? x i8 ] c",\00", align 8 +@"string#3" = private unnamed_addr constant {i64, i64} { i64 2, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +@"string#4" = private unnamed_addr constant {i64, i64} { i64 1, i64 ptrtoint( ptr @"cstring#1" to i64 ) }, align 8 +@"string#5" = private unnamed_addr constant {i64, i64} { i64 1, i64 ptrtoint( ptr @"cstring#2" to i64 ) }, align 8 + +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"position.printPosition<0>"(i64 %"pos##0") { + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#3" to i64 )) + %"tmp#13##0" = inttoptr i64 %"pos##0" to ptr + %"tmp#0##0" = load i64, ptr %"tmp#13##0" + call ccc void @print_int(i64 %"tmp#0##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#5" to i64 )) + %"tmp#14##0" = add i64 %"pos##0", 8 + %"tmp#15##0" = inttoptr i64 %"tmp#14##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#15##0" + call ccc void @print_int(i64 %"tmp#1##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#4" to i64 )) + call ccc void @putchar(i8 10) + ret void } + -------------------------------------------------- Module position.position - representation : address + representation : pointer public submods : public resources: public procs : position.position.=<0> @@ -504,134 +447,110 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'position.position' - - - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i1 @"position.position.=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %"#right##0" to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = icmp eq i64 %1, %6 - br i1 %10, label %if.then, label %if.else -if.then: - %11 = icmp eq i64 %4, %9 - ret i1 %11 -if.else: - ret i1 0 +source_filename = "!ROOT!/final-dump/position.wybe" +target triple ???? + + +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc i1 @"position.position.=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#9##0" = inttoptr i64 %"#left##0" to ptr + %"#left#x##0" = load i64, ptr %"tmp#9##0" + %"tmp#10##0" = add i64 %"#left##0", 8 + %"tmp#11##0" = inttoptr i64 %"tmp#10##0" to ptr + %"#left#y##0" = load i64, ptr %"tmp#11##0" + %"tmp#12##0" = inttoptr i64 %"#right##0" to ptr + %"#right#x##0" = load i64, ptr %"tmp#12##0" + %"tmp#13##0" = add i64 %"#right##0", 8 + %"tmp#14##0" = inttoptr i64 %"tmp#13##0" to ptr + %"#right#y##0" = load i64, ptr %"tmp#14##0" + %"tmp#1##0" = icmp eq i64 %"#left#x##0", %"#right#x##0" + br i1 %"tmp#1##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#15##0" = icmp eq i64 %"#left#y##0", %"#right#y##0" + ret i1 %"tmp#15##0" +if.else.0: + ret i1 0 } - -define external fastcc i64 @"position.position.position<0>"(i64 %"x##0", i64 %"y##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"x##0", i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"y##0", i64* %5 - ret i64 %2 +define external fastcc i64 @"position.position.position<0>"(i64 %"x##0", i64 %"y##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 16) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"x##0", ptr %"tmp#1##0" + %"tmp#2##0" = add i64 %"#rec##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"y##0", ptr %"tmp#3##0" + ret i64 %"#rec##0" } - -define external fastcc {i64, i64} @"position.position.position<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#result##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#result##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = insertvalue {i64, i64} undef, i64 %1, 0 - %6 = insertvalue {i64, i64} %5, i64 %4, 1 - ret {i64, i64} %6 +define external fastcc {i64, i64} @"position.position.position<1>"(i64 %"#result##0") { + %"tmp#0##0" = inttoptr i64 %"#result##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + %"tmp#2##0" = add i64 %"#result##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#3##0" + %"tmp#5##0" = insertvalue {i64, i64} undef, i64 %"tmp#1##0", 0 + %"tmp#6##0" = insertvalue {i64, i64} %"tmp#5##0", i64 %"tmp#4##0", 1 + ret {i64, i64} %"tmp#6##0" } - -define external fastcc i64 @"position.position.x<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#rec##0" to i64* - %1 = load i64, i64* %0 - ret i64 %1 +define external fastcc i64 @"position.position.x<0>"(i64 %"#rec##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + ret i64 %"tmp#1##0" } - -define external fastcc i64 @"position.position.x<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = inttoptr i64 %2 to i64* - store i64 %"#field##0", i64* %6 - ret i64 %2 +define external fastcc i64 @"position.position.x<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"#field##0", ptr %"tmp#3##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"position.position.y<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = add i64 %"#rec##0", 8 - %1 = inttoptr i64 %0 to i64* - %2 = load i64, i64* %1 - ret i64 %2 +define external fastcc i64 @"position.position.y<0>"(i64 %"#rec##0") { + %"tmp#0##0" = add i64 %"#rec##0", 8 + %"tmp#1##0" = inttoptr i64 %"tmp#0##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"position.position.y<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = add i64 %2, 8 - %7 = inttoptr i64 %6 to i64* - store i64 %"#field##0", i64* %7 - ret i64 %2 +define external fastcc i64 @"position.position.y<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = add i64 %"tmp#2##0", 8 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 %"#field##0", ptr %"tmp#4##0" + ret i64 %"tmp#2##0" } - -define external fastcc i1 @"position.position.~=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %"#right##0" to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = icmp eq i64 %1, %6 - br i1 %10, label %if.then, label %if.else -if.then: - %11 = icmp eq i64 %4, %9 - %12 = xor i1 %11, 1 - ret i1 %12 -if.else: - %13 = xor i1 0, 1 - ret i1 %13 +define external fastcc i1 @"position.position.~=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#8##0" = inttoptr i64 %"#left##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#8##0" + %"tmp#9##0" = add i64 %"#left##0", 8 + %"tmp#10##0" = inttoptr i64 %"tmp#9##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#10##0" + %"tmp#11##0" = inttoptr i64 %"#right##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#11##0" + %"tmp#12##0" = add i64 %"#right##0", 8 + %"tmp#13##0" = inttoptr i64 %"tmp#12##0" to ptr + %"tmp#6##0" = load i64, ptr %"tmp#13##0" + %"tmp#7##0" = icmp eq i64 %"tmp#3##0", %"tmp#5##0" + br i1 %"tmp#7##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#0##0" = icmp eq i64 %"tmp#4##0", %"tmp#6##0" + %"tmp#14##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#14##0" +if.else.0: + %"tmp#15##0" = xor i1 0, 1 + ret i1 %"tmp#15##0" } diff --git a/test-cases/final-dump/multi_specz_cyclic_exe.exp b/test-cases/final-dump/multi_specz_cyclic_exe.exp index fbf9c29d2..168e4605f 100644 --- a/test-cases/final-dump/multi_specz_cyclic_exe.exp +++ b/test-cases/final-dump/multi_specz_cyclic_exe.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module multi_specz_cyclic_exe representation : (not a type) public submods : @@ -55,94 +58,70 @@ main()<{<>}; {<>}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'multi_specz_cyclic_exe' +source_filename = "!ROOT!/final-dump/multi_specz_cyclic_exe.wybe" +target triple ???? - - - -@multi_specz_cyclic_exe.1 = constant {i64, i64} { i64 13, i64 ptrtoint ([?? x i8]* @multi_specz_cyclic_exe.0 to i64) } - - -@multi_specz_cyclic_exe.3 = constant {i64, i64} { i64 13, i64 ptrtoint ([?? x i8]* @multi_specz_cyclic_exe.2 to i64) } - - -@multi_specz_cyclic_exe.2 = constant [?? x i8] c"-------------\00" - - -@multi_specz_cyclic_exe.0 = constant [?? x i8] c"=============\00" - +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c"-------------\00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c"=============\00", align 8 +@"string#2" = private unnamed_addr constant {i64, i64} { i64 13, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +@"string#3" = private unnamed_addr constant {i64, i64} { i64 13, i64 ptrtoint( ptr @"cstring#1" to i64 ) }, align 8 -declare external ccc void @putchar(i8) +declare external fastcc void @"multi_specz_cyclic_lib.foo1<0>[7477e50a09]"(i64, i64, i64, i64, i64) +declare external fastcc void @"multi_specz_cyclic_lib.printPosition<0>"(i64) +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @putchar(i8) +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external fastcc void @"multi_specz_cyclic_lib.printPosition<0>"(i64) - - -declare external fastcc void @"multi_specz_cyclic_lib.foo1<0>[7477e50a09]"(i64, i64, i64, i64, i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"multi_specz_cyclic_exe.<0>"() alwaysinline { -entry: - musttail call fastcc void @"multi_specz_cyclic_exe.main<0>"() - ret void +define external fastcc void @"multi_specz_cyclic_exe.<0>"() { + tail call fastcc void @"multi_specz_cyclic_exe.main<0>"() + ret void } - -define external fastcc void @"multi_specz_cyclic_exe.main<0>"() { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 0, i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 1, i64* %5 - %6 = trunc i64 16 to i32 - %7 = tail call ccc i8* @wybe_malloc(i32 %6) - %8 = ptrtoint i8* %7 to i64 - %9 = inttoptr i64 %8 to i64* - store i64 0, i64* %9 - %10 = add i64 %8, 8 - %11 = inttoptr i64 %10 to i64* - store i64 2, i64* %11 - %12 = trunc i64 16 to i32 - %13 = tail call ccc i8* @wybe_malloc(i32 %12) - %14 = ptrtoint i8* %13 to i64 - %15 = inttoptr i64 %14 to i64* - store i64 0, i64* %15 - %16 = add i64 %14, 8 - %17 = inttoptr i64 %16 to i64* - store i64 3, i64* %17 - %18 = trunc i64 16 to i32 - %19 = tail call ccc i8* @wybe_malloc(i32 %18) - %20 = ptrtoint i8* %19 to i64 - %21 = inttoptr i64 %20 to i64* - store i64 0, i64* %21 - %22 = add i64 %20, 8 - %23 = inttoptr i64 %22 to i64* - store i64 4, i64* %23 - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @multi_specz_cyclic_exe.1, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"multi_specz_cyclic_lib.foo1<0>[7477e50a09]"(i64 %2, i64 %8, i64 %14, i64 %20, i64 3) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @multi_specz_cyclic_exe.3, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"multi_specz_cyclic_lib.printPosition<0>"(i64 %14) - tail call fastcc void @"multi_specz_cyclic_lib.printPosition<0>"(i64 %20) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @multi_specz_cyclic_exe.1, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"multi_specz_cyclic_exe.main<0>"() { + %"tmp#29##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#6##0" = ptrtoint ptr %"tmp#29##0" to i64 + %"tmp#30##0" = inttoptr i64 %"tmp#6##0" to ptr + store i64 0, ptr %"tmp#30##0" + %"tmp#31##0" = add i64 %"tmp#6##0", 8 + %"tmp#32##0" = inttoptr i64 %"tmp#31##0" to ptr + store i64 1, ptr %"tmp#32##0" + %"tmp#33##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#10##0" = ptrtoint ptr %"tmp#33##0" to i64 + %"tmp#34##0" = inttoptr i64 %"tmp#10##0" to ptr + store i64 0, ptr %"tmp#34##0" + %"tmp#35##0" = add i64 %"tmp#10##0", 8 + %"tmp#36##0" = inttoptr i64 %"tmp#35##0" to ptr + store i64 2, ptr %"tmp#36##0" + %"tmp#37##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#14##0" = ptrtoint ptr %"tmp#37##0" to i64 + %"tmp#38##0" = inttoptr i64 %"tmp#14##0" to ptr + store i64 0, ptr %"tmp#38##0" + %"tmp#39##0" = add i64 %"tmp#14##0", 8 + %"tmp#40##0" = inttoptr i64 %"tmp#39##0" to ptr + store i64 3, ptr %"tmp#40##0" + %"tmp#41##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#18##0" = ptrtoint ptr %"tmp#41##0" to i64 + %"tmp#42##0" = inttoptr i64 %"tmp#18##0" to ptr + store i64 0, ptr %"tmp#42##0" + %"tmp#43##0" = add i64 %"tmp#18##0", 8 + %"tmp#44##0" = inttoptr i64 %"tmp#43##0" to ptr + store i64 4, ptr %"tmp#44##0" + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#3" to i64 )) + call ccc void @putchar(i8 10) + tail call fastcc void @"multi_specz_cyclic_lib.foo1<0>[7477e50a09]"(i64 %"tmp#6##0", i64 %"tmp#10##0", i64 %"tmp#14##0", i64 %"tmp#18##0", i64 3) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#2" to i64 )) + call ccc void @putchar(i8 10) + tail call fastcc void @"multi_specz_cyclic_lib.printPosition<0>"(i64 %"tmp#14##0") + tail call fastcc void @"multi_specz_cyclic_lib.printPosition<0>"(i64 %"tmp#18##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#3" to i64 )) + call ccc void @putchar(i8 10) + ret void } + -------------------------------------------------- Module multi_specz_cyclic_lib representation : (not a type) @@ -247,148 +226,109 @@ printPosition(pos##0:multi_specz_cyclic_lib.position)<{<>}; {<"(i64) - - -declare external ccc void @print_int(i64) - - -declare external fastcc void @"multi_specz_cyclic_lib2.foo2<0>[ff3a297a4f]"(i64, i64, i64, i64, i64) - - -declare external fastcc void @"multi_specz_cyclic_lib2.foo2<0>[d4b0b4930c]"(i64, i64, i64, i64, i64) - - -declare external fastcc void @"multi_specz_cyclic_lib2.foo2<0>"(i64, i64, i64, i64, i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"multi_specz_cyclic_lib.foo1<0>"(i64 %"x1##0", i64 %"x2##0", i64 %"x3##0", i64 %"x4##0", i64 %"n##0") { -entry: - %0 = sub i64 %"n##0", 1 - %1 = icmp slt i64 %0, 0 - br i1 %1, label %if.then, label %if.else -if.then: - tail call fastcc void @"multi_specz_cyclic_lib.modifyAndPrint<0>"(i64 %"x1##0", i64 111) - tail call fastcc void @"multi_specz_cyclic_lib.modifyAndPrint<0>"(i64 %"x2##0", i64 222) - tail call fastcc void @"multi_specz_cyclic_lib.modifyAndPrint<0>"(i64 %"x3##0", i64 333) - tail call fastcc void @"multi_specz_cyclic_lib.modifyAndPrint<0>"(i64 %"x4##0", i64 444) - ret void -if.else: - musttail call fastcc void @"multi_specz_cyclic_lib2.foo2<0>"(i64 %"x2##0", i64 %"x3##0", i64 %"x4##0", i64 %"x1##0", i64 %0) - ret void +source_filename = "!ROOT!/final-dump/multi_specz_cyclic_lib.wybe" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c" (\00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c")\00", align 8 +@"cstring#2" = private unnamed_addr constant [ ?? x i8 ] c",\00", align 8 +@"string#3" = private unnamed_addr constant {i64, i64} { i64 2, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +@"string#4" = private unnamed_addr constant {i64, i64} { i64 1, i64 ptrtoint( ptr @"cstring#1" to i64 ) }, align 8 +@"string#5" = private unnamed_addr constant {i64, i64} { i64 1, i64 ptrtoint( ptr @"cstring#2" to i64 ) }, align 8 + +declare external fastcc void @"multi_specz_cyclic_lib2.foo2<0>"(i64, i64, i64, i64, i64) +declare external fastcc void @"multi_specz_cyclic_lib2.foo2<0>[d4b0b4930c]"(i64, i64, i64, i64, i64) +declare external fastcc void @"multi_specz_cyclic_lib2.foo2<0>[ff3a297a4f]"(i64, i64, i64, i64, i64) +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"multi_specz_cyclic_lib.foo1<0>"(i64 %"x1##0", i64 %"x2##0", i64 %"x3##0", i64 %"x4##0", i64 %"n##0") { + %"tmp#0##0" = sub i64 %"n##0", 1 + %"tmp#1##0" = icmp slt i64 %"tmp#0##0", 0 + br i1 %"tmp#1##0", label %if.then.0, label %if.else.0 +if.then.0: + tail call fastcc void @"multi_specz_cyclic_lib.modifyAndPrint<0>"(i64 %"x1##0", i64 111) + tail call fastcc void @"multi_specz_cyclic_lib.modifyAndPrint<0>"(i64 %"x2##0", i64 222) + tail call fastcc void @"multi_specz_cyclic_lib.modifyAndPrint<0>"(i64 %"x3##0", i64 333) + tail call fastcc void @"multi_specz_cyclic_lib.modifyAndPrint<0>"(i64 %"x4##0", i64 444) + ret void +if.else.0: + tail call fastcc void @"multi_specz_cyclic_lib2.foo2<0>"(i64 %"x2##0", i64 %"x3##0", i64 %"x4##0", i64 %"x1##0", i64 %"tmp#0##0") + ret void } - -define external fastcc void @"multi_specz_cyclic_lib.foo1<0>[7477e50a09]"(i64 %"x1##0", i64 %"x2##0", i64 %"x3##0", i64 %"x4##0", i64 %"n##0") { -entry: - %0 = sub i64 %"n##0", 1 - %1 = icmp slt i64 %0, 0 - br i1 %1, label %if.then, label %if.else -if.then: - tail call fastcc void @"multi_specz_cyclic_lib.modifyAndPrint<0>[410bae77d3]"(i64 %"x1##0", i64 111) - tail call fastcc void @"multi_specz_cyclic_lib.modifyAndPrint<0>[410bae77d3]"(i64 %"x2##0", i64 222) - tail call fastcc void @"multi_specz_cyclic_lib.modifyAndPrint<0>"(i64 %"x3##0", i64 333) - tail call fastcc void @"multi_specz_cyclic_lib.modifyAndPrint<0>"(i64 %"x4##0", i64 444) - ret void -if.else: - musttail call fastcc void @"multi_specz_cyclic_lib2.foo2<0>[d4b0b4930c]"(i64 %"x2##0", i64 %"x3##0", i64 %"x4##0", i64 %"x1##0", i64 %0) - ret void +define external fastcc void @"multi_specz_cyclic_lib.foo1<0>[7477e50a09]"(i64 %"x1##0", i64 %"x2##0", i64 %"x3##0", i64 %"x4##0", i64 %"n##0") { + %"tmp#0##0" = sub i64 %"n##0", 1 + %"tmp#1##0" = icmp slt i64 %"tmp#0##0", 0 + br i1 %"tmp#1##0", label %if.then.0, label %if.else.0 +if.then.0: + tail call fastcc void @"multi_specz_cyclic_lib.modifyAndPrint<0>[410bae77d3]"(i64 %"x1##0", i64 111) + tail call fastcc void @"multi_specz_cyclic_lib.modifyAndPrint<0>[410bae77d3]"(i64 %"x2##0", i64 222) + tail call fastcc void @"multi_specz_cyclic_lib.modifyAndPrint<0>"(i64 %"x3##0", i64 333) + tail call fastcc void @"multi_specz_cyclic_lib.modifyAndPrint<0>"(i64 %"x4##0", i64 444) + ret void +if.else.0: + tail call fastcc void @"multi_specz_cyclic_lib2.foo2<0>[d4b0b4930c]"(i64 %"x2##0", i64 %"x3##0", i64 %"x4##0", i64 %"x1##0", i64 %"tmp#0##0") + ret void } - -define external fastcc void @"multi_specz_cyclic_lib.foo1<0>[29a1d4275b]"(i64 %"x1##0", i64 %"x2##0", i64 %"x3##0", i64 %"x4##0", i64 %"n##0") { -entry: - %0 = sub i64 %"n##0", 1 - %1 = icmp slt i64 %0, 0 - br i1 %1, label %if.then, label %if.else -if.then: - tail call fastcc void @"multi_specz_cyclic_lib.modifyAndPrint<0>"(i64 %"x1##0", i64 111) - tail call fastcc void @"multi_specz_cyclic_lib.modifyAndPrint<0>"(i64 %"x2##0", i64 222) - tail call fastcc void @"multi_specz_cyclic_lib.modifyAndPrint<0>[410bae77d3]"(i64 %"x3##0", i64 333) - tail call fastcc void @"multi_specz_cyclic_lib.modifyAndPrint<0>[410bae77d3]"(i64 %"x4##0", i64 444) - ret void -if.else: - musttail call fastcc void @"multi_specz_cyclic_lib2.foo2<0>[ff3a297a4f]"(i64 %"x2##0", i64 %"x3##0", i64 %"x4##0", i64 %"x1##0", i64 %0) - ret void +define external fastcc void @"multi_specz_cyclic_lib.foo1<0>[29a1d4275b]"(i64 %"x1##0", i64 %"x2##0", i64 %"x3##0", i64 %"x4##0", i64 %"n##0") { + %"tmp#0##0" = sub i64 %"n##0", 1 + %"tmp#1##0" = icmp slt i64 %"tmp#0##0", 0 + br i1 %"tmp#1##0", label %if.then.0, label %if.else.0 +if.then.0: + tail call fastcc void @"multi_specz_cyclic_lib.modifyAndPrint<0>"(i64 %"x1##0", i64 111) + tail call fastcc void @"multi_specz_cyclic_lib.modifyAndPrint<0>"(i64 %"x2##0", i64 222) + tail call fastcc void @"multi_specz_cyclic_lib.modifyAndPrint<0>[410bae77d3]"(i64 %"x3##0", i64 333) + tail call fastcc void @"multi_specz_cyclic_lib.modifyAndPrint<0>[410bae77d3]"(i64 %"x4##0", i64 444) + ret void +if.else.0: + tail call fastcc void @"multi_specz_cyclic_lib2.foo2<0>[ff3a297a4f]"(i64 %"x2##0", i64 %"x3##0", i64 %"x4##0", i64 %"x1##0", i64 %"tmp#0##0") + ret void } - -define external fastcc void @"multi_specz_cyclic_lib.modifyAndPrint<0>"(i64 %"pos##0", i64 %"v##0") { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"pos##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = inttoptr i64 %2 to i64* - store i64 %"v##0", i64* %6 - tail call fastcc void @"multi_specz_cyclic_lib.printPosition<0>"(i64 %2) - ret void +define external fastcc void @"multi_specz_cyclic_lib.modifyAndPrint<0>"(i64 %"pos##0", i64 %"v##0") { + %"tmp#2##0" = inttoptr i64 %"pos##0" to ptr + %"tmp#3##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#3##0", ptr %"tmp#2##0", i64 16, i1 0) + %"tmp#4##0" = ptrtoint ptr %"tmp#3##0" to i64 + %"tmp#5##0" = inttoptr i64 %"tmp#4##0" to ptr + store i64 %"v##0", ptr %"tmp#5##0" + tail call fastcc void @"multi_specz_cyclic_lib.printPosition<0>"(i64 %"tmp#4##0") + ret void } - -define external fastcc void @"multi_specz_cyclic_lib.modifyAndPrint<0>[410bae77d3]"(i64 %"pos##0", i64 %"v##0") { -entry: - %0 = inttoptr i64 %"pos##0" to i64* - store i64 %"v##0", i64* %0 - tail call fastcc void @"multi_specz_cyclic_lib.printPosition<0>"(i64 %"pos##0") - ret void +define external fastcc void @"multi_specz_cyclic_lib.modifyAndPrint<0>[410bae77d3]"(i64 %"pos##0", i64 %"v##0") { + %"tmp#2##0" = inttoptr i64 %"pos##0" to ptr + store i64 %"v##0", ptr %"tmp#2##0" + tail call fastcc void @"multi_specz_cyclic_lib.printPosition<0>"(i64 %"pos##0") + ret void } - -define external fastcc void @"multi_specz_cyclic_lib.printPosition<0>"(i64 %"pos##0") { -entry: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @multi_specz_cyclic_lib.1, i32 0, i32 0) to i64)) - %0 = inttoptr i64 %"pos##0" to i64* - %1 = load i64, i64* %0 - tail call ccc void @print_int(i64 %1) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @multi_specz_cyclic_lib.3, i32 0, i32 0) to i64)) - %2 = add i64 %"pos##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - tail call ccc void @print_int(i64 %4) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @multi_specz_cyclic_lib.5, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"multi_specz_cyclic_lib.printPosition<0>"(i64 %"pos##0") { + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#3" to i64 )) + %"tmp#13##0" = inttoptr i64 %"pos##0" to ptr + %"tmp#0##0" = load i64, ptr %"tmp#13##0" + call ccc void @print_int(i64 %"tmp#0##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#5" to i64 )) + %"tmp#14##0" = add i64 %"pos##0", 8 + %"tmp#15##0" = inttoptr i64 %"tmp#14##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#15##0" + call ccc void @print_int(i64 %"tmp#1##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#4" to i64 )) + call ccc void @putchar(i8 10) + ret void } + -------------------------------------------------- Module multi_specz_cyclic_lib.position - representation : address + representation : pointer public submods : public resources: public procs : multi_specz_cyclic_lib.position.=<0> @@ -490,137 +430,114 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'multi_specz_cyclic_lib.position' - - - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i1 @"multi_specz_cyclic_lib.position.=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %"#right##0" to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = icmp eq i64 %1, %6 - br i1 %10, label %if.then, label %if.else -if.then: - %11 = icmp eq i64 %4, %9 - ret i1 %11 -if.else: - ret i1 0 +source_filename = "!ROOT!/final-dump/multi_specz_cyclic_lib.wybe" +target triple ???? + + +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc i1 @"multi_specz_cyclic_lib.position.=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#9##0" = inttoptr i64 %"#left##0" to ptr + %"#left#x##0" = load i64, ptr %"tmp#9##0" + %"tmp#10##0" = add i64 %"#left##0", 8 + %"tmp#11##0" = inttoptr i64 %"tmp#10##0" to ptr + %"#left#y##0" = load i64, ptr %"tmp#11##0" + %"tmp#12##0" = inttoptr i64 %"#right##0" to ptr + %"#right#x##0" = load i64, ptr %"tmp#12##0" + %"tmp#13##0" = add i64 %"#right##0", 8 + %"tmp#14##0" = inttoptr i64 %"tmp#13##0" to ptr + %"#right#y##0" = load i64, ptr %"tmp#14##0" + %"tmp#1##0" = icmp eq i64 %"#left#x##0", %"#right#x##0" + br i1 %"tmp#1##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#15##0" = icmp eq i64 %"#left#y##0", %"#right#y##0" + ret i1 %"tmp#15##0" +if.else.0: + ret i1 0 } - -define external fastcc i64 @"multi_specz_cyclic_lib.position.position<0>"(i64 %"x##0", i64 %"y##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"x##0", i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"y##0", i64* %5 - ret i64 %2 +define external fastcc i64 @"multi_specz_cyclic_lib.position.position<0>"(i64 %"x##0", i64 %"y##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 16) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"x##0", ptr %"tmp#1##0" + %"tmp#2##0" = add i64 %"#rec##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"y##0", ptr %"tmp#3##0" + ret i64 %"#rec##0" } - -define external fastcc {i64, i64} @"multi_specz_cyclic_lib.position.position<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#result##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#result##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = insertvalue {i64, i64} undef, i64 %1, 0 - %6 = insertvalue {i64, i64} %5, i64 %4, 1 - ret {i64, i64} %6 +define external fastcc {i64, i64} @"multi_specz_cyclic_lib.position.position<1>"(i64 %"#result##0") { + %"tmp#0##0" = inttoptr i64 %"#result##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + %"tmp#2##0" = add i64 %"#result##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#3##0" + %"tmp#5##0" = insertvalue {i64, i64} undef, i64 %"tmp#1##0", 0 + %"tmp#6##0" = insertvalue {i64, i64} %"tmp#5##0", i64 %"tmp#4##0", 1 + ret {i64, i64} %"tmp#6##0" } - -define external fastcc i64 @"multi_specz_cyclic_lib.position.x<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#rec##0" to i64* - %1 = load i64, i64* %0 - ret i64 %1 +define external fastcc i64 @"multi_specz_cyclic_lib.position.x<0>"(i64 %"#rec##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + ret i64 %"tmp#1##0" } - -define external fastcc i64 @"multi_specz_cyclic_lib.position.x<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = inttoptr i64 %2 to i64* - store i64 %"#field##0", i64* %6 - ret i64 %2 +define external fastcc i64 @"multi_specz_cyclic_lib.position.x<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"#field##0", ptr %"tmp#3##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"multi_specz_cyclic_lib.position.y<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = add i64 %"#rec##0", 8 - %1 = inttoptr i64 %0 to i64* - %2 = load i64, i64* %1 - ret i64 %2 +define external fastcc i64 @"multi_specz_cyclic_lib.position.y<0>"(i64 %"#rec##0") { + %"tmp#0##0" = add i64 %"#rec##0", 8 + %"tmp#1##0" = inttoptr i64 %"tmp#0##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"multi_specz_cyclic_lib.position.y<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = add i64 %2, 8 - %7 = inttoptr i64 %6 to i64* - store i64 %"#field##0", i64* %7 - ret i64 %2 +define external fastcc i64 @"multi_specz_cyclic_lib.position.y<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = add i64 %"tmp#2##0", 8 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 %"#field##0", ptr %"tmp#4##0" + ret i64 %"tmp#2##0" } - -define external fastcc i1 @"multi_specz_cyclic_lib.position.~=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %"#right##0" to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = icmp eq i64 %1, %6 - br i1 %10, label %if.then, label %if.else -if.then: - %11 = icmp eq i64 %4, %9 - %12 = xor i1 %11, 1 - ret i1 %12 -if.else: - %13 = xor i1 0, 1 - ret i1 %13 +define external fastcc i1 @"multi_specz_cyclic_lib.position.~=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#8##0" = inttoptr i64 %"#left##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#8##0" + %"tmp#9##0" = add i64 %"#left##0", 8 + %"tmp#10##0" = inttoptr i64 %"tmp#9##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#10##0" + %"tmp#11##0" = inttoptr i64 %"#right##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#11##0" + %"tmp#12##0" = add i64 %"#right##0", 8 + %"tmp#13##0" = inttoptr i64 %"tmp#12##0" to ptr + %"tmp#6##0" = load i64, ptr %"tmp#13##0" + %"tmp#7##0" = icmp eq i64 %"tmp#3##0", %"tmp#5##0" + br i1 %"tmp#7##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#0##0" = icmp eq i64 %"tmp#4##0", %"tmp#6##0" + %"tmp#14##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#14##0" +if.else.0: + %"tmp#15##0" = xor i1 0, 1 + ret i1 %"tmp#15##0" } + -------------------------------------------------- Module multi_specz_cyclic_lib2 representation : (not a type) @@ -680,79 +597,61 @@ foo2(x1##0:multi_specz_cyclic_lib.position, x2##0:multi_specz_cyclic_lib.positio LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'multi_specz_cyclic_lib2' - - - - -declare external fastcc void @"multi_specz_cyclic_lib.foo1<0>[7477e50a09]"(i64, i64, i64, i64, i64) - - -declare external fastcc void @"multi_specz_cyclic_lib.modifyAndPrint<0>"(i64, i64) - - -declare external fastcc void @"multi_specz_cyclic_lib.modifyAndPrint<0>[410bae77d3]"(i64, i64) - - -declare external fastcc void @"multi_specz_cyclic_lib.foo1<0>[29a1d4275b]"(i64, i64, i64, i64, i64) - - -declare external fastcc void @"multi_specz_cyclic_lib.foo1<0>"(i64, i64, i64, i64, i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"multi_specz_cyclic_lib2.foo2<0>"(i64 %"x1##0", i64 %"x2##0", i64 %"x3##0", i64 %"x4##0", i64 %"n##0") { -entry: - %0 = sub i64 %"n##0", 1 - %1 = icmp slt i64 %0, 0 - br i1 %1, label %if.then, label %if.else -if.then: - tail call fastcc void @"multi_specz_cyclic_lib.modifyAndPrint<0>"(i64 %"x1##0", i64 111) - tail call fastcc void @"multi_specz_cyclic_lib.modifyAndPrint<0>"(i64 %"x2##0", i64 222) - tail call fastcc void @"multi_specz_cyclic_lib.modifyAndPrint<0>"(i64 %"x3##0", i64 333) - tail call fastcc void @"multi_specz_cyclic_lib.modifyAndPrint<0>"(i64 %"x4##0", i64 444) - ret void -if.else: - musttail call fastcc void @"multi_specz_cyclic_lib.foo1<0>"(i64 %"x2##0", i64 %"x3##0", i64 %"x4##0", i64 %"x1##0", i64 %0) - ret void +source_filename = "!ROOT!/final-dump/multi_specz_cyclic_lib2.wybe" +target triple ???? + + +declare external fastcc void @"multi_specz_cyclic_lib.foo1<0>"(i64, i64, i64, i64, i64) +declare external fastcc void @"multi_specz_cyclic_lib.foo1<0>[29a1d4275b]"(i64, i64, i64, i64, i64) +declare external fastcc void @"multi_specz_cyclic_lib.foo1<0>[7477e50a09]"(i64, i64, i64, i64, i64) +declare external fastcc void @"multi_specz_cyclic_lib.modifyAndPrint<0>"(i64, i64) +declare external fastcc void @"multi_specz_cyclic_lib.modifyAndPrint<0>[410bae77d3]"(i64, i64) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"multi_specz_cyclic_lib2.foo2<0>"(i64 %"x1##0", i64 %"x2##0", i64 %"x3##0", i64 %"x4##0", i64 %"n##0") { + %"tmp#0##0" = sub i64 %"n##0", 1 + %"tmp#1##0" = icmp slt i64 %"tmp#0##0", 0 + br i1 %"tmp#1##0", label %if.then.0, label %if.else.0 +if.then.0: + tail call fastcc void @"multi_specz_cyclic_lib.modifyAndPrint<0>"(i64 %"x1##0", i64 111) + tail call fastcc void @"multi_specz_cyclic_lib.modifyAndPrint<0>"(i64 %"x2##0", i64 222) + tail call fastcc void @"multi_specz_cyclic_lib.modifyAndPrint<0>"(i64 %"x3##0", i64 333) + tail call fastcc void @"multi_specz_cyclic_lib.modifyAndPrint<0>"(i64 %"x4##0", i64 444) + ret void +if.else.0: + tail call fastcc void @"multi_specz_cyclic_lib.foo1<0>"(i64 %"x2##0", i64 %"x3##0", i64 %"x4##0", i64 %"x1##0", i64 %"tmp#0##0") + ret void } - -define external fastcc void @"multi_specz_cyclic_lib2.foo2<0>[d4b0b4930c]"(i64 %"x1##0", i64 %"x2##0", i64 %"x3##0", i64 %"x4##0", i64 %"n##0") { -entry: - %0 = sub i64 %"n##0", 1 - %1 = icmp slt i64 %0, 0 - br i1 %1, label %if.then, label %if.else -if.then: - tail call fastcc void @"multi_specz_cyclic_lib.modifyAndPrint<0>[410bae77d3]"(i64 %"x1##0", i64 111) - tail call fastcc void @"multi_specz_cyclic_lib.modifyAndPrint<0>"(i64 %"x2##0", i64 222) - tail call fastcc void @"multi_specz_cyclic_lib.modifyAndPrint<0>"(i64 %"x3##0", i64 333) - tail call fastcc void @"multi_specz_cyclic_lib.modifyAndPrint<0>[410bae77d3]"(i64 %"x4##0", i64 444) - ret void -if.else: - musttail call fastcc void @"multi_specz_cyclic_lib.foo1<0>[29a1d4275b]"(i64 %"x2##0", i64 %"x3##0", i64 %"x4##0", i64 %"x1##0", i64 %0) - ret void +define external fastcc void @"multi_specz_cyclic_lib2.foo2<0>[d4b0b4930c]"(i64 %"x1##0", i64 %"x2##0", i64 %"x3##0", i64 %"x4##0", i64 %"n##0") { + %"tmp#0##0" = sub i64 %"n##0", 1 + %"tmp#1##0" = icmp slt i64 %"tmp#0##0", 0 + br i1 %"tmp#1##0", label %if.then.0, label %if.else.0 +if.then.0: + tail call fastcc void @"multi_specz_cyclic_lib.modifyAndPrint<0>[410bae77d3]"(i64 %"x1##0", i64 111) + tail call fastcc void @"multi_specz_cyclic_lib.modifyAndPrint<0>"(i64 %"x2##0", i64 222) + tail call fastcc void @"multi_specz_cyclic_lib.modifyAndPrint<0>"(i64 %"x3##0", i64 333) + tail call fastcc void @"multi_specz_cyclic_lib.modifyAndPrint<0>[410bae77d3]"(i64 %"x4##0", i64 444) + ret void +if.else.0: + tail call fastcc void @"multi_specz_cyclic_lib.foo1<0>[29a1d4275b]"(i64 %"x2##0", i64 %"x3##0", i64 %"x4##0", i64 %"x1##0", i64 %"tmp#0##0") + ret void } - -define external fastcc void @"multi_specz_cyclic_lib2.foo2<0>[ff3a297a4f]"(i64 %"x1##0", i64 %"x2##0", i64 %"x3##0", i64 %"x4##0", i64 %"n##0") { -entry: - %0 = sub i64 %"n##0", 1 - %1 = icmp slt i64 %0, 0 - br i1 %1, label %if.then, label %if.else -if.then: - tail call fastcc void @"multi_specz_cyclic_lib.modifyAndPrint<0>"(i64 %"x1##0", i64 111) - tail call fastcc void @"multi_specz_cyclic_lib.modifyAndPrint<0>[410bae77d3]"(i64 %"x2##0", i64 222) - tail call fastcc void @"multi_specz_cyclic_lib.modifyAndPrint<0>[410bae77d3]"(i64 %"x3##0", i64 333) - tail call fastcc void @"multi_specz_cyclic_lib.modifyAndPrint<0>"(i64 %"x4##0", i64 444) - ret void -if.else: - musttail call fastcc void @"multi_specz_cyclic_lib.foo1<0>[7477e50a09]"(i64 %"x2##0", i64 %"x3##0", i64 %"x4##0", i64 %"x1##0", i64 %0) - ret void +define external fastcc void @"multi_specz_cyclic_lib2.foo2<0>[ff3a297a4f]"(i64 %"x1##0", i64 %"x2##0", i64 %"x3##0", i64 %"x4##0", i64 %"n##0") { + %"tmp#0##0" = sub i64 %"n##0", 1 + %"tmp#1##0" = icmp slt i64 %"tmp#0##0", 0 + br i1 %"tmp#1##0", label %if.then.0, label %if.else.0 +if.then.0: + tail call fastcc void @"multi_specz_cyclic_lib.modifyAndPrint<0>"(i64 %"x1##0", i64 111) + tail call fastcc void @"multi_specz_cyclic_lib.modifyAndPrint<0>[410bae77d3]"(i64 %"x2##0", i64 222) + tail call fastcc void @"multi_specz_cyclic_lib.modifyAndPrint<0>[410bae77d3]"(i64 %"x3##0", i64 333) + tail call fastcc void @"multi_specz_cyclic_lib.modifyAndPrint<0>"(i64 %"x4##0", i64 444) + ret void +if.else.0: + tail call fastcc void @"multi_specz_cyclic_lib.foo1<0>[7477e50a09]"(i64 %"x2##0", i64 %"x3##0", i64 %"x4##0", i64 %"x1##0", i64 %"tmp#0##0") + ret void } diff --git a/test-cases/final-dump/multi_specz_cyclic_lib.exp b/test-cases/final-dump/multi_specz_cyclic_lib.exp index 98e5bf21c..5ee3a5ce4 100644 --- a/test-cases/final-dump/multi_specz_cyclic_lib.exp +++ b/test-cases/final-dump/multi_specz_cyclic_lib.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module multi_specz_cyclic_lib representation : (not a type) public submods : position -> multi_specz_cyclic_lib.position @@ -73,99 +76,70 @@ printPosition(pos##0:multi_specz_cyclic_lib.position)<{<>}; {<"(i64) - - -declare external ccc void @print_int(i64) - - -declare external fastcc void @"multi_specz_cyclic_lib2.foo2<0>"(i64, i64, i64, i64, i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"multi_specz_cyclic_lib.foo1<0>"(i64 %"x1##0", i64 %"x2##0", i64 %"x3##0", i64 %"x4##0", i64 %"n##0") { -entry: - %0 = sub i64 %"n##0", 1 - %1 = icmp slt i64 %0, 0 - br i1 %1, label %if.then, label %if.else -if.then: - tail call fastcc void @"multi_specz_cyclic_lib.modifyAndPrint<0>"(i64 %"x1##0", i64 111) - tail call fastcc void @"multi_specz_cyclic_lib.modifyAndPrint<0>"(i64 %"x2##0", i64 222) - tail call fastcc void @"multi_specz_cyclic_lib.modifyAndPrint<0>"(i64 %"x3##0", i64 333) - tail call fastcc void @"multi_specz_cyclic_lib.modifyAndPrint<0>"(i64 %"x4##0", i64 444) - ret void -if.else: - musttail call fastcc void @"multi_specz_cyclic_lib2.foo2<0>"(i64 %"x2##0", i64 %"x3##0", i64 %"x4##0", i64 %"x1##0", i64 %0) - ret void +source_filename = "!ROOT!/final-dump/multi_specz_cyclic_lib.wybe" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c" (\00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c")\00", align 8 +@"cstring#2" = private unnamed_addr constant [ ?? x i8 ] c",\00", align 8 +@"string#3" = private unnamed_addr constant {i64, i64} { i64 2, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +@"string#4" = private unnamed_addr constant {i64, i64} { i64 1, i64 ptrtoint( ptr @"cstring#1" to i64 ) }, align 8 +@"string#5" = private unnamed_addr constant {i64, i64} { i64 1, i64 ptrtoint( ptr @"cstring#2" to i64 ) }, align 8 + +declare external fastcc void @"multi_specz_cyclic_lib2.foo2<0>"(i64, i64, i64, i64, i64) +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"multi_specz_cyclic_lib.foo1<0>"(i64 %"x1##0", i64 %"x2##0", i64 %"x3##0", i64 %"x4##0", i64 %"n##0") { + %"tmp#0##0" = sub i64 %"n##0", 1 + %"tmp#1##0" = icmp slt i64 %"tmp#0##0", 0 + br i1 %"tmp#1##0", label %if.then.0, label %if.else.0 +if.then.0: + tail call fastcc void @"multi_specz_cyclic_lib.modifyAndPrint<0>"(i64 %"x1##0", i64 111) + tail call fastcc void @"multi_specz_cyclic_lib.modifyAndPrint<0>"(i64 %"x2##0", i64 222) + tail call fastcc void @"multi_specz_cyclic_lib.modifyAndPrint<0>"(i64 %"x3##0", i64 333) + tail call fastcc void @"multi_specz_cyclic_lib.modifyAndPrint<0>"(i64 %"x4##0", i64 444) + ret void +if.else.0: + tail call fastcc void @"multi_specz_cyclic_lib2.foo2<0>"(i64 %"x2##0", i64 %"x3##0", i64 %"x4##0", i64 %"x1##0", i64 %"tmp#0##0") + ret void } - -define external fastcc void @"multi_specz_cyclic_lib.modifyAndPrint<0>"(i64 %"pos##0", i64 %"v##0") { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"pos##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = inttoptr i64 %2 to i64* - store i64 %"v##0", i64* %6 - tail call fastcc void @"multi_specz_cyclic_lib.printPosition<0>"(i64 %2) - ret void +define external fastcc void @"multi_specz_cyclic_lib.modifyAndPrint<0>"(i64 %"pos##0", i64 %"v##0") { + %"tmp#2##0" = inttoptr i64 %"pos##0" to ptr + %"tmp#3##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#3##0", ptr %"tmp#2##0", i64 16, i1 0) + %"tmp#4##0" = ptrtoint ptr %"tmp#3##0" to i64 + %"tmp#5##0" = inttoptr i64 %"tmp#4##0" to ptr + store i64 %"v##0", ptr %"tmp#5##0" + tail call fastcc void @"multi_specz_cyclic_lib.printPosition<0>"(i64 %"tmp#4##0") + ret void } - -define external fastcc void @"multi_specz_cyclic_lib.printPosition<0>"(i64 %"pos##0") { -entry: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @multi_specz_cyclic_lib.1, i32 0, i32 0) to i64)) - %0 = inttoptr i64 %"pos##0" to i64* - %1 = load i64, i64* %0 - tail call ccc void @print_int(i64 %1) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @multi_specz_cyclic_lib.3, i32 0, i32 0) to i64)) - %2 = add i64 %"pos##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - tail call ccc void @print_int(i64 %4) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @multi_specz_cyclic_lib.5, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"multi_specz_cyclic_lib.printPosition<0>"(i64 %"pos##0") { + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#3" to i64 )) + %"tmp#13##0" = inttoptr i64 %"pos##0" to ptr + %"tmp#0##0" = load i64, ptr %"tmp#13##0" + call ccc void @print_int(i64 %"tmp#0##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#5" to i64 )) + %"tmp#14##0" = add i64 %"pos##0", 8 + %"tmp#15##0" = inttoptr i64 %"tmp#14##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#15##0" + call ccc void @print_int(i64 %"tmp#1##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#4" to i64 )) + call ccc void @putchar(i8 10) + ret void } + -------------------------------------------------- Module multi_specz_cyclic_lib.position - representation : address + representation : pointer public submods : public resources: public procs : multi_specz_cyclic_lib.position.=<0> @@ -267,137 +241,114 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'multi_specz_cyclic_lib.position' - - - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i1 @"multi_specz_cyclic_lib.position.=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %"#right##0" to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = icmp eq i64 %1, %6 - br i1 %10, label %if.then, label %if.else -if.then: - %11 = icmp eq i64 %4, %9 - ret i1 %11 -if.else: - ret i1 0 +source_filename = "!ROOT!/final-dump/multi_specz_cyclic_lib.wybe" +target triple ???? + + +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc i1 @"multi_specz_cyclic_lib.position.=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#9##0" = inttoptr i64 %"#left##0" to ptr + %"#left#x##0" = load i64, ptr %"tmp#9##0" + %"tmp#10##0" = add i64 %"#left##0", 8 + %"tmp#11##0" = inttoptr i64 %"tmp#10##0" to ptr + %"#left#y##0" = load i64, ptr %"tmp#11##0" + %"tmp#12##0" = inttoptr i64 %"#right##0" to ptr + %"#right#x##0" = load i64, ptr %"tmp#12##0" + %"tmp#13##0" = add i64 %"#right##0", 8 + %"tmp#14##0" = inttoptr i64 %"tmp#13##0" to ptr + %"#right#y##0" = load i64, ptr %"tmp#14##0" + %"tmp#1##0" = icmp eq i64 %"#left#x##0", %"#right#x##0" + br i1 %"tmp#1##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#15##0" = icmp eq i64 %"#left#y##0", %"#right#y##0" + ret i1 %"tmp#15##0" +if.else.0: + ret i1 0 } - -define external fastcc i64 @"multi_specz_cyclic_lib.position.position<0>"(i64 %"x##0", i64 %"y##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"x##0", i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"y##0", i64* %5 - ret i64 %2 +define external fastcc i64 @"multi_specz_cyclic_lib.position.position<0>"(i64 %"x##0", i64 %"y##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 16) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"x##0", ptr %"tmp#1##0" + %"tmp#2##0" = add i64 %"#rec##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"y##0", ptr %"tmp#3##0" + ret i64 %"#rec##0" } - -define external fastcc {i64, i64} @"multi_specz_cyclic_lib.position.position<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#result##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#result##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = insertvalue {i64, i64} undef, i64 %1, 0 - %6 = insertvalue {i64, i64} %5, i64 %4, 1 - ret {i64, i64} %6 +define external fastcc {i64, i64} @"multi_specz_cyclic_lib.position.position<1>"(i64 %"#result##0") { + %"tmp#0##0" = inttoptr i64 %"#result##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + %"tmp#2##0" = add i64 %"#result##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#3##0" + %"tmp#5##0" = insertvalue {i64, i64} undef, i64 %"tmp#1##0", 0 + %"tmp#6##0" = insertvalue {i64, i64} %"tmp#5##0", i64 %"tmp#4##0", 1 + ret {i64, i64} %"tmp#6##0" } - -define external fastcc i64 @"multi_specz_cyclic_lib.position.x<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#rec##0" to i64* - %1 = load i64, i64* %0 - ret i64 %1 +define external fastcc i64 @"multi_specz_cyclic_lib.position.x<0>"(i64 %"#rec##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + ret i64 %"tmp#1##0" } - -define external fastcc i64 @"multi_specz_cyclic_lib.position.x<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = inttoptr i64 %2 to i64* - store i64 %"#field##0", i64* %6 - ret i64 %2 +define external fastcc i64 @"multi_specz_cyclic_lib.position.x<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"#field##0", ptr %"tmp#3##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"multi_specz_cyclic_lib.position.y<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = add i64 %"#rec##0", 8 - %1 = inttoptr i64 %0 to i64* - %2 = load i64, i64* %1 - ret i64 %2 +define external fastcc i64 @"multi_specz_cyclic_lib.position.y<0>"(i64 %"#rec##0") { + %"tmp#0##0" = add i64 %"#rec##0", 8 + %"tmp#1##0" = inttoptr i64 %"tmp#0##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"multi_specz_cyclic_lib.position.y<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = add i64 %2, 8 - %7 = inttoptr i64 %6 to i64* - store i64 %"#field##0", i64* %7 - ret i64 %2 +define external fastcc i64 @"multi_specz_cyclic_lib.position.y<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = add i64 %"tmp#2##0", 8 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 %"#field##0", ptr %"tmp#4##0" + ret i64 %"tmp#2##0" } - -define external fastcc i1 @"multi_specz_cyclic_lib.position.~=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %"#right##0" to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = icmp eq i64 %1, %6 - br i1 %10, label %if.then, label %if.else -if.then: - %11 = icmp eq i64 %4, %9 - %12 = xor i1 %11, 1 - ret i1 %12 -if.else: - %13 = xor i1 0, 1 - ret i1 %13 +define external fastcc i1 @"multi_specz_cyclic_lib.position.~=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#8##0" = inttoptr i64 %"#left##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#8##0" + %"tmp#9##0" = add i64 %"#left##0", 8 + %"tmp#10##0" = inttoptr i64 %"tmp#9##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#10##0" + %"tmp#11##0" = inttoptr i64 %"#right##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#11##0" + %"tmp#12##0" = add i64 %"#right##0", 8 + %"tmp#13##0" = inttoptr i64 %"tmp#12##0" to ptr + %"tmp#6##0" = load i64, ptr %"tmp#13##0" + %"tmp#7##0" = icmp eq i64 %"tmp#3##0", %"tmp#5##0" + br i1 %"tmp#7##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#0##0" = icmp eq i64 %"tmp#4##0", %"tmp#6##0" + %"tmp#14##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#14##0" +if.else.0: + %"tmp#15##0" = xor i1 0, 1 + ret i1 %"tmp#15##0" } + -------------------------------------------------- Module multi_specz_cyclic_lib2 representation : (not a type) @@ -430,36 +381,28 @@ foo2(x1##0:multi_specz_cyclic_lib.position, x2##0:multi_specz_cyclic_lib.positio LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'multi_specz_cyclic_lib2' - - - - -declare external fastcc void @"multi_specz_cyclic_lib.foo1<0>"(i64, i64, i64, i64, i64) - - -declare external fastcc void @"multi_specz_cyclic_lib.modifyAndPrint<0>"(i64, i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"multi_specz_cyclic_lib2.foo2<0>"(i64 %"x1##0", i64 %"x2##0", i64 %"x3##0", i64 %"x4##0", i64 %"n##0") { -entry: - %0 = sub i64 %"n##0", 1 - %1 = icmp slt i64 %0, 0 - br i1 %1, label %if.then, label %if.else -if.then: - tail call fastcc void @"multi_specz_cyclic_lib.modifyAndPrint<0>"(i64 %"x1##0", i64 111) - tail call fastcc void @"multi_specz_cyclic_lib.modifyAndPrint<0>"(i64 %"x2##0", i64 222) - tail call fastcc void @"multi_specz_cyclic_lib.modifyAndPrint<0>"(i64 %"x3##0", i64 333) - tail call fastcc void @"multi_specz_cyclic_lib.modifyAndPrint<0>"(i64 %"x4##0", i64 444) - ret void -if.else: - musttail call fastcc void @"multi_specz_cyclic_lib.foo1<0>"(i64 %"x2##0", i64 %"x3##0", i64 %"x4##0", i64 %"x1##0", i64 %0) - ret void +source_filename = "!ROOT!/final-dump/multi_specz_cyclic_lib2.wybe" +target triple ???? + + +declare external fastcc void @"multi_specz_cyclic_lib.foo1<0>"(i64, i64, i64, i64, i64) +declare external fastcc void @"multi_specz_cyclic_lib.modifyAndPrint<0>"(i64, i64) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"multi_specz_cyclic_lib2.foo2<0>"(i64 %"x1##0", i64 %"x2##0", i64 %"x3##0", i64 %"x4##0", i64 %"n##0") { + %"tmp#0##0" = sub i64 %"n##0", 1 + %"tmp#1##0" = icmp slt i64 %"tmp#0##0", 0 + br i1 %"tmp#1##0", label %if.then.0, label %if.else.0 +if.then.0: + tail call fastcc void @"multi_specz_cyclic_lib.modifyAndPrint<0>"(i64 %"x1##0", i64 111) + tail call fastcc void @"multi_specz_cyclic_lib.modifyAndPrint<0>"(i64 %"x2##0", i64 222) + tail call fastcc void @"multi_specz_cyclic_lib.modifyAndPrint<0>"(i64 %"x3##0", i64 333) + tail call fastcc void @"multi_specz_cyclic_lib.modifyAndPrint<0>"(i64 %"x4##0", i64 444) + ret void +if.else.0: + tail call fastcc void @"multi_specz_cyclic_lib.foo1<0>"(i64 %"x2##0", i64 %"x3##0", i64 %"x4##0", i64 %"x1##0", i64 %"tmp#0##0") + ret void } diff --git a/test-cases/final-dump/multi_specz_cyclic_lib2.exp b/test-cases/final-dump/multi_specz_cyclic_lib2.exp index 98e5bf21c..5ee3a5ce4 100644 --- a/test-cases/final-dump/multi_specz_cyclic_lib2.exp +++ b/test-cases/final-dump/multi_specz_cyclic_lib2.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module multi_specz_cyclic_lib representation : (not a type) public submods : position -> multi_specz_cyclic_lib.position @@ -73,99 +76,70 @@ printPosition(pos##0:multi_specz_cyclic_lib.position)<{<>}; {<"(i64) - - -declare external ccc void @print_int(i64) - - -declare external fastcc void @"multi_specz_cyclic_lib2.foo2<0>"(i64, i64, i64, i64, i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"multi_specz_cyclic_lib.foo1<0>"(i64 %"x1##0", i64 %"x2##0", i64 %"x3##0", i64 %"x4##0", i64 %"n##0") { -entry: - %0 = sub i64 %"n##0", 1 - %1 = icmp slt i64 %0, 0 - br i1 %1, label %if.then, label %if.else -if.then: - tail call fastcc void @"multi_specz_cyclic_lib.modifyAndPrint<0>"(i64 %"x1##0", i64 111) - tail call fastcc void @"multi_specz_cyclic_lib.modifyAndPrint<0>"(i64 %"x2##0", i64 222) - tail call fastcc void @"multi_specz_cyclic_lib.modifyAndPrint<0>"(i64 %"x3##0", i64 333) - tail call fastcc void @"multi_specz_cyclic_lib.modifyAndPrint<0>"(i64 %"x4##0", i64 444) - ret void -if.else: - musttail call fastcc void @"multi_specz_cyclic_lib2.foo2<0>"(i64 %"x2##0", i64 %"x3##0", i64 %"x4##0", i64 %"x1##0", i64 %0) - ret void +source_filename = "!ROOT!/final-dump/multi_specz_cyclic_lib.wybe" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c" (\00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c")\00", align 8 +@"cstring#2" = private unnamed_addr constant [ ?? x i8 ] c",\00", align 8 +@"string#3" = private unnamed_addr constant {i64, i64} { i64 2, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +@"string#4" = private unnamed_addr constant {i64, i64} { i64 1, i64 ptrtoint( ptr @"cstring#1" to i64 ) }, align 8 +@"string#5" = private unnamed_addr constant {i64, i64} { i64 1, i64 ptrtoint( ptr @"cstring#2" to i64 ) }, align 8 + +declare external fastcc void @"multi_specz_cyclic_lib2.foo2<0>"(i64, i64, i64, i64, i64) +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"multi_specz_cyclic_lib.foo1<0>"(i64 %"x1##0", i64 %"x2##0", i64 %"x3##0", i64 %"x4##0", i64 %"n##0") { + %"tmp#0##0" = sub i64 %"n##0", 1 + %"tmp#1##0" = icmp slt i64 %"tmp#0##0", 0 + br i1 %"tmp#1##0", label %if.then.0, label %if.else.0 +if.then.0: + tail call fastcc void @"multi_specz_cyclic_lib.modifyAndPrint<0>"(i64 %"x1##0", i64 111) + tail call fastcc void @"multi_specz_cyclic_lib.modifyAndPrint<0>"(i64 %"x2##0", i64 222) + tail call fastcc void @"multi_specz_cyclic_lib.modifyAndPrint<0>"(i64 %"x3##0", i64 333) + tail call fastcc void @"multi_specz_cyclic_lib.modifyAndPrint<0>"(i64 %"x4##0", i64 444) + ret void +if.else.0: + tail call fastcc void @"multi_specz_cyclic_lib2.foo2<0>"(i64 %"x2##0", i64 %"x3##0", i64 %"x4##0", i64 %"x1##0", i64 %"tmp#0##0") + ret void } - -define external fastcc void @"multi_specz_cyclic_lib.modifyAndPrint<0>"(i64 %"pos##0", i64 %"v##0") { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"pos##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = inttoptr i64 %2 to i64* - store i64 %"v##0", i64* %6 - tail call fastcc void @"multi_specz_cyclic_lib.printPosition<0>"(i64 %2) - ret void +define external fastcc void @"multi_specz_cyclic_lib.modifyAndPrint<0>"(i64 %"pos##0", i64 %"v##0") { + %"tmp#2##0" = inttoptr i64 %"pos##0" to ptr + %"tmp#3##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#3##0", ptr %"tmp#2##0", i64 16, i1 0) + %"tmp#4##0" = ptrtoint ptr %"tmp#3##0" to i64 + %"tmp#5##0" = inttoptr i64 %"tmp#4##0" to ptr + store i64 %"v##0", ptr %"tmp#5##0" + tail call fastcc void @"multi_specz_cyclic_lib.printPosition<0>"(i64 %"tmp#4##0") + ret void } - -define external fastcc void @"multi_specz_cyclic_lib.printPosition<0>"(i64 %"pos##0") { -entry: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @multi_specz_cyclic_lib.1, i32 0, i32 0) to i64)) - %0 = inttoptr i64 %"pos##0" to i64* - %1 = load i64, i64* %0 - tail call ccc void @print_int(i64 %1) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @multi_specz_cyclic_lib.3, i32 0, i32 0) to i64)) - %2 = add i64 %"pos##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - tail call ccc void @print_int(i64 %4) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @multi_specz_cyclic_lib.5, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"multi_specz_cyclic_lib.printPosition<0>"(i64 %"pos##0") { + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#3" to i64 )) + %"tmp#13##0" = inttoptr i64 %"pos##0" to ptr + %"tmp#0##0" = load i64, ptr %"tmp#13##0" + call ccc void @print_int(i64 %"tmp#0##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#5" to i64 )) + %"tmp#14##0" = add i64 %"pos##0", 8 + %"tmp#15##0" = inttoptr i64 %"tmp#14##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#15##0" + call ccc void @print_int(i64 %"tmp#1##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#4" to i64 )) + call ccc void @putchar(i8 10) + ret void } + -------------------------------------------------- Module multi_specz_cyclic_lib.position - representation : address + representation : pointer public submods : public resources: public procs : multi_specz_cyclic_lib.position.=<0> @@ -267,137 +241,114 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'multi_specz_cyclic_lib.position' - - - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i1 @"multi_specz_cyclic_lib.position.=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %"#right##0" to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = icmp eq i64 %1, %6 - br i1 %10, label %if.then, label %if.else -if.then: - %11 = icmp eq i64 %4, %9 - ret i1 %11 -if.else: - ret i1 0 +source_filename = "!ROOT!/final-dump/multi_specz_cyclic_lib.wybe" +target triple ???? + + +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc i1 @"multi_specz_cyclic_lib.position.=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#9##0" = inttoptr i64 %"#left##0" to ptr + %"#left#x##0" = load i64, ptr %"tmp#9##0" + %"tmp#10##0" = add i64 %"#left##0", 8 + %"tmp#11##0" = inttoptr i64 %"tmp#10##0" to ptr + %"#left#y##0" = load i64, ptr %"tmp#11##0" + %"tmp#12##0" = inttoptr i64 %"#right##0" to ptr + %"#right#x##0" = load i64, ptr %"tmp#12##0" + %"tmp#13##0" = add i64 %"#right##0", 8 + %"tmp#14##0" = inttoptr i64 %"tmp#13##0" to ptr + %"#right#y##0" = load i64, ptr %"tmp#14##0" + %"tmp#1##0" = icmp eq i64 %"#left#x##0", %"#right#x##0" + br i1 %"tmp#1##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#15##0" = icmp eq i64 %"#left#y##0", %"#right#y##0" + ret i1 %"tmp#15##0" +if.else.0: + ret i1 0 } - -define external fastcc i64 @"multi_specz_cyclic_lib.position.position<0>"(i64 %"x##0", i64 %"y##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"x##0", i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"y##0", i64* %5 - ret i64 %2 +define external fastcc i64 @"multi_specz_cyclic_lib.position.position<0>"(i64 %"x##0", i64 %"y##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 16) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"x##0", ptr %"tmp#1##0" + %"tmp#2##0" = add i64 %"#rec##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"y##0", ptr %"tmp#3##0" + ret i64 %"#rec##0" } - -define external fastcc {i64, i64} @"multi_specz_cyclic_lib.position.position<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#result##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#result##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = insertvalue {i64, i64} undef, i64 %1, 0 - %6 = insertvalue {i64, i64} %5, i64 %4, 1 - ret {i64, i64} %6 +define external fastcc {i64, i64} @"multi_specz_cyclic_lib.position.position<1>"(i64 %"#result##0") { + %"tmp#0##0" = inttoptr i64 %"#result##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + %"tmp#2##0" = add i64 %"#result##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#3##0" + %"tmp#5##0" = insertvalue {i64, i64} undef, i64 %"tmp#1##0", 0 + %"tmp#6##0" = insertvalue {i64, i64} %"tmp#5##0", i64 %"tmp#4##0", 1 + ret {i64, i64} %"tmp#6##0" } - -define external fastcc i64 @"multi_specz_cyclic_lib.position.x<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#rec##0" to i64* - %1 = load i64, i64* %0 - ret i64 %1 +define external fastcc i64 @"multi_specz_cyclic_lib.position.x<0>"(i64 %"#rec##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + ret i64 %"tmp#1##0" } - -define external fastcc i64 @"multi_specz_cyclic_lib.position.x<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = inttoptr i64 %2 to i64* - store i64 %"#field##0", i64* %6 - ret i64 %2 +define external fastcc i64 @"multi_specz_cyclic_lib.position.x<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"#field##0", ptr %"tmp#3##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"multi_specz_cyclic_lib.position.y<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = add i64 %"#rec##0", 8 - %1 = inttoptr i64 %0 to i64* - %2 = load i64, i64* %1 - ret i64 %2 +define external fastcc i64 @"multi_specz_cyclic_lib.position.y<0>"(i64 %"#rec##0") { + %"tmp#0##0" = add i64 %"#rec##0", 8 + %"tmp#1##0" = inttoptr i64 %"tmp#0##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"multi_specz_cyclic_lib.position.y<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = add i64 %2, 8 - %7 = inttoptr i64 %6 to i64* - store i64 %"#field##0", i64* %7 - ret i64 %2 +define external fastcc i64 @"multi_specz_cyclic_lib.position.y<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = add i64 %"tmp#2##0", 8 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 %"#field##0", ptr %"tmp#4##0" + ret i64 %"tmp#2##0" } - -define external fastcc i1 @"multi_specz_cyclic_lib.position.~=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %"#right##0" to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = icmp eq i64 %1, %6 - br i1 %10, label %if.then, label %if.else -if.then: - %11 = icmp eq i64 %4, %9 - %12 = xor i1 %11, 1 - ret i1 %12 -if.else: - %13 = xor i1 0, 1 - ret i1 %13 +define external fastcc i1 @"multi_specz_cyclic_lib.position.~=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#8##0" = inttoptr i64 %"#left##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#8##0" + %"tmp#9##0" = add i64 %"#left##0", 8 + %"tmp#10##0" = inttoptr i64 %"tmp#9##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#10##0" + %"tmp#11##0" = inttoptr i64 %"#right##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#11##0" + %"tmp#12##0" = add i64 %"#right##0", 8 + %"tmp#13##0" = inttoptr i64 %"tmp#12##0" to ptr + %"tmp#6##0" = load i64, ptr %"tmp#13##0" + %"tmp#7##0" = icmp eq i64 %"tmp#3##0", %"tmp#5##0" + br i1 %"tmp#7##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#0##0" = icmp eq i64 %"tmp#4##0", %"tmp#6##0" + %"tmp#14##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#14##0" +if.else.0: + %"tmp#15##0" = xor i1 0, 1 + ret i1 %"tmp#15##0" } + -------------------------------------------------- Module multi_specz_cyclic_lib2 representation : (not a type) @@ -430,36 +381,28 @@ foo2(x1##0:multi_specz_cyclic_lib.position, x2##0:multi_specz_cyclic_lib.positio LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'multi_specz_cyclic_lib2' - - - - -declare external fastcc void @"multi_specz_cyclic_lib.foo1<0>"(i64, i64, i64, i64, i64) - - -declare external fastcc void @"multi_specz_cyclic_lib.modifyAndPrint<0>"(i64, i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"multi_specz_cyclic_lib2.foo2<0>"(i64 %"x1##0", i64 %"x2##0", i64 %"x3##0", i64 %"x4##0", i64 %"n##0") { -entry: - %0 = sub i64 %"n##0", 1 - %1 = icmp slt i64 %0, 0 - br i1 %1, label %if.then, label %if.else -if.then: - tail call fastcc void @"multi_specz_cyclic_lib.modifyAndPrint<0>"(i64 %"x1##0", i64 111) - tail call fastcc void @"multi_specz_cyclic_lib.modifyAndPrint<0>"(i64 %"x2##0", i64 222) - tail call fastcc void @"multi_specz_cyclic_lib.modifyAndPrint<0>"(i64 %"x3##0", i64 333) - tail call fastcc void @"multi_specz_cyclic_lib.modifyAndPrint<0>"(i64 %"x4##0", i64 444) - ret void -if.else: - musttail call fastcc void @"multi_specz_cyclic_lib.foo1<0>"(i64 %"x2##0", i64 %"x3##0", i64 %"x4##0", i64 %"x1##0", i64 %0) - ret void +source_filename = "!ROOT!/final-dump/multi_specz_cyclic_lib2.wybe" +target triple ???? + + +declare external fastcc void @"multi_specz_cyclic_lib.foo1<0>"(i64, i64, i64, i64, i64) +declare external fastcc void @"multi_specz_cyclic_lib.modifyAndPrint<0>"(i64, i64) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"multi_specz_cyclic_lib2.foo2<0>"(i64 %"x1##0", i64 %"x2##0", i64 %"x3##0", i64 %"x4##0", i64 %"n##0") { + %"tmp#0##0" = sub i64 %"n##0", 1 + %"tmp#1##0" = icmp slt i64 %"tmp#0##0", 0 + br i1 %"tmp#1##0", label %if.then.0, label %if.else.0 +if.then.0: + tail call fastcc void @"multi_specz_cyclic_lib.modifyAndPrint<0>"(i64 %"x1##0", i64 111) + tail call fastcc void @"multi_specz_cyclic_lib.modifyAndPrint<0>"(i64 %"x2##0", i64 222) + tail call fastcc void @"multi_specz_cyclic_lib.modifyAndPrint<0>"(i64 %"x3##0", i64 333) + tail call fastcc void @"multi_specz_cyclic_lib.modifyAndPrint<0>"(i64 %"x4##0", i64 444) + ret void +if.else.0: + tail call fastcc void @"multi_specz_cyclic_lib.foo1<0>"(i64 %"x2##0", i64 %"x3##0", i64 %"x4##0", i64 %"x1##0", i64 %"tmp#0##0") + ret void } diff --git a/test-cases/final-dump/multi_specz_reverse.exp b/test-cases/final-dump/multi_specz_reverse.exp index 632c33c5e..55a0f545a 100644 --- a/test-cases/final-dump/multi_specz_reverse.exp +++ b/test-cases/final-dump/multi_specz_reverse.exp @@ -139,134 +139,134 @@ declare external ccc void @putchar(i8) declare external ccc void @print_string(i64) -@multi_specz_reverse.81 = constant [29 x i8] c"============================\00" +@multi_specz_reverse.81 = constant [?? x i8] c"============================\00" declare external ccc void @print_int(i64) -@multi_specz_reverse.90 = constant [2 x i8] c" \00" +@multi_specz_reverse.90 = constant [?? x i8] c" \00" -declare external ccc i8* @wybe_malloc(i32) +declare external ccc ptr @wybe_malloc(i32) -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i32, i1) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i32, i32, i1) define external fastcc void @"multi_specz_reverse.<0>"(i64 %"argc##0", i64 %"argv##0", i64 %"exit_code##0") { entry: %1 = trunc i64 16 to i32 - %2 = tail call ccc i8* @wybe_malloc(i32 %1) - %3 = ptrtoint i8* %2 to i64 - %4 = inttoptr i64 %3 to i64* - %5 = getelementptr i64, i64* %4, i64 0 - store i64 10, i64* %5 + %2 = call ccc ptr @wybe_malloc(i32 %1) + %3 = ptrtoint ptr %2 to i64 + %4 = inttoptr i64 %3 to ptr + %5 = getelementptr i64, ptr %4, i64 0 + store i64 10, ptr %5 %6 = add i64 %3, 8 - %7 = inttoptr i64 %6 to i64* - %8 = getelementptr i64, i64* %7, i64 0 - store i64 0, i64* %8 + %7 = inttoptr i64 %6 to ptr + %8 = getelementptr i64, ptr %7, i64 0 + store i64 0, ptr %8 %9 = trunc i64 16 to i32 - %10 = tail call ccc i8* @wybe_malloc(i32 %9) - %11 = ptrtoint i8* %10 to i64 - %12 = inttoptr i64 %11 to i64* - %13 = getelementptr i64, i64* %12, i64 0 - store i64 9, i64* %13 + %10 = call ccc ptr @wybe_malloc(i32 %9) + %11 = ptrtoint ptr %10 to i64 + %12 = inttoptr i64 %11 to ptr + %13 = getelementptr i64, ptr %12, i64 0 + store i64 9, ptr %13 %14 = add i64 %11, 8 - %15 = inttoptr i64 %14 to i64* - %16 = getelementptr i64, i64* %15, i64 0 - store i64 %3, i64* %16 + %15 = inttoptr i64 %14 to ptr + %16 = getelementptr i64, ptr %15, i64 0 + store i64 %3, ptr %16 %17 = trunc i64 16 to i32 - %18 = tail call ccc i8* @wybe_malloc(i32 %17) - %19 = ptrtoint i8* %18 to i64 - %20 = inttoptr i64 %19 to i64* - %21 = getelementptr i64, i64* %20, i64 0 - store i64 8, i64* %21 + %18 = call ccc ptr @wybe_malloc(i32 %17) + %19 = ptrtoint ptr %18 to i64 + %20 = inttoptr i64 %19 to ptr + %21 = getelementptr i64, ptr %20, i64 0 + store i64 8, ptr %21 %22 = add i64 %19, 8 - %23 = inttoptr i64 %22 to i64* - %24 = getelementptr i64, i64* %23, i64 0 - store i64 %11, i64* %24 + %23 = inttoptr i64 %22 to ptr + %24 = getelementptr i64, ptr %23, i64 0 + store i64 %11, ptr %24 %25 = trunc i64 16 to i32 - %26 = tail call ccc i8* @wybe_malloc(i32 %25) - %27 = ptrtoint i8* %26 to i64 - %28 = inttoptr i64 %27 to i64* - %29 = getelementptr i64, i64* %28, i64 0 - store i64 7, i64* %29 + %26 = call ccc ptr @wybe_malloc(i32 %25) + %27 = ptrtoint ptr %26 to i64 + %28 = inttoptr i64 %27 to ptr + %29 = getelementptr i64, ptr %28, i64 0 + store i64 7, ptr %29 %30 = add i64 %27, 8 - %31 = inttoptr i64 %30 to i64* - %32 = getelementptr i64, i64* %31, i64 0 - store i64 %19, i64* %32 + %31 = inttoptr i64 %30 to ptr + %32 = getelementptr i64, ptr %31, i64 0 + store i64 %19, ptr %32 %33 = trunc i64 16 to i32 - %34 = tail call ccc i8* @wybe_malloc(i32 %33) - %35 = ptrtoint i8* %34 to i64 - %36 = inttoptr i64 %35 to i64* - %37 = getelementptr i64, i64* %36, i64 0 - store i64 6, i64* %37 + %34 = call ccc ptr @wybe_malloc(i32 %33) + %35 = ptrtoint ptr %34 to i64 + %36 = inttoptr i64 %35 to ptr + %37 = getelementptr i64, ptr %36, i64 0 + store i64 6, ptr %37 %38 = add i64 %35, 8 - %39 = inttoptr i64 %38 to i64* - %40 = getelementptr i64, i64* %39, i64 0 - store i64 %27, i64* %40 + %39 = inttoptr i64 %38 to ptr + %40 = getelementptr i64, ptr %39, i64 0 + store i64 %27, ptr %40 %41 = trunc i64 16 to i32 - %42 = tail call ccc i8* @wybe_malloc(i32 %41) - %43 = ptrtoint i8* %42 to i64 - %44 = inttoptr i64 %43 to i64* - %45 = getelementptr i64, i64* %44, i64 0 - store i64 5, i64* %45 + %42 = call ccc ptr @wybe_malloc(i32 %41) + %43 = ptrtoint ptr %42 to i64 + %44 = inttoptr i64 %43 to ptr + %45 = getelementptr i64, ptr %44, i64 0 + store i64 5, ptr %45 %46 = add i64 %43, 8 - %47 = inttoptr i64 %46 to i64* - %48 = getelementptr i64, i64* %47, i64 0 - store i64 %35, i64* %48 + %47 = inttoptr i64 %46 to ptr + %48 = getelementptr i64, ptr %47, i64 0 + store i64 %35, ptr %48 %49 = trunc i64 16 to i32 - %50 = tail call ccc i8* @wybe_malloc(i32 %49) - %51 = ptrtoint i8* %50 to i64 - %52 = inttoptr i64 %51 to i64* - %53 = getelementptr i64, i64* %52, i64 0 - store i64 4, i64* %53 + %50 = call ccc ptr @wybe_malloc(i32 %49) + %51 = ptrtoint ptr %50 to i64 + %52 = inttoptr i64 %51 to ptr + %53 = getelementptr i64, ptr %52, i64 0 + store i64 4, ptr %53 %54 = add i64 %51, 8 - %55 = inttoptr i64 %54 to i64* - %56 = getelementptr i64, i64* %55, i64 0 - store i64 %43, i64* %56 + %55 = inttoptr i64 %54 to ptr + %56 = getelementptr i64, ptr %55, i64 0 + store i64 %43, ptr %56 %57 = trunc i64 16 to i32 - %58 = tail call ccc i8* @wybe_malloc(i32 %57) - %59 = ptrtoint i8* %58 to i64 - %60 = inttoptr i64 %59 to i64* - %61 = getelementptr i64, i64* %60, i64 0 - store i64 3, i64* %61 + %58 = call ccc ptr @wybe_malloc(i32 %57) + %59 = ptrtoint ptr %58 to i64 + %60 = inttoptr i64 %59 to ptr + %61 = getelementptr i64, ptr %60, i64 0 + store i64 3, ptr %61 %62 = add i64 %59, 8 - %63 = inttoptr i64 %62 to i64* - %64 = getelementptr i64, i64* %63, i64 0 - store i64 %51, i64* %64 + %63 = inttoptr i64 %62 to ptr + %64 = getelementptr i64, ptr %63, i64 0 + store i64 %51, ptr %64 %65 = trunc i64 16 to i32 - %66 = tail call ccc i8* @wybe_malloc(i32 %65) - %67 = ptrtoint i8* %66 to i64 - %68 = inttoptr i64 %67 to i64* - %69 = getelementptr i64, i64* %68, i64 0 - store i64 2, i64* %69 + %66 = call ccc ptr @wybe_malloc(i32 %65) + %67 = ptrtoint ptr %66 to i64 + %68 = inttoptr i64 %67 to ptr + %69 = getelementptr i64, ptr %68, i64 0 + store i64 2, ptr %69 %70 = add i64 %67, 8 - %71 = inttoptr i64 %70 to i64* - %72 = getelementptr i64, i64* %71, i64 0 - store i64 %59, i64* %72 + %71 = inttoptr i64 %70 to ptr + %72 = getelementptr i64, ptr %71, i64 0 + store i64 %59, ptr %72 %73 = trunc i64 16 to i32 - %74 = tail call ccc i8* @wybe_malloc(i32 %73) - %75 = ptrtoint i8* %74 to i64 - %76 = inttoptr i64 %75 to i64* - %77 = getelementptr i64, i64* %76, i64 0 - store i64 1, i64* %77 + %74 = call ccc ptr @wybe_malloc(i32 %73) + %75 = ptrtoint ptr %74 to i64 + %76 = inttoptr i64 %75 to ptr + %77 = getelementptr i64, ptr %76, i64 0 + store i64 1, ptr %77 %78 = add i64 %75, 8 - %79 = inttoptr i64 %78 to i64* - %80 = getelementptr i64, i64* %79, i64 0 - store i64 %67, i64* %80 + %79 = inttoptr i64 %78 to ptr + %80 = getelementptr i64, ptr %79, i64 0 + store i64 %67, ptr %80 %"1#foo##1" = tail call fastcc i64 @"multi_specz_reverse.list_reverse_helper<0>[04d1467a4d]"(i64 %75, i64 0) tail call fastcc void @"multi_specz_reverse.list_print<0>"(i64 %"1#foo##1") - tail call ccc void @putchar(i8 10) - %82 = ptrtoint i8* getelementptr inbounds ([29 x i8], [29 x i8]* @multi_specz_reverse.81, i32 0, i32 0) to i64 - tail call ccc void @print_string(i64 %82) - tail call ccc void @putchar(i8 10) + call ccc void @putchar(i8 10) + %82 = ptrtoint ptr getelementptr inbounds ([?? x i8], ptr @multi_specz_reverse.81, i32 0, i32 0) to i64 + call ccc void @print_string(i64 %82) + call ccc void @putchar(i8 10) %"1#foo##2" = tail call fastcc i64 @"multi_specz_reverse.list_reverse_helper<0>"(i64 %"1#foo##1", i64 0) tail call fastcc void @"multi_specz_reverse.list_print<0>"(i64 %"1#foo##2") - tail call ccc void @putchar(i8 10) + call ccc void @putchar(i8 10) tail call fastcc void @"multi_specz_reverse.list_print<0>"(i64 %"1#foo##1") - tail call ccc void @putchar(i8 10) + call ccc void @putchar(i8 10) ret void } @@ -276,16 +276,16 @@ entry: %"1#tmp#2##0" = icmp ne i64 %"x##0", 0 br i1 %"1#tmp#2##0", label %if.then, label %if.else if.then: - %83 = inttoptr i64 %"x##0" to i64* - %84 = getelementptr i64, i64* %83, i64 0 - %85 = load i64, i64* %84 + %83 = inttoptr i64 %"x##0" to ptr + %84 = getelementptr i64, ptr %83, i64 0 + %85 = load i64, ptr %84 %86 = add i64 %"x##0", 8 - %87 = inttoptr i64 %86 to i64* - %88 = getelementptr i64, i64* %87, i64 0 - %89 = load i64, i64* %88 - tail call ccc void @print_int(i64 %85) - %91 = ptrtoint i8* getelementptr inbounds ([2 x i8], [2 x i8]* @multi_specz_reverse.90, i32 0, i32 0) to i64 - tail call ccc void @print_string(i64 %91) + %87 = inttoptr i64 %86 to ptr + %88 = getelementptr i64, ptr %87, i64 0 + %89 = load i64, ptr %88 + call ccc void @print_int(i64 %85) + %91 = ptrtoint ptr getelementptr inbounds ([?? x i8], ptr @multi_specz_reverse.90, i32 0, i32 0) to i64 + call ccc void @print_string(i64 %91) tail call fastcc void @"multi_specz_reverse.list_print<0>"(i64 %89) ret void if.else: @@ -305,23 +305,23 @@ entry: %"1#tmp#5##0" = icmp ne i64 %"lst##0", 0 br i1 %"1#tmp#5##0", label %if.then, label %if.else if.then: - %92 = inttoptr i64 %"lst##0" to i64* - %93 = getelementptr i64, i64* %92, i64 0 - %94 = load i64, i64* %93 + %92 = inttoptr i64 %"lst##0" to ptr + %93 = getelementptr i64, ptr %92, i64 0 + %94 = load i64, ptr %93 %95 = add i64 %"lst##0", 8 - %96 = inttoptr i64 %95 to i64* - %97 = getelementptr i64, i64* %96, i64 0 - %98 = load i64, i64* %97 + %96 = inttoptr i64 %95 to ptr + %97 = getelementptr i64, ptr %96, i64 0 + %98 = load i64, ptr %97 %99 = trunc i64 16 to i32 - %100 = tail call ccc i8* @wybe_malloc(i32 %99) - %101 = ptrtoint i8* %100 to i64 - %102 = inttoptr i64 %101 to i64* - %103 = getelementptr i64, i64* %102, i64 0 - store i64 %94, i64* %103 + %100 = call ccc ptr @wybe_malloc(i32 %99) + %101 = ptrtoint ptr %100 to i64 + %102 = inttoptr i64 %101 to ptr + %103 = getelementptr i64, ptr %102, i64 0 + store i64 %94, ptr %103 %104 = add i64 %101, 8 - %105 = inttoptr i64 %104 to i64* - %106 = getelementptr i64, i64* %105, i64 0 - store i64 %"acc##0", i64* %106 + %105 = inttoptr i64 %104 to ptr + %106 = getelementptr i64, ptr %105, i64 0 + store i64 %"acc##0", ptr %106 %"2#success##0" = tail call fastcc i64 @"multi_specz_reverse.list_reverse_helper<0>"(i64 %98, i64 %101) ret i64 %"2#success##0" if.else: @@ -335,13 +335,13 @@ entry: br i1 %"1#tmp#5##0", label %if.then, label %if.else if.then: %107 = add i64 %"lst##0", 8 - %108 = inttoptr i64 %107 to i64* - %109 = getelementptr i64, i64* %108, i64 0 - %110 = load i64, i64* %109 + %108 = inttoptr i64 %107 to ptr + %109 = getelementptr i64, ptr %108, i64 0 + %110 = load i64, ptr %109 %111 = add i64 %"lst##0", 8 - %112 = inttoptr i64 %111 to i64* - %113 = getelementptr i64, i64* %112, i64 0 - store i64 %"acc##0", i64* %113 + %112 = inttoptr i64 %111 to ptr + %113 = getelementptr i64, ptr %112, i64 0 + store i64 %"acc##0", ptr %113 %"2#success##0" = tail call fastcc i64 @"multi_specz_reverse.list_reverse_helper<0>[04d1467a4d]"(i64 %110, i64 %"lst##0") ret i64 %"2#success##0" if.else: @@ -349,7 +349,7 @@ if.else: } -------------------------------------------------- Module multi_specz_reverse.intlist - representation : address + representation : pointer public submods : public resources: public procs : multi_specz_reverse.intlist./=<0> @@ -505,10 +505,10 @@ tail > public {inline} (0 calls) -declare external ccc i8* @wybe_malloc(i32) +declare external ccc ptr @wybe_malloc(i32) -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i32, i1) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i32, i32, i1) define external fastcc i1 @"multi_specz_reverse.intlist./=<0>"(i64 %"#left##0", i64 %"#right##0") { @@ -524,26 +524,26 @@ entry: %"1#tmp#0##0" = icmp ne i64 %"#left##0", 0 br i1 %"1#tmp#0##0", label %if.then, label %if.else if.then: - %1 = inttoptr i64 %"#left##0" to i64* - %2 = getelementptr i64, i64* %1, i64 0 - %3 = load i64, i64* %2 + %1 = inttoptr i64 %"#left##0" to ptr + %2 = getelementptr i64, ptr %1, i64 0 + %3 = load i64, ptr %2 %4 = add i64 %"#left##0", 8 - %5 = inttoptr i64 %4 to i64* - %6 = getelementptr i64, i64* %5, i64 0 - %7 = load i64, i64* %6 + %5 = inttoptr i64 %4 to ptr + %6 = getelementptr i64, ptr %5, i64 0 + %7 = load i64, ptr %6 %"2#tmp#9##0" = icmp ne i64 %"#right##0", 0 br i1 %"2#tmp#9##0", label %if.then1, label %if.else1 if.else: %"3##success##0" = icmp eq i64 %"#left##0", %"#right##0" ret i1 %"3##success##0" if.then1: - %8 = inttoptr i64 %"#right##0" to i64* - %9 = getelementptr i64, i64* %8, i64 0 - %10 = load i64, i64* %9 + %8 = inttoptr i64 %"#right##0" to ptr + %9 = getelementptr i64, ptr %8, i64 0 + %10 = load i64, ptr %9 %11 = add i64 %"#right##0", 8 - %12 = inttoptr i64 %11 to i64* - %13 = getelementptr i64, i64* %12, i64 0 - %14 = load i64, i64* %13 + %12 = inttoptr i64 %11 to ptr + %13 = getelementptr i64, ptr %12, i64 0 + %14 = load i64, ptr %13 %"4#tmp#4##0" = icmp eq i64 %3, %10 br i1 %"4#tmp#4##0", label %if.then2, label %if.else2 if.else1: @@ -565,15 +565,15 @@ entry: define external fastcc i64 @"multi_specz_reverse.intlist.[|]<0>"(i64 %"head##0", i64 %"tail##0") { entry: %15 = trunc i64 16 to i32 - %16 = tail call ccc i8* @wybe_malloc(i32 %15) - %17 = ptrtoint i8* %16 to i64 - %18 = inttoptr i64 %17 to i64* - %19 = getelementptr i64, i64* %18, i64 0 - store i64 %"head##0", i64* %19 + %16 = call ccc ptr @wybe_malloc(i32 %15) + %17 = ptrtoint ptr %16 to i64 + %18 = inttoptr i64 %17 to ptr + %19 = getelementptr i64, ptr %18, i64 0 + store i64 %"head##0", ptr %19 %20 = add i64 %17, 8 - %21 = inttoptr i64 %20 to i64* - %22 = getelementptr i64, i64* %21, i64 0 - store i64 %"tail##0", i64* %22 + %21 = inttoptr i64 %20 to ptr + %22 = getelementptr i64, ptr %21, i64 0 + store i64 %"tail##0", ptr %22 ret i64 %17 } @@ -583,13 +583,13 @@ entry: %"1#tmp#0##0" = icmp ne i64 %"#result##0", 0 br i1 %"1#tmp#0##0", label %if.then, label %if.else if.then: - %23 = inttoptr i64 %"#result##0" to i64* - %24 = getelementptr i64, i64* %23, i64 0 - %25 = load i64, i64* %24 + %23 = inttoptr i64 %"#result##0" to ptr + %24 = getelementptr i64, ptr %23, i64 0 + %25 = load i64, ptr %24 %26 = add i64 %"#result##0", 8 - %27 = inttoptr i64 %26 to i64* - %28 = getelementptr i64, i64* %27, i64 0 - %29 = load i64, i64* %28 + %27 = inttoptr i64 %26 to ptr + %28 = getelementptr i64, ptr %27, i64 0 + %29 = load i64, ptr %28 %30 = insertvalue {i64, i64, i1} undef, i64 %25, 0 %31 = insertvalue {i64, i64, i1} %30, i64 %29, 1 %32 = insertvalue {i64, i64, i1} %31, i1 1, 2 @@ -607,9 +607,9 @@ entry: %"1#tmp#0##0" = icmp ne i64 %"#rec##0", 0 br i1 %"1#tmp#0##0", label %if.then, label %if.else if.then: - %36 = inttoptr i64 %"#rec##0" to i64* - %37 = getelementptr i64, i64* %36, i64 0 - %38 = load i64, i64* %37 + %36 = inttoptr i64 %"#rec##0" to ptr + %37 = getelementptr i64, ptr %36, i64 0 + %38 = load i64, ptr %37 %39 = insertvalue {i64, i1} undef, i64 %38, 0 %40 = insertvalue {i64, i1} %39, i1 1, 1 ret {i64, i1} %40 @@ -626,15 +626,15 @@ entry: br i1 %"1#tmp#0##0", label %if.then, label %if.else if.then: %43 = trunc i64 16 to i32 - %44 = tail call ccc i8* @wybe_malloc(i32 %43) - %45 = ptrtoint i8* %44 to i64 - %46 = inttoptr i64 %45 to i8* - %47 = inttoptr i64 %"#rec##0" to i8* + %44 = call ccc ptr @wybe_malloc(i32 %43) + %45 = ptrtoint ptr %44 to i64 + %46 = inttoptr i64 %45 to ptr + %47 = inttoptr i64 %"#rec##0" to ptr %48 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %46, i8* %47, i32 %48, i32 8, i1 0) - %49 = inttoptr i64 %45 to i64* - %50 = getelementptr i64, i64* %49, i64 0 - store i64 %"#field##0", i64* %50 + call ccc void @llvm.memcpy.p0.p0.i64(ptr %46, ptr %47, i32 %48, i32 8, i1 0) + %49 = inttoptr i64 %45 to ptr + %50 = getelementptr i64, ptr %49, i64 0 + store i64 %"#field##0", ptr %50 %51 = insertvalue {i64, i1} undef, i64 %45, 0 %52 = insertvalue {i64, i1} %51, i1 1, 1 ret {i64, i1} %52 @@ -651,9 +651,9 @@ entry: br i1 %"1#tmp#0##0", label %if.then, label %if.else if.then: %55 = add i64 %"#rec##0", 8 - %56 = inttoptr i64 %55 to i64* - %57 = getelementptr i64, i64* %56, i64 0 - %58 = load i64, i64* %57 + %56 = inttoptr i64 %55 to ptr + %57 = getelementptr i64, ptr %56, i64 0 + %58 = load i64, ptr %57 %59 = insertvalue {i64, i1} undef, i64 %58, 0 %60 = insertvalue {i64, i1} %59, i1 1, 1 ret {i64, i1} %60 @@ -670,16 +670,16 @@ entry: br i1 %"1#tmp#0##0", label %if.then, label %if.else if.then: %63 = trunc i64 16 to i32 - %64 = tail call ccc i8* @wybe_malloc(i32 %63) - %65 = ptrtoint i8* %64 to i64 - %66 = inttoptr i64 %65 to i8* - %67 = inttoptr i64 %"#rec##0" to i8* + %64 = call ccc ptr @wybe_malloc(i32 %63) + %65 = ptrtoint ptr %64 to i64 + %66 = inttoptr i64 %65 to ptr + %67 = inttoptr i64 %"#rec##0" to ptr %68 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %66, i8* %67, i32 %68, i32 8, i1 0) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %66, ptr %67, i32 %68, i32 8, i1 0) %69 = add i64 %65, 8 - %70 = inttoptr i64 %69 to i64* - %71 = getelementptr i64, i64* %70, i64 0 - store i64 %"#field##0", i64* %71 + %70 = inttoptr i64 %69 to ptr + %71 = getelementptr i64, ptr %70, i64 0 + store i64 %"#field##0", ptr %71 %72 = insertvalue {i64, i1} undef, i64 %65, 0 %73 = insertvalue {i64, i1} %72, i1 1, 1 ret {i64, i1} %73 diff --git a/test-cases/final-dump/multictr.exp b/test-cases/final-dump/multictr.exp index f90c27034..841e35c17 100644 --- a/test-cases/final-dump/multictr.exp +++ b/test-cases/final-dump/multictr.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module multictr representation : (not a type) public submods : card -> multictr.card @@ -179,16 +182,15 @@ AFTER EVERYTHING: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'multictr' +source_filename = "!ROOT!/final-dump/multictr.wybe" +target triple ???? - +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) -------------------------------------------------- Module multictr.card representation : 6 bit unsigned @@ -220,8 +222,10 @@ proc card > public {inline} (0 calls) card(rank##0:multictr.rank, suit##0:multictr.suit, ?#result##3:multictr.card)<{}; {}; {}>: AliasPairs: [] InterestingCallProperties: [] - foreign llvm shl(~rank##0:multictr.card, 2:multictr.card, ?#temp##0:multictr.card) @multictr:nn:nn - foreign llvm or(~#temp##0:multictr.card, ~suit##0:multictr.card, ?#result##3:multictr.card) @multictr:nn:nn + foreign lpvm cast(~rank##0:multictr.rank, ?#temp##0:multictr.card) @multictr:nn:nn + foreign llvm shl(~#temp##0:multictr.card, 2:multictr.card, ?#temp##1:multictr.card) @multictr:nn:nn + foreign lpvm cast(~suit##0:multictr.suit, ?#temp##2:multictr.card) @multictr:nn:nn + foreign llvm or(~#temp##1:multictr.card, ~#temp##2:multictr.card, ?#result##3:multictr.card) @multictr:nn:nn proc card > public {inline} (0 calls) 1: multictr.card.card<1> card(?rank##0:multictr.rank, ?suit##0:multictr.suit, #result##0:multictr.card)<{}; {}; {}>: @@ -248,8 +252,9 @@ rank(#rec##0:multictr.card, ?#rec##2:multictr.card, #field##0:multictr.rank)<{}; AliasPairs: [] InterestingCallProperties: [] foreign llvm and(~#rec##0:multictr.card, -61:multictr.card, ?#rec##1:multictr.card) @multictr:nn:nn - foreign llvm shl(~#field##0:multictr.card, 2:multictr.card, ?#temp##0:multictr.card) @multictr:nn:nn - foreign llvm or(~#rec##1:multictr.card, ~#temp##0:multictr.card, ?#rec##2:multictr.card) @multictr:nn:nn + foreign lpvm cast(~#field##0:multictr.rank, ?#temp##0:multictr.card) @multictr:nn:nn + foreign llvm shl(~#temp##0:multictr.card, 2:multictr.card, ?#temp##1:multictr.card) @multictr:nn:nn + foreign llvm or(~#rec##1:multictr.card, ~#temp##1:multictr.card, ?#rec##2:multictr.card) @multictr:nn:nn proc suit > public {inline} (0 calls) @@ -265,7 +270,8 @@ suit(#rec##0:multictr.card, ?#rec##2:multictr.card, #field##0:multictr.suit)<{}; AliasPairs: [] InterestingCallProperties: [] foreign llvm and(~#rec##0:multictr.card, -4:multictr.card, ?#rec##1:multictr.card) @multictr:nn:nn - foreign llvm or(~#field##0:multictr.card, ~#rec##1:multictr.card, ?#rec##2:multictr.card) @multictr:nn:nn + foreign lpvm cast(~#field##0:multictr.suit, ?#temp##0:multictr.card) @multictr:nn:nn + foreign llvm or(~#rec##1:multictr.card, ~#temp##0:multictr.card, ?#rec##2:multictr.card) @multictr:nn:nn proc ~= > public {inline} (0 calls) @@ -278,93 +284,76 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'multictr.card' +source_filename = "!ROOT!/final-dump/multictr.wybe" +target triple ???? - - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -define external fastcc i1 @"multictr.card.=<0>"(i6 %"#left##0", i6 %"#right##0") alwaysinline { -entry: - %0 = icmp eq i6 %"#left##0", %"#right##0" - ret i1 %0 +define external fastcc i1 @"multictr.card.=<0>"(i6 %"#left##0", i6 %"#right##0") { + %"tmp#1##0" = icmp eq i6 %"#left##0", %"#right##0" + ret i1 %"tmp#1##0" } - -define external fastcc i6 @"multictr.card.card<0>"(i4 %"rank##0", i2 %"suit##0") alwaysinline { -entry: - %0 = zext i4 %"rank##0" to i6 - %1 = shl i6 %0, 2 - %2 = zext i2 %"suit##0" to i6 - %3 = or i6 %1, %2 - ret i6 %3 +define external fastcc i6 @"multictr.card.card<0>"(i4 %"rank##0", i2 %"suit##0") { + %"#temp##0" = zext i4 %"rank##0" to i6 + %"#temp##1" = shl i6 %"#temp##0", 2 + %"#temp##2" = zext i2 %"suit##0" to i6 + %"tmp#0##0" = or i6 %"#temp##1", %"#temp##2" + ret i6 %"tmp#0##0" } - -define external fastcc {i4, i2} @"multictr.card.card<1>"(i6 %"#result##0") alwaysinline { -entry: - %0 = lshr i6 %"#result##0", 2 - %1 = and i6 %0, 15 - %2 = trunc i6 %1 to i4 - %3 = and i6 %"#result##0", 3 - %4 = trunc i6 %3 to i2 - %5 = insertvalue {i4, i2} undef, i4 %2, 0 - %6 = insertvalue {i4, i2} %5, i2 %4, 1 - ret {i4, i2} %6 +define external fastcc {i4, i2} @"multictr.card.card<1>"(i6 %"#result##0") { + %"#temp##0" = lshr i6 %"#result##0", 2 + %"#temp2##0" = and i6 %"#temp##0", 15 + %"tmp#0##0" = trunc i6 %"#temp2##0" to i4 + %"#temp2##1" = and i6 %"#result##0", 3 + %"tmp#1##0" = trunc i6 %"#temp2##1" to i2 + %"tmp#2##0" = insertvalue {i4, i2} undef, i4 %"tmp#0##0", 0 + %"tmp#3##0" = insertvalue {i4, i2} %"tmp#2##0", i2 %"tmp#1##0", 1 + ret {i4, i2} %"tmp#3##0" } - -define external fastcc i4 @"multictr.card.rank<0>"(i6 %"#rec##0") alwaysinline { -entry: - %0 = lshr i6 %"#rec##0", 2 - %1 = and i6 %0, 15 - %2 = trunc i6 %1 to i4 - ret i4 %2 +define external fastcc i4 @"multictr.card.rank<0>"(i6 %"#rec##0") { + %"#rec##1" = lshr i6 %"#rec##0", 2 + %"#field##0" = and i6 %"#rec##1", 15 + %"tmp#0##0" = trunc i6 %"#field##0" to i4 + ret i4 %"tmp#0##0" } - -define external fastcc i6 @"multictr.card.rank<1>"(i6 %"#rec##0", i4 %"#field##0") alwaysinline { -entry: - %0 = and i6 %"#rec##0", -61 - %1 = zext i4 %"#field##0" to i6 - %2 = shl i6 %1, 2 - %3 = or i6 %0, %2 - ret i6 %3 +define external fastcc i6 @"multictr.card.rank<1>"(i6 %"#rec##0", i4 %"#field##0") { + %"#rec##1" = and i6 %"#rec##0", -61 + %"#temp##0" = zext i4 %"#field##0" to i6 + %"#temp##1" = shl i6 %"#temp##0", 2 + %"tmp#0##0" = or i6 %"#rec##1", %"#temp##1" + ret i6 %"tmp#0##0" } - -define external fastcc i2 @"multictr.card.suit<0>"(i6 %"#rec##0") alwaysinline { -entry: - %0 = and i6 %"#rec##0", 3 - %1 = trunc i6 %0 to i2 - ret i2 %1 +define external fastcc i2 @"multictr.card.suit<0>"(i6 %"#rec##0") { + %"#field##0" = and i6 %"#rec##0", 3 + %"tmp#0##0" = trunc i6 %"#field##0" to i2 + ret i2 %"tmp#0##0" } - -define external fastcc i6 @"multictr.card.suit<1>"(i6 %"#rec##0", i2 %"#field##0") alwaysinline { -entry: - %0 = and i6 %"#rec##0", -4 - %1 = zext i2 %"#field##0" to i6 - %2 = or i6 %1, %0 - ret i6 %2 +define external fastcc i6 @"multictr.card.suit<1>"(i6 %"#rec##0", i2 %"#field##0") { + %"#rec##1" = and i6 %"#rec##0", -4 + %"#temp##0" = zext i2 %"#field##0" to i6 + %"tmp#0##0" = or i6 %"#rec##1", %"#temp##0" + ret i6 %"tmp#0##0" } - -define external fastcc i1 @"multictr.card.~=<0>"(i6 %"#left##0", i6 %"#right##0") alwaysinline { -entry: - %0 = icmp eq i6 %"#left##0", %"#right##0" - %1 = xor i1 %0, 1 - ret i1 %1 +define external fastcc i1 @"multictr.card.~=<0>"(i6 %"#left##0", i6 %"#right##0") { + %"tmp#0##0" = icmp eq i6 %"#left##0", %"#right##0" + %"tmp#3##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#3##0" } + -------------------------------------------------- Module multictr.complicated - representation : address + representation : pointer public submods : public resources: public procs : multictr.complicated.=<0> @@ -2682,2526 +2671,2318 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'multictr.complicated' - - - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i1 @"multictr.complicated.=<0>"(i64 %"#left##0", i64 %"#right##0") { -entry: - %0 = icmp uge i64 %"#left##0", 4 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = and i64 %"#left##0", 7 - %2 = icmp eq i64 %1, 7 - switch i64 %1, label %switch.8.7 [i64 0, label %switch.8.0 i64 1, label %switch.8.1 i64 2, label %switch.8.2 i64 3, label %switch.8.3 i64 4, label %switch.8.4 i64 5, label %switch.8.5 i64 6, label %switch.8.6 i64 7, label %switch.8.7] -if.else: - %224 = icmp eq i64 %"#left##0", %"#right##0" - ret i1 %224 -switch.8.0: - %3 = inttoptr i64 %"#left##0" to i64* - %4 = load i64, i64* %3 - %5 = icmp uge i64 %"#right##0", 4 - br i1 %5, label %if.then1, label %if.else1 -switch.8.1: - %11 = add i64 %"#left##0", -1 - %12 = inttoptr i64 %11 to i64* - %13 = load i64, i64* %12 - %14 = icmp uge i64 %"#right##0", 4 - br i1 %14, label %if.then3, label %if.else3 -switch.8.2: - %21 = add i64 %"#left##0", -2 - %22 = inttoptr i64 %21 to i64* - %23 = load i64, i64* %22 - %24 = icmp uge i64 %"#right##0", 4 - br i1 %24, label %if.then5, label %if.else5 -switch.8.3: - %31 = add i64 %"#left##0", -3 - %32 = inttoptr i64 %31 to i64* - %33 = load i64, i64* %32 - %34 = icmp uge i64 %"#right##0", 4 - br i1 %34, label %if.then7, label %if.else7 -switch.8.4: - %41 = add i64 %"#left##0", -4 - %42 = inttoptr i64 %41 to i64* - %43 = load i64, i64* %42 - %44 = icmp uge i64 %"#right##0", 4 - br i1 %44, label %if.then9, label %if.else9 -switch.8.5: - %51 = add i64 %"#left##0", -5 - %52 = inttoptr i64 %51 to i64* - %53 = load i64, i64* %52 - %54 = icmp uge i64 %"#right##0", 4 - br i1 %54, label %if.then11, label %if.else11 -switch.8.6: - %61 = add i64 %"#left##0", -6 - %62 = inttoptr i64 %61 to i64* - %63 = load i64, i64* %62 - %64 = icmp uge i64 %"#right##0", 4 - br i1 %64, label %if.then13, label %if.else13 -switch.8.7: - %71 = add i64 %"#left##0", -7 - %72 = inttoptr i64 %71 to i16* - %73 = load i16, i16* %72 - %74 = icmp eq i16 %73, 7 - br i1 %74, label %if.then15, label %if.else15 -if.then1: - %6 = and i64 %"#right##0", 7 - %7 = icmp eq i64 %6, 0 - br i1 %7, label %if.then2, label %if.else2 -if.else1: - ret i1 0 -if.then2: - %8 = inttoptr i64 %"#right##0" to i64* - %9 = load i64, i64* %8 - %10 = icmp eq i64 %4, %9 - ret i1 %10 -if.else2: - ret i1 0 -if.then3: - %15 = and i64 %"#right##0", 7 - %16 = icmp eq i64 %15, 1 - br i1 %16, label %if.then4, label %if.else4 -if.else3: - ret i1 0 -if.then4: - %17 = add i64 %"#right##0", -1 - %18 = inttoptr i64 %17 to i64* - %19 = load i64, i64* %18 - %20 = icmp eq i64 %13, %19 - ret i1 %20 -if.else4: - ret i1 0 -if.then5: - %25 = and i64 %"#right##0", 7 - %26 = icmp eq i64 %25, 2 - br i1 %26, label %if.then6, label %if.else6 -if.else5: - ret i1 0 -if.then6: - %27 = add i64 %"#right##0", -2 - %28 = inttoptr i64 %27 to i64* - %29 = load i64, i64* %28 - %30 = icmp eq i64 %23, %29 - ret i1 %30 -if.else6: - ret i1 0 -if.then7: - %35 = and i64 %"#right##0", 7 - %36 = icmp eq i64 %35, 3 - br i1 %36, label %if.then8, label %if.else8 -if.else7: - ret i1 0 -if.then8: - %37 = add i64 %"#right##0", -3 - %38 = inttoptr i64 %37 to i64* - %39 = load i64, i64* %38 - %40 = icmp eq i64 %33, %39 - ret i1 %40 -if.else8: - ret i1 0 -if.then9: - %45 = and i64 %"#right##0", 7 - %46 = icmp eq i64 %45, 4 - br i1 %46, label %if.then10, label %if.else10 -if.else9: - ret i1 0 -if.then10: - %47 = add i64 %"#right##0", -4 - %48 = inttoptr i64 %47 to i64* - %49 = load i64, i64* %48 - %50 = icmp eq i64 %43, %49 - ret i1 %50 -if.else10: - ret i1 0 -if.then11: - %55 = and i64 %"#right##0", 7 - %56 = icmp eq i64 %55, 5 - br i1 %56, label %if.then12, label %if.else12 -if.else11: - ret i1 0 -if.then12: - %57 = add i64 %"#right##0", -5 - %58 = inttoptr i64 %57 to i64* - %59 = load i64, i64* %58 - %60 = icmp eq i64 %53, %59 - ret i1 %60 -if.else12: - ret i1 0 -if.then13: - %65 = and i64 %"#right##0", 7 - %66 = icmp eq i64 %65, 6 - br i1 %66, label %if.then14, label %if.else14 -if.else13: - ret i1 0 -if.then14: - %67 = add i64 %"#right##0", -6 - %68 = inttoptr i64 %67 to i64* - %69 = load i64, i64* %68 - %70 = icmp eq i64 %63, %69 - ret i1 %70 -if.else14: - ret i1 0 -if.then15: - %75 = add i64 %"#left##0", 1 - %76 = inttoptr i64 %75 to i64* - %77 = load i64, i64* %76 - %78 = icmp uge i64 %"#right##0", 4 - br i1 %78, label %if.then16, label %if.else16 -if.else15: - %89 = icmp eq i16 %73, 8 - br i1 %89, label %if.then19, label %if.else19 -if.then16: - %79 = and i64 %"#right##0", 7 - %80 = icmp eq i64 %79, 7 - br i1 %80, label %if.then17, label %if.else17 -if.else16: - ret i1 0 -if.then17: - %81 = add i64 %"#right##0", -7 - %82 = inttoptr i64 %81 to i16* - %83 = load i16, i16* %82 - %84 = icmp eq i16 %83, 7 - br i1 %84, label %if.then18, label %if.else18 -if.else17: - ret i1 0 -if.then18: - %85 = add i64 %"#right##0", 1 - %86 = inttoptr i64 %85 to i64* - %87 = load i64, i64* %86 - %88 = icmp eq i64 %77, %87 - ret i1 %88 -if.else18: - ret i1 0 -if.then19: - %90 = add i64 %"#left##0", 1 - %91 = inttoptr i64 %90 to i64* - %92 = load i64, i64* %91 - %93 = icmp uge i64 %"#right##0", 4 - br i1 %93, label %if.then20, label %if.else20 -if.else19: - br i1 %2, label %if.then23, label %if.else23 -if.then20: - %94 = and i64 %"#right##0", 7 - %95 = icmp eq i64 %94, 7 - br i1 %95, label %if.then21, label %if.else21 -if.else20: - ret i1 0 -if.then21: - %96 = add i64 %"#right##0", -7 - %97 = inttoptr i64 %96 to i16* - %98 = load i16, i16* %97 - %99 = icmp eq i16 %98, 8 - br i1 %99, label %if.then22, label %if.else22 -if.else21: - ret i1 0 -if.then22: - %100 = add i64 %"#right##0", 1 - %101 = inttoptr i64 %100 to i64* - %102 = load i64, i64* %101 - %103 = icmp eq i64 %92, %102 - ret i1 %103 -if.else22: - ret i1 0 -if.then23: - %104 = icmp eq i16 %73, 9 - br i1 %104, label %if.then24, label %if.else24 -if.else23: - ret i1 0 -if.then24: - %105 = add i64 %"#left##0", 1 - %106 = inttoptr i64 %105 to i64* - %107 = load i64, i64* %106 - %108 = icmp uge i64 %"#right##0", 4 - br i1 %108, label %if.then25, label %if.else25 -if.else24: - %119 = icmp eq i16 %73, 10 - br i1 %119, label %if.then28, label %if.else28 -if.then25: - %109 = and i64 %"#right##0", 7 - %110 = icmp eq i64 %109, 7 - br i1 %110, label %if.then26, label %if.else26 -if.else25: - ret i1 0 -if.then26: - %111 = add i64 %"#right##0", -7 - %112 = inttoptr i64 %111 to i16* - %113 = load i16, i16* %112 - %114 = icmp eq i16 %113, 9 - br i1 %114, label %if.then27, label %if.else27 -if.else26: - ret i1 0 -if.then27: - %115 = add i64 %"#right##0", 1 - %116 = inttoptr i64 %115 to i64* - %117 = load i64, i64* %116 - %118 = icmp eq i64 %107, %117 - ret i1 %118 -if.else27: - ret i1 0 -if.then28: - %120 = add i64 %"#left##0", 1 - %121 = inttoptr i64 %120 to i64* - %122 = load i64, i64* %121 - %123 = icmp uge i64 %"#right##0", 4 - br i1 %123, label %if.then29, label %if.else29 -if.else28: - %134 = icmp eq i16 %73, 11 - br i1 %134, label %if.then32, label %if.else32 -if.then29: - %124 = and i64 %"#right##0", 7 - %125 = icmp eq i64 %124, 7 - br i1 %125, label %if.then30, label %if.else30 -if.else29: - ret i1 0 -if.then30: - %126 = add i64 %"#right##0", -7 - %127 = inttoptr i64 %126 to i16* - %128 = load i16, i16* %127 - %129 = icmp eq i16 %128, 10 - br i1 %129, label %if.then31, label %if.else31 -if.else30: - ret i1 0 -if.then31: - %130 = add i64 %"#right##0", 1 - %131 = inttoptr i64 %130 to i64* - %132 = load i64, i64* %131 - %133 = icmp eq i64 %122, %132 - ret i1 %133 -if.else31: - ret i1 0 -if.then32: - %135 = add i64 %"#left##0", 1 - %136 = inttoptr i64 %135 to i64* - %137 = load i64, i64* %136 - %138 = icmp uge i64 %"#right##0", 4 - br i1 %138, label %if.then33, label %if.else33 -if.else32: - %149 = icmp eq i16 %73, 12 - br i1 %149, label %if.then36, label %if.else36 -if.then33: - %139 = and i64 %"#right##0", 7 - %140 = icmp eq i64 %139, 7 - br i1 %140, label %if.then34, label %if.else34 -if.else33: - ret i1 0 -if.then34: - %141 = add i64 %"#right##0", -7 - %142 = inttoptr i64 %141 to i16* - %143 = load i16, i16* %142 - %144 = icmp eq i16 %143, 11 - br i1 %144, label %if.then35, label %if.else35 -if.else34: - ret i1 0 -if.then35: - %145 = add i64 %"#right##0", 1 - %146 = inttoptr i64 %145 to i64* - %147 = load i64, i64* %146 - %148 = icmp eq i64 %137, %147 - ret i1 %148 -if.else35: - ret i1 0 -if.then36: - %150 = add i64 %"#left##0", 1 - %151 = inttoptr i64 %150 to i64* - %152 = load i64, i64* %151 - %153 = icmp uge i64 %"#right##0", 4 - br i1 %153, label %if.then37, label %if.else37 -if.else36: - %164 = icmp eq i16 %73, 13 - br i1 %164, label %if.then40, label %if.else40 -if.then37: - %154 = and i64 %"#right##0", 7 - %155 = icmp eq i64 %154, 7 - br i1 %155, label %if.then38, label %if.else38 -if.else37: - ret i1 0 -if.then38: - %156 = add i64 %"#right##0", -7 - %157 = inttoptr i64 %156 to i16* - %158 = load i16, i16* %157 - %159 = icmp eq i16 %158, 12 - br i1 %159, label %if.then39, label %if.else39 -if.else38: - ret i1 0 -if.then39: - %160 = add i64 %"#right##0", 1 - %161 = inttoptr i64 %160 to i64* - %162 = load i64, i64* %161 - %163 = icmp eq i64 %152, %162 - ret i1 %163 -if.else39: - ret i1 0 -if.then40: - %165 = add i64 %"#left##0", 1 - %166 = inttoptr i64 %165 to i64* - %167 = load i64, i64* %166 - %168 = icmp uge i64 %"#right##0", 4 - br i1 %168, label %if.then41, label %if.else41 -if.else40: - %179 = icmp eq i16 %73, 14 - br i1 %179, label %if.then44, label %if.else44 -if.then41: - %169 = and i64 %"#right##0", 7 - %170 = icmp eq i64 %169, 7 - br i1 %170, label %if.then42, label %if.else42 -if.else41: - ret i1 0 -if.then42: - %171 = add i64 %"#right##0", -7 - %172 = inttoptr i64 %171 to i16* - %173 = load i16, i16* %172 - %174 = icmp eq i16 %173, 13 - br i1 %174, label %if.then43, label %if.else43 -if.else42: - ret i1 0 -if.then43: - %175 = add i64 %"#right##0", 1 - %176 = inttoptr i64 %175 to i64* - %177 = load i64, i64* %176 - %178 = icmp eq i64 %167, %177 - ret i1 %178 -if.else43: - ret i1 0 -if.then44: - %180 = add i64 %"#left##0", 1 - %181 = inttoptr i64 %180 to i64* - %182 = load i64, i64* %181 - %183 = icmp uge i64 %"#right##0", 4 - br i1 %183, label %if.then45, label %if.else45 -if.else44: - %194 = icmp eq i16 %73, 15 - br i1 %194, label %if.then48, label %if.else48 -if.then45: - %184 = and i64 %"#right##0", 7 - %185 = icmp eq i64 %184, 7 - br i1 %185, label %if.then46, label %if.else46 -if.else45: - ret i1 0 -if.then46: - %186 = add i64 %"#right##0", -7 - %187 = inttoptr i64 %186 to i16* - %188 = load i16, i16* %187 - %189 = icmp eq i16 %188, 14 - br i1 %189, label %if.then47, label %if.else47 -if.else46: - ret i1 0 -if.then47: - %190 = add i64 %"#right##0", 1 - %191 = inttoptr i64 %190 to i64* - %192 = load i64, i64* %191 - %193 = icmp eq i64 %182, %192 - ret i1 %193 -if.else47: - ret i1 0 -if.then48: - %195 = add i64 %"#left##0", 1 - %196 = inttoptr i64 %195 to i64* - %197 = load i64, i64* %196 - %198 = icmp uge i64 %"#right##0", 4 - br i1 %198, label %if.then49, label %if.else49 -if.else48: - %209 = icmp eq i16 %73, 16 - br i1 %209, label %if.then52, label %if.else52 -if.then49: - %199 = and i64 %"#right##0", 7 - %200 = icmp eq i64 %199, 7 - br i1 %200, label %if.then50, label %if.else50 -if.else49: - ret i1 0 -if.then50: - %201 = add i64 %"#right##0", -7 - %202 = inttoptr i64 %201 to i16* - %203 = load i16, i16* %202 - %204 = icmp eq i16 %203, 15 - br i1 %204, label %if.then51, label %if.else51 -if.else50: - ret i1 0 -if.then51: - %205 = add i64 %"#right##0", 1 - %206 = inttoptr i64 %205 to i64* - %207 = load i64, i64* %206 - %208 = icmp eq i64 %197, %207 - ret i1 %208 -if.else51: - ret i1 0 -if.then52: - %210 = add i64 %"#left##0", 1 - %211 = inttoptr i64 %210 to i64* - %212 = load i64, i64* %211 - %213 = icmp uge i64 %"#right##0", 4 - br i1 %213, label %if.then53, label %if.else53 -if.else52: - ret i1 0 -if.then53: - %214 = and i64 %"#right##0", 7 - %215 = icmp eq i64 %214, 7 - br i1 %215, label %if.then54, label %if.else54 -if.else53: - ret i1 0 -if.then54: - %216 = add i64 %"#right##0", -7 - %217 = inttoptr i64 %216 to i16* - %218 = load i16, i16* %217 - %219 = icmp eq i16 %218, 16 - br i1 %219, label %if.then55, label %if.else55 -if.else54: - ret i1 0 -if.then55: - %220 = add i64 %"#right##0", 1 - %221 = inttoptr i64 %220 to i64* - %222 = load i64, i64* %221 - %223 = icmp eq i64 %212, %222 - ret i1 %223 -if.else55: - ret i1 0 -} - - -define external fastcc i64 @"multictr.complicated.autumn<0>"() alwaysinline { -entry: - ret i64 3 -} - - -define external fastcc i64 @"multictr.complicated.c01<0>"(i64 %"f01##0") alwaysinline { -entry: - %0 = trunc i64 8 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"f01##0", i64* %3 - ret i64 %2 -} - - -define external fastcc {i64, i1} @"multictr.complicated.c01<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = icmp uge i64 %"#result##0", 4 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = and i64 %"#result##0", 7 - %2 = icmp eq i64 %1, 0 - br i1 %2, label %if.then1, label %if.else1 -if.else: - %9 = insertvalue {i64, i1} undef, i64 undef, 0 - %10 = insertvalue {i64, i1} %9, i1 0, 1 - ret {i64, i1} %10 -if.then1: - %3 = inttoptr i64 %"#result##0" to i64* - %4 = load i64, i64* %3 - %5 = insertvalue {i64, i1} undef, i64 %4, 0 - %6 = insertvalue {i64, i1} %5, i1 1, 1 - ret {i64, i1} %6 -if.else1: - %7 = insertvalue {i64, i1} undef, i64 undef, 0 - %8 = insertvalue {i64, i1} %7, i1 0, 1 - ret {i64, i1} %8 -} - - -define external fastcc i64 @"multictr.complicated.c02<0>"(i64 %"f02##0") alwaysinline { -entry: - %0 = trunc i64 8 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"f02##0", i64* %3 - %4 = or i64 %2, 1 - ret i64 %4 -} - - -define external fastcc {i64, i1} @"multictr.complicated.c02<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = icmp uge i64 %"#result##0", 4 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = and i64 %"#result##0", 7 - %2 = icmp eq i64 %1, 1 - br i1 %2, label %if.then1, label %if.else1 -if.else: - %10 = insertvalue {i64, i1} undef, i64 undef, 0 - %11 = insertvalue {i64, i1} %10, i1 0, 1 - ret {i64, i1} %11 -if.then1: - %3 = add i64 %"#result##0", -1 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = insertvalue {i64, i1} undef, i64 %5, 0 - %7 = insertvalue {i64, i1} %6, i1 1, 1 - ret {i64, i1} %7 -if.else1: - %8 = insertvalue {i64, i1} undef, i64 undef, 0 - %9 = insertvalue {i64, i1} %8, i1 0, 1 - ret {i64, i1} %9 -} - - -define external fastcc i64 @"multictr.complicated.c03<0>"(i64 %"f03##0") alwaysinline { -entry: - %0 = trunc i64 8 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"f03##0", i64* %3 - %4 = or i64 %2, 2 - ret i64 %4 -} - - -define external fastcc {i64, i1} @"multictr.complicated.c03<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = icmp uge i64 %"#result##0", 4 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = and i64 %"#result##0", 7 - %2 = icmp eq i64 %1, 2 - br i1 %2, label %if.then1, label %if.else1 -if.else: - %10 = insertvalue {i64, i1} undef, i64 undef, 0 - %11 = insertvalue {i64, i1} %10, i1 0, 1 - ret {i64, i1} %11 -if.then1: - %3 = add i64 %"#result##0", -2 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = insertvalue {i64, i1} undef, i64 %5, 0 - %7 = insertvalue {i64, i1} %6, i1 1, 1 - ret {i64, i1} %7 -if.else1: - %8 = insertvalue {i64, i1} undef, i64 undef, 0 - %9 = insertvalue {i64, i1} %8, i1 0, 1 - ret {i64, i1} %9 -} - - -define external fastcc i64 @"multictr.complicated.c04<0>"(i64 %"f04##0") alwaysinline { -entry: - %0 = trunc i64 8 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"f04##0", i64* %3 - %4 = or i64 %2, 3 - ret i64 %4 -} - - -define external fastcc {i64, i1} @"multictr.complicated.c04<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = icmp uge i64 %"#result##0", 4 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = and i64 %"#result##0", 7 - %2 = icmp eq i64 %1, 3 - br i1 %2, label %if.then1, label %if.else1 -if.else: - %10 = insertvalue {i64, i1} undef, i64 undef, 0 - %11 = insertvalue {i64, i1} %10, i1 0, 1 - ret {i64, i1} %11 -if.then1: - %3 = add i64 %"#result##0", -3 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = insertvalue {i64, i1} undef, i64 %5, 0 - %7 = insertvalue {i64, i1} %6, i1 1, 1 - ret {i64, i1} %7 -if.else1: - %8 = insertvalue {i64, i1} undef, i64 undef, 0 - %9 = insertvalue {i64, i1} %8, i1 0, 1 - ret {i64, i1} %9 -} - - -define external fastcc i64 @"multictr.complicated.c05<0>"(i64 %"f05##0") alwaysinline { -entry: - %0 = trunc i64 8 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"f05##0", i64* %3 - %4 = or i64 %2, 4 - ret i64 %4 -} - - -define external fastcc {i64, i1} @"multictr.complicated.c05<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = icmp uge i64 %"#result##0", 4 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = and i64 %"#result##0", 7 - %2 = icmp eq i64 %1, 4 - br i1 %2, label %if.then1, label %if.else1 -if.else: - %10 = insertvalue {i64, i1} undef, i64 undef, 0 - %11 = insertvalue {i64, i1} %10, i1 0, 1 - ret {i64, i1} %11 -if.then1: - %3 = add i64 %"#result##0", -4 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = insertvalue {i64, i1} undef, i64 %5, 0 - %7 = insertvalue {i64, i1} %6, i1 1, 1 - ret {i64, i1} %7 -if.else1: - %8 = insertvalue {i64, i1} undef, i64 undef, 0 - %9 = insertvalue {i64, i1} %8, i1 0, 1 - ret {i64, i1} %9 -} - - -define external fastcc i64 @"multictr.complicated.c06<0>"(i64 %"f06##0") alwaysinline { -entry: - %0 = trunc i64 8 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"f06##0", i64* %3 - %4 = or i64 %2, 5 - ret i64 %4 -} - - -define external fastcc {i64, i1} @"multictr.complicated.c06<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = icmp uge i64 %"#result##0", 4 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = and i64 %"#result##0", 7 - %2 = icmp eq i64 %1, 5 - br i1 %2, label %if.then1, label %if.else1 -if.else: - %10 = insertvalue {i64, i1} undef, i64 undef, 0 - %11 = insertvalue {i64, i1} %10, i1 0, 1 - ret {i64, i1} %11 -if.then1: - %3 = add i64 %"#result##0", -5 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = insertvalue {i64, i1} undef, i64 %5, 0 - %7 = insertvalue {i64, i1} %6, i1 1, 1 - ret {i64, i1} %7 -if.else1: - %8 = insertvalue {i64, i1} undef, i64 undef, 0 - %9 = insertvalue {i64, i1} %8, i1 0, 1 - ret {i64, i1} %9 -} - - -define external fastcc i64 @"multictr.complicated.c07<0>"(i64 %"f07##0") alwaysinline { -entry: - %0 = trunc i64 8 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"f07##0", i64* %3 - %4 = or i64 %2, 6 - ret i64 %4 -} - - -define external fastcc {i64, i1} @"multictr.complicated.c07<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = icmp uge i64 %"#result##0", 4 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = and i64 %"#result##0", 7 - %2 = icmp eq i64 %1, 6 - br i1 %2, label %if.then1, label %if.else1 -if.else: - %10 = insertvalue {i64, i1} undef, i64 undef, 0 - %11 = insertvalue {i64, i1} %10, i1 0, 1 - ret {i64, i1} %11 -if.then1: - %3 = add i64 %"#result##0", -6 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = insertvalue {i64, i1} undef, i64 %5, 0 - %7 = insertvalue {i64, i1} %6, i1 1, 1 - ret {i64, i1} %7 -if.else1: - %8 = insertvalue {i64, i1} undef, i64 undef, 0 - %9 = insertvalue {i64, i1} %8, i1 0, 1 - ret {i64, i1} %9 -} - - -define external fastcc i64 @"multictr.complicated.c08<0>"(i64 %"f08##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 7, i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"f08##0", i64* %5 - %6 = or i64 %2, 7 - ret i64 %6 -} - - -define external fastcc {i64, i1} @"multictr.complicated.c08<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = icmp uge i64 %"#result##0", 4 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = and i64 %"#result##0", 7 - %2 = icmp eq i64 %1, 7 - br i1 %2, label %if.then1, label %if.else1 -if.else: - %16 = insertvalue {i64, i1} undef, i64 undef, 0 - %17 = insertvalue {i64, i1} %16, i1 0, 1 - ret {i64, i1} %17 -if.then1: - %3 = add i64 %"#result##0", -7 - %4 = inttoptr i64 %3 to i16* - %5 = load i16, i16* %4 - %6 = icmp eq i16 %5, 7 - br i1 %6, label %if.then2, label %if.else2 -if.else1: - %14 = insertvalue {i64, i1} undef, i64 undef, 0 - %15 = insertvalue {i64, i1} %14, i1 0, 1 - ret {i64, i1} %15 -if.then2: - %7 = add i64 %"#result##0", 1 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = insertvalue {i64, i1} undef, i64 %9, 0 - %11 = insertvalue {i64, i1} %10, i1 1, 1 - ret {i64, i1} %11 -if.else2: - %12 = insertvalue {i64, i1} undef, i64 undef, 0 - %13 = insertvalue {i64, i1} %12, i1 0, 1 - ret {i64, i1} %13 -} - - -define external fastcc i64 @"multictr.complicated.c09<0>"(i64 %"f09##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 8, i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"f09##0", i64* %5 - %6 = or i64 %2, 7 - ret i64 %6 -} - - -define external fastcc {i64, i1} @"multictr.complicated.c09<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = icmp uge i64 %"#result##0", 4 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = and i64 %"#result##0", 7 - %2 = icmp eq i64 %1, 7 - br i1 %2, label %if.then1, label %if.else1 -if.else: - %16 = insertvalue {i64, i1} undef, i64 undef, 0 - %17 = insertvalue {i64, i1} %16, i1 0, 1 - ret {i64, i1} %17 -if.then1: - %3 = add i64 %"#result##0", -7 - %4 = inttoptr i64 %3 to i16* - %5 = load i16, i16* %4 - %6 = icmp eq i16 %5, 8 - br i1 %6, label %if.then2, label %if.else2 -if.else1: - %14 = insertvalue {i64, i1} undef, i64 undef, 0 - %15 = insertvalue {i64, i1} %14, i1 0, 1 - ret {i64, i1} %15 -if.then2: - %7 = add i64 %"#result##0", 1 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = insertvalue {i64, i1} undef, i64 %9, 0 - %11 = insertvalue {i64, i1} %10, i1 1, 1 - ret {i64, i1} %11 -if.else2: - %12 = insertvalue {i64, i1} undef, i64 undef, 0 - %13 = insertvalue {i64, i1} %12, i1 0, 1 - ret {i64, i1} %13 -} - - -define external fastcc i64 @"multictr.complicated.c10<0>"(i64 %"f10##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 9, i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"f10##0", i64* %5 - %6 = or i64 %2, 7 - ret i64 %6 -} - - -define external fastcc {i64, i1} @"multictr.complicated.c10<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = icmp uge i64 %"#result##0", 4 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = and i64 %"#result##0", 7 - %2 = icmp eq i64 %1, 7 - br i1 %2, label %if.then1, label %if.else1 -if.else: - %16 = insertvalue {i64, i1} undef, i64 undef, 0 - %17 = insertvalue {i64, i1} %16, i1 0, 1 - ret {i64, i1} %17 -if.then1: - %3 = add i64 %"#result##0", -7 - %4 = inttoptr i64 %3 to i16* - %5 = load i16, i16* %4 - %6 = icmp eq i16 %5, 9 - br i1 %6, label %if.then2, label %if.else2 -if.else1: - %14 = insertvalue {i64, i1} undef, i64 undef, 0 - %15 = insertvalue {i64, i1} %14, i1 0, 1 - ret {i64, i1} %15 -if.then2: - %7 = add i64 %"#result##0", 1 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = insertvalue {i64, i1} undef, i64 %9, 0 - %11 = insertvalue {i64, i1} %10, i1 1, 1 - ret {i64, i1} %11 -if.else2: - %12 = insertvalue {i64, i1} undef, i64 undef, 0 - %13 = insertvalue {i64, i1} %12, i1 0, 1 - ret {i64, i1} %13 -} - - -define external fastcc i64 @"multictr.complicated.c11<0>"(i64 %"f11##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 10, i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"f11##0", i64* %5 - %6 = or i64 %2, 7 - ret i64 %6 -} - - -define external fastcc {i64, i1} @"multictr.complicated.c11<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = icmp uge i64 %"#result##0", 4 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = and i64 %"#result##0", 7 - %2 = icmp eq i64 %1, 7 - br i1 %2, label %if.then1, label %if.else1 -if.else: - %16 = insertvalue {i64, i1} undef, i64 undef, 0 - %17 = insertvalue {i64, i1} %16, i1 0, 1 - ret {i64, i1} %17 -if.then1: - %3 = add i64 %"#result##0", -7 - %4 = inttoptr i64 %3 to i16* - %5 = load i16, i16* %4 - %6 = icmp eq i16 %5, 10 - br i1 %6, label %if.then2, label %if.else2 -if.else1: - %14 = insertvalue {i64, i1} undef, i64 undef, 0 - %15 = insertvalue {i64, i1} %14, i1 0, 1 - ret {i64, i1} %15 -if.then2: - %7 = add i64 %"#result##0", 1 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = insertvalue {i64, i1} undef, i64 %9, 0 - %11 = insertvalue {i64, i1} %10, i1 1, 1 - ret {i64, i1} %11 -if.else2: - %12 = insertvalue {i64, i1} undef, i64 undef, 0 - %13 = insertvalue {i64, i1} %12, i1 0, 1 - ret {i64, i1} %13 -} - - -define external fastcc i64 @"multictr.complicated.c12<0>"(i64 %"f12##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 11, i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"f12##0", i64* %5 - %6 = or i64 %2, 7 - ret i64 %6 -} - - -define external fastcc {i64, i1} @"multictr.complicated.c12<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = icmp uge i64 %"#result##0", 4 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = and i64 %"#result##0", 7 - %2 = icmp eq i64 %1, 7 - br i1 %2, label %if.then1, label %if.else1 -if.else: - %16 = insertvalue {i64, i1} undef, i64 undef, 0 - %17 = insertvalue {i64, i1} %16, i1 0, 1 - ret {i64, i1} %17 -if.then1: - %3 = add i64 %"#result##0", -7 - %4 = inttoptr i64 %3 to i16* - %5 = load i16, i16* %4 - %6 = icmp eq i16 %5, 11 - br i1 %6, label %if.then2, label %if.else2 -if.else1: - %14 = insertvalue {i64, i1} undef, i64 undef, 0 - %15 = insertvalue {i64, i1} %14, i1 0, 1 - ret {i64, i1} %15 -if.then2: - %7 = add i64 %"#result##0", 1 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = insertvalue {i64, i1} undef, i64 %9, 0 - %11 = insertvalue {i64, i1} %10, i1 1, 1 - ret {i64, i1} %11 -if.else2: - %12 = insertvalue {i64, i1} undef, i64 undef, 0 - %13 = insertvalue {i64, i1} %12, i1 0, 1 - ret {i64, i1} %13 -} - - -define external fastcc i64 @"multictr.complicated.c13<0>"(i64 %"f13##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 12, i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"f13##0", i64* %5 - %6 = or i64 %2, 7 - ret i64 %6 -} - - -define external fastcc {i64, i1} @"multictr.complicated.c13<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = icmp uge i64 %"#result##0", 4 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = and i64 %"#result##0", 7 - %2 = icmp eq i64 %1, 7 - br i1 %2, label %if.then1, label %if.else1 -if.else: - %16 = insertvalue {i64, i1} undef, i64 undef, 0 - %17 = insertvalue {i64, i1} %16, i1 0, 1 - ret {i64, i1} %17 -if.then1: - %3 = add i64 %"#result##0", -7 - %4 = inttoptr i64 %3 to i16* - %5 = load i16, i16* %4 - %6 = icmp eq i16 %5, 12 - br i1 %6, label %if.then2, label %if.else2 -if.else1: - %14 = insertvalue {i64, i1} undef, i64 undef, 0 - %15 = insertvalue {i64, i1} %14, i1 0, 1 - ret {i64, i1} %15 -if.then2: - %7 = add i64 %"#result##0", 1 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = insertvalue {i64, i1} undef, i64 %9, 0 - %11 = insertvalue {i64, i1} %10, i1 1, 1 - ret {i64, i1} %11 -if.else2: - %12 = insertvalue {i64, i1} undef, i64 undef, 0 - %13 = insertvalue {i64, i1} %12, i1 0, 1 - ret {i64, i1} %13 -} - - -define external fastcc i64 @"multictr.complicated.c14<0>"(i64 %"f14##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 13, i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"f14##0", i64* %5 - %6 = or i64 %2, 7 - ret i64 %6 -} - - -define external fastcc {i64, i1} @"multictr.complicated.c14<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = icmp uge i64 %"#result##0", 4 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = and i64 %"#result##0", 7 - %2 = icmp eq i64 %1, 7 - br i1 %2, label %if.then1, label %if.else1 -if.else: - %16 = insertvalue {i64, i1} undef, i64 undef, 0 - %17 = insertvalue {i64, i1} %16, i1 0, 1 - ret {i64, i1} %17 -if.then1: - %3 = add i64 %"#result##0", -7 - %4 = inttoptr i64 %3 to i16* - %5 = load i16, i16* %4 - %6 = icmp eq i16 %5, 13 - br i1 %6, label %if.then2, label %if.else2 -if.else1: - %14 = insertvalue {i64, i1} undef, i64 undef, 0 - %15 = insertvalue {i64, i1} %14, i1 0, 1 - ret {i64, i1} %15 -if.then2: - %7 = add i64 %"#result##0", 1 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = insertvalue {i64, i1} undef, i64 %9, 0 - %11 = insertvalue {i64, i1} %10, i1 1, 1 - ret {i64, i1} %11 -if.else2: - %12 = insertvalue {i64, i1} undef, i64 undef, 0 - %13 = insertvalue {i64, i1} %12, i1 0, 1 - ret {i64, i1} %13 -} - - -define external fastcc i64 @"multictr.complicated.c15<0>"(i64 %"f15##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 14, i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"f15##0", i64* %5 - %6 = or i64 %2, 7 - ret i64 %6 -} - - -define external fastcc {i64, i1} @"multictr.complicated.c15<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = icmp uge i64 %"#result##0", 4 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = and i64 %"#result##0", 7 - %2 = icmp eq i64 %1, 7 - br i1 %2, label %if.then1, label %if.else1 -if.else: - %16 = insertvalue {i64, i1} undef, i64 undef, 0 - %17 = insertvalue {i64, i1} %16, i1 0, 1 - ret {i64, i1} %17 -if.then1: - %3 = add i64 %"#result##0", -7 - %4 = inttoptr i64 %3 to i16* - %5 = load i16, i16* %4 - %6 = icmp eq i16 %5, 14 - br i1 %6, label %if.then2, label %if.else2 -if.else1: - %14 = insertvalue {i64, i1} undef, i64 undef, 0 - %15 = insertvalue {i64, i1} %14, i1 0, 1 - ret {i64, i1} %15 -if.then2: - %7 = add i64 %"#result##0", 1 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = insertvalue {i64, i1} undef, i64 %9, 0 - %11 = insertvalue {i64, i1} %10, i1 1, 1 - ret {i64, i1} %11 -if.else2: - %12 = insertvalue {i64, i1} undef, i64 undef, 0 - %13 = insertvalue {i64, i1} %12, i1 0, 1 - ret {i64, i1} %13 -} - - -define external fastcc i64 @"multictr.complicated.c16<0>"(i64 %"f16##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 15, i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"f16##0", i64* %5 - %6 = or i64 %2, 7 - ret i64 %6 -} - - -define external fastcc {i64, i1} @"multictr.complicated.c16<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = icmp uge i64 %"#result##0", 4 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = and i64 %"#result##0", 7 - %2 = icmp eq i64 %1, 7 - br i1 %2, label %if.then1, label %if.else1 -if.else: - %16 = insertvalue {i64, i1} undef, i64 undef, 0 - %17 = insertvalue {i64, i1} %16, i1 0, 1 - ret {i64, i1} %17 -if.then1: - %3 = add i64 %"#result##0", -7 - %4 = inttoptr i64 %3 to i16* - %5 = load i16, i16* %4 - %6 = icmp eq i16 %5, 15 - br i1 %6, label %if.then2, label %if.else2 -if.else1: - %14 = insertvalue {i64, i1} undef, i64 undef, 0 - %15 = insertvalue {i64, i1} %14, i1 0, 1 - ret {i64, i1} %15 -if.then2: - %7 = add i64 %"#result##0", 1 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = insertvalue {i64, i1} undef, i64 %9, 0 - %11 = insertvalue {i64, i1} %10, i1 1, 1 - ret {i64, i1} %11 -if.else2: - %12 = insertvalue {i64, i1} undef, i64 undef, 0 - %13 = insertvalue {i64, i1} %12, i1 0, 1 - ret {i64, i1} %13 -} - - -define external fastcc i64 @"multictr.complicated.c17<0>"(i64 %"f17##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 16, i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"f17##0", i64* %5 - %6 = or i64 %2, 7 - ret i64 %6 -} - - -define external fastcc {i64, i1} @"multictr.complicated.c17<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = icmp uge i64 %"#result##0", 4 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = and i64 %"#result##0", 7 - %2 = icmp eq i64 %1, 7 - br i1 %2, label %if.then1, label %if.else1 -if.else: - %16 = insertvalue {i64, i1} undef, i64 undef, 0 - %17 = insertvalue {i64, i1} %16, i1 0, 1 - ret {i64, i1} %17 -if.then1: - %3 = add i64 %"#result##0", -7 - %4 = inttoptr i64 %3 to i16* - %5 = load i16, i16* %4 - %6 = icmp eq i16 %5, 16 - br i1 %6, label %if.then2, label %if.else2 -if.else1: - %14 = insertvalue {i64, i1} undef, i64 undef, 0 - %15 = insertvalue {i64, i1} %14, i1 0, 1 - ret {i64, i1} %15 -if.then2: - %7 = add i64 %"#result##0", 1 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = insertvalue {i64, i1} undef, i64 %9, 0 - %11 = insertvalue {i64, i1} %10, i1 1, 1 - ret {i64, i1} %11 -if.else2: - %12 = insertvalue {i64, i1} undef, i64 undef, 0 - %13 = insertvalue {i64, i1} %12, i1 0, 1 - ret {i64, i1} %13 -} - - -define external fastcc {i64, i1} @"multictr.complicated.f01<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = icmp uge i64 %"#rec##0", 4 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = and i64 %"#rec##0", 7 - %2 = icmp eq i64 %1, 0 - br i1 %2, label %if.then1, label %if.else1 -if.else: - %9 = insertvalue {i64, i1} undef, i64 undef, 0 - %10 = insertvalue {i64, i1} %9, i1 0, 1 - ret {i64, i1} %10 -if.then1: - %3 = inttoptr i64 %"#rec##0" to i64* - %4 = load i64, i64* %3 - %5 = insertvalue {i64, i1} undef, i64 %4, 0 - %6 = insertvalue {i64, i1} %5, i1 1, 1 - ret {i64, i1} %6 -if.else1: - %7 = insertvalue {i64, i1} undef, i64 undef, 0 - %8 = insertvalue {i64, i1} %7, i1 0, 1 - ret {i64, i1} %8 -} - - -define external fastcc {i64, i1} @"multictr.complicated.f01<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = icmp uge i64 %"#rec##0", 4 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = and i64 %"#rec##0", 7 - %2 = icmp eq i64 %1, 0 - br i1 %2, label %if.then1, label %if.else1 -if.else: - %14 = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 - %15 = insertvalue {i64, i1} %14, i1 0, 1 - ret {i64, i1} %15 -if.then1: - %3 = trunc i64 8 to i32 - %4 = tail call ccc i8* @wybe_malloc(i32 %3) - %5 = ptrtoint i8* %4 to i64 - %6 = inttoptr i64 %5 to i8* - %7 = inttoptr i64 %"#rec##0" to i8* - %8 = trunc i64 8 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %6, i8* %7, i32 %8, i1 0) - %9 = inttoptr i64 %5 to i64* - store i64 %"#field##0", i64* %9 - %10 = insertvalue {i64, i1} undef, i64 %5, 0 - %11 = insertvalue {i64, i1} %10, i1 1, 1 - ret {i64, i1} %11 -if.else1: - %12 = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 - %13 = insertvalue {i64, i1} %12, i1 0, 1 - ret {i64, i1} %13 -} - - -define external fastcc {i64, i1} @"multictr.complicated.f02<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = icmp uge i64 %"#rec##0", 4 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = and i64 %"#rec##0", 7 - %2 = icmp eq i64 %1, 1 - br i1 %2, label %if.then1, label %if.else1 -if.else: - %10 = insertvalue {i64, i1} undef, i64 undef, 0 - %11 = insertvalue {i64, i1} %10, i1 0, 1 - ret {i64, i1} %11 -if.then1: - %3 = add i64 %"#rec##0", -1 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = insertvalue {i64, i1} undef, i64 %5, 0 - %7 = insertvalue {i64, i1} %6, i1 1, 1 - ret {i64, i1} %7 -if.else1: - %8 = insertvalue {i64, i1} undef, i64 undef, 0 - %9 = insertvalue {i64, i1} %8, i1 0, 1 - ret {i64, i1} %9 -} - - -define external fastcc {i64, i1} @"multictr.complicated.f02<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = icmp uge i64 %"#rec##0", 4 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = and i64 %"#rec##0", 7 - %2 = icmp eq i64 %1, 1 - br i1 %2, label %if.then1, label %if.else1 -if.else: - %17 = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 - %18 = insertvalue {i64, i1} %17, i1 0, 1 - ret {i64, i1} %18 -if.then1: - %3 = trunc i64 8 to i32 - %4 = tail call ccc i8* @wybe_malloc(i32 %3) - %5 = ptrtoint i8* %4 to i64 - %6 = add i64 %5, 1 - %7 = sub i64 %"#rec##0", 1 - %8 = inttoptr i64 %5 to i8* - %9 = inttoptr i64 %7 to i8* - %10 = trunc i64 8 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %8, i8* %9, i32 %10, i1 0) - %11 = add i64 %6, -1 - %12 = inttoptr i64 %11 to i64* - store i64 %"#field##0", i64* %12 - %13 = insertvalue {i64, i1} undef, i64 %6, 0 - %14 = insertvalue {i64, i1} %13, i1 1, 1 - ret {i64, i1} %14 -if.else1: - %15 = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 - %16 = insertvalue {i64, i1} %15, i1 0, 1 - ret {i64, i1} %16 -} - - -define external fastcc {i64, i1} @"multictr.complicated.f03<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = icmp uge i64 %"#rec##0", 4 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = and i64 %"#rec##0", 7 - %2 = icmp eq i64 %1, 2 - br i1 %2, label %if.then1, label %if.else1 -if.else: - %10 = insertvalue {i64, i1} undef, i64 undef, 0 - %11 = insertvalue {i64, i1} %10, i1 0, 1 - ret {i64, i1} %11 -if.then1: - %3 = add i64 %"#rec##0", -2 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = insertvalue {i64, i1} undef, i64 %5, 0 - %7 = insertvalue {i64, i1} %6, i1 1, 1 - ret {i64, i1} %7 -if.else1: - %8 = insertvalue {i64, i1} undef, i64 undef, 0 - %9 = insertvalue {i64, i1} %8, i1 0, 1 - ret {i64, i1} %9 -} - - -define external fastcc {i64, i1} @"multictr.complicated.f03<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = icmp uge i64 %"#rec##0", 4 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = and i64 %"#rec##0", 7 - %2 = icmp eq i64 %1, 2 - br i1 %2, label %if.then1, label %if.else1 -if.else: - %17 = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 - %18 = insertvalue {i64, i1} %17, i1 0, 1 - ret {i64, i1} %18 -if.then1: - %3 = trunc i64 8 to i32 - %4 = tail call ccc i8* @wybe_malloc(i32 %3) - %5 = ptrtoint i8* %4 to i64 - %6 = add i64 %5, 2 - %7 = sub i64 %"#rec##0", 2 - %8 = inttoptr i64 %5 to i8* - %9 = inttoptr i64 %7 to i8* - %10 = trunc i64 8 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %8, i8* %9, i32 %10, i1 0) - %11 = add i64 %6, -2 - %12 = inttoptr i64 %11 to i64* - store i64 %"#field##0", i64* %12 - %13 = insertvalue {i64, i1} undef, i64 %6, 0 - %14 = insertvalue {i64, i1} %13, i1 1, 1 - ret {i64, i1} %14 -if.else1: - %15 = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 - %16 = insertvalue {i64, i1} %15, i1 0, 1 - ret {i64, i1} %16 -} - - -define external fastcc {i64, i1} @"multictr.complicated.f04<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = icmp uge i64 %"#rec##0", 4 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = and i64 %"#rec##0", 7 - %2 = icmp eq i64 %1, 3 - br i1 %2, label %if.then1, label %if.else1 -if.else: - %10 = insertvalue {i64, i1} undef, i64 undef, 0 - %11 = insertvalue {i64, i1} %10, i1 0, 1 - ret {i64, i1} %11 -if.then1: - %3 = add i64 %"#rec##0", -3 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = insertvalue {i64, i1} undef, i64 %5, 0 - %7 = insertvalue {i64, i1} %6, i1 1, 1 - ret {i64, i1} %7 -if.else1: - %8 = insertvalue {i64, i1} undef, i64 undef, 0 - %9 = insertvalue {i64, i1} %8, i1 0, 1 - ret {i64, i1} %9 -} - - -define external fastcc {i64, i1} @"multictr.complicated.f04<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = icmp uge i64 %"#rec##0", 4 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = and i64 %"#rec##0", 7 - %2 = icmp eq i64 %1, 3 - br i1 %2, label %if.then1, label %if.else1 -if.else: - %17 = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 - %18 = insertvalue {i64, i1} %17, i1 0, 1 - ret {i64, i1} %18 -if.then1: - %3 = trunc i64 8 to i32 - %4 = tail call ccc i8* @wybe_malloc(i32 %3) - %5 = ptrtoint i8* %4 to i64 - %6 = add i64 %5, 3 - %7 = sub i64 %"#rec##0", 3 - %8 = inttoptr i64 %5 to i8* - %9 = inttoptr i64 %7 to i8* - %10 = trunc i64 8 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %8, i8* %9, i32 %10, i1 0) - %11 = add i64 %6, -3 - %12 = inttoptr i64 %11 to i64* - store i64 %"#field##0", i64* %12 - %13 = insertvalue {i64, i1} undef, i64 %6, 0 - %14 = insertvalue {i64, i1} %13, i1 1, 1 - ret {i64, i1} %14 -if.else1: - %15 = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 - %16 = insertvalue {i64, i1} %15, i1 0, 1 - ret {i64, i1} %16 -} - - -define external fastcc {i64, i1} @"multictr.complicated.f05<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = icmp uge i64 %"#rec##0", 4 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = and i64 %"#rec##0", 7 - %2 = icmp eq i64 %1, 4 - br i1 %2, label %if.then1, label %if.else1 -if.else: - %10 = insertvalue {i64, i1} undef, i64 undef, 0 - %11 = insertvalue {i64, i1} %10, i1 0, 1 - ret {i64, i1} %11 -if.then1: - %3 = add i64 %"#rec##0", -4 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = insertvalue {i64, i1} undef, i64 %5, 0 - %7 = insertvalue {i64, i1} %6, i1 1, 1 - ret {i64, i1} %7 -if.else1: - %8 = insertvalue {i64, i1} undef, i64 undef, 0 - %9 = insertvalue {i64, i1} %8, i1 0, 1 - ret {i64, i1} %9 -} - - -define external fastcc {i64, i1} @"multictr.complicated.f05<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = icmp uge i64 %"#rec##0", 4 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = and i64 %"#rec##0", 7 - %2 = icmp eq i64 %1, 4 - br i1 %2, label %if.then1, label %if.else1 -if.else: - %17 = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 - %18 = insertvalue {i64, i1} %17, i1 0, 1 - ret {i64, i1} %18 -if.then1: - %3 = trunc i64 8 to i32 - %4 = tail call ccc i8* @wybe_malloc(i32 %3) - %5 = ptrtoint i8* %4 to i64 - %6 = add i64 %5, 4 - %7 = sub i64 %"#rec##0", 4 - %8 = inttoptr i64 %5 to i8* - %9 = inttoptr i64 %7 to i8* - %10 = trunc i64 8 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %8, i8* %9, i32 %10, i1 0) - %11 = add i64 %6, -4 - %12 = inttoptr i64 %11 to i64* - store i64 %"#field##0", i64* %12 - %13 = insertvalue {i64, i1} undef, i64 %6, 0 - %14 = insertvalue {i64, i1} %13, i1 1, 1 - ret {i64, i1} %14 -if.else1: - %15 = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 - %16 = insertvalue {i64, i1} %15, i1 0, 1 - ret {i64, i1} %16 -} - - -define external fastcc {i64, i1} @"multictr.complicated.f06<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = icmp uge i64 %"#rec##0", 4 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = and i64 %"#rec##0", 7 - %2 = icmp eq i64 %1, 5 - br i1 %2, label %if.then1, label %if.else1 -if.else: - %10 = insertvalue {i64, i1} undef, i64 undef, 0 - %11 = insertvalue {i64, i1} %10, i1 0, 1 - ret {i64, i1} %11 -if.then1: - %3 = add i64 %"#rec##0", -5 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = insertvalue {i64, i1} undef, i64 %5, 0 - %7 = insertvalue {i64, i1} %6, i1 1, 1 - ret {i64, i1} %7 -if.else1: - %8 = insertvalue {i64, i1} undef, i64 undef, 0 - %9 = insertvalue {i64, i1} %8, i1 0, 1 - ret {i64, i1} %9 -} - - -define external fastcc {i64, i1} @"multictr.complicated.f06<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = icmp uge i64 %"#rec##0", 4 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = and i64 %"#rec##0", 7 - %2 = icmp eq i64 %1, 5 - br i1 %2, label %if.then1, label %if.else1 -if.else: - %17 = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 - %18 = insertvalue {i64, i1} %17, i1 0, 1 - ret {i64, i1} %18 -if.then1: - %3 = trunc i64 8 to i32 - %4 = tail call ccc i8* @wybe_malloc(i32 %3) - %5 = ptrtoint i8* %4 to i64 - %6 = add i64 %5, 5 - %7 = sub i64 %"#rec##0", 5 - %8 = inttoptr i64 %5 to i8* - %9 = inttoptr i64 %7 to i8* - %10 = trunc i64 8 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %8, i8* %9, i32 %10, i1 0) - %11 = add i64 %6, -5 - %12 = inttoptr i64 %11 to i64* - store i64 %"#field##0", i64* %12 - %13 = insertvalue {i64, i1} undef, i64 %6, 0 - %14 = insertvalue {i64, i1} %13, i1 1, 1 - ret {i64, i1} %14 -if.else1: - %15 = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 - %16 = insertvalue {i64, i1} %15, i1 0, 1 - ret {i64, i1} %16 -} - - -define external fastcc {i64, i1} @"multictr.complicated.f07<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = icmp uge i64 %"#rec##0", 4 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = and i64 %"#rec##0", 7 - %2 = icmp eq i64 %1, 6 - br i1 %2, label %if.then1, label %if.else1 -if.else: - %10 = insertvalue {i64, i1} undef, i64 undef, 0 - %11 = insertvalue {i64, i1} %10, i1 0, 1 - ret {i64, i1} %11 -if.then1: - %3 = add i64 %"#rec##0", -6 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = insertvalue {i64, i1} undef, i64 %5, 0 - %7 = insertvalue {i64, i1} %6, i1 1, 1 - ret {i64, i1} %7 -if.else1: - %8 = insertvalue {i64, i1} undef, i64 undef, 0 - %9 = insertvalue {i64, i1} %8, i1 0, 1 - ret {i64, i1} %9 -} - - -define external fastcc {i64, i1} @"multictr.complicated.f07<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = icmp uge i64 %"#rec##0", 4 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = and i64 %"#rec##0", 7 - %2 = icmp eq i64 %1, 6 - br i1 %2, label %if.then1, label %if.else1 -if.else: - %17 = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 - %18 = insertvalue {i64, i1} %17, i1 0, 1 - ret {i64, i1} %18 -if.then1: - %3 = trunc i64 8 to i32 - %4 = tail call ccc i8* @wybe_malloc(i32 %3) - %5 = ptrtoint i8* %4 to i64 - %6 = add i64 %5, 6 - %7 = sub i64 %"#rec##0", 6 - %8 = inttoptr i64 %5 to i8* - %9 = inttoptr i64 %7 to i8* - %10 = trunc i64 8 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %8, i8* %9, i32 %10, i1 0) - %11 = add i64 %6, -6 - %12 = inttoptr i64 %11 to i64* - store i64 %"#field##0", i64* %12 - %13 = insertvalue {i64, i1} undef, i64 %6, 0 - %14 = insertvalue {i64, i1} %13, i1 1, 1 - ret {i64, i1} %14 -if.else1: - %15 = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 - %16 = insertvalue {i64, i1} %15, i1 0, 1 - ret {i64, i1} %16 -} - - -define external fastcc {i64, i1} @"multictr.complicated.f08<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = icmp uge i64 %"#rec##0", 4 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = and i64 %"#rec##0", 7 - %2 = icmp eq i64 %1, 7 - br i1 %2, label %if.then1, label %if.else1 -if.else: - %16 = insertvalue {i64, i1} undef, i64 undef, 0 - %17 = insertvalue {i64, i1} %16, i1 0, 1 - ret {i64, i1} %17 -if.then1: - %3 = add i64 %"#rec##0", -7 - %4 = inttoptr i64 %3 to i16* - %5 = load i16, i16* %4 - %6 = icmp eq i16 %5, 7 - br i1 %6, label %if.then2, label %if.else2 -if.else1: - %14 = insertvalue {i64, i1} undef, i64 undef, 0 - %15 = insertvalue {i64, i1} %14, i1 0, 1 - ret {i64, i1} %15 -if.then2: - %7 = add i64 %"#rec##0", 1 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = insertvalue {i64, i1} undef, i64 %9, 0 - %11 = insertvalue {i64, i1} %10, i1 1, 1 - ret {i64, i1} %11 -if.else2: - %12 = insertvalue {i64, i1} undef, i64 undef, 0 - %13 = insertvalue {i64, i1} %12, i1 0, 1 - ret {i64, i1} %13 -} - - -define external fastcc {i64, i1} @"multictr.complicated.f08<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = icmp uge i64 %"#rec##0", 4 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = and i64 %"#rec##0", 7 - %2 = icmp eq i64 %1, 7 - br i1 %2, label %if.then1, label %if.else1 -if.else: - %23 = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 - %24 = insertvalue {i64, i1} %23, i1 0, 1 - ret {i64, i1} %24 -if.then1: - %3 = add i64 %"#rec##0", -7 - %4 = inttoptr i64 %3 to i16* - %5 = load i16, i16* %4 - %6 = icmp eq i16 %5, 7 - br i1 %6, label %if.then2, label %if.else2 -if.else1: - %21 = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 - %22 = insertvalue {i64, i1} %21, i1 0, 1 - ret {i64, i1} %22 -if.then2: - %7 = trunc i64 16 to i32 - %8 = tail call ccc i8* @wybe_malloc(i32 %7) - %9 = ptrtoint i8* %8 to i64 - %10 = add i64 %9, 7 - %11 = sub i64 %"#rec##0", 7 - %12 = inttoptr i64 %9 to i8* - %13 = inttoptr i64 %11 to i8* - %14 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %12, i8* %13, i32 %14, i1 0) - %15 = add i64 %10, 1 - %16 = inttoptr i64 %15 to i64* - store i64 %"#field##0", i64* %16 - %17 = insertvalue {i64, i1} undef, i64 %10, 0 - %18 = insertvalue {i64, i1} %17, i1 1, 1 - ret {i64, i1} %18 -if.else2: - %19 = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 - %20 = insertvalue {i64, i1} %19, i1 0, 1 - ret {i64, i1} %20 -} - - -define external fastcc {i64, i1} @"multictr.complicated.f09<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = icmp uge i64 %"#rec##0", 4 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = and i64 %"#rec##0", 7 - %2 = icmp eq i64 %1, 7 - br i1 %2, label %if.then1, label %if.else1 -if.else: - %16 = insertvalue {i64, i1} undef, i64 undef, 0 - %17 = insertvalue {i64, i1} %16, i1 0, 1 - ret {i64, i1} %17 -if.then1: - %3 = add i64 %"#rec##0", -7 - %4 = inttoptr i64 %3 to i16* - %5 = load i16, i16* %4 - %6 = icmp eq i16 %5, 8 - br i1 %6, label %if.then2, label %if.else2 -if.else1: - %14 = insertvalue {i64, i1} undef, i64 undef, 0 - %15 = insertvalue {i64, i1} %14, i1 0, 1 - ret {i64, i1} %15 -if.then2: - %7 = add i64 %"#rec##0", 1 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = insertvalue {i64, i1} undef, i64 %9, 0 - %11 = insertvalue {i64, i1} %10, i1 1, 1 - ret {i64, i1} %11 -if.else2: - %12 = insertvalue {i64, i1} undef, i64 undef, 0 - %13 = insertvalue {i64, i1} %12, i1 0, 1 - ret {i64, i1} %13 -} - - -define external fastcc {i64, i1} @"multictr.complicated.f09<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = icmp uge i64 %"#rec##0", 4 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = and i64 %"#rec##0", 7 - %2 = icmp eq i64 %1, 7 - br i1 %2, label %if.then1, label %if.else1 -if.else: - %23 = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 - %24 = insertvalue {i64, i1} %23, i1 0, 1 - ret {i64, i1} %24 -if.then1: - %3 = add i64 %"#rec##0", -7 - %4 = inttoptr i64 %3 to i16* - %5 = load i16, i16* %4 - %6 = icmp eq i16 %5, 8 - br i1 %6, label %if.then2, label %if.else2 -if.else1: - %21 = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 - %22 = insertvalue {i64, i1} %21, i1 0, 1 - ret {i64, i1} %22 -if.then2: - %7 = trunc i64 16 to i32 - %8 = tail call ccc i8* @wybe_malloc(i32 %7) - %9 = ptrtoint i8* %8 to i64 - %10 = add i64 %9, 7 - %11 = sub i64 %"#rec##0", 7 - %12 = inttoptr i64 %9 to i8* - %13 = inttoptr i64 %11 to i8* - %14 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %12, i8* %13, i32 %14, i1 0) - %15 = add i64 %10, 1 - %16 = inttoptr i64 %15 to i64* - store i64 %"#field##0", i64* %16 - %17 = insertvalue {i64, i1} undef, i64 %10, 0 - %18 = insertvalue {i64, i1} %17, i1 1, 1 - ret {i64, i1} %18 -if.else2: - %19 = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 - %20 = insertvalue {i64, i1} %19, i1 0, 1 - ret {i64, i1} %20 -} - - -define external fastcc {i64, i1} @"multictr.complicated.f10<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = icmp uge i64 %"#rec##0", 4 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = and i64 %"#rec##0", 7 - %2 = icmp eq i64 %1, 7 - br i1 %2, label %if.then1, label %if.else1 -if.else: - %16 = insertvalue {i64, i1} undef, i64 undef, 0 - %17 = insertvalue {i64, i1} %16, i1 0, 1 - ret {i64, i1} %17 -if.then1: - %3 = add i64 %"#rec##0", -7 - %4 = inttoptr i64 %3 to i16* - %5 = load i16, i16* %4 - %6 = icmp eq i16 %5, 9 - br i1 %6, label %if.then2, label %if.else2 -if.else1: - %14 = insertvalue {i64, i1} undef, i64 undef, 0 - %15 = insertvalue {i64, i1} %14, i1 0, 1 - ret {i64, i1} %15 -if.then2: - %7 = add i64 %"#rec##0", 1 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = insertvalue {i64, i1} undef, i64 %9, 0 - %11 = insertvalue {i64, i1} %10, i1 1, 1 - ret {i64, i1} %11 -if.else2: - %12 = insertvalue {i64, i1} undef, i64 undef, 0 - %13 = insertvalue {i64, i1} %12, i1 0, 1 - ret {i64, i1} %13 -} - - -define external fastcc {i64, i1} @"multictr.complicated.f10<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = icmp uge i64 %"#rec##0", 4 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = and i64 %"#rec##0", 7 - %2 = icmp eq i64 %1, 7 - br i1 %2, label %if.then1, label %if.else1 -if.else: - %23 = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 - %24 = insertvalue {i64, i1} %23, i1 0, 1 - ret {i64, i1} %24 -if.then1: - %3 = add i64 %"#rec##0", -7 - %4 = inttoptr i64 %3 to i16* - %5 = load i16, i16* %4 - %6 = icmp eq i16 %5, 9 - br i1 %6, label %if.then2, label %if.else2 -if.else1: - %21 = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 - %22 = insertvalue {i64, i1} %21, i1 0, 1 - ret {i64, i1} %22 -if.then2: - %7 = trunc i64 16 to i32 - %8 = tail call ccc i8* @wybe_malloc(i32 %7) - %9 = ptrtoint i8* %8 to i64 - %10 = add i64 %9, 7 - %11 = sub i64 %"#rec##0", 7 - %12 = inttoptr i64 %9 to i8* - %13 = inttoptr i64 %11 to i8* - %14 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %12, i8* %13, i32 %14, i1 0) - %15 = add i64 %10, 1 - %16 = inttoptr i64 %15 to i64* - store i64 %"#field##0", i64* %16 - %17 = insertvalue {i64, i1} undef, i64 %10, 0 - %18 = insertvalue {i64, i1} %17, i1 1, 1 - ret {i64, i1} %18 -if.else2: - %19 = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 - %20 = insertvalue {i64, i1} %19, i1 0, 1 - ret {i64, i1} %20 -} - - -define external fastcc {i64, i1} @"multictr.complicated.f11<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = icmp uge i64 %"#rec##0", 4 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = and i64 %"#rec##0", 7 - %2 = icmp eq i64 %1, 7 - br i1 %2, label %if.then1, label %if.else1 -if.else: - %16 = insertvalue {i64, i1} undef, i64 undef, 0 - %17 = insertvalue {i64, i1} %16, i1 0, 1 - ret {i64, i1} %17 -if.then1: - %3 = add i64 %"#rec##0", -7 - %4 = inttoptr i64 %3 to i16* - %5 = load i16, i16* %4 - %6 = icmp eq i16 %5, 10 - br i1 %6, label %if.then2, label %if.else2 -if.else1: - %14 = insertvalue {i64, i1} undef, i64 undef, 0 - %15 = insertvalue {i64, i1} %14, i1 0, 1 - ret {i64, i1} %15 -if.then2: - %7 = add i64 %"#rec##0", 1 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = insertvalue {i64, i1} undef, i64 %9, 0 - %11 = insertvalue {i64, i1} %10, i1 1, 1 - ret {i64, i1} %11 -if.else2: - %12 = insertvalue {i64, i1} undef, i64 undef, 0 - %13 = insertvalue {i64, i1} %12, i1 0, 1 - ret {i64, i1} %13 -} - - -define external fastcc {i64, i1} @"multictr.complicated.f11<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = icmp uge i64 %"#rec##0", 4 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = and i64 %"#rec##0", 7 - %2 = icmp eq i64 %1, 7 - br i1 %2, label %if.then1, label %if.else1 -if.else: - %23 = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 - %24 = insertvalue {i64, i1} %23, i1 0, 1 - ret {i64, i1} %24 -if.then1: - %3 = add i64 %"#rec##0", -7 - %4 = inttoptr i64 %3 to i16* - %5 = load i16, i16* %4 - %6 = icmp eq i16 %5, 10 - br i1 %6, label %if.then2, label %if.else2 -if.else1: - %21 = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 - %22 = insertvalue {i64, i1} %21, i1 0, 1 - ret {i64, i1} %22 -if.then2: - %7 = trunc i64 16 to i32 - %8 = tail call ccc i8* @wybe_malloc(i32 %7) - %9 = ptrtoint i8* %8 to i64 - %10 = add i64 %9, 7 - %11 = sub i64 %"#rec##0", 7 - %12 = inttoptr i64 %9 to i8* - %13 = inttoptr i64 %11 to i8* - %14 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %12, i8* %13, i32 %14, i1 0) - %15 = add i64 %10, 1 - %16 = inttoptr i64 %15 to i64* - store i64 %"#field##0", i64* %16 - %17 = insertvalue {i64, i1} undef, i64 %10, 0 - %18 = insertvalue {i64, i1} %17, i1 1, 1 - ret {i64, i1} %18 -if.else2: - %19 = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 - %20 = insertvalue {i64, i1} %19, i1 0, 1 - ret {i64, i1} %20 -} - - -define external fastcc {i64, i1} @"multictr.complicated.f12<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = icmp uge i64 %"#rec##0", 4 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = and i64 %"#rec##0", 7 - %2 = icmp eq i64 %1, 7 - br i1 %2, label %if.then1, label %if.else1 -if.else: - %16 = insertvalue {i64, i1} undef, i64 undef, 0 - %17 = insertvalue {i64, i1} %16, i1 0, 1 - ret {i64, i1} %17 -if.then1: - %3 = add i64 %"#rec##0", -7 - %4 = inttoptr i64 %3 to i16* - %5 = load i16, i16* %4 - %6 = icmp eq i16 %5, 11 - br i1 %6, label %if.then2, label %if.else2 -if.else1: - %14 = insertvalue {i64, i1} undef, i64 undef, 0 - %15 = insertvalue {i64, i1} %14, i1 0, 1 - ret {i64, i1} %15 -if.then2: - %7 = add i64 %"#rec##0", 1 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = insertvalue {i64, i1} undef, i64 %9, 0 - %11 = insertvalue {i64, i1} %10, i1 1, 1 - ret {i64, i1} %11 -if.else2: - %12 = insertvalue {i64, i1} undef, i64 undef, 0 - %13 = insertvalue {i64, i1} %12, i1 0, 1 - ret {i64, i1} %13 -} - - -define external fastcc {i64, i1} @"multictr.complicated.f12<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = icmp uge i64 %"#rec##0", 4 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = and i64 %"#rec##0", 7 - %2 = icmp eq i64 %1, 7 - br i1 %2, label %if.then1, label %if.else1 -if.else: - %23 = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 - %24 = insertvalue {i64, i1} %23, i1 0, 1 - ret {i64, i1} %24 -if.then1: - %3 = add i64 %"#rec##0", -7 - %4 = inttoptr i64 %3 to i16* - %5 = load i16, i16* %4 - %6 = icmp eq i16 %5, 11 - br i1 %6, label %if.then2, label %if.else2 -if.else1: - %21 = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 - %22 = insertvalue {i64, i1} %21, i1 0, 1 - ret {i64, i1} %22 -if.then2: - %7 = trunc i64 16 to i32 - %8 = tail call ccc i8* @wybe_malloc(i32 %7) - %9 = ptrtoint i8* %8 to i64 - %10 = add i64 %9, 7 - %11 = sub i64 %"#rec##0", 7 - %12 = inttoptr i64 %9 to i8* - %13 = inttoptr i64 %11 to i8* - %14 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %12, i8* %13, i32 %14, i1 0) - %15 = add i64 %10, 1 - %16 = inttoptr i64 %15 to i64* - store i64 %"#field##0", i64* %16 - %17 = insertvalue {i64, i1} undef, i64 %10, 0 - %18 = insertvalue {i64, i1} %17, i1 1, 1 - ret {i64, i1} %18 -if.else2: - %19 = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 - %20 = insertvalue {i64, i1} %19, i1 0, 1 - ret {i64, i1} %20 -} - - -define external fastcc {i64, i1} @"multictr.complicated.f13<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = icmp uge i64 %"#rec##0", 4 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = and i64 %"#rec##0", 7 - %2 = icmp eq i64 %1, 7 - br i1 %2, label %if.then1, label %if.else1 -if.else: - %16 = insertvalue {i64, i1} undef, i64 undef, 0 - %17 = insertvalue {i64, i1} %16, i1 0, 1 - ret {i64, i1} %17 -if.then1: - %3 = add i64 %"#rec##0", -7 - %4 = inttoptr i64 %3 to i16* - %5 = load i16, i16* %4 - %6 = icmp eq i16 %5, 12 - br i1 %6, label %if.then2, label %if.else2 -if.else1: - %14 = insertvalue {i64, i1} undef, i64 undef, 0 - %15 = insertvalue {i64, i1} %14, i1 0, 1 - ret {i64, i1} %15 -if.then2: - %7 = add i64 %"#rec##0", 1 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = insertvalue {i64, i1} undef, i64 %9, 0 - %11 = insertvalue {i64, i1} %10, i1 1, 1 - ret {i64, i1} %11 -if.else2: - %12 = insertvalue {i64, i1} undef, i64 undef, 0 - %13 = insertvalue {i64, i1} %12, i1 0, 1 - ret {i64, i1} %13 -} - - -define external fastcc {i64, i1} @"multictr.complicated.f13<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = icmp uge i64 %"#rec##0", 4 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = and i64 %"#rec##0", 7 - %2 = icmp eq i64 %1, 7 - br i1 %2, label %if.then1, label %if.else1 -if.else: - %23 = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 - %24 = insertvalue {i64, i1} %23, i1 0, 1 - ret {i64, i1} %24 -if.then1: - %3 = add i64 %"#rec##0", -7 - %4 = inttoptr i64 %3 to i16* - %5 = load i16, i16* %4 - %6 = icmp eq i16 %5, 12 - br i1 %6, label %if.then2, label %if.else2 -if.else1: - %21 = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 - %22 = insertvalue {i64, i1} %21, i1 0, 1 - ret {i64, i1} %22 -if.then2: - %7 = trunc i64 16 to i32 - %8 = tail call ccc i8* @wybe_malloc(i32 %7) - %9 = ptrtoint i8* %8 to i64 - %10 = add i64 %9, 7 - %11 = sub i64 %"#rec##0", 7 - %12 = inttoptr i64 %9 to i8* - %13 = inttoptr i64 %11 to i8* - %14 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %12, i8* %13, i32 %14, i1 0) - %15 = add i64 %10, 1 - %16 = inttoptr i64 %15 to i64* - store i64 %"#field##0", i64* %16 - %17 = insertvalue {i64, i1} undef, i64 %10, 0 - %18 = insertvalue {i64, i1} %17, i1 1, 1 - ret {i64, i1} %18 -if.else2: - %19 = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 - %20 = insertvalue {i64, i1} %19, i1 0, 1 - ret {i64, i1} %20 -} - - -define external fastcc {i64, i1} @"multictr.complicated.f14<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = icmp uge i64 %"#rec##0", 4 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = and i64 %"#rec##0", 7 - %2 = icmp eq i64 %1, 7 - br i1 %2, label %if.then1, label %if.else1 -if.else: - %16 = insertvalue {i64, i1} undef, i64 undef, 0 - %17 = insertvalue {i64, i1} %16, i1 0, 1 - ret {i64, i1} %17 -if.then1: - %3 = add i64 %"#rec##0", -7 - %4 = inttoptr i64 %3 to i16* - %5 = load i16, i16* %4 - %6 = icmp eq i16 %5, 13 - br i1 %6, label %if.then2, label %if.else2 -if.else1: - %14 = insertvalue {i64, i1} undef, i64 undef, 0 - %15 = insertvalue {i64, i1} %14, i1 0, 1 - ret {i64, i1} %15 -if.then2: - %7 = add i64 %"#rec##0", 1 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = insertvalue {i64, i1} undef, i64 %9, 0 - %11 = insertvalue {i64, i1} %10, i1 1, 1 - ret {i64, i1} %11 -if.else2: - %12 = insertvalue {i64, i1} undef, i64 undef, 0 - %13 = insertvalue {i64, i1} %12, i1 0, 1 - ret {i64, i1} %13 -} - - -define external fastcc {i64, i1} @"multictr.complicated.f14<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = icmp uge i64 %"#rec##0", 4 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = and i64 %"#rec##0", 7 - %2 = icmp eq i64 %1, 7 - br i1 %2, label %if.then1, label %if.else1 -if.else: - %23 = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 - %24 = insertvalue {i64, i1} %23, i1 0, 1 - ret {i64, i1} %24 -if.then1: - %3 = add i64 %"#rec##0", -7 - %4 = inttoptr i64 %3 to i16* - %5 = load i16, i16* %4 - %6 = icmp eq i16 %5, 13 - br i1 %6, label %if.then2, label %if.else2 -if.else1: - %21 = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 - %22 = insertvalue {i64, i1} %21, i1 0, 1 - ret {i64, i1} %22 -if.then2: - %7 = trunc i64 16 to i32 - %8 = tail call ccc i8* @wybe_malloc(i32 %7) - %9 = ptrtoint i8* %8 to i64 - %10 = add i64 %9, 7 - %11 = sub i64 %"#rec##0", 7 - %12 = inttoptr i64 %9 to i8* - %13 = inttoptr i64 %11 to i8* - %14 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %12, i8* %13, i32 %14, i1 0) - %15 = add i64 %10, 1 - %16 = inttoptr i64 %15 to i64* - store i64 %"#field##0", i64* %16 - %17 = insertvalue {i64, i1} undef, i64 %10, 0 - %18 = insertvalue {i64, i1} %17, i1 1, 1 - ret {i64, i1} %18 -if.else2: - %19 = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 - %20 = insertvalue {i64, i1} %19, i1 0, 1 - ret {i64, i1} %20 -} - - -define external fastcc {i64, i1} @"multictr.complicated.f15<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = icmp uge i64 %"#rec##0", 4 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = and i64 %"#rec##0", 7 - %2 = icmp eq i64 %1, 7 - br i1 %2, label %if.then1, label %if.else1 -if.else: - %16 = insertvalue {i64, i1} undef, i64 undef, 0 - %17 = insertvalue {i64, i1} %16, i1 0, 1 - ret {i64, i1} %17 -if.then1: - %3 = add i64 %"#rec##0", -7 - %4 = inttoptr i64 %3 to i16* - %5 = load i16, i16* %4 - %6 = icmp eq i16 %5, 14 - br i1 %6, label %if.then2, label %if.else2 -if.else1: - %14 = insertvalue {i64, i1} undef, i64 undef, 0 - %15 = insertvalue {i64, i1} %14, i1 0, 1 - ret {i64, i1} %15 -if.then2: - %7 = add i64 %"#rec##0", 1 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = insertvalue {i64, i1} undef, i64 %9, 0 - %11 = insertvalue {i64, i1} %10, i1 1, 1 - ret {i64, i1} %11 -if.else2: - %12 = insertvalue {i64, i1} undef, i64 undef, 0 - %13 = insertvalue {i64, i1} %12, i1 0, 1 - ret {i64, i1} %13 -} - - -define external fastcc {i64, i1} @"multictr.complicated.f15<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = icmp uge i64 %"#rec##0", 4 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = and i64 %"#rec##0", 7 - %2 = icmp eq i64 %1, 7 - br i1 %2, label %if.then1, label %if.else1 -if.else: - %23 = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 - %24 = insertvalue {i64, i1} %23, i1 0, 1 - ret {i64, i1} %24 -if.then1: - %3 = add i64 %"#rec##0", -7 - %4 = inttoptr i64 %3 to i16* - %5 = load i16, i16* %4 - %6 = icmp eq i16 %5, 14 - br i1 %6, label %if.then2, label %if.else2 -if.else1: - %21 = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 - %22 = insertvalue {i64, i1} %21, i1 0, 1 - ret {i64, i1} %22 -if.then2: - %7 = trunc i64 16 to i32 - %8 = tail call ccc i8* @wybe_malloc(i32 %7) - %9 = ptrtoint i8* %8 to i64 - %10 = add i64 %9, 7 - %11 = sub i64 %"#rec##0", 7 - %12 = inttoptr i64 %9 to i8* - %13 = inttoptr i64 %11 to i8* - %14 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %12, i8* %13, i32 %14, i1 0) - %15 = add i64 %10, 1 - %16 = inttoptr i64 %15 to i64* - store i64 %"#field##0", i64* %16 - %17 = insertvalue {i64, i1} undef, i64 %10, 0 - %18 = insertvalue {i64, i1} %17, i1 1, 1 - ret {i64, i1} %18 -if.else2: - %19 = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 - %20 = insertvalue {i64, i1} %19, i1 0, 1 - ret {i64, i1} %20 -} - - -define external fastcc {i64, i1} @"multictr.complicated.f16<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = icmp uge i64 %"#rec##0", 4 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = and i64 %"#rec##0", 7 - %2 = icmp eq i64 %1, 7 - br i1 %2, label %if.then1, label %if.else1 -if.else: - %16 = insertvalue {i64, i1} undef, i64 undef, 0 - %17 = insertvalue {i64, i1} %16, i1 0, 1 - ret {i64, i1} %17 -if.then1: - %3 = add i64 %"#rec##0", -7 - %4 = inttoptr i64 %3 to i16* - %5 = load i16, i16* %4 - %6 = icmp eq i16 %5, 15 - br i1 %6, label %if.then2, label %if.else2 -if.else1: - %14 = insertvalue {i64, i1} undef, i64 undef, 0 - %15 = insertvalue {i64, i1} %14, i1 0, 1 - ret {i64, i1} %15 -if.then2: - %7 = add i64 %"#rec##0", 1 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = insertvalue {i64, i1} undef, i64 %9, 0 - %11 = insertvalue {i64, i1} %10, i1 1, 1 - ret {i64, i1} %11 -if.else2: - %12 = insertvalue {i64, i1} undef, i64 undef, 0 - %13 = insertvalue {i64, i1} %12, i1 0, 1 - ret {i64, i1} %13 -} - - -define external fastcc {i64, i1} @"multictr.complicated.f16<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = icmp uge i64 %"#rec##0", 4 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = and i64 %"#rec##0", 7 - %2 = icmp eq i64 %1, 7 - br i1 %2, label %if.then1, label %if.else1 -if.else: - %23 = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 - %24 = insertvalue {i64, i1} %23, i1 0, 1 - ret {i64, i1} %24 -if.then1: - %3 = add i64 %"#rec##0", -7 - %4 = inttoptr i64 %3 to i16* - %5 = load i16, i16* %4 - %6 = icmp eq i16 %5, 15 - br i1 %6, label %if.then2, label %if.else2 -if.else1: - %21 = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 - %22 = insertvalue {i64, i1} %21, i1 0, 1 - ret {i64, i1} %22 -if.then2: - %7 = trunc i64 16 to i32 - %8 = tail call ccc i8* @wybe_malloc(i32 %7) - %9 = ptrtoint i8* %8 to i64 - %10 = add i64 %9, 7 - %11 = sub i64 %"#rec##0", 7 - %12 = inttoptr i64 %9 to i8* - %13 = inttoptr i64 %11 to i8* - %14 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %12, i8* %13, i32 %14, i1 0) - %15 = add i64 %10, 1 - %16 = inttoptr i64 %15 to i64* - store i64 %"#field##0", i64* %16 - %17 = insertvalue {i64, i1} undef, i64 %10, 0 - %18 = insertvalue {i64, i1} %17, i1 1, 1 - ret {i64, i1} %18 -if.else2: - %19 = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 - %20 = insertvalue {i64, i1} %19, i1 0, 1 - ret {i64, i1} %20 -} - - -define external fastcc {i64, i1} @"multictr.complicated.f17<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = icmp uge i64 %"#rec##0", 4 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = and i64 %"#rec##0", 7 - %2 = icmp eq i64 %1, 7 - br i1 %2, label %if.then1, label %if.else1 -if.else: - %16 = insertvalue {i64, i1} undef, i64 undef, 0 - %17 = insertvalue {i64, i1} %16, i1 0, 1 - ret {i64, i1} %17 -if.then1: - %3 = add i64 %"#rec##0", -7 - %4 = inttoptr i64 %3 to i16* - %5 = load i16, i16* %4 - %6 = icmp eq i16 %5, 16 - br i1 %6, label %if.then2, label %if.else2 -if.else1: - %14 = insertvalue {i64, i1} undef, i64 undef, 0 - %15 = insertvalue {i64, i1} %14, i1 0, 1 - ret {i64, i1} %15 -if.then2: - %7 = add i64 %"#rec##0", 1 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = insertvalue {i64, i1} undef, i64 %9, 0 - %11 = insertvalue {i64, i1} %10, i1 1, 1 - ret {i64, i1} %11 -if.else2: - %12 = insertvalue {i64, i1} undef, i64 undef, 0 - %13 = insertvalue {i64, i1} %12, i1 0, 1 - ret {i64, i1} %13 -} - - -define external fastcc {i64, i1} @"multictr.complicated.f17<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = icmp uge i64 %"#rec##0", 4 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = and i64 %"#rec##0", 7 - %2 = icmp eq i64 %1, 7 - br i1 %2, label %if.then1, label %if.else1 -if.else: - %23 = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 - %24 = insertvalue {i64, i1} %23, i1 0, 1 - ret {i64, i1} %24 -if.then1: - %3 = add i64 %"#rec##0", -7 - %4 = inttoptr i64 %3 to i16* - %5 = load i16, i16* %4 - %6 = icmp eq i16 %5, 16 - br i1 %6, label %if.then2, label %if.else2 -if.else1: - %21 = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 - %22 = insertvalue {i64, i1} %21, i1 0, 1 - ret {i64, i1} %22 -if.then2: - %7 = trunc i64 16 to i32 - %8 = tail call ccc i8* @wybe_malloc(i32 %7) - %9 = ptrtoint i8* %8 to i64 - %10 = add i64 %9, 7 - %11 = sub i64 %"#rec##0", 7 - %12 = inttoptr i64 %9 to i8* - %13 = inttoptr i64 %11 to i8* - %14 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %12, i8* %13, i32 %14, i1 0) - %15 = add i64 %10, 1 - %16 = inttoptr i64 %15 to i64* - store i64 %"#field##0", i64* %16 - %17 = insertvalue {i64, i1} undef, i64 %10, 0 - %18 = insertvalue {i64, i1} %17, i1 1, 1 - ret {i64, i1} %18 -if.else2: - %19 = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 - %20 = insertvalue {i64, i1} %19, i1 0, 1 - ret {i64, i1} %20 -} - - -define external fastcc i64 @"multictr.complicated.spring<0>"() alwaysinline { -entry: - ret i64 1 -} - - -define external fastcc i64 @"multictr.complicated.summer<0>"() alwaysinline { -entry: - ret i64 2 -} - - -define external fastcc i64 @"multictr.complicated.winter<0>"() alwaysinline { -entry: - ret i64 0 -} - - -define external fastcc i1 @"multictr.complicated.~=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = tail call fastcc i1 @"multictr.complicated.=<0>"(i64 %"#left##0", i64 %"#right##0") - %1 = xor i1 %0, 1 - ret i1 %1 +source_filename = "!ROOT!/final-dump/multictr.wybe" +target triple ???? + + +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc i1 @"multictr.complicated.=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#0##0" = icmp uge i64 %"#left##0", 4 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#55##0" = and i64 %"#left##0", 7 + %"tmp#84##0" = icmp eq i64 %"tmp#55##0", 7 + switch i64 %"tmp#55##0", label %case.7.switch.1 [ + i64 0, label %case.0.switch.1 + i64 1, label %case.1.switch.1 + i64 2, label %case.2.switch.1 + i64 3, label %case.3.switch.1 + i64 4, label %case.4.switch.1 + i64 5, label %case.5.switch.1 + i64 6, label %case.6.switch.1 + i64 7, label %case.7.switch.1 ] +case.0.switch.1: + %"tmp#263##0" = inttoptr i64 %"#left##0" to ptr + %"#left#f01##0" = load i64, ptr %"tmp#263##0" + %"tmp#258##0" = icmp uge i64 %"#right##0", 4 + br i1 %"tmp#258##0", label %if.then.2, label %if.else.2 +if.then.2: + %"tmp#259##0" = and i64 %"#right##0", 7 + %"tmp#260##0" = icmp eq i64 %"tmp#259##0", 0 + br i1 %"tmp#260##0", label %if.then.3, label %if.else.3 +if.then.3: + %"tmp#264##0" = inttoptr i64 %"#right##0" to ptr + %"#right#f01##0" = load i64, ptr %"tmp#264##0" + %"tmp#265##0" = icmp eq i64 %"#left#f01##0", %"#right#f01##0" + ret i1 %"tmp#265##0" +if.else.3: + ret i1 0 +if.else.2: + ret i1 0 +case.1.switch.1: + %"tmp#266##0" = add i64 %"#left##0", -1 + %"tmp#267##0" = inttoptr i64 %"tmp#266##0" to ptr + %"#left#f02##0" = load i64, ptr %"tmp#267##0" + %"tmp#252##0" = icmp uge i64 %"#right##0", 4 + br i1 %"tmp#252##0", label %if.then.4, label %if.else.4 +if.then.4: + %"tmp#253##0" = and i64 %"#right##0", 7 + %"tmp#254##0" = icmp eq i64 %"tmp#253##0", 1 + br i1 %"tmp#254##0", label %if.then.5, label %if.else.5 +if.then.5: + %"tmp#268##0" = add i64 %"#right##0", -1 + %"tmp#269##0" = inttoptr i64 %"tmp#268##0" to ptr + %"#right#f02##0" = load i64, ptr %"tmp#269##0" + %"tmp#270##0" = icmp eq i64 %"#left#f02##0", %"#right#f02##0" + ret i1 %"tmp#270##0" +if.else.5: + ret i1 0 +if.else.4: + ret i1 0 +case.2.switch.1: + %"tmp#271##0" = add i64 %"#left##0", -2 + %"tmp#272##0" = inttoptr i64 %"tmp#271##0" to ptr + %"#left#f03##0" = load i64, ptr %"tmp#272##0" + %"tmp#246##0" = icmp uge i64 %"#right##0", 4 + br i1 %"tmp#246##0", label %if.then.6, label %if.else.6 +if.then.6: + %"tmp#247##0" = and i64 %"#right##0", 7 + %"tmp#248##0" = icmp eq i64 %"tmp#247##0", 2 + br i1 %"tmp#248##0", label %if.then.7, label %if.else.7 +if.then.7: + %"tmp#273##0" = add i64 %"#right##0", -2 + %"tmp#274##0" = inttoptr i64 %"tmp#273##0" to ptr + %"#right#f03##0" = load i64, ptr %"tmp#274##0" + %"tmp#275##0" = icmp eq i64 %"#left#f03##0", %"#right#f03##0" + ret i1 %"tmp#275##0" +if.else.7: + ret i1 0 +if.else.6: + ret i1 0 +case.3.switch.1: + %"tmp#276##0" = add i64 %"#left##0", -3 + %"tmp#277##0" = inttoptr i64 %"tmp#276##0" to ptr + %"#left#f04##0" = load i64, ptr %"tmp#277##0" + %"tmp#240##0" = icmp uge i64 %"#right##0", 4 + br i1 %"tmp#240##0", label %if.then.8, label %if.else.8 +if.then.8: + %"tmp#241##0" = and i64 %"#right##0", 7 + %"tmp#242##0" = icmp eq i64 %"tmp#241##0", 3 + br i1 %"tmp#242##0", label %if.then.9, label %if.else.9 +if.then.9: + %"tmp#278##0" = add i64 %"#right##0", -3 + %"tmp#279##0" = inttoptr i64 %"tmp#278##0" to ptr + %"#right#f04##0" = load i64, ptr %"tmp#279##0" + %"tmp#280##0" = icmp eq i64 %"#left#f04##0", %"#right#f04##0" + ret i1 %"tmp#280##0" +if.else.9: + ret i1 0 +if.else.8: + ret i1 0 +case.4.switch.1: + %"tmp#281##0" = add i64 %"#left##0", -4 + %"tmp#282##0" = inttoptr i64 %"tmp#281##0" to ptr + %"#left#f05##0" = load i64, ptr %"tmp#282##0" + %"tmp#234##0" = icmp uge i64 %"#right##0", 4 + br i1 %"tmp#234##0", label %if.then.10, label %if.else.10 +if.then.10: + %"tmp#235##0" = and i64 %"#right##0", 7 + %"tmp#236##0" = icmp eq i64 %"tmp#235##0", 4 + br i1 %"tmp#236##0", label %if.then.11, label %if.else.11 +if.then.11: + %"tmp#283##0" = add i64 %"#right##0", -4 + %"tmp#284##0" = inttoptr i64 %"tmp#283##0" to ptr + %"#right#f05##0" = load i64, ptr %"tmp#284##0" + %"tmp#285##0" = icmp eq i64 %"#left#f05##0", %"#right#f05##0" + ret i1 %"tmp#285##0" +if.else.11: + ret i1 0 +if.else.10: + ret i1 0 +case.5.switch.1: + %"tmp#286##0" = add i64 %"#left##0", -5 + %"tmp#287##0" = inttoptr i64 %"tmp#286##0" to ptr + %"#left#f06##0" = load i64, ptr %"tmp#287##0" + %"tmp#228##0" = icmp uge i64 %"#right##0", 4 + br i1 %"tmp#228##0", label %if.then.12, label %if.else.12 +if.then.12: + %"tmp#229##0" = and i64 %"#right##0", 7 + %"tmp#230##0" = icmp eq i64 %"tmp#229##0", 5 + br i1 %"tmp#230##0", label %if.then.13, label %if.else.13 +if.then.13: + %"tmp#288##0" = add i64 %"#right##0", -5 + %"tmp#289##0" = inttoptr i64 %"tmp#288##0" to ptr + %"#right#f06##0" = load i64, ptr %"tmp#289##0" + %"tmp#290##0" = icmp eq i64 %"#left#f06##0", %"#right#f06##0" + ret i1 %"tmp#290##0" +if.else.13: + ret i1 0 +if.else.12: + ret i1 0 +case.6.switch.1: + %"tmp#291##0" = add i64 %"#left##0", -6 + %"tmp#292##0" = inttoptr i64 %"tmp#291##0" to ptr + %"#left#f07##0" = load i64, ptr %"tmp#292##0" + %"tmp#222##0" = icmp uge i64 %"#right##0", 4 + br i1 %"tmp#222##0", label %if.then.14, label %if.else.14 +if.then.14: + %"tmp#223##0" = and i64 %"#right##0", 7 + %"tmp#224##0" = icmp eq i64 %"tmp#223##0", 6 + br i1 %"tmp#224##0", label %if.then.15, label %if.else.15 +if.then.15: + %"tmp#293##0" = add i64 %"#right##0", -6 + %"tmp#294##0" = inttoptr i64 %"tmp#293##0" to ptr + %"#right#f07##0" = load i64, ptr %"tmp#294##0" + %"tmp#295##0" = icmp eq i64 %"#left#f07##0", %"#right#f07##0" + ret i1 %"tmp#295##0" +if.else.15: + ret i1 0 +if.else.14: + ret i1 0 +case.7.switch.1: + %"tmp#296##0" = add i64 %"#left##0", -7 + %"tmp#297##0" = inttoptr i64 %"tmp#296##0" to ptr + %"tmp#85##0" = load i16, ptr %"tmp#297##0" + %"tmp#86##0" = icmp eq i16 %"tmp#85##0", 7 + br i1 %"tmp#86##0", label %if.then.16, label %if.else.16 +if.then.16: + %"tmp#298##0" = add i64 %"#left##0", 1 + %"tmp#299##0" = inttoptr i64 %"tmp#298##0" to ptr + %"#left#f08##0" = load i64, ptr %"tmp#299##0" + %"tmp#214##0" = icmp uge i64 %"#right##0", 4 + br i1 %"tmp#214##0", label %if.then.17, label %if.else.17 +if.then.17: + %"tmp#215##0" = and i64 %"#right##0", 7 + %"tmp#216##0" = icmp eq i64 %"tmp#215##0", 7 + br i1 %"tmp#216##0", label %if.then.18, label %if.else.18 +if.then.18: + %"tmp#300##0" = add i64 %"#right##0", -7 + %"tmp#301##0" = inttoptr i64 %"tmp#300##0" to ptr + %"tmp#217##0" = load i16, ptr %"tmp#301##0" + %"tmp#218##0" = icmp eq i16 %"tmp#217##0", 7 + br i1 %"tmp#218##0", label %if.then.19, label %if.else.19 +if.then.19: + %"tmp#302##0" = add i64 %"#right##0", 1 + %"tmp#303##0" = inttoptr i64 %"tmp#302##0" to ptr + %"#right#f08##0" = load i64, ptr %"tmp#303##0" + %"tmp#304##0" = icmp eq i64 %"#left#f08##0", %"#right#f08##0" + ret i1 %"tmp#304##0" +if.else.19: + ret i1 0 +if.else.18: + ret i1 0 +if.else.17: + ret i1 0 +if.else.16: + %"tmp#92##0" = icmp eq i16 %"tmp#85##0", 8 + br i1 %"tmp#92##0", label %if.then.20, label %if.else.20 +if.then.20: + %"tmp#305##0" = add i64 %"#left##0", 1 + %"tmp#306##0" = inttoptr i64 %"tmp#305##0" to ptr + %"#left#f09##0" = load i64, ptr %"tmp#306##0" + %"tmp#206##0" = icmp uge i64 %"#right##0", 4 + br i1 %"tmp#206##0", label %if.then.21, label %if.else.21 +if.then.21: + %"tmp#207##0" = and i64 %"#right##0", 7 + %"tmp#208##0" = icmp eq i64 %"tmp#207##0", 7 + br i1 %"tmp#208##0", label %if.then.22, label %if.else.22 +if.then.22: + %"tmp#307##0" = add i64 %"#right##0", -7 + %"tmp#308##0" = inttoptr i64 %"tmp#307##0" to ptr + %"tmp#209##0" = load i16, ptr %"tmp#308##0" + %"tmp#210##0" = icmp eq i16 %"tmp#209##0", 8 + br i1 %"tmp#210##0", label %if.then.23, label %if.else.23 +if.then.23: + %"tmp#309##0" = add i64 %"#right##0", 1 + %"tmp#310##0" = inttoptr i64 %"tmp#309##0" to ptr + %"#right#f09##0" = load i64, ptr %"tmp#310##0" + %"tmp#311##0" = icmp eq i64 %"#left#f09##0", %"#right#f09##0" + ret i1 %"tmp#311##0" +if.else.23: + ret i1 0 +if.else.22: + ret i1 0 +if.else.21: + ret i1 0 +if.else.20: + br i1 %"tmp#84##0", label %if.then.24, label %if.else.24 +if.then.24: + %"tmp#98##0" = icmp eq i16 %"tmp#85##0", 9 + br i1 %"tmp#98##0", label %if.then.25, label %if.else.25 +if.then.25: + %"tmp#312##0" = add i64 %"#left##0", 1 + %"tmp#313##0" = inttoptr i64 %"tmp#312##0" to ptr + %"#left#f10##0" = load i64, ptr %"tmp#313##0" + %"tmp#198##0" = icmp uge i64 %"#right##0", 4 + br i1 %"tmp#198##0", label %if.then.26, label %if.else.26 +if.then.26: + %"tmp#199##0" = and i64 %"#right##0", 7 + %"tmp#200##0" = icmp eq i64 %"tmp#199##0", 7 + br i1 %"tmp#200##0", label %if.then.27, label %if.else.27 +if.then.27: + %"tmp#314##0" = add i64 %"#right##0", -7 + %"tmp#315##0" = inttoptr i64 %"tmp#314##0" to ptr + %"tmp#201##0" = load i16, ptr %"tmp#315##0" + %"tmp#202##0" = icmp eq i16 %"tmp#201##0", 9 + br i1 %"tmp#202##0", label %if.then.28, label %if.else.28 +if.then.28: + %"tmp#316##0" = add i64 %"#right##0", 1 + %"tmp#317##0" = inttoptr i64 %"tmp#316##0" to ptr + %"#right#f10##0" = load i64, ptr %"tmp#317##0" + %"tmp#318##0" = icmp eq i64 %"#left#f10##0", %"#right#f10##0" + ret i1 %"tmp#318##0" +if.else.28: + ret i1 0 +if.else.27: + ret i1 0 +if.else.26: + ret i1 0 +if.else.25: + %"tmp#104##0" = icmp eq i16 %"tmp#85##0", 10 + br i1 %"tmp#104##0", label %if.then.29, label %if.else.29 +if.then.29: + %"tmp#319##0" = add i64 %"#left##0", 1 + %"tmp#320##0" = inttoptr i64 %"tmp#319##0" to ptr + %"#left#f11##0" = load i64, ptr %"tmp#320##0" + %"tmp#190##0" = icmp uge i64 %"#right##0", 4 + br i1 %"tmp#190##0", label %if.then.30, label %if.else.30 +if.then.30: + %"tmp#191##0" = and i64 %"#right##0", 7 + %"tmp#192##0" = icmp eq i64 %"tmp#191##0", 7 + br i1 %"tmp#192##0", label %if.then.31, label %if.else.31 +if.then.31: + %"tmp#321##0" = add i64 %"#right##0", -7 + %"tmp#322##0" = inttoptr i64 %"tmp#321##0" to ptr + %"tmp#193##0" = load i16, ptr %"tmp#322##0" + %"tmp#194##0" = icmp eq i16 %"tmp#193##0", 10 + br i1 %"tmp#194##0", label %if.then.32, label %if.else.32 +if.then.32: + %"tmp#323##0" = add i64 %"#right##0", 1 + %"tmp#324##0" = inttoptr i64 %"tmp#323##0" to ptr + %"#right#f11##0" = load i64, ptr %"tmp#324##0" + %"tmp#325##0" = icmp eq i64 %"#left#f11##0", %"#right#f11##0" + ret i1 %"tmp#325##0" +if.else.32: + ret i1 0 +if.else.31: + ret i1 0 +if.else.30: + ret i1 0 +if.else.29: + %"tmp#110##0" = icmp eq i16 %"tmp#85##0", 11 + br i1 %"tmp#110##0", label %if.then.33, label %if.else.33 +if.then.33: + %"tmp#326##0" = add i64 %"#left##0", 1 + %"tmp#327##0" = inttoptr i64 %"tmp#326##0" to ptr + %"#left#f12##0" = load i64, ptr %"tmp#327##0" + %"tmp#182##0" = icmp uge i64 %"#right##0", 4 + br i1 %"tmp#182##0", label %if.then.34, label %if.else.34 +if.then.34: + %"tmp#183##0" = and i64 %"#right##0", 7 + %"tmp#184##0" = icmp eq i64 %"tmp#183##0", 7 + br i1 %"tmp#184##0", label %if.then.35, label %if.else.35 +if.then.35: + %"tmp#328##0" = add i64 %"#right##0", -7 + %"tmp#329##0" = inttoptr i64 %"tmp#328##0" to ptr + %"tmp#185##0" = load i16, ptr %"tmp#329##0" + %"tmp#186##0" = icmp eq i16 %"tmp#185##0", 11 + br i1 %"tmp#186##0", label %if.then.36, label %if.else.36 +if.then.36: + %"tmp#330##0" = add i64 %"#right##0", 1 + %"tmp#331##0" = inttoptr i64 %"tmp#330##0" to ptr + %"#right#f12##0" = load i64, ptr %"tmp#331##0" + %"tmp#332##0" = icmp eq i64 %"#left#f12##0", %"#right#f12##0" + ret i1 %"tmp#332##0" +if.else.36: + ret i1 0 +if.else.35: + ret i1 0 +if.else.34: + ret i1 0 +if.else.33: + %"tmp#116##0" = icmp eq i16 %"tmp#85##0", 12 + br i1 %"tmp#116##0", label %if.then.37, label %if.else.37 +if.then.37: + %"tmp#333##0" = add i64 %"#left##0", 1 + %"tmp#334##0" = inttoptr i64 %"tmp#333##0" to ptr + %"#left#f13##0" = load i64, ptr %"tmp#334##0" + %"tmp#174##0" = icmp uge i64 %"#right##0", 4 + br i1 %"tmp#174##0", label %if.then.38, label %if.else.38 +if.then.38: + %"tmp#175##0" = and i64 %"#right##0", 7 + %"tmp#176##0" = icmp eq i64 %"tmp#175##0", 7 + br i1 %"tmp#176##0", label %if.then.39, label %if.else.39 +if.then.39: + %"tmp#335##0" = add i64 %"#right##0", -7 + %"tmp#336##0" = inttoptr i64 %"tmp#335##0" to ptr + %"tmp#177##0" = load i16, ptr %"tmp#336##0" + %"tmp#178##0" = icmp eq i16 %"tmp#177##0", 12 + br i1 %"tmp#178##0", label %if.then.40, label %if.else.40 +if.then.40: + %"tmp#337##0" = add i64 %"#right##0", 1 + %"tmp#338##0" = inttoptr i64 %"tmp#337##0" to ptr + %"#right#f13##0" = load i64, ptr %"tmp#338##0" + %"tmp#339##0" = icmp eq i64 %"#left#f13##0", %"#right#f13##0" + ret i1 %"tmp#339##0" +if.else.40: + ret i1 0 +if.else.39: + ret i1 0 +if.else.38: + ret i1 0 +if.else.37: + %"tmp#122##0" = icmp eq i16 %"tmp#85##0", 13 + br i1 %"tmp#122##0", label %if.then.41, label %if.else.41 +if.then.41: + %"tmp#340##0" = add i64 %"#left##0", 1 + %"tmp#341##0" = inttoptr i64 %"tmp#340##0" to ptr + %"#left#f14##0" = load i64, ptr %"tmp#341##0" + %"tmp#166##0" = icmp uge i64 %"#right##0", 4 + br i1 %"tmp#166##0", label %if.then.42, label %if.else.42 +if.then.42: + %"tmp#167##0" = and i64 %"#right##0", 7 + %"tmp#168##0" = icmp eq i64 %"tmp#167##0", 7 + br i1 %"tmp#168##0", label %if.then.43, label %if.else.43 +if.then.43: + %"tmp#342##0" = add i64 %"#right##0", -7 + %"tmp#343##0" = inttoptr i64 %"tmp#342##0" to ptr + %"tmp#169##0" = load i16, ptr %"tmp#343##0" + %"tmp#170##0" = icmp eq i16 %"tmp#169##0", 13 + br i1 %"tmp#170##0", label %if.then.44, label %if.else.44 +if.then.44: + %"tmp#344##0" = add i64 %"#right##0", 1 + %"tmp#345##0" = inttoptr i64 %"tmp#344##0" to ptr + %"#right#f14##0" = load i64, ptr %"tmp#345##0" + %"tmp#346##0" = icmp eq i64 %"#left#f14##0", %"#right#f14##0" + ret i1 %"tmp#346##0" +if.else.44: + ret i1 0 +if.else.43: + ret i1 0 +if.else.42: + ret i1 0 +if.else.41: + %"tmp#128##0" = icmp eq i16 %"tmp#85##0", 14 + br i1 %"tmp#128##0", label %if.then.45, label %if.else.45 +if.then.45: + %"tmp#347##0" = add i64 %"#left##0", 1 + %"tmp#348##0" = inttoptr i64 %"tmp#347##0" to ptr + %"#left#f15##0" = load i64, ptr %"tmp#348##0" + %"tmp#158##0" = icmp uge i64 %"#right##0", 4 + br i1 %"tmp#158##0", label %if.then.46, label %if.else.46 +if.then.46: + %"tmp#159##0" = and i64 %"#right##0", 7 + %"tmp#160##0" = icmp eq i64 %"tmp#159##0", 7 + br i1 %"tmp#160##0", label %if.then.47, label %if.else.47 +if.then.47: + %"tmp#349##0" = add i64 %"#right##0", -7 + %"tmp#350##0" = inttoptr i64 %"tmp#349##0" to ptr + %"tmp#161##0" = load i16, ptr %"tmp#350##0" + %"tmp#162##0" = icmp eq i16 %"tmp#161##0", 14 + br i1 %"tmp#162##0", label %if.then.48, label %if.else.48 +if.then.48: + %"tmp#351##0" = add i64 %"#right##0", 1 + %"tmp#352##0" = inttoptr i64 %"tmp#351##0" to ptr + %"#right#f15##0" = load i64, ptr %"tmp#352##0" + %"tmp#353##0" = icmp eq i64 %"#left#f15##0", %"#right#f15##0" + ret i1 %"tmp#353##0" +if.else.48: + ret i1 0 +if.else.47: + ret i1 0 +if.else.46: + ret i1 0 +if.else.45: + %"tmp#134##0" = icmp eq i16 %"tmp#85##0", 15 + br i1 %"tmp#134##0", label %if.then.49, label %if.else.49 +if.then.49: + %"tmp#354##0" = add i64 %"#left##0", 1 + %"tmp#355##0" = inttoptr i64 %"tmp#354##0" to ptr + %"#left#f16##0" = load i64, ptr %"tmp#355##0" + %"tmp#150##0" = icmp uge i64 %"#right##0", 4 + br i1 %"tmp#150##0", label %if.then.50, label %if.else.50 +if.then.50: + %"tmp#151##0" = and i64 %"#right##0", 7 + %"tmp#152##0" = icmp eq i64 %"tmp#151##0", 7 + br i1 %"tmp#152##0", label %if.then.51, label %if.else.51 +if.then.51: + %"tmp#356##0" = add i64 %"#right##0", -7 + %"tmp#357##0" = inttoptr i64 %"tmp#356##0" to ptr + %"tmp#153##0" = load i16, ptr %"tmp#357##0" + %"tmp#154##0" = icmp eq i16 %"tmp#153##0", 15 + br i1 %"tmp#154##0", label %if.then.52, label %if.else.52 +if.then.52: + %"tmp#358##0" = add i64 %"#right##0", 1 + %"tmp#359##0" = inttoptr i64 %"tmp#358##0" to ptr + %"#right#f16##0" = load i64, ptr %"tmp#359##0" + %"tmp#360##0" = icmp eq i64 %"#left#f16##0", %"#right#f16##0" + ret i1 %"tmp#360##0" +if.else.52: + ret i1 0 +if.else.51: + ret i1 0 +if.else.50: + ret i1 0 +if.else.49: + %"tmp#140##0" = icmp eq i16 %"tmp#85##0", 16 + br i1 %"tmp#140##0", label %if.then.53, label %if.else.53 +if.then.53: + %"tmp#361##0" = add i64 %"#left##0", 1 + %"tmp#362##0" = inttoptr i64 %"tmp#361##0" to ptr + %"#left#f17##0" = load i64, ptr %"tmp#362##0" + %"tmp#142##0" = icmp uge i64 %"#right##0", 4 + br i1 %"tmp#142##0", label %if.then.54, label %if.else.54 +if.then.54: + %"tmp#143##0" = and i64 %"#right##0", 7 + %"tmp#144##0" = icmp eq i64 %"tmp#143##0", 7 + br i1 %"tmp#144##0", label %if.then.55, label %if.else.55 +if.then.55: + %"tmp#363##0" = add i64 %"#right##0", -7 + %"tmp#364##0" = inttoptr i64 %"tmp#363##0" to ptr + %"tmp#145##0" = load i16, ptr %"tmp#364##0" + %"tmp#146##0" = icmp eq i16 %"tmp#145##0", 16 + br i1 %"tmp#146##0", label %if.then.56, label %if.else.56 +if.then.56: + %"tmp#365##0" = add i64 %"#right##0", 1 + %"tmp#366##0" = inttoptr i64 %"tmp#365##0" to ptr + %"#right#f17##0" = load i64, ptr %"tmp#366##0" + %"tmp#367##0" = icmp eq i64 %"#left#f17##0", %"#right#f17##0" + ret i1 %"tmp#367##0" +if.else.56: + ret i1 0 +if.else.55: + ret i1 0 +if.else.54: + ret i1 0 +if.else.53: + ret i1 0 +if.else.24: + ret i1 0 +if.else.0: + %"tmp#368##0" = icmp eq i64 %"#left##0", %"#right##0" + ret i1 %"tmp#368##0" +} + +define external fastcc i64 @"multictr.complicated.autumn<0>"() { + ret i64 3 +} + +define external fastcc i64 @"multictr.complicated.c01<0>"(i64 %"f01##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 8) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"f01##0", ptr %"tmp#1##0" + ret i64 %"#rec##0" +} + +define external fastcc {i64, i1} @"multictr.complicated.c01<1>"(i64 %"#result##0") { + %"tmp#0##0" = icmp uge i64 %"#result##0", 4 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = and i64 %"#result##0", 7 + %"tmp#1##0" = icmp eq i64 %"tmp#2##0", 0 + br i1 %"tmp#1##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#3##0" = inttoptr i64 %"#result##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#3##0" + %"tmp#5##0" = insertvalue {i64, i1} undef, i64 %"tmp#4##0", 0 + %"tmp#6##0" = insertvalue {i64, i1} %"tmp#5##0", i1 1, 1 + ret {i64, i1} %"tmp#6##0" +if.else.1: + %"tmp#7##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#8##0" = insertvalue {i64, i1} %"tmp#7##0", i1 0, 1 + ret {i64, i1} %"tmp#8##0" +if.else.0: + %"tmp#9##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#10##0" = insertvalue {i64, i1} %"tmp#9##0", i1 0, 1 + ret {i64, i1} %"tmp#10##0" +} + +define external fastcc i64 @"multictr.complicated.c02<0>"(i64 %"f02##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 8) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"f02##0", ptr %"tmp#1##0" + %"tmp#2##0" = or i64 %"#rec##0", 1 + ret i64 %"tmp#2##0" +} + +define external fastcc {i64, i1} @"multictr.complicated.c02<1>"(i64 %"#result##0") { + %"tmp#0##0" = icmp uge i64 %"#result##0", 4 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = and i64 %"#result##0", 7 + %"tmp#1##0" = icmp eq i64 %"tmp#2##0", 1 + br i1 %"tmp#1##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#3##0" = add i64 %"#result##0", -1 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#4##0" + %"tmp#6##0" = insertvalue {i64, i1} undef, i64 %"tmp#5##0", 0 + %"tmp#7##0" = insertvalue {i64, i1} %"tmp#6##0", i1 1, 1 + ret {i64, i1} %"tmp#7##0" +if.else.1: + %"tmp#8##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#9##0" = insertvalue {i64, i1} %"tmp#8##0", i1 0, 1 + ret {i64, i1} %"tmp#9##0" +if.else.0: + %"tmp#10##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#11##0" = insertvalue {i64, i1} %"tmp#10##0", i1 0, 1 + ret {i64, i1} %"tmp#11##0" +} + +define external fastcc i64 @"multictr.complicated.c03<0>"(i64 %"f03##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 8) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"f03##0", ptr %"tmp#1##0" + %"tmp#2##0" = or i64 %"#rec##0", 2 + ret i64 %"tmp#2##0" +} + +define external fastcc {i64, i1} @"multictr.complicated.c03<1>"(i64 %"#result##0") { + %"tmp#0##0" = icmp uge i64 %"#result##0", 4 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = and i64 %"#result##0", 7 + %"tmp#1##0" = icmp eq i64 %"tmp#2##0", 2 + br i1 %"tmp#1##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#3##0" = add i64 %"#result##0", -2 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#4##0" + %"tmp#6##0" = insertvalue {i64, i1} undef, i64 %"tmp#5##0", 0 + %"tmp#7##0" = insertvalue {i64, i1} %"tmp#6##0", i1 1, 1 + ret {i64, i1} %"tmp#7##0" +if.else.1: + %"tmp#8##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#9##0" = insertvalue {i64, i1} %"tmp#8##0", i1 0, 1 + ret {i64, i1} %"tmp#9##0" +if.else.0: + %"tmp#10##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#11##0" = insertvalue {i64, i1} %"tmp#10##0", i1 0, 1 + ret {i64, i1} %"tmp#11##0" +} + +define external fastcc i64 @"multictr.complicated.c04<0>"(i64 %"f04##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 8) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"f04##0", ptr %"tmp#1##0" + %"tmp#2##0" = or i64 %"#rec##0", 3 + ret i64 %"tmp#2##0" +} + +define external fastcc {i64, i1} @"multictr.complicated.c04<1>"(i64 %"#result##0") { + %"tmp#0##0" = icmp uge i64 %"#result##0", 4 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = and i64 %"#result##0", 7 + %"tmp#1##0" = icmp eq i64 %"tmp#2##0", 3 + br i1 %"tmp#1##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#3##0" = add i64 %"#result##0", -3 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#4##0" + %"tmp#6##0" = insertvalue {i64, i1} undef, i64 %"tmp#5##0", 0 + %"tmp#7##0" = insertvalue {i64, i1} %"tmp#6##0", i1 1, 1 + ret {i64, i1} %"tmp#7##0" +if.else.1: + %"tmp#8##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#9##0" = insertvalue {i64, i1} %"tmp#8##0", i1 0, 1 + ret {i64, i1} %"tmp#9##0" +if.else.0: + %"tmp#10##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#11##0" = insertvalue {i64, i1} %"tmp#10##0", i1 0, 1 + ret {i64, i1} %"tmp#11##0" +} + +define external fastcc i64 @"multictr.complicated.c05<0>"(i64 %"f05##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 8) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"f05##0", ptr %"tmp#1##0" + %"tmp#2##0" = or i64 %"#rec##0", 4 + ret i64 %"tmp#2##0" +} + +define external fastcc {i64, i1} @"multictr.complicated.c05<1>"(i64 %"#result##0") { + %"tmp#0##0" = icmp uge i64 %"#result##0", 4 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = and i64 %"#result##0", 7 + %"tmp#1##0" = icmp eq i64 %"tmp#2##0", 4 + br i1 %"tmp#1##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#3##0" = add i64 %"#result##0", -4 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#4##0" + %"tmp#6##0" = insertvalue {i64, i1} undef, i64 %"tmp#5##0", 0 + %"tmp#7##0" = insertvalue {i64, i1} %"tmp#6##0", i1 1, 1 + ret {i64, i1} %"tmp#7##0" +if.else.1: + %"tmp#8##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#9##0" = insertvalue {i64, i1} %"tmp#8##0", i1 0, 1 + ret {i64, i1} %"tmp#9##0" +if.else.0: + %"tmp#10##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#11##0" = insertvalue {i64, i1} %"tmp#10##0", i1 0, 1 + ret {i64, i1} %"tmp#11##0" +} + +define external fastcc i64 @"multictr.complicated.c06<0>"(i64 %"f06##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 8) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"f06##0", ptr %"tmp#1##0" + %"tmp#2##0" = or i64 %"#rec##0", 5 + ret i64 %"tmp#2##0" +} + +define external fastcc {i64, i1} @"multictr.complicated.c06<1>"(i64 %"#result##0") { + %"tmp#0##0" = icmp uge i64 %"#result##0", 4 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = and i64 %"#result##0", 7 + %"tmp#1##0" = icmp eq i64 %"tmp#2##0", 5 + br i1 %"tmp#1##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#3##0" = add i64 %"#result##0", -5 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#4##0" + %"tmp#6##0" = insertvalue {i64, i1} undef, i64 %"tmp#5##0", 0 + %"tmp#7##0" = insertvalue {i64, i1} %"tmp#6##0", i1 1, 1 + ret {i64, i1} %"tmp#7##0" +if.else.1: + %"tmp#8##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#9##0" = insertvalue {i64, i1} %"tmp#8##0", i1 0, 1 + ret {i64, i1} %"tmp#9##0" +if.else.0: + %"tmp#10##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#11##0" = insertvalue {i64, i1} %"tmp#10##0", i1 0, 1 + ret {i64, i1} %"tmp#11##0" +} + +define external fastcc i64 @"multictr.complicated.c07<0>"(i64 %"f07##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 8) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"f07##0", ptr %"tmp#1##0" + %"tmp#2##0" = or i64 %"#rec##0", 6 + ret i64 %"tmp#2##0" +} + +define external fastcc {i64, i1} @"multictr.complicated.c07<1>"(i64 %"#result##0") { + %"tmp#0##0" = icmp uge i64 %"#result##0", 4 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = and i64 %"#result##0", 7 + %"tmp#1##0" = icmp eq i64 %"tmp#2##0", 6 + br i1 %"tmp#1##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#3##0" = add i64 %"#result##0", -6 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#4##0" + %"tmp#6##0" = insertvalue {i64, i1} undef, i64 %"tmp#5##0", 0 + %"tmp#7##0" = insertvalue {i64, i1} %"tmp#6##0", i1 1, 1 + ret {i64, i1} %"tmp#7##0" +if.else.1: + %"tmp#8##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#9##0" = insertvalue {i64, i1} %"tmp#8##0", i1 0, 1 + ret {i64, i1} %"tmp#9##0" +if.else.0: + %"tmp#10##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#11##0" = insertvalue {i64, i1} %"tmp#10##0", i1 0, 1 + ret {i64, i1} %"tmp#11##0" +} + +define external fastcc i64 @"multictr.complicated.c08<0>"(i64 %"f08##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 16) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 7, ptr %"tmp#1##0" + %"tmp#2##0" = add i64 %"#rec##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"f08##0", ptr %"tmp#3##0" + %"tmp#4##0" = or i64 %"#rec##0", 7 + ret i64 %"tmp#4##0" +} + +define external fastcc {i64, i1} @"multictr.complicated.c08<1>"(i64 %"#result##0") { + %"tmp#0##0" = icmp uge i64 %"#result##0", 4 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = and i64 %"#result##0", 7 + %"tmp#1##0" = icmp eq i64 %"tmp#2##0", 7 + br i1 %"tmp#1##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#4##0" = add i64 %"#result##0", -7 + %"tmp#5##0" = inttoptr i64 %"tmp#4##0" to ptr + %"#tag##0" = load i16, ptr %"tmp#5##0" + %"tmp#3##0" = icmp eq i16 %"#tag##0", 7 + br i1 %"tmp#3##0", label %if.then.2, label %if.else.2 +if.then.2: + %"tmp#6##0" = add i64 %"#result##0", 1 + %"tmp#7##0" = inttoptr i64 %"tmp#6##0" to ptr + %"tmp#8##0" = load i64, ptr %"tmp#7##0" + %"tmp#9##0" = insertvalue {i64, i1} undef, i64 %"tmp#8##0", 0 + %"tmp#10##0" = insertvalue {i64, i1} %"tmp#9##0", i1 1, 1 + ret {i64, i1} %"tmp#10##0" +if.else.2: + %"tmp#11##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#12##0" = insertvalue {i64, i1} %"tmp#11##0", i1 0, 1 + ret {i64, i1} %"tmp#12##0" +if.else.1: + %"tmp#13##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#14##0" = insertvalue {i64, i1} %"tmp#13##0", i1 0, 1 + ret {i64, i1} %"tmp#14##0" +if.else.0: + %"tmp#15##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#16##0" = insertvalue {i64, i1} %"tmp#15##0", i1 0, 1 + ret {i64, i1} %"tmp#16##0" +} + +define external fastcc i64 @"multictr.complicated.c09<0>"(i64 %"f09##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 16) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 8, ptr %"tmp#1##0" + %"tmp#2##0" = add i64 %"#rec##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"f09##0", ptr %"tmp#3##0" + %"tmp#4##0" = or i64 %"#rec##0", 7 + ret i64 %"tmp#4##0" +} + +define external fastcc {i64, i1} @"multictr.complicated.c09<1>"(i64 %"#result##0") { + %"tmp#0##0" = icmp uge i64 %"#result##0", 4 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = and i64 %"#result##0", 7 + %"tmp#1##0" = icmp eq i64 %"tmp#2##0", 7 + br i1 %"tmp#1##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#4##0" = add i64 %"#result##0", -7 + %"tmp#5##0" = inttoptr i64 %"tmp#4##0" to ptr + %"#tag##0" = load i16, ptr %"tmp#5##0" + %"tmp#3##0" = icmp eq i16 %"#tag##0", 8 + br i1 %"tmp#3##0", label %if.then.2, label %if.else.2 +if.then.2: + %"tmp#6##0" = add i64 %"#result##0", 1 + %"tmp#7##0" = inttoptr i64 %"tmp#6##0" to ptr + %"tmp#8##0" = load i64, ptr %"tmp#7##0" + %"tmp#9##0" = insertvalue {i64, i1} undef, i64 %"tmp#8##0", 0 + %"tmp#10##0" = insertvalue {i64, i1} %"tmp#9##0", i1 1, 1 + ret {i64, i1} %"tmp#10##0" +if.else.2: + %"tmp#11##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#12##0" = insertvalue {i64, i1} %"tmp#11##0", i1 0, 1 + ret {i64, i1} %"tmp#12##0" +if.else.1: + %"tmp#13##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#14##0" = insertvalue {i64, i1} %"tmp#13##0", i1 0, 1 + ret {i64, i1} %"tmp#14##0" +if.else.0: + %"tmp#15##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#16##0" = insertvalue {i64, i1} %"tmp#15##0", i1 0, 1 + ret {i64, i1} %"tmp#16##0" +} + +define external fastcc i64 @"multictr.complicated.c10<0>"(i64 %"f10##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 16) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 9, ptr %"tmp#1##0" + %"tmp#2##0" = add i64 %"#rec##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"f10##0", ptr %"tmp#3##0" + %"tmp#4##0" = or i64 %"#rec##0", 7 + ret i64 %"tmp#4##0" +} + +define external fastcc {i64, i1} @"multictr.complicated.c10<1>"(i64 %"#result##0") { + %"tmp#0##0" = icmp uge i64 %"#result##0", 4 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = and i64 %"#result##0", 7 + %"tmp#1##0" = icmp eq i64 %"tmp#2##0", 7 + br i1 %"tmp#1##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#4##0" = add i64 %"#result##0", -7 + %"tmp#5##0" = inttoptr i64 %"tmp#4##0" to ptr + %"#tag##0" = load i16, ptr %"tmp#5##0" + %"tmp#3##0" = icmp eq i16 %"#tag##0", 9 + br i1 %"tmp#3##0", label %if.then.2, label %if.else.2 +if.then.2: + %"tmp#6##0" = add i64 %"#result##0", 1 + %"tmp#7##0" = inttoptr i64 %"tmp#6##0" to ptr + %"tmp#8##0" = load i64, ptr %"tmp#7##0" + %"tmp#9##0" = insertvalue {i64, i1} undef, i64 %"tmp#8##0", 0 + %"tmp#10##0" = insertvalue {i64, i1} %"tmp#9##0", i1 1, 1 + ret {i64, i1} %"tmp#10##0" +if.else.2: + %"tmp#11##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#12##0" = insertvalue {i64, i1} %"tmp#11##0", i1 0, 1 + ret {i64, i1} %"tmp#12##0" +if.else.1: + %"tmp#13##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#14##0" = insertvalue {i64, i1} %"tmp#13##0", i1 0, 1 + ret {i64, i1} %"tmp#14##0" +if.else.0: + %"tmp#15##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#16##0" = insertvalue {i64, i1} %"tmp#15##0", i1 0, 1 + ret {i64, i1} %"tmp#16##0" +} + +define external fastcc i64 @"multictr.complicated.c11<0>"(i64 %"f11##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 16) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 10, ptr %"tmp#1##0" + %"tmp#2##0" = add i64 %"#rec##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"f11##0", ptr %"tmp#3##0" + %"tmp#4##0" = or i64 %"#rec##0", 7 + ret i64 %"tmp#4##0" +} + +define external fastcc {i64, i1} @"multictr.complicated.c11<1>"(i64 %"#result##0") { + %"tmp#0##0" = icmp uge i64 %"#result##0", 4 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = and i64 %"#result##0", 7 + %"tmp#1##0" = icmp eq i64 %"tmp#2##0", 7 + br i1 %"tmp#1##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#4##0" = add i64 %"#result##0", -7 + %"tmp#5##0" = inttoptr i64 %"tmp#4##0" to ptr + %"#tag##0" = load i16, ptr %"tmp#5##0" + %"tmp#3##0" = icmp eq i16 %"#tag##0", 10 + br i1 %"tmp#3##0", label %if.then.2, label %if.else.2 +if.then.2: + %"tmp#6##0" = add i64 %"#result##0", 1 + %"tmp#7##0" = inttoptr i64 %"tmp#6##0" to ptr + %"tmp#8##0" = load i64, ptr %"tmp#7##0" + %"tmp#9##0" = insertvalue {i64, i1} undef, i64 %"tmp#8##0", 0 + %"tmp#10##0" = insertvalue {i64, i1} %"tmp#9##0", i1 1, 1 + ret {i64, i1} %"tmp#10##0" +if.else.2: + %"tmp#11##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#12##0" = insertvalue {i64, i1} %"tmp#11##0", i1 0, 1 + ret {i64, i1} %"tmp#12##0" +if.else.1: + %"tmp#13##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#14##0" = insertvalue {i64, i1} %"tmp#13##0", i1 0, 1 + ret {i64, i1} %"tmp#14##0" +if.else.0: + %"tmp#15##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#16##0" = insertvalue {i64, i1} %"tmp#15##0", i1 0, 1 + ret {i64, i1} %"tmp#16##0" +} + +define external fastcc i64 @"multictr.complicated.c12<0>"(i64 %"f12##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 16) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 11, ptr %"tmp#1##0" + %"tmp#2##0" = add i64 %"#rec##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"f12##0", ptr %"tmp#3##0" + %"tmp#4##0" = or i64 %"#rec##0", 7 + ret i64 %"tmp#4##0" +} + +define external fastcc {i64, i1} @"multictr.complicated.c12<1>"(i64 %"#result##0") { + %"tmp#0##0" = icmp uge i64 %"#result##0", 4 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = and i64 %"#result##0", 7 + %"tmp#1##0" = icmp eq i64 %"tmp#2##0", 7 + br i1 %"tmp#1##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#4##0" = add i64 %"#result##0", -7 + %"tmp#5##0" = inttoptr i64 %"tmp#4##0" to ptr + %"#tag##0" = load i16, ptr %"tmp#5##0" + %"tmp#3##0" = icmp eq i16 %"#tag##0", 11 + br i1 %"tmp#3##0", label %if.then.2, label %if.else.2 +if.then.2: + %"tmp#6##0" = add i64 %"#result##0", 1 + %"tmp#7##0" = inttoptr i64 %"tmp#6##0" to ptr + %"tmp#8##0" = load i64, ptr %"tmp#7##0" + %"tmp#9##0" = insertvalue {i64, i1} undef, i64 %"tmp#8##0", 0 + %"tmp#10##0" = insertvalue {i64, i1} %"tmp#9##0", i1 1, 1 + ret {i64, i1} %"tmp#10##0" +if.else.2: + %"tmp#11##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#12##0" = insertvalue {i64, i1} %"tmp#11##0", i1 0, 1 + ret {i64, i1} %"tmp#12##0" +if.else.1: + %"tmp#13##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#14##0" = insertvalue {i64, i1} %"tmp#13##0", i1 0, 1 + ret {i64, i1} %"tmp#14##0" +if.else.0: + %"tmp#15##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#16##0" = insertvalue {i64, i1} %"tmp#15##0", i1 0, 1 + ret {i64, i1} %"tmp#16##0" +} + +define external fastcc i64 @"multictr.complicated.c13<0>"(i64 %"f13##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 16) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 12, ptr %"tmp#1##0" + %"tmp#2##0" = add i64 %"#rec##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"f13##0", ptr %"tmp#3##0" + %"tmp#4##0" = or i64 %"#rec##0", 7 + ret i64 %"tmp#4##0" +} + +define external fastcc {i64, i1} @"multictr.complicated.c13<1>"(i64 %"#result##0") { + %"tmp#0##0" = icmp uge i64 %"#result##0", 4 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = and i64 %"#result##0", 7 + %"tmp#1##0" = icmp eq i64 %"tmp#2##0", 7 + br i1 %"tmp#1##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#4##0" = add i64 %"#result##0", -7 + %"tmp#5##0" = inttoptr i64 %"tmp#4##0" to ptr + %"#tag##0" = load i16, ptr %"tmp#5##0" + %"tmp#3##0" = icmp eq i16 %"#tag##0", 12 + br i1 %"tmp#3##0", label %if.then.2, label %if.else.2 +if.then.2: + %"tmp#6##0" = add i64 %"#result##0", 1 + %"tmp#7##0" = inttoptr i64 %"tmp#6##0" to ptr + %"tmp#8##0" = load i64, ptr %"tmp#7##0" + %"tmp#9##0" = insertvalue {i64, i1} undef, i64 %"tmp#8##0", 0 + %"tmp#10##0" = insertvalue {i64, i1} %"tmp#9##0", i1 1, 1 + ret {i64, i1} %"tmp#10##0" +if.else.2: + %"tmp#11##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#12##0" = insertvalue {i64, i1} %"tmp#11##0", i1 0, 1 + ret {i64, i1} %"tmp#12##0" +if.else.1: + %"tmp#13##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#14##0" = insertvalue {i64, i1} %"tmp#13##0", i1 0, 1 + ret {i64, i1} %"tmp#14##0" +if.else.0: + %"tmp#15##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#16##0" = insertvalue {i64, i1} %"tmp#15##0", i1 0, 1 + ret {i64, i1} %"tmp#16##0" +} + +define external fastcc i64 @"multictr.complicated.c14<0>"(i64 %"f14##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 16) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 13, ptr %"tmp#1##0" + %"tmp#2##0" = add i64 %"#rec##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"f14##0", ptr %"tmp#3##0" + %"tmp#4##0" = or i64 %"#rec##0", 7 + ret i64 %"tmp#4##0" +} + +define external fastcc {i64, i1} @"multictr.complicated.c14<1>"(i64 %"#result##0") { + %"tmp#0##0" = icmp uge i64 %"#result##0", 4 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = and i64 %"#result##0", 7 + %"tmp#1##0" = icmp eq i64 %"tmp#2##0", 7 + br i1 %"tmp#1##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#4##0" = add i64 %"#result##0", -7 + %"tmp#5##0" = inttoptr i64 %"tmp#4##0" to ptr + %"#tag##0" = load i16, ptr %"tmp#5##0" + %"tmp#3##0" = icmp eq i16 %"#tag##0", 13 + br i1 %"tmp#3##0", label %if.then.2, label %if.else.2 +if.then.2: + %"tmp#6##0" = add i64 %"#result##0", 1 + %"tmp#7##0" = inttoptr i64 %"tmp#6##0" to ptr + %"tmp#8##0" = load i64, ptr %"tmp#7##0" + %"tmp#9##0" = insertvalue {i64, i1} undef, i64 %"tmp#8##0", 0 + %"tmp#10##0" = insertvalue {i64, i1} %"tmp#9##0", i1 1, 1 + ret {i64, i1} %"tmp#10##0" +if.else.2: + %"tmp#11##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#12##0" = insertvalue {i64, i1} %"tmp#11##0", i1 0, 1 + ret {i64, i1} %"tmp#12##0" +if.else.1: + %"tmp#13##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#14##0" = insertvalue {i64, i1} %"tmp#13##0", i1 0, 1 + ret {i64, i1} %"tmp#14##0" +if.else.0: + %"tmp#15##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#16##0" = insertvalue {i64, i1} %"tmp#15##0", i1 0, 1 + ret {i64, i1} %"tmp#16##0" +} + +define external fastcc i64 @"multictr.complicated.c15<0>"(i64 %"f15##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 16) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 14, ptr %"tmp#1##0" + %"tmp#2##0" = add i64 %"#rec##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"f15##0", ptr %"tmp#3##0" + %"tmp#4##0" = or i64 %"#rec##0", 7 + ret i64 %"tmp#4##0" +} + +define external fastcc {i64, i1} @"multictr.complicated.c15<1>"(i64 %"#result##0") { + %"tmp#0##0" = icmp uge i64 %"#result##0", 4 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = and i64 %"#result##0", 7 + %"tmp#1##0" = icmp eq i64 %"tmp#2##0", 7 + br i1 %"tmp#1##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#4##0" = add i64 %"#result##0", -7 + %"tmp#5##0" = inttoptr i64 %"tmp#4##0" to ptr + %"#tag##0" = load i16, ptr %"tmp#5##0" + %"tmp#3##0" = icmp eq i16 %"#tag##0", 14 + br i1 %"tmp#3##0", label %if.then.2, label %if.else.2 +if.then.2: + %"tmp#6##0" = add i64 %"#result##0", 1 + %"tmp#7##0" = inttoptr i64 %"tmp#6##0" to ptr + %"tmp#8##0" = load i64, ptr %"tmp#7##0" + %"tmp#9##0" = insertvalue {i64, i1} undef, i64 %"tmp#8##0", 0 + %"tmp#10##0" = insertvalue {i64, i1} %"tmp#9##0", i1 1, 1 + ret {i64, i1} %"tmp#10##0" +if.else.2: + %"tmp#11##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#12##0" = insertvalue {i64, i1} %"tmp#11##0", i1 0, 1 + ret {i64, i1} %"tmp#12##0" +if.else.1: + %"tmp#13##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#14##0" = insertvalue {i64, i1} %"tmp#13##0", i1 0, 1 + ret {i64, i1} %"tmp#14##0" +if.else.0: + %"tmp#15##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#16##0" = insertvalue {i64, i1} %"tmp#15##0", i1 0, 1 + ret {i64, i1} %"tmp#16##0" +} + +define external fastcc i64 @"multictr.complicated.c16<0>"(i64 %"f16##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 16) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 15, ptr %"tmp#1##0" + %"tmp#2##0" = add i64 %"#rec##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"f16##0", ptr %"tmp#3##0" + %"tmp#4##0" = or i64 %"#rec##0", 7 + ret i64 %"tmp#4##0" +} + +define external fastcc {i64, i1} @"multictr.complicated.c16<1>"(i64 %"#result##0") { + %"tmp#0##0" = icmp uge i64 %"#result##0", 4 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = and i64 %"#result##0", 7 + %"tmp#1##0" = icmp eq i64 %"tmp#2##0", 7 + br i1 %"tmp#1##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#4##0" = add i64 %"#result##0", -7 + %"tmp#5##0" = inttoptr i64 %"tmp#4##0" to ptr + %"#tag##0" = load i16, ptr %"tmp#5##0" + %"tmp#3##0" = icmp eq i16 %"#tag##0", 15 + br i1 %"tmp#3##0", label %if.then.2, label %if.else.2 +if.then.2: + %"tmp#6##0" = add i64 %"#result##0", 1 + %"tmp#7##0" = inttoptr i64 %"tmp#6##0" to ptr + %"tmp#8##0" = load i64, ptr %"tmp#7##0" + %"tmp#9##0" = insertvalue {i64, i1} undef, i64 %"tmp#8##0", 0 + %"tmp#10##0" = insertvalue {i64, i1} %"tmp#9##0", i1 1, 1 + ret {i64, i1} %"tmp#10##0" +if.else.2: + %"tmp#11##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#12##0" = insertvalue {i64, i1} %"tmp#11##0", i1 0, 1 + ret {i64, i1} %"tmp#12##0" +if.else.1: + %"tmp#13##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#14##0" = insertvalue {i64, i1} %"tmp#13##0", i1 0, 1 + ret {i64, i1} %"tmp#14##0" +if.else.0: + %"tmp#15##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#16##0" = insertvalue {i64, i1} %"tmp#15##0", i1 0, 1 + ret {i64, i1} %"tmp#16##0" +} + +define external fastcc i64 @"multictr.complicated.c17<0>"(i64 %"f17##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 16) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 16, ptr %"tmp#1##0" + %"tmp#2##0" = add i64 %"#rec##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"f17##0", ptr %"tmp#3##0" + %"tmp#4##0" = or i64 %"#rec##0", 7 + ret i64 %"tmp#4##0" +} + +define external fastcc {i64, i1} @"multictr.complicated.c17<1>"(i64 %"#result##0") { + %"tmp#0##0" = icmp uge i64 %"#result##0", 4 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = and i64 %"#result##0", 7 + %"tmp#1##0" = icmp eq i64 %"tmp#2##0", 7 + br i1 %"tmp#1##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#4##0" = add i64 %"#result##0", -7 + %"tmp#5##0" = inttoptr i64 %"tmp#4##0" to ptr + %"#tag##0" = load i16, ptr %"tmp#5##0" + %"tmp#3##0" = icmp eq i16 %"#tag##0", 16 + br i1 %"tmp#3##0", label %if.then.2, label %if.else.2 +if.then.2: + %"tmp#6##0" = add i64 %"#result##0", 1 + %"tmp#7##0" = inttoptr i64 %"tmp#6##0" to ptr + %"tmp#8##0" = load i64, ptr %"tmp#7##0" + %"tmp#9##0" = insertvalue {i64, i1} undef, i64 %"tmp#8##0", 0 + %"tmp#10##0" = insertvalue {i64, i1} %"tmp#9##0", i1 1, 1 + ret {i64, i1} %"tmp#10##0" +if.else.2: + %"tmp#11##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#12##0" = insertvalue {i64, i1} %"tmp#11##0", i1 0, 1 + ret {i64, i1} %"tmp#12##0" +if.else.1: + %"tmp#13##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#14##0" = insertvalue {i64, i1} %"tmp#13##0", i1 0, 1 + ret {i64, i1} %"tmp#14##0" +if.else.0: + %"tmp#15##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#16##0" = insertvalue {i64, i1} %"tmp#15##0", i1 0, 1 + ret {i64, i1} %"tmp#16##0" +} + +define external fastcc {i64, i1} @"multictr.complicated.f01<0>"(i64 %"#rec##0") { + %"tmp#0##0" = icmp uge i64 %"#rec##0", 4 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = and i64 %"#rec##0", 7 + %"tmp#1##0" = icmp eq i64 %"tmp#2##0", 0 + br i1 %"tmp#1##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#3##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#3##0" + %"tmp#5##0" = insertvalue {i64, i1} undef, i64 %"tmp#4##0", 0 + %"tmp#6##0" = insertvalue {i64, i1} %"tmp#5##0", i1 1, 1 + ret {i64, i1} %"tmp#6##0" +if.else.1: + %"tmp#7##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#8##0" = insertvalue {i64, i1} %"tmp#7##0", i1 0, 1 + ret {i64, i1} %"tmp#8##0" +if.else.0: + %"tmp#9##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#10##0" = insertvalue {i64, i1} %"tmp#9##0", i1 0, 1 + ret {i64, i1} %"tmp#10##0" +} + +define external fastcc {i64, i1} @"multictr.complicated.f01<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = icmp uge i64 %"#rec##0", 4 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = and i64 %"#rec##0", 7 + %"tmp#1##0" = icmp eq i64 %"tmp#2##0", 0 + br i1 %"tmp#1##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#3##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#4##0" = call ccc ptr @wybe_malloc(i32 8) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#4##0", ptr %"tmp#3##0", i64 8, i1 0) + %"tmp#5##0" = ptrtoint ptr %"tmp#4##0" to i64 + %"tmp#6##0" = inttoptr i64 %"tmp#5##0" to ptr + store i64 %"#field##0", ptr %"tmp#6##0" + %"tmp#7##0" = insertvalue {i64, i1} undef, i64 %"tmp#5##0", 0 + %"tmp#8##0" = insertvalue {i64, i1} %"tmp#7##0", i1 1, 1 + ret {i64, i1} %"tmp#8##0" +if.else.1: + %"tmp#9##0" = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 + %"tmp#10##0" = insertvalue {i64, i1} %"tmp#9##0", i1 0, 1 + ret {i64, i1} %"tmp#10##0" +if.else.0: + %"tmp#11##0" = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 + %"tmp#12##0" = insertvalue {i64, i1} %"tmp#11##0", i1 0, 1 + ret {i64, i1} %"tmp#12##0" +} + +define external fastcc {i64, i1} @"multictr.complicated.f02<0>"(i64 %"#rec##0") { + %"tmp#0##0" = icmp uge i64 %"#rec##0", 4 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = and i64 %"#rec##0", 7 + %"tmp#1##0" = icmp eq i64 %"tmp#2##0", 1 + br i1 %"tmp#1##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#3##0" = add i64 %"#rec##0", -1 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#4##0" + %"tmp#6##0" = insertvalue {i64, i1} undef, i64 %"tmp#5##0", 0 + %"tmp#7##0" = insertvalue {i64, i1} %"tmp#6##0", i1 1, 1 + ret {i64, i1} %"tmp#7##0" +if.else.1: + %"tmp#8##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#9##0" = insertvalue {i64, i1} %"tmp#8##0", i1 0, 1 + ret {i64, i1} %"tmp#9##0" +if.else.0: + %"tmp#10##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#11##0" = insertvalue {i64, i1} %"tmp#10##0", i1 0, 1 + ret {i64, i1} %"tmp#11##0" +} + +define external fastcc {i64, i1} @"multictr.complicated.f02<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = icmp uge i64 %"#rec##0", 4 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = and i64 %"#rec##0", 7 + %"tmp#1##0" = icmp eq i64 %"tmp#2##0", 1 + br i1 %"tmp#1##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#3##0" = sub i64 %"#rec##0", 1 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + %"tmp#5##0" = call ccc ptr @wybe_malloc(i32 8) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#5##0", ptr %"tmp#4##0", i64 8, i1 0) + %"tmp#6##0" = ptrtoint ptr %"tmp#5##0" to i64 + %"tmp#7##0" = add i64 %"tmp#6##0", 1 + %"tmp#8##0" = add i64 %"tmp#7##0", -1 + %"tmp#9##0" = inttoptr i64 %"tmp#8##0" to ptr + store i64 %"#field##0", ptr %"tmp#9##0" + %"tmp#10##0" = insertvalue {i64, i1} undef, i64 %"tmp#7##0", 0 + %"tmp#11##0" = insertvalue {i64, i1} %"tmp#10##0", i1 1, 1 + ret {i64, i1} %"tmp#11##0" +if.else.1: + %"tmp#12##0" = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 + %"tmp#13##0" = insertvalue {i64, i1} %"tmp#12##0", i1 0, 1 + ret {i64, i1} %"tmp#13##0" +if.else.0: + %"tmp#14##0" = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 + %"tmp#15##0" = insertvalue {i64, i1} %"tmp#14##0", i1 0, 1 + ret {i64, i1} %"tmp#15##0" +} + +define external fastcc {i64, i1} @"multictr.complicated.f03<0>"(i64 %"#rec##0") { + %"tmp#0##0" = icmp uge i64 %"#rec##0", 4 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = and i64 %"#rec##0", 7 + %"tmp#1##0" = icmp eq i64 %"tmp#2##0", 2 + br i1 %"tmp#1##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#3##0" = add i64 %"#rec##0", -2 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#4##0" + %"tmp#6##0" = insertvalue {i64, i1} undef, i64 %"tmp#5##0", 0 + %"tmp#7##0" = insertvalue {i64, i1} %"tmp#6##0", i1 1, 1 + ret {i64, i1} %"tmp#7##0" +if.else.1: + %"tmp#8##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#9##0" = insertvalue {i64, i1} %"tmp#8##0", i1 0, 1 + ret {i64, i1} %"tmp#9##0" +if.else.0: + %"tmp#10##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#11##0" = insertvalue {i64, i1} %"tmp#10##0", i1 0, 1 + ret {i64, i1} %"tmp#11##0" +} + +define external fastcc {i64, i1} @"multictr.complicated.f03<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = icmp uge i64 %"#rec##0", 4 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = and i64 %"#rec##0", 7 + %"tmp#1##0" = icmp eq i64 %"tmp#2##0", 2 + br i1 %"tmp#1##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#3##0" = sub i64 %"#rec##0", 2 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + %"tmp#5##0" = call ccc ptr @wybe_malloc(i32 8) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#5##0", ptr %"tmp#4##0", i64 8, i1 0) + %"tmp#6##0" = ptrtoint ptr %"tmp#5##0" to i64 + %"tmp#7##0" = add i64 %"tmp#6##0", 2 + %"tmp#8##0" = add i64 %"tmp#7##0", -2 + %"tmp#9##0" = inttoptr i64 %"tmp#8##0" to ptr + store i64 %"#field##0", ptr %"tmp#9##0" + %"tmp#10##0" = insertvalue {i64, i1} undef, i64 %"tmp#7##0", 0 + %"tmp#11##0" = insertvalue {i64, i1} %"tmp#10##0", i1 1, 1 + ret {i64, i1} %"tmp#11##0" +if.else.1: + %"tmp#12##0" = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 + %"tmp#13##0" = insertvalue {i64, i1} %"tmp#12##0", i1 0, 1 + ret {i64, i1} %"tmp#13##0" +if.else.0: + %"tmp#14##0" = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 + %"tmp#15##0" = insertvalue {i64, i1} %"tmp#14##0", i1 0, 1 + ret {i64, i1} %"tmp#15##0" +} + +define external fastcc {i64, i1} @"multictr.complicated.f04<0>"(i64 %"#rec##0") { + %"tmp#0##0" = icmp uge i64 %"#rec##0", 4 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = and i64 %"#rec##0", 7 + %"tmp#1##0" = icmp eq i64 %"tmp#2##0", 3 + br i1 %"tmp#1##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#3##0" = add i64 %"#rec##0", -3 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#4##0" + %"tmp#6##0" = insertvalue {i64, i1} undef, i64 %"tmp#5##0", 0 + %"tmp#7##0" = insertvalue {i64, i1} %"tmp#6##0", i1 1, 1 + ret {i64, i1} %"tmp#7##0" +if.else.1: + %"tmp#8##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#9##0" = insertvalue {i64, i1} %"tmp#8##0", i1 0, 1 + ret {i64, i1} %"tmp#9##0" +if.else.0: + %"tmp#10##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#11##0" = insertvalue {i64, i1} %"tmp#10##0", i1 0, 1 + ret {i64, i1} %"tmp#11##0" +} + +define external fastcc {i64, i1} @"multictr.complicated.f04<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = icmp uge i64 %"#rec##0", 4 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = and i64 %"#rec##0", 7 + %"tmp#1##0" = icmp eq i64 %"tmp#2##0", 3 + br i1 %"tmp#1##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#3##0" = sub i64 %"#rec##0", 3 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + %"tmp#5##0" = call ccc ptr @wybe_malloc(i32 8) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#5##0", ptr %"tmp#4##0", i64 8, i1 0) + %"tmp#6##0" = ptrtoint ptr %"tmp#5##0" to i64 + %"tmp#7##0" = add i64 %"tmp#6##0", 3 + %"tmp#8##0" = add i64 %"tmp#7##0", -3 + %"tmp#9##0" = inttoptr i64 %"tmp#8##0" to ptr + store i64 %"#field##0", ptr %"tmp#9##0" + %"tmp#10##0" = insertvalue {i64, i1} undef, i64 %"tmp#7##0", 0 + %"tmp#11##0" = insertvalue {i64, i1} %"tmp#10##0", i1 1, 1 + ret {i64, i1} %"tmp#11##0" +if.else.1: + %"tmp#12##0" = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 + %"tmp#13##0" = insertvalue {i64, i1} %"tmp#12##0", i1 0, 1 + ret {i64, i1} %"tmp#13##0" +if.else.0: + %"tmp#14##0" = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 + %"tmp#15##0" = insertvalue {i64, i1} %"tmp#14##0", i1 0, 1 + ret {i64, i1} %"tmp#15##0" +} + +define external fastcc {i64, i1} @"multictr.complicated.f05<0>"(i64 %"#rec##0") { + %"tmp#0##0" = icmp uge i64 %"#rec##0", 4 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = and i64 %"#rec##0", 7 + %"tmp#1##0" = icmp eq i64 %"tmp#2##0", 4 + br i1 %"tmp#1##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#3##0" = add i64 %"#rec##0", -4 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#4##0" + %"tmp#6##0" = insertvalue {i64, i1} undef, i64 %"tmp#5##0", 0 + %"tmp#7##0" = insertvalue {i64, i1} %"tmp#6##0", i1 1, 1 + ret {i64, i1} %"tmp#7##0" +if.else.1: + %"tmp#8##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#9##0" = insertvalue {i64, i1} %"tmp#8##0", i1 0, 1 + ret {i64, i1} %"tmp#9##0" +if.else.0: + %"tmp#10##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#11##0" = insertvalue {i64, i1} %"tmp#10##0", i1 0, 1 + ret {i64, i1} %"tmp#11##0" +} + +define external fastcc {i64, i1} @"multictr.complicated.f05<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = icmp uge i64 %"#rec##0", 4 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = and i64 %"#rec##0", 7 + %"tmp#1##0" = icmp eq i64 %"tmp#2##0", 4 + br i1 %"tmp#1##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#3##0" = sub i64 %"#rec##0", 4 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + %"tmp#5##0" = call ccc ptr @wybe_malloc(i32 8) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#5##0", ptr %"tmp#4##0", i64 8, i1 0) + %"tmp#6##0" = ptrtoint ptr %"tmp#5##0" to i64 + %"tmp#7##0" = add i64 %"tmp#6##0", 4 + %"tmp#8##0" = add i64 %"tmp#7##0", -4 + %"tmp#9##0" = inttoptr i64 %"tmp#8##0" to ptr + store i64 %"#field##0", ptr %"tmp#9##0" + %"tmp#10##0" = insertvalue {i64, i1} undef, i64 %"tmp#7##0", 0 + %"tmp#11##0" = insertvalue {i64, i1} %"tmp#10##0", i1 1, 1 + ret {i64, i1} %"tmp#11##0" +if.else.1: + %"tmp#12##0" = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 + %"tmp#13##0" = insertvalue {i64, i1} %"tmp#12##0", i1 0, 1 + ret {i64, i1} %"tmp#13##0" +if.else.0: + %"tmp#14##0" = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 + %"tmp#15##0" = insertvalue {i64, i1} %"tmp#14##0", i1 0, 1 + ret {i64, i1} %"tmp#15##0" +} + +define external fastcc {i64, i1} @"multictr.complicated.f06<0>"(i64 %"#rec##0") { + %"tmp#0##0" = icmp uge i64 %"#rec##0", 4 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = and i64 %"#rec##0", 7 + %"tmp#1##0" = icmp eq i64 %"tmp#2##0", 5 + br i1 %"tmp#1##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#3##0" = add i64 %"#rec##0", -5 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#4##0" + %"tmp#6##0" = insertvalue {i64, i1} undef, i64 %"tmp#5##0", 0 + %"tmp#7##0" = insertvalue {i64, i1} %"tmp#6##0", i1 1, 1 + ret {i64, i1} %"tmp#7##0" +if.else.1: + %"tmp#8##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#9##0" = insertvalue {i64, i1} %"tmp#8##0", i1 0, 1 + ret {i64, i1} %"tmp#9##0" +if.else.0: + %"tmp#10##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#11##0" = insertvalue {i64, i1} %"tmp#10##0", i1 0, 1 + ret {i64, i1} %"tmp#11##0" +} + +define external fastcc {i64, i1} @"multictr.complicated.f06<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = icmp uge i64 %"#rec##0", 4 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = and i64 %"#rec##0", 7 + %"tmp#1##0" = icmp eq i64 %"tmp#2##0", 5 + br i1 %"tmp#1##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#3##0" = sub i64 %"#rec##0", 5 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + %"tmp#5##0" = call ccc ptr @wybe_malloc(i32 8) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#5##0", ptr %"tmp#4##0", i64 8, i1 0) + %"tmp#6##0" = ptrtoint ptr %"tmp#5##0" to i64 + %"tmp#7##0" = add i64 %"tmp#6##0", 5 + %"tmp#8##0" = add i64 %"tmp#7##0", -5 + %"tmp#9##0" = inttoptr i64 %"tmp#8##0" to ptr + store i64 %"#field##0", ptr %"tmp#9##0" + %"tmp#10##0" = insertvalue {i64, i1} undef, i64 %"tmp#7##0", 0 + %"tmp#11##0" = insertvalue {i64, i1} %"tmp#10##0", i1 1, 1 + ret {i64, i1} %"tmp#11##0" +if.else.1: + %"tmp#12##0" = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 + %"tmp#13##0" = insertvalue {i64, i1} %"tmp#12##0", i1 0, 1 + ret {i64, i1} %"tmp#13##0" +if.else.0: + %"tmp#14##0" = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 + %"tmp#15##0" = insertvalue {i64, i1} %"tmp#14##0", i1 0, 1 + ret {i64, i1} %"tmp#15##0" +} + +define external fastcc {i64, i1} @"multictr.complicated.f07<0>"(i64 %"#rec##0") { + %"tmp#0##0" = icmp uge i64 %"#rec##0", 4 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = and i64 %"#rec##0", 7 + %"tmp#1##0" = icmp eq i64 %"tmp#2##0", 6 + br i1 %"tmp#1##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#3##0" = add i64 %"#rec##0", -6 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#4##0" + %"tmp#6##0" = insertvalue {i64, i1} undef, i64 %"tmp#5##0", 0 + %"tmp#7##0" = insertvalue {i64, i1} %"tmp#6##0", i1 1, 1 + ret {i64, i1} %"tmp#7##0" +if.else.1: + %"tmp#8##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#9##0" = insertvalue {i64, i1} %"tmp#8##0", i1 0, 1 + ret {i64, i1} %"tmp#9##0" +if.else.0: + %"tmp#10##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#11##0" = insertvalue {i64, i1} %"tmp#10##0", i1 0, 1 + ret {i64, i1} %"tmp#11##0" +} + +define external fastcc {i64, i1} @"multictr.complicated.f07<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = icmp uge i64 %"#rec##0", 4 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = and i64 %"#rec##0", 7 + %"tmp#1##0" = icmp eq i64 %"tmp#2##0", 6 + br i1 %"tmp#1##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#3##0" = sub i64 %"#rec##0", 6 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + %"tmp#5##0" = call ccc ptr @wybe_malloc(i32 8) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#5##0", ptr %"tmp#4##0", i64 8, i1 0) + %"tmp#6##0" = ptrtoint ptr %"tmp#5##0" to i64 + %"tmp#7##0" = add i64 %"tmp#6##0", 6 + %"tmp#8##0" = add i64 %"tmp#7##0", -6 + %"tmp#9##0" = inttoptr i64 %"tmp#8##0" to ptr + store i64 %"#field##0", ptr %"tmp#9##0" + %"tmp#10##0" = insertvalue {i64, i1} undef, i64 %"tmp#7##0", 0 + %"tmp#11##0" = insertvalue {i64, i1} %"tmp#10##0", i1 1, 1 + ret {i64, i1} %"tmp#11##0" +if.else.1: + %"tmp#12##0" = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 + %"tmp#13##0" = insertvalue {i64, i1} %"tmp#12##0", i1 0, 1 + ret {i64, i1} %"tmp#13##0" +if.else.0: + %"tmp#14##0" = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 + %"tmp#15##0" = insertvalue {i64, i1} %"tmp#14##0", i1 0, 1 + ret {i64, i1} %"tmp#15##0" +} + +define external fastcc {i64, i1} @"multictr.complicated.f08<0>"(i64 %"#rec##0") { + %"tmp#0##0" = icmp uge i64 %"#rec##0", 4 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = and i64 %"#rec##0", 7 + %"tmp#1##0" = icmp eq i64 %"tmp#2##0", 7 + br i1 %"tmp#1##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#4##0" = add i64 %"#rec##0", -7 + %"tmp#5##0" = inttoptr i64 %"tmp#4##0" to ptr + %"#tag##0" = load i16, ptr %"tmp#5##0" + %"tmp#3##0" = icmp eq i16 %"#tag##0", 7 + br i1 %"tmp#3##0", label %if.then.2, label %if.else.2 +if.then.2: + %"tmp#6##0" = add i64 %"#rec##0", 1 + %"tmp#7##0" = inttoptr i64 %"tmp#6##0" to ptr + %"tmp#8##0" = load i64, ptr %"tmp#7##0" + %"tmp#9##0" = insertvalue {i64, i1} undef, i64 %"tmp#8##0", 0 + %"tmp#10##0" = insertvalue {i64, i1} %"tmp#9##0", i1 1, 1 + ret {i64, i1} %"tmp#10##0" +if.else.2: + %"tmp#11##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#12##0" = insertvalue {i64, i1} %"tmp#11##0", i1 0, 1 + ret {i64, i1} %"tmp#12##0" +if.else.1: + %"tmp#13##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#14##0" = insertvalue {i64, i1} %"tmp#13##0", i1 0, 1 + ret {i64, i1} %"tmp#14##0" +if.else.0: + %"tmp#15##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#16##0" = insertvalue {i64, i1} %"tmp#15##0", i1 0, 1 + ret {i64, i1} %"tmp#16##0" +} + +define external fastcc {i64, i1} @"multictr.complicated.f08<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = icmp uge i64 %"#rec##0", 4 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = and i64 %"#rec##0", 7 + %"tmp#1##0" = icmp eq i64 %"tmp#2##0", 7 + br i1 %"tmp#1##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#4##0" = add i64 %"#rec##0", -7 + %"tmp#5##0" = inttoptr i64 %"tmp#4##0" to ptr + %"#tag##0" = load i16, ptr %"tmp#5##0" + %"tmp#3##0" = icmp eq i16 %"#tag##0", 7 + br i1 %"tmp#3##0", label %if.then.2, label %if.else.2 +if.then.2: + %"tmp#6##0" = sub i64 %"#rec##0", 7 + %"tmp#7##0" = inttoptr i64 %"tmp#6##0" to ptr + %"tmp#8##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#8##0", ptr %"tmp#7##0", i64 16, i1 0) + %"tmp#9##0" = ptrtoint ptr %"tmp#8##0" to i64 + %"tmp#10##0" = add i64 %"tmp#9##0", 7 + %"tmp#11##0" = add i64 %"tmp#10##0", 1 + %"tmp#12##0" = inttoptr i64 %"tmp#11##0" to ptr + store i64 %"#field##0", ptr %"tmp#12##0" + %"tmp#13##0" = insertvalue {i64, i1} undef, i64 %"tmp#10##0", 0 + %"tmp#14##0" = insertvalue {i64, i1} %"tmp#13##0", i1 1, 1 + ret {i64, i1} %"tmp#14##0" +if.else.2: + %"tmp#15##0" = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 + %"tmp#16##0" = insertvalue {i64, i1} %"tmp#15##0", i1 0, 1 + ret {i64, i1} %"tmp#16##0" +if.else.1: + %"tmp#17##0" = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 + %"tmp#18##0" = insertvalue {i64, i1} %"tmp#17##0", i1 0, 1 + ret {i64, i1} %"tmp#18##0" +if.else.0: + %"tmp#19##0" = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 + %"tmp#20##0" = insertvalue {i64, i1} %"tmp#19##0", i1 0, 1 + ret {i64, i1} %"tmp#20##0" +} + +define external fastcc {i64, i1} @"multictr.complicated.f09<0>"(i64 %"#rec##0") { + %"tmp#0##0" = icmp uge i64 %"#rec##0", 4 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = and i64 %"#rec##0", 7 + %"tmp#1##0" = icmp eq i64 %"tmp#2##0", 7 + br i1 %"tmp#1##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#4##0" = add i64 %"#rec##0", -7 + %"tmp#5##0" = inttoptr i64 %"tmp#4##0" to ptr + %"#tag##0" = load i16, ptr %"tmp#5##0" + %"tmp#3##0" = icmp eq i16 %"#tag##0", 8 + br i1 %"tmp#3##0", label %if.then.2, label %if.else.2 +if.then.2: + %"tmp#6##0" = add i64 %"#rec##0", 1 + %"tmp#7##0" = inttoptr i64 %"tmp#6##0" to ptr + %"tmp#8##0" = load i64, ptr %"tmp#7##0" + %"tmp#9##0" = insertvalue {i64, i1} undef, i64 %"tmp#8##0", 0 + %"tmp#10##0" = insertvalue {i64, i1} %"tmp#9##0", i1 1, 1 + ret {i64, i1} %"tmp#10##0" +if.else.2: + %"tmp#11##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#12##0" = insertvalue {i64, i1} %"tmp#11##0", i1 0, 1 + ret {i64, i1} %"tmp#12##0" +if.else.1: + %"tmp#13##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#14##0" = insertvalue {i64, i1} %"tmp#13##0", i1 0, 1 + ret {i64, i1} %"tmp#14##0" +if.else.0: + %"tmp#15##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#16##0" = insertvalue {i64, i1} %"tmp#15##0", i1 0, 1 + ret {i64, i1} %"tmp#16##0" +} + +define external fastcc {i64, i1} @"multictr.complicated.f09<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = icmp uge i64 %"#rec##0", 4 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = and i64 %"#rec##0", 7 + %"tmp#1##0" = icmp eq i64 %"tmp#2##0", 7 + br i1 %"tmp#1##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#4##0" = add i64 %"#rec##0", -7 + %"tmp#5##0" = inttoptr i64 %"tmp#4##0" to ptr + %"#tag##0" = load i16, ptr %"tmp#5##0" + %"tmp#3##0" = icmp eq i16 %"#tag##0", 8 + br i1 %"tmp#3##0", label %if.then.2, label %if.else.2 +if.then.2: + %"tmp#6##0" = sub i64 %"#rec##0", 7 + %"tmp#7##0" = inttoptr i64 %"tmp#6##0" to ptr + %"tmp#8##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#8##0", ptr %"tmp#7##0", i64 16, i1 0) + %"tmp#9##0" = ptrtoint ptr %"tmp#8##0" to i64 + %"tmp#10##0" = add i64 %"tmp#9##0", 7 + %"tmp#11##0" = add i64 %"tmp#10##0", 1 + %"tmp#12##0" = inttoptr i64 %"tmp#11##0" to ptr + store i64 %"#field##0", ptr %"tmp#12##0" + %"tmp#13##0" = insertvalue {i64, i1} undef, i64 %"tmp#10##0", 0 + %"tmp#14##0" = insertvalue {i64, i1} %"tmp#13##0", i1 1, 1 + ret {i64, i1} %"tmp#14##0" +if.else.2: + %"tmp#15##0" = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 + %"tmp#16##0" = insertvalue {i64, i1} %"tmp#15##0", i1 0, 1 + ret {i64, i1} %"tmp#16##0" +if.else.1: + %"tmp#17##0" = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 + %"tmp#18##0" = insertvalue {i64, i1} %"tmp#17##0", i1 0, 1 + ret {i64, i1} %"tmp#18##0" +if.else.0: + %"tmp#19##0" = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 + %"tmp#20##0" = insertvalue {i64, i1} %"tmp#19##0", i1 0, 1 + ret {i64, i1} %"tmp#20##0" +} + +define external fastcc {i64, i1} @"multictr.complicated.f10<0>"(i64 %"#rec##0") { + %"tmp#0##0" = icmp uge i64 %"#rec##0", 4 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = and i64 %"#rec##0", 7 + %"tmp#1##0" = icmp eq i64 %"tmp#2##0", 7 + br i1 %"tmp#1##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#4##0" = add i64 %"#rec##0", -7 + %"tmp#5##0" = inttoptr i64 %"tmp#4##0" to ptr + %"#tag##0" = load i16, ptr %"tmp#5##0" + %"tmp#3##0" = icmp eq i16 %"#tag##0", 9 + br i1 %"tmp#3##0", label %if.then.2, label %if.else.2 +if.then.2: + %"tmp#6##0" = add i64 %"#rec##0", 1 + %"tmp#7##0" = inttoptr i64 %"tmp#6##0" to ptr + %"tmp#8##0" = load i64, ptr %"tmp#7##0" + %"tmp#9##0" = insertvalue {i64, i1} undef, i64 %"tmp#8##0", 0 + %"tmp#10##0" = insertvalue {i64, i1} %"tmp#9##0", i1 1, 1 + ret {i64, i1} %"tmp#10##0" +if.else.2: + %"tmp#11##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#12##0" = insertvalue {i64, i1} %"tmp#11##0", i1 0, 1 + ret {i64, i1} %"tmp#12##0" +if.else.1: + %"tmp#13##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#14##0" = insertvalue {i64, i1} %"tmp#13##0", i1 0, 1 + ret {i64, i1} %"tmp#14##0" +if.else.0: + %"tmp#15##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#16##0" = insertvalue {i64, i1} %"tmp#15##0", i1 0, 1 + ret {i64, i1} %"tmp#16##0" +} + +define external fastcc {i64, i1} @"multictr.complicated.f10<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = icmp uge i64 %"#rec##0", 4 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = and i64 %"#rec##0", 7 + %"tmp#1##0" = icmp eq i64 %"tmp#2##0", 7 + br i1 %"tmp#1##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#4##0" = add i64 %"#rec##0", -7 + %"tmp#5##0" = inttoptr i64 %"tmp#4##0" to ptr + %"#tag##0" = load i16, ptr %"tmp#5##0" + %"tmp#3##0" = icmp eq i16 %"#tag##0", 9 + br i1 %"tmp#3##0", label %if.then.2, label %if.else.2 +if.then.2: + %"tmp#6##0" = sub i64 %"#rec##0", 7 + %"tmp#7##0" = inttoptr i64 %"tmp#6##0" to ptr + %"tmp#8##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#8##0", ptr %"tmp#7##0", i64 16, i1 0) + %"tmp#9##0" = ptrtoint ptr %"tmp#8##0" to i64 + %"tmp#10##0" = add i64 %"tmp#9##0", 7 + %"tmp#11##0" = add i64 %"tmp#10##0", 1 + %"tmp#12##0" = inttoptr i64 %"tmp#11##0" to ptr + store i64 %"#field##0", ptr %"tmp#12##0" + %"tmp#13##0" = insertvalue {i64, i1} undef, i64 %"tmp#10##0", 0 + %"tmp#14##0" = insertvalue {i64, i1} %"tmp#13##0", i1 1, 1 + ret {i64, i1} %"tmp#14##0" +if.else.2: + %"tmp#15##0" = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 + %"tmp#16##0" = insertvalue {i64, i1} %"tmp#15##0", i1 0, 1 + ret {i64, i1} %"tmp#16##0" +if.else.1: + %"tmp#17##0" = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 + %"tmp#18##0" = insertvalue {i64, i1} %"tmp#17##0", i1 0, 1 + ret {i64, i1} %"tmp#18##0" +if.else.0: + %"tmp#19##0" = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 + %"tmp#20##0" = insertvalue {i64, i1} %"tmp#19##0", i1 0, 1 + ret {i64, i1} %"tmp#20##0" +} + +define external fastcc {i64, i1} @"multictr.complicated.f11<0>"(i64 %"#rec##0") { + %"tmp#0##0" = icmp uge i64 %"#rec##0", 4 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = and i64 %"#rec##0", 7 + %"tmp#1##0" = icmp eq i64 %"tmp#2##0", 7 + br i1 %"tmp#1##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#4##0" = add i64 %"#rec##0", -7 + %"tmp#5##0" = inttoptr i64 %"tmp#4##0" to ptr + %"#tag##0" = load i16, ptr %"tmp#5##0" + %"tmp#3##0" = icmp eq i16 %"#tag##0", 10 + br i1 %"tmp#3##0", label %if.then.2, label %if.else.2 +if.then.2: + %"tmp#6##0" = add i64 %"#rec##0", 1 + %"tmp#7##0" = inttoptr i64 %"tmp#6##0" to ptr + %"tmp#8##0" = load i64, ptr %"tmp#7##0" + %"tmp#9##0" = insertvalue {i64, i1} undef, i64 %"tmp#8##0", 0 + %"tmp#10##0" = insertvalue {i64, i1} %"tmp#9##0", i1 1, 1 + ret {i64, i1} %"tmp#10##0" +if.else.2: + %"tmp#11##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#12##0" = insertvalue {i64, i1} %"tmp#11##0", i1 0, 1 + ret {i64, i1} %"tmp#12##0" +if.else.1: + %"tmp#13##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#14##0" = insertvalue {i64, i1} %"tmp#13##0", i1 0, 1 + ret {i64, i1} %"tmp#14##0" +if.else.0: + %"tmp#15##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#16##0" = insertvalue {i64, i1} %"tmp#15##0", i1 0, 1 + ret {i64, i1} %"tmp#16##0" +} + +define external fastcc {i64, i1} @"multictr.complicated.f11<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = icmp uge i64 %"#rec##0", 4 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = and i64 %"#rec##0", 7 + %"tmp#1##0" = icmp eq i64 %"tmp#2##0", 7 + br i1 %"tmp#1##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#4##0" = add i64 %"#rec##0", -7 + %"tmp#5##0" = inttoptr i64 %"tmp#4##0" to ptr + %"#tag##0" = load i16, ptr %"tmp#5##0" + %"tmp#3##0" = icmp eq i16 %"#tag##0", 10 + br i1 %"tmp#3##0", label %if.then.2, label %if.else.2 +if.then.2: + %"tmp#6##0" = sub i64 %"#rec##0", 7 + %"tmp#7##0" = inttoptr i64 %"tmp#6##0" to ptr + %"tmp#8##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#8##0", ptr %"tmp#7##0", i64 16, i1 0) + %"tmp#9##0" = ptrtoint ptr %"tmp#8##0" to i64 + %"tmp#10##0" = add i64 %"tmp#9##0", 7 + %"tmp#11##0" = add i64 %"tmp#10##0", 1 + %"tmp#12##0" = inttoptr i64 %"tmp#11##0" to ptr + store i64 %"#field##0", ptr %"tmp#12##0" + %"tmp#13##0" = insertvalue {i64, i1} undef, i64 %"tmp#10##0", 0 + %"tmp#14##0" = insertvalue {i64, i1} %"tmp#13##0", i1 1, 1 + ret {i64, i1} %"tmp#14##0" +if.else.2: + %"tmp#15##0" = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 + %"tmp#16##0" = insertvalue {i64, i1} %"tmp#15##0", i1 0, 1 + ret {i64, i1} %"tmp#16##0" +if.else.1: + %"tmp#17##0" = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 + %"tmp#18##0" = insertvalue {i64, i1} %"tmp#17##0", i1 0, 1 + ret {i64, i1} %"tmp#18##0" +if.else.0: + %"tmp#19##0" = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 + %"tmp#20##0" = insertvalue {i64, i1} %"tmp#19##0", i1 0, 1 + ret {i64, i1} %"tmp#20##0" +} + +define external fastcc {i64, i1} @"multictr.complicated.f12<0>"(i64 %"#rec##0") { + %"tmp#0##0" = icmp uge i64 %"#rec##0", 4 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = and i64 %"#rec##0", 7 + %"tmp#1##0" = icmp eq i64 %"tmp#2##0", 7 + br i1 %"tmp#1##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#4##0" = add i64 %"#rec##0", -7 + %"tmp#5##0" = inttoptr i64 %"tmp#4##0" to ptr + %"#tag##0" = load i16, ptr %"tmp#5##0" + %"tmp#3##0" = icmp eq i16 %"#tag##0", 11 + br i1 %"tmp#3##0", label %if.then.2, label %if.else.2 +if.then.2: + %"tmp#6##0" = add i64 %"#rec##0", 1 + %"tmp#7##0" = inttoptr i64 %"tmp#6##0" to ptr + %"tmp#8##0" = load i64, ptr %"tmp#7##0" + %"tmp#9##0" = insertvalue {i64, i1} undef, i64 %"tmp#8##0", 0 + %"tmp#10##0" = insertvalue {i64, i1} %"tmp#9##0", i1 1, 1 + ret {i64, i1} %"tmp#10##0" +if.else.2: + %"tmp#11##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#12##0" = insertvalue {i64, i1} %"tmp#11##0", i1 0, 1 + ret {i64, i1} %"tmp#12##0" +if.else.1: + %"tmp#13##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#14##0" = insertvalue {i64, i1} %"tmp#13##0", i1 0, 1 + ret {i64, i1} %"tmp#14##0" +if.else.0: + %"tmp#15##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#16##0" = insertvalue {i64, i1} %"tmp#15##0", i1 0, 1 + ret {i64, i1} %"tmp#16##0" +} + +define external fastcc {i64, i1} @"multictr.complicated.f12<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = icmp uge i64 %"#rec##0", 4 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = and i64 %"#rec##0", 7 + %"tmp#1##0" = icmp eq i64 %"tmp#2##0", 7 + br i1 %"tmp#1##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#4##0" = add i64 %"#rec##0", -7 + %"tmp#5##0" = inttoptr i64 %"tmp#4##0" to ptr + %"#tag##0" = load i16, ptr %"tmp#5##0" + %"tmp#3##0" = icmp eq i16 %"#tag##0", 11 + br i1 %"tmp#3##0", label %if.then.2, label %if.else.2 +if.then.2: + %"tmp#6##0" = sub i64 %"#rec##0", 7 + %"tmp#7##0" = inttoptr i64 %"tmp#6##0" to ptr + %"tmp#8##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#8##0", ptr %"tmp#7##0", i64 16, i1 0) + %"tmp#9##0" = ptrtoint ptr %"tmp#8##0" to i64 + %"tmp#10##0" = add i64 %"tmp#9##0", 7 + %"tmp#11##0" = add i64 %"tmp#10##0", 1 + %"tmp#12##0" = inttoptr i64 %"tmp#11##0" to ptr + store i64 %"#field##0", ptr %"tmp#12##0" + %"tmp#13##0" = insertvalue {i64, i1} undef, i64 %"tmp#10##0", 0 + %"tmp#14##0" = insertvalue {i64, i1} %"tmp#13##0", i1 1, 1 + ret {i64, i1} %"tmp#14##0" +if.else.2: + %"tmp#15##0" = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 + %"tmp#16##0" = insertvalue {i64, i1} %"tmp#15##0", i1 0, 1 + ret {i64, i1} %"tmp#16##0" +if.else.1: + %"tmp#17##0" = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 + %"tmp#18##0" = insertvalue {i64, i1} %"tmp#17##0", i1 0, 1 + ret {i64, i1} %"tmp#18##0" +if.else.0: + %"tmp#19##0" = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 + %"tmp#20##0" = insertvalue {i64, i1} %"tmp#19##0", i1 0, 1 + ret {i64, i1} %"tmp#20##0" +} + +define external fastcc {i64, i1} @"multictr.complicated.f13<0>"(i64 %"#rec##0") { + %"tmp#0##0" = icmp uge i64 %"#rec##0", 4 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = and i64 %"#rec##0", 7 + %"tmp#1##0" = icmp eq i64 %"tmp#2##0", 7 + br i1 %"tmp#1##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#4##0" = add i64 %"#rec##0", -7 + %"tmp#5##0" = inttoptr i64 %"tmp#4##0" to ptr + %"#tag##0" = load i16, ptr %"tmp#5##0" + %"tmp#3##0" = icmp eq i16 %"#tag##0", 12 + br i1 %"tmp#3##0", label %if.then.2, label %if.else.2 +if.then.2: + %"tmp#6##0" = add i64 %"#rec##0", 1 + %"tmp#7##0" = inttoptr i64 %"tmp#6##0" to ptr + %"tmp#8##0" = load i64, ptr %"tmp#7##0" + %"tmp#9##0" = insertvalue {i64, i1} undef, i64 %"tmp#8##0", 0 + %"tmp#10##0" = insertvalue {i64, i1} %"tmp#9##0", i1 1, 1 + ret {i64, i1} %"tmp#10##0" +if.else.2: + %"tmp#11##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#12##0" = insertvalue {i64, i1} %"tmp#11##0", i1 0, 1 + ret {i64, i1} %"tmp#12##0" +if.else.1: + %"tmp#13##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#14##0" = insertvalue {i64, i1} %"tmp#13##0", i1 0, 1 + ret {i64, i1} %"tmp#14##0" +if.else.0: + %"tmp#15##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#16##0" = insertvalue {i64, i1} %"tmp#15##0", i1 0, 1 + ret {i64, i1} %"tmp#16##0" +} + +define external fastcc {i64, i1} @"multictr.complicated.f13<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = icmp uge i64 %"#rec##0", 4 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = and i64 %"#rec##0", 7 + %"tmp#1##0" = icmp eq i64 %"tmp#2##0", 7 + br i1 %"tmp#1##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#4##0" = add i64 %"#rec##0", -7 + %"tmp#5##0" = inttoptr i64 %"tmp#4##0" to ptr + %"#tag##0" = load i16, ptr %"tmp#5##0" + %"tmp#3##0" = icmp eq i16 %"#tag##0", 12 + br i1 %"tmp#3##0", label %if.then.2, label %if.else.2 +if.then.2: + %"tmp#6##0" = sub i64 %"#rec##0", 7 + %"tmp#7##0" = inttoptr i64 %"tmp#6##0" to ptr + %"tmp#8##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#8##0", ptr %"tmp#7##0", i64 16, i1 0) + %"tmp#9##0" = ptrtoint ptr %"tmp#8##0" to i64 + %"tmp#10##0" = add i64 %"tmp#9##0", 7 + %"tmp#11##0" = add i64 %"tmp#10##0", 1 + %"tmp#12##0" = inttoptr i64 %"tmp#11##0" to ptr + store i64 %"#field##0", ptr %"tmp#12##0" + %"tmp#13##0" = insertvalue {i64, i1} undef, i64 %"tmp#10##0", 0 + %"tmp#14##0" = insertvalue {i64, i1} %"tmp#13##0", i1 1, 1 + ret {i64, i1} %"tmp#14##0" +if.else.2: + %"tmp#15##0" = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 + %"tmp#16##0" = insertvalue {i64, i1} %"tmp#15##0", i1 0, 1 + ret {i64, i1} %"tmp#16##0" +if.else.1: + %"tmp#17##0" = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 + %"tmp#18##0" = insertvalue {i64, i1} %"tmp#17##0", i1 0, 1 + ret {i64, i1} %"tmp#18##0" +if.else.0: + %"tmp#19##0" = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 + %"tmp#20##0" = insertvalue {i64, i1} %"tmp#19##0", i1 0, 1 + ret {i64, i1} %"tmp#20##0" +} + +define external fastcc {i64, i1} @"multictr.complicated.f14<0>"(i64 %"#rec##0") { + %"tmp#0##0" = icmp uge i64 %"#rec##0", 4 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = and i64 %"#rec##0", 7 + %"tmp#1##0" = icmp eq i64 %"tmp#2##0", 7 + br i1 %"tmp#1##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#4##0" = add i64 %"#rec##0", -7 + %"tmp#5##0" = inttoptr i64 %"tmp#4##0" to ptr + %"#tag##0" = load i16, ptr %"tmp#5##0" + %"tmp#3##0" = icmp eq i16 %"#tag##0", 13 + br i1 %"tmp#3##0", label %if.then.2, label %if.else.2 +if.then.2: + %"tmp#6##0" = add i64 %"#rec##0", 1 + %"tmp#7##0" = inttoptr i64 %"tmp#6##0" to ptr + %"tmp#8##0" = load i64, ptr %"tmp#7##0" + %"tmp#9##0" = insertvalue {i64, i1} undef, i64 %"tmp#8##0", 0 + %"tmp#10##0" = insertvalue {i64, i1} %"tmp#9##0", i1 1, 1 + ret {i64, i1} %"tmp#10##0" +if.else.2: + %"tmp#11##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#12##0" = insertvalue {i64, i1} %"tmp#11##0", i1 0, 1 + ret {i64, i1} %"tmp#12##0" +if.else.1: + %"tmp#13##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#14##0" = insertvalue {i64, i1} %"tmp#13##0", i1 0, 1 + ret {i64, i1} %"tmp#14##0" +if.else.0: + %"tmp#15##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#16##0" = insertvalue {i64, i1} %"tmp#15##0", i1 0, 1 + ret {i64, i1} %"tmp#16##0" +} + +define external fastcc {i64, i1} @"multictr.complicated.f14<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = icmp uge i64 %"#rec##0", 4 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = and i64 %"#rec##0", 7 + %"tmp#1##0" = icmp eq i64 %"tmp#2##0", 7 + br i1 %"tmp#1##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#4##0" = add i64 %"#rec##0", -7 + %"tmp#5##0" = inttoptr i64 %"tmp#4##0" to ptr + %"#tag##0" = load i16, ptr %"tmp#5##0" + %"tmp#3##0" = icmp eq i16 %"#tag##0", 13 + br i1 %"tmp#3##0", label %if.then.2, label %if.else.2 +if.then.2: + %"tmp#6##0" = sub i64 %"#rec##0", 7 + %"tmp#7##0" = inttoptr i64 %"tmp#6##0" to ptr + %"tmp#8##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#8##0", ptr %"tmp#7##0", i64 16, i1 0) + %"tmp#9##0" = ptrtoint ptr %"tmp#8##0" to i64 + %"tmp#10##0" = add i64 %"tmp#9##0", 7 + %"tmp#11##0" = add i64 %"tmp#10##0", 1 + %"tmp#12##0" = inttoptr i64 %"tmp#11##0" to ptr + store i64 %"#field##0", ptr %"tmp#12##0" + %"tmp#13##0" = insertvalue {i64, i1} undef, i64 %"tmp#10##0", 0 + %"tmp#14##0" = insertvalue {i64, i1} %"tmp#13##0", i1 1, 1 + ret {i64, i1} %"tmp#14##0" +if.else.2: + %"tmp#15##0" = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 + %"tmp#16##0" = insertvalue {i64, i1} %"tmp#15##0", i1 0, 1 + ret {i64, i1} %"tmp#16##0" +if.else.1: + %"tmp#17##0" = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 + %"tmp#18##0" = insertvalue {i64, i1} %"tmp#17##0", i1 0, 1 + ret {i64, i1} %"tmp#18##0" +if.else.0: + %"tmp#19##0" = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 + %"tmp#20##0" = insertvalue {i64, i1} %"tmp#19##0", i1 0, 1 + ret {i64, i1} %"tmp#20##0" +} + +define external fastcc {i64, i1} @"multictr.complicated.f15<0>"(i64 %"#rec##0") { + %"tmp#0##0" = icmp uge i64 %"#rec##0", 4 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = and i64 %"#rec##0", 7 + %"tmp#1##0" = icmp eq i64 %"tmp#2##0", 7 + br i1 %"tmp#1##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#4##0" = add i64 %"#rec##0", -7 + %"tmp#5##0" = inttoptr i64 %"tmp#4##0" to ptr + %"#tag##0" = load i16, ptr %"tmp#5##0" + %"tmp#3##0" = icmp eq i16 %"#tag##0", 14 + br i1 %"tmp#3##0", label %if.then.2, label %if.else.2 +if.then.2: + %"tmp#6##0" = add i64 %"#rec##0", 1 + %"tmp#7##0" = inttoptr i64 %"tmp#6##0" to ptr + %"tmp#8##0" = load i64, ptr %"tmp#7##0" + %"tmp#9##0" = insertvalue {i64, i1} undef, i64 %"tmp#8##0", 0 + %"tmp#10##0" = insertvalue {i64, i1} %"tmp#9##0", i1 1, 1 + ret {i64, i1} %"tmp#10##0" +if.else.2: + %"tmp#11##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#12##0" = insertvalue {i64, i1} %"tmp#11##0", i1 0, 1 + ret {i64, i1} %"tmp#12##0" +if.else.1: + %"tmp#13##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#14##0" = insertvalue {i64, i1} %"tmp#13##0", i1 0, 1 + ret {i64, i1} %"tmp#14##0" +if.else.0: + %"tmp#15##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#16##0" = insertvalue {i64, i1} %"tmp#15##0", i1 0, 1 + ret {i64, i1} %"tmp#16##0" +} + +define external fastcc {i64, i1} @"multictr.complicated.f15<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = icmp uge i64 %"#rec##0", 4 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = and i64 %"#rec##0", 7 + %"tmp#1##0" = icmp eq i64 %"tmp#2##0", 7 + br i1 %"tmp#1##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#4##0" = add i64 %"#rec##0", -7 + %"tmp#5##0" = inttoptr i64 %"tmp#4##0" to ptr + %"#tag##0" = load i16, ptr %"tmp#5##0" + %"tmp#3##0" = icmp eq i16 %"#tag##0", 14 + br i1 %"tmp#3##0", label %if.then.2, label %if.else.2 +if.then.2: + %"tmp#6##0" = sub i64 %"#rec##0", 7 + %"tmp#7##0" = inttoptr i64 %"tmp#6##0" to ptr + %"tmp#8##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#8##0", ptr %"tmp#7##0", i64 16, i1 0) + %"tmp#9##0" = ptrtoint ptr %"tmp#8##0" to i64 + %"tmp#10##0" = add i64 %"tmp#9##0", 7 + %"tmp#11##0" = add i64 %"tmp#10##0", 1 + %"tmp#12##0" = inttoptr i64 %"tmp#11##0" to ptr + store i64 %"#field##0", ptr %"tmp#12##0" + %"tmp#13##0" = insertvalue {i64, i1} undef, i64 %"tmp#10##0", 0 + %"tmp#14##0" = insertvalue {i64, i1} %"tmp#13##0", i1 1, 1 + ret {i64, i1} %"tmp#14##0" +if.else.2: + %"tmp#15##0" = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 + %"tmp#16##0" = insertvalue {i64, i1} %"tmp#15##0", i1 0, 1 + ret {i64, i1} %"tmp#16##0" +if.else.1: + %"tmp#17##0" = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 + %"tmp#18##0" = insertvalue {i64, i1} %"tmp#17##0", i1 0, 1 + ret {i64, i1} %"tmp#18##0" +if.else.0: + %"tmp#19##0" = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 + %"tmp#20##0" = insertvalue {i64, i1} %"tmp#19##0", i1 0, 1 + ret {i64, i1} %"tmp#20##0" +} + +define external fastcc {i64, i1} @"multictr.complicated.f16<0>"(i64 %"#rec##0") { + %"tmp#0##0" = icmp uge i64 %"#rec##0", 4 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = and i64 %"#rec##0", 7 + %"tmp#1##0" = icmp eq i64 %"tmp#2##0", 7 + br i1 %"tmp#1##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#4##0" = add i64 %"#rec##0", -7 + %"tmp#5##0" = inttoptr i64 %"tmp#4##0" to ptr + %"#tag##0" = load i16, ptr %"tmp#5##0" + %"tmp#3##0" = icmp eq i16 %"#tag##0", 15 + br i1 %"tmp#3##0", label %if.then.2, label %if.else.2 +if.then.2: + %"tmp#6##0" = add i64 %"#rec##0", 1 + %"tmp#7##0" = inttoptr i64 %"tmp#6##0" to ptr + %"tmp#8##0" = load i64, ptr %"tmp#7##0" + %"tmp#9##0" = insertvalue {i64, i1} undef, i64 %"tmp#8##0", 0 + %"tmp#10##0" = insertvalue {i64, i1} %"tmp#9##0", i1 1, 1 + ret {i64, i1} %"tmp#10##0" +if.else.2: + %"tmp#11##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#12##0" = insertvalue {i64, i1} %"tmp#11##0", i1 0, 1 + ret {i64, i1} %"tmp#12##0" +if.else.1: + %"tmp#13##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#14##0" = insertvalue {i64, i1} %"tmp#13##0", i1 0, 1 + ret {i64, i1} %"tmp#14##0" +if.else.0: + %"tmp#15##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#16##0" = insertvalue {i64, i1} %"tmp#15##0", i1 0, 1 + ret {i64, i1} %"tmp#16##0" +} + +define external fastcc {i64, i1} @"multictr.complicated.f16<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = icmp uge i64 %"#rec##0", 4 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = and i64 %"#rec##0", 7 + %"tmp#1##0" = icmp eq i64 %"tmp#2##0", 7 + br i1 %"tmp#1##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#4##0" = add i64 %"#rec##0", -7 + %"tmp#5##0" = inttoptr i64 %"tmp#4##0" to ptr + %"#tag##0" = load i16, ptr %"tmp#5##0" + %"tmp#3##0" = icmp eq i16 %"#tag##0", 15 + br i1 %"tmp#3##0", label %if.then.2, label %if.else.2 +if.then.2: + %"tmp#6##0" = sub i64 %"#rec##0", 7 + %"tmp#7##0" = inttoptr i64 %"tmp#6##0" to ptr + %"tmp#8##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#8##0", ptr %"tmp#7##0", i64 16, i1 0) + %"tmp#9##0" = ptrtoint ptr %"tmp#8##0" to i64 + %"tmp#10##0" = add i64 %"tmp#9##0", 7 + %"tmp#11##0" = add i64 %"tmp#10##0", 1 + %"tmp#12##0" = inttoptr i64 %"tmp#11##0" to ptr + store i64 %"#field##0", ptr %"tmp#12##0" + %"tmp#13##0" = insertvalue {i64, i1} undef, i64 %"tmp#10##0", 0 + %"tmp#14##0" = insertvalue {i64, i1} %"tmp#13##0", i1 1, 1 + ret {i64, i1} %"tmp#14##0" +if.else.2: + %"tmp#15##0" = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 + %"tmp#16##0" = insertvalue {i64, i1} %"tmp#15##0", i1 0, 1 + ret {i64, i1} %"tmp#16##0" +if.else.1: + %"tmp#17##0" = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 + %"tmp#18##0" = insertvalue {i64, i1} %"tmp#17##0", i1 0, 1 + ret {i64, i1} %"tmp#18##0" +if.else.0: + %"tmp#19##0" = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 + %"tmp#20##0" = insertvalue {i64, i1} %"tmp#19##0", i1 0, 1 + ret {i64, i1} %"tmp#20##0" +} + +define external fastcc {i64, i1} @"multictr.complicated.f17<0>"(i64 %"#rec##0") { + %"tmp#0##0" = icmp uge i64 %"#rec##0", 4 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = and i64 %"#rec##0", 7 + %"tmp#1##0" = icmp eq i64 %"tmp#2##0", 7 + br i1 %"tmp#1##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#4##0" = add i64 %"#rec##0", -7 + %"tmp#5##0" = inttoptr i64 %"tmp#4##0" to ptr + %"#tag##0" = load i16, ptr %"tmp#5##0" + %"tmp#3##0" = icmp eq i16 %"#tag##0", 16 + br i1 %"tmp#3##0", label %if.then.2, label %if.else.2 +if.then.2: + %"tmp#6##0" = add i64 %"#rec##0", 1 + %"tmp#7##0" = inttoptr i64 %"tmp#6##0" to ptr + %"tmp#8##0" = load i64, ptr %"tmp#7##0" + %"tmp#9##0" = insertvalue {i64, i1} undef, i64 %"tmp#8##0", 0 + %"tmp#10##0" = insertvalue {i64, i1} %"tmp#9##0", i1 1, 1 + ret {i64, i1} %"tmp#10##0" +if.else.2: + %"tmp#11##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#12##0" = insertvalue {i64, i1} %"tmp#11##0", i1 0, 1 + ret {i64, i1} %"tmp#12##0" +if.else.1: + %"tmp#13##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#14##0" = insertvalue {i64, i1} %"tmp#13##0", i1 0, 1 + ret {i64, i1} %"tmp#14##0" +if.else.0: + %"tmp#15##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#16##0" = insertvalue {i64, i1} %"tmp#15##0", i1 0, 1 + ret {i64, i1} %"tmp#16##0" +} + +define external fastcc {i64, i1} @"multictr.complicated.f17<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = icmp uge i64 %"#rec##0", 4 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = and i64 %"#rec##0", 7 + %"tmp#1##0" = icmp eq i64 %"tmp#2##0", 7 + br i1 %"tmp#1##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#4##0" = add i64 %"#rec##0", -7 + %"tmp#5##0" = inttoptr i64 %"tmp#4##0" to ptr + %"#tag##0" = load i16, ptr %"tmp#5##0" + %"tmp#3##0" = icmp eq i16 %"#tag##0", 16 + br i1 %"tmp#3##0", label %if.then.2, label %if.else.2 +if.then.2: + %"tmp#6##0" = sub i64 %"#rec##0", 7 + %"tmp#7##0" = inttoptr i64 %"tmp#6##0" to ptr + %"tmp#8##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#8##0", ptr %"tmp#7##0", i64 16, i1 0) + %"tmp#9##0" = ptrtoint ptr %"tmp#8##0" to i64 + %"tmp#10##0" = add i64 %"tmp#9##0", 7 + %"tmp#11##0" = add i64 %"tmp#10##0", 1 + %"tmp#12##0" = inttoptr i64 %"tmp#11##0" to ptr + store i64 %"#field##0", ptr %"tmp#12##0" + %"tmp#13##0" = insertvalue {i64, i1} undef, i64 %"tmp#10##0", 0 + %"tmp#14##0" = insertvalue {i64, i1} %"tmp#13##0", i1 1, 1 + ret {i64, i1} %"tmp#14##0" +if.else.2: + %"tmp#15##0" = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 + %"tmp#16##0" = insertvalue {i64, i1} %"tmp#15##0", i1 0, 1 + ret {i64, i1} %"tmp#16##0" +if.else.1: + %"tmp#17##0" = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 + %"tmp#18##0" = insertvalue {i64, i1} %"tmp#17##0", i1 0, 1 + ret {i64, i1} %"tmp#18##0" +if.else.0: + %"tmp#19##0" = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 + %"tmp#20##0" = insertvalue {i64, i1} %"tmp#19##0", i1 0, 1 + ret {i64, i1} %"tmp#20##0" +} + +define external fastcc i64 @"multictr.complicated.spring<0>"() { + ret i64 1 +} + +define external fastcc i64 @"multictr.complicated.summer<0>"() { + ret i64 2 +} + +define external fastcc i64 @"multictr.complicated.winter<0>"() { + ret i64 0 +} + +define external fastcc i1 @"multictr.complicated.~=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#0##0" = tail call fastcc i1 @"multictr.complicated.=<0>"(i64 %"#left##0", i64 %"#right##0") + %"tmp#1##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#1##0" } + -------------------------------------------------- Module multictr.length representation : 64 bit unsigned @@ -5231,7 +5012,7 @@ proc metres > public {inline} (0 calls) metres(value##0:wybe.float, ?#result##2:multictr.length)<{}; {}; {}>: AliasPairs: [] InterestingCallProperties: [] - foreign llvm move(~value##0:multictr.length, ?#result##2:multictr.length) @multictr:nn:nn + foreign lpvm cast(~value##0:wybe.float, ?#result##2:multictr.length) @multictr:nn:nn proc metres > public {inline} (0 calls) 1: multictr.length.metres<1> metres(?value##0:wybe.float, #result##0:multictr.length)<{}; {}; {}>: @@ -5251,7 +5032,7 @@ proc value > public {inline} (0 calls) value([#rec##0:multictr.length], ?#rec##2:multictr.length, #field##0:wybe.float)<{}; {}; {}>: AliasPairs: [] InterestingCallProperties: [] - foreign llvm move(~#field##0:multictr.length, ?#rec##2:multictr.length) @multictr:nn:nn + foreign lpvm cast(~#field##0:wybe.float, ?#rec##2:multictr.length) @multictr:nn:nn proc ~= > public {inline} (0 calls) @@ -5264,62 +5045,49 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'multictr.length' +source_filename = "!ROOT!/final-dump/multictr.wybe" +target triple ???? - +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i1 @"multictr.length.=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = icmp eq i64 %"#left##0", %"#right##0" - ret i1 %0 +define external fastcc i1 @"multictr.length.=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#1##0" = icmp eq i64 %"#left##0", %"#right##0" + ret i1 %"tmp#1##0" } - -define external fastcc i64 @"multictr.length.metres<0>"(double %"value##0") alwaysinline { -entry: - %0 = bitcast double %"value##0" to i64 - ret i64 %0 +define external fastcc i64 @"multictr.length.metres<0>"(double %"value##0") { + %"tmp#0##0" = bitcast double %"value##0" to i64 + ret i64 %"tmp#0##0" } - -define external fastcc double @"multictr.length.metres<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = bitcast i64 %"#result##0" to double - ret double %0 +define external fastcc double @"multictr.length.metres<1>"(i64 %"#result##0") { + %"tmp#0##0" = bitcast i64 %"#result##0" to double + ret double %"tmp#0##0" } - -define external fastcc double @"multictr.length.value<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = bitcast i64 %"#rec##0" to double - ret double %0 +define external fastcc double @"multictr.length.value<0>"(i64 %"#rec##0") { + %"tmp#0##0" = bitcast i64 %"#rec##0" to double + ret double %"tmp#0##0" } - -define external fastcc i64 @"multictr.length.value<1>"(double %"#field##0") alwaysinline { -entry: - %0 = bitcast double %"#field##0" to i64 - ret i64 %0 +define external fastcc i64 @"multictr.length.value<1>"(double %"#field##0") { + %"tmp#0##0" = bitcast double %"#field##0" to i64 + ret i64 %"tmp#0##0" } - -define external fastcc i1 @"multictr.length.~=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = icmp eq i64 %"#left##0", %"#right##0" - %1 = xor i1 %0, 1 - ret i1 %1 +define external fastcc i1 @"multictr.length.~=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#0##0" = icmp eq i64 %"#left##0", %"#right##0" + %"tmp#3##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#3##0" } + -------------------------------------------------- Module multictr.maybe_int - representation : address + representation : pointer public submods : public resources: public procs : multictr.maybe_int.=<0> @@ -5432,124 +5200,106 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'multictr.maybe_int' - - - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i1 @"multictr.maybe_int.=<0>"(i64 %"#left##0", i64 %"#right##0") { -entry: - %0 = icmp ne i64 %"#left##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"#left##0" to i64* - %2 = load i64, i64* %1 - %3 = icmp ne i64 %"#right##0", 0 - br i1 %3, label %if.then1, label %if.else1 -if.else: - %7 = icmp eq i64 %"#right##0", 0 - ret i1 %7 -if.then1: - %4 = inttoptr i64 %"#right##0" to i64* - %5 = load i64, i64* %4 - %6 = icmp eq i64 %2, %5 - ret i1 %6 -if.else1: - ret i1 0 -} - - -define external fastcc i64 @"multictr.maybe_int.just<0>"(i64 %"value##0") alwaysinline { -entry: - %0 = trunc i64 8 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"value##0", i64* %3 - ret i64 %2 -} - - -define external fastcc {i64, i1} @"multictr.maybe_int.just<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#result##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"#result##0" to i64* - %2 = load i64, i64* %1 - %3 = insertvalue {i64, i1} undef, i64 %2, 0 - %4 = insertvalue {i64, i1} %3, i1 1, 1 - ret {i64, i1} %4 -if.else: - %5 = insertvalue {i64, i1} undef, i64 undef, 0 - %6 = insertvalue {i64, i1} %5, i1 0, 1 - ret {i64, i1} %6 -} - - -define external fastcc i64 @"multictr.maybe_int.nothing<0>"() alwaysinline { -entry: - ret i64 0 -} - - -define external fastcc {i64, i1} @"multictr.maybe_int.value<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"#rec##0" to i64* - %2 = load i64, i64* %1 - %3 = insertvalue {i64, i1} undef, i64 %2, 0 - %4 = insertvalue {i64, i1} %3, i1 1, 1 - ret {i64, i1} %4 -if.else: - %5 = insertvalue {i64, i1} undef, i64 undef, 0 - %6 = insertvalue {i64, i1} %5, i1 0, 1 - ret {i64, i1} %6 -} - - -define external fastcc {i64, i1} @"multictr.maybe_int.value<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = trunc i64 8 to i32 - %2 = tail call ccc i8* @wybe_malloc(i32 %1) - %3 = ptrtoint i8* %2 to i64 - %4 = inttoptr i64 %3 to i8* - %5 = inttoptr i64 %"#rec##0" to i8* - %6 = trunc i64 8 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %4, i8* %5, i32 %6, i1 0) - %7 = inttoptr i64 %3 to i64* - store i64 %"#field##0", i64* %7 - %8 = insertvalue {i64, i1} undef, i64 %3, 0 - %9 = insertvalue {i64, i1} %8, i1 1, 1 - ret {i64, i1} %9 -if.else: - %10 = insertvalue {i64, i1} undef, i64 0, 0 - %11 = insertvalue {i64, i1} %10, i1 0, 1 - ret {i64, i1} %11 -} - - -define external fastcc i1 @"multictr.maybe_int.~=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = tail call fastcc i1 @"multictr.maybe_int.=<0>"(i64 %"#left##0", i64 %"#right##0") - %1 = xor i1 %0, 1 - ret i1 %1 +source_filename = "!ROOT!/final-dump/multictr.wybe" +target triple ???? + + +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc i1 @"multictr.maybe_int.=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#0##0" = icmp ne i64 %"#left##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#11##0" = inttoptr i64 %"#left##0" to ptr + %"#left#value##0" = load i64, ptr %"tmp#11##0" + %"tmp#8##0" = icmp ne i64 %"#right##0", 0 + br i1 %"tmp#8##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#12##0" = inttoptr i64 %"#right##0" to ptr + %"#right#value##0" = load i64, ptr %"tmp#12##0" + %"tmp#13##0" = icmp eq i64 %"#left#value##0", %"#right#value##0" + ret i1 %"tmp#13##0" +if.else.1: + ret i1 0 +if.else.0: + %"tmp#14##0" = icmp eq i64 %"#right##0", 0 + ret i1 %"tmp#14##0" +} + +define external fastcc i64 @"multictr.maybe_int.just<0>"(i64 %"value##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 8) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"value##0", ptr %"tmp#1##0" + ret i64 %"#rec##0" +} + +define external fastcc {i64, i1} @"multictr.maybe_int.just<1>"(i64 %"#result##0") { + %"tmp#0##0" = icmp ne i64 %"#result##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = inttoptr i64 %"#result##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + %"tmp#3##0" = insertvalue {i64, i1} undef, i64 %"tmp#2##0", 0 + %"tmp#4##0" = insertvalue {i64, i1} %"tmp#3##0", i1 1, 1 + ret {i64, i1} %"tmp#4##0" +if.else.0: + %"tmp#5##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#6##0" = insertvalue {i64, i1} %"tmp#5##0", i1 0, 1 + ret {i64, i1} %"tmp#6##0" +} + +define external fastcc i64 @"multictr.maybe_int.nothing<0>"() { + ret i64 0 +} + +define external fastcc {i64, i1} @"multictr.maybe_int.value<0>"(i64 %"#rec##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + %"tmp#3##0" = insertvalue {i64, i1} undef, i64 %"tmp#2##0", 0 + %"tmp#4##0" = insertvalue {i64, i1} %"tmp#3##0", i1 1, 1 + ret {i64, i1} %"tmp#4##0" +if.else.0: + %"tmp#5##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#6##0" = insertvalue {i64, i1} %"tmp#5##0", i1 0, 1 + ret {i64, i1} %"tmp#6##0" +} + +define external fastcc {i64, i1} @"multictr.maybe_int.value<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#2##0" = call ccc ptr @wybe_malloc(i32 8) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#2##0", ptr %"tmp#1##0", i64 8, i1 0) + %"tmp#3##0" = ptrtoint ptr %"tmp#2##0" to i64 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 %"#field##0", ptr %"tmp#4##0" + %"tmp#5##0" = insertvalue {i64, i1} undef, i64 %"tmp#3##0", 0 + %"tmp#6##0" = insertvalue {i64, i1} %"tmp#5##0", i1 1, 1 + ret {i64, i1} %"tmp#6##0" +if.else.0: + %"tmp#7##0" = insertvalue {i64, i1} undef, i64 0, 0 + %"tmp#8##0" = insertvalue {i64, i1} %"tmp#7##0", i1 0, 1 + ret {i64, i1} %"tmp#8##0" +} + +define external fastcc i1 @"multictr.maybe_int.~=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#0##0" = tail call fastcc i1 @"multictr.maybe_int.=<0>"(i64 %"#left##0", i64 %"#right##0") + %"tmp#1##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#1##0" } + -------------------------------------------------- Module multictr.number - representation : address + representation : pointer public submods : public resources: public procs : multictr.number.=<0> @@ -5591,7 +5341,7 @@ proc = > public (1 calls) 1: foreign lpvm access(~#right##0:multictr.number, -1:wybe.int, 8:wybe.int, 1:wybe.int, ?#right#float_value##0:wybe.float) @multictr:nn:nn - foreign llvm fcmp_eq(~#left#float_value##0:wybe.float, ~#right#float_value##0:wybe.float, ?#success##0:wybe.bool) @float:nn:nn + foreign llvm fcmp_oeq(~#left#float_value##0:wybe.float, ~#right#float_value##0:wybe.float, ?#success##0:wybe.bool) @float:nn:nn @@ -5739,215 +5489,187 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'multictr.number' - - - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i1 @"multictr.number.=<0>"(i64 %"#left##0", i64 %"#right##0") { -entry: - %0 = and i64 %"#left##0", 1 - %1 = icmp eq i64 %0, 0 - br i1 %1, label %if.then, label %if.else -if.then: - %2 = inttoptr i64 %"#left##0" to i64* - %3 = load i64, i64* %2 - %4 = and i64 %"#right##0", 1 - %5 = icmp eq i64 %4, 0 - br i1 %5, label %if.then1, label %if.else1 -if.else: - %9 = icmp eq i64 %0, 1 - br i1 %9, label %if.then2, label %if.else2 -if.then1: - %6 = inttoptr i64 %"#right##0" to i64* - %7 = load i64, i64* %6 - %8 = icmp eq i64 %3, %7 - ret i1 %8 -if.else1: - ret i1 0 -if.then2: - %10 = add i64 %"#left##0", -1 - %11 = inttoptr i64 %10 to double* - %12 = load double, double* %11 - %13 = and i64 %"#right##0", 1 - %14 = icmp eq i64 %13, 1 - br i1 %14, label %if.then3, label %if.else3 -if.else2: - ret i1 0 -if.then3: - %15 = add i64 %"#right##0", -1 - %16 = inttoptr i64 %15 to double* - %17 = load double, double* %16 - %18 = fcmp oeq double %12, %17 - ret i1 %18 -if.else3: - ret i1 0 -} - - -define external fastcc i64 @"multictr.number.float<0>"(double %"float_value##0") alwaysinline { -entry: - %0 = trunc i64 8 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to double* - store double %"float_value##0", double* %3 - %4 = or i64 %2, 1 - ret i64 %4 -} - - -define external fastcc {double, i1} @"multictr.number.float<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = and i64 %"#result##0", 1 - %1 = icmp eq i64 %0, 1 - br i1 %1, label %if.then, label %if.else -if.then: - %2 = add i64 %"#result##0", -1 - %3 = inttoptr i64 %2 to double* - %4 = load double, double* %3 - %5 = insertvalue {double, i1} undef, double %4, 0 - %6 = insertvalue {double, i1} %5, i1 1, 1 - ret {double, i1} %6 -if.else: - %7 = insertvalue {double, i1} undef, double undef, 0 - %8 = insertvalue {double, i1} %7, i1 0, 1 - ret {double, i1} %8 -} - - -define external fastcc {double, i1} @"multictr.number.float_value<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = and i64 %"#rec##0", 1 - %1 = icmp eq i64 %0, 1 - br i1 %1, label %if.then, label %if.else -if.then: - %2 = add i64 %"#rec##0", -1 - %3 = inttoptr i64 %2 to double* - %4 = load double, double* %3 - %5 = insertvalue {double, i1} undef, double %4, 0 - %6 = insertvalue {double, i1} %5, i1 1, 1 - ret {double, i1} %6 -if.else: - %7 = insertvalue {double, i1} undef, double undef, 0 - %8 = insertvalue {double, i1} %7, i1 0, 1 - ret {double, i1} %8 -} - - -define external fastcc {i64, i1} @"multictr.number.float_value<1>"(i64 %"#rec##0", double %"#field##0") alwaysinline { -entry: - %0 = and i64 %"#rec##0", 1 - %1 = icmp eq i64 %0, 1 - br i1 %1, label %if.then, label %if.else -if.then: - %2 = trunc i64 8 to i32 - %3 = tail call ccc i8* @wybe_malloc(i32 %2) - %4 = ptrtoint i8* %3 to i64 - %5 = add i64 %4, 1 - %6 = sub i64 %"#rec##0", 1 - %7 = inttoptr i64 %4 to i8* - %8 = inttoptr i64 %6 to i8* - %9 = trunc i64 8 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %7, i8* %8, i32 %9, i1 0) - %10 = add i64 %5, -1 - %11 = inttoptr i64 %10 to double* - store double %"#field##0", double* %11 - %12 = insertvalue {i64, i1} undef, i64 %5, 0 - %13 = insertvalue {i64, i1} %12, i1 1, 1 - ret {i64, i1} %13 -if.else: - %14 = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 - %15 = insertvalue {i64, i1} %14, i1 0, 1 - ret {i64, i1} %15 -} - - -define external fastcc i64 @"multictr.number.int<0>"(i64 %"int_value##0") alwaysinline { -entry: - %0 = trunc i64 8 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"int_value##0", i64* %3 - ret i64 %2 -} - - -define external fastcc {i64, i1} @"multictr.number.int<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = and i64 %"#result##0", 1 - %1 = icmp eq i64 %0, 0 - br i1 %1, label %if.then, label %if.else -if.then: - %2 = inttoptr i64 %"#result##0" to i64* - %3 = load i64, i64* %2 - %4 = insertvalue {i64, i1} undef, i64 %3, 0 - %5 = insertvalue {i64, i1} %4, i1 1, 1 - ret {i64, i1} %5 -if.else: - %6 = insertvalue {i64, i1} undef, i64 undef, 0 - %7 = insertvalue {i64, i1} %6, i1 0, 1 - ret {i64, i1} %7 -} - - -define external fastcc {i64, i1} @"multictr.number.int_value<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = and i64 %"#rec##0", 1 - %1 = icmp eq i64 %0, 0 - br i1 %1, label %if.then, label %if.else -if.then: - %2 = inttoptr i64 %"#rec##0" to i64* - %3 = load i64, i64* %2 - %4 = insertvalue {i64, i1} undef, i64 %3, 0 - %5 = insertvalue {i64, i1} %4, i1 1, 1 - ret {i64, i1} %5 -if.else: - %6 = insertvalue {i64, i1} undef, i64 undef, 0 - %7 = insertvalue {i64, i1} %6, i1 0, 1 - ret {i64, i1} %7 -} - - -define external fastcc {i64, i1} @"multictr.number.int_value<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = and i64 %"#rec##0", 1 - %1 = icmp eq i64 %0, 0 - br i1 %1, label %if.then, label %if.else -if.then: - %2 = trunc i64 8 to i32 - %3 = tail call ccc i8* @wybe_malloc(i32 %2) - %4 = ptrtoint i8* %3 to i64 - %5 = inttoptr i64 %4 to i8* - %6 = inttoptr i64 %"#rec##0" to i8* - %7 = trunc i64 8 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %5, i8* %6, i32 %7, i1 0) - %8 = inttoptr i64 %4 to i64* - store i64 %"#field##0", i64* %8 - %9 = insertvalue {i64, i1} undef, i64 %4, 0 - %10 = insertvalue {i64, i1} %9, i1 1, 1 - ret {i64, i1} %10 -if.else: - %11 = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 - %12 = insertvalue {i64, i1} %11, i1 0, 1 - ret {i64, i1} %12 -} - - -define external fastcc i1 @"multictr.number.~=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = tail call fastcc i1 @"multictr.number.=<0>"(i64 %"#left##0", i64 %"#right##0") - %1 = xor i1 %0, 1 - ret i1 %1 +source_filename = "!ROOT!/final-dump/multictr.wybe" +target triple ???? + + +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc i1 @"multictr.number.=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#8##0" = and i64 %"#left##0", 1 + %"tmp#9##0" = icmp eq i64 %"tmp#8##0", 0 + br i1 %"tmp#9##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#23##0" = inttoptr i64 %"#left##0" to ptr + %"#left#int_value##0" = load i64, ptr %"tmp#23##0" + %"tmp#19##0" = and i64 %"#right##0", 1 + %"tmp#20##0" = icmp eq i64 %"tmp#19##0", 0 + br i1 %"tmp#20##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#24##0" = inttoptr i64 %"#right##0" to ptr + %"#right#int_value##0" = load i64, ptr %"tmp#24##0" + %"tmp#25##0" = icmp eq i64 %"#left#int_value##0", %"#right#int_value##0" + ret i1 %"tmp#25##0" +if.else.1: + ret i1 0 +if.else.0: + %"tmp#12##0" = icmp eq i64 %"tmp#8##0", 1 + br i1 %"tmp#12##0", label %if.then.2, label %if.else.2 +if.then.2: + %"tmp#26##0" = add i64 %"#left##0", -1 + %"tmp#27##0" = inttoptr i64 %"tmp#26##0" to ptr + %"#left#float_value##0" = load double, ptr %"tmp#27##0" + %"tmp#14##0" = and i64 %"#right##0", 1 + %"tmp#15##0" = icmp eq i64 %"tmp#14##0", 1 + br i1 %"tmp#15##0", label %if.then.3, label %if.else.3 +if.then.3: + %"tmp#28##0" = add i64 %"#right##0", -1 + %"tmp#29##0" = inttoptr i64 %"tmp#28##0" to ptr + %"#right#float_value##0" = load double, ptr %"tmp#29##0" + %"tmp#30##0" = fcmp oeq double %"#left#float_value##0", %"#right#float_value##0" + ret i1 %"tmp#30##0" +if.else.3: + ret i1 0 +if.else.2: + ret i1 0 +} + +define external fastcc i64 @"multictr.number.float<0>"(double %"float_value##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 8) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store double %"float_value##0", ptr %"tmp#1##0" + %"tmp#2##0" = or i64 %"#rec##0", 1 + ret i64 %"tmp#2##0" +} + +define external fastcc {double, i1} @"multictr.number.float<1>"(i64 %"#result##0") { + %"tmp#1##0" = and i64 %"#result##0", 1 + %"tmp#0##0" = icmp eq i64 %"tmp#1##0", 1 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = add i64 %"#result##0", -1 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = load double, ptr %"tmp#3##0" + %"tmp#5##0" = insertvalue {double, i1} undef, double %"tmp#4##0", 0 + %"tmp#6##0" = insertvalue {double, i1} %"tmp#5##0", i1 1, 1 + ret {double, i1} %"tmp#6##0" +if.else.0: + %"tmp#7##0" = insertvalue {double, i1} undef, double undef, 0 + %"tmp#8##0" = insertvalue {double, i1} %"tmp#7##0", i1 0, 1 + ret {double, i1} %"tmp#8##0" +} + +define external fastcc {double, i1} @"multictr.number.float_value<0>"(i64 %"#rec##0") { + %"tmp#1##0" = and i64 %"#rec##0", 1 + %"tmp#0##0" = icmp eq i64 %"tmp#1##0", 1 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = add i64 %"#rec##0", -1 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = load double, ptr %"tmp#3##0" + %"tmp#5##0" = insertvalue {double, i1} undef, double %"tmp#4##0", 0 + %"tmp#6##0" = insertvalue {double, i1} %"tmp#5##0", i1 1, 1 + ret {double, i1} %"tmp#6##0" +if.else.0: + %"tmp#7##0" = insertvalue {double, i1} undef, double undef, 0 + %"tmp#8##0" = insertvalue {double, i1} %"tmp#7##0", i1 0, 1 + ret {double, i1} %"tmp#8##0" +} + +define external fastcc {i64, i1} @"multictr.number.float_value<1>"(i64 %"#rec##0", double %"#field##0") { + %"tmp#1##0" = and i64 %"#rec##0", 1 + %"tmp#0##0" = icmp eq i64 %"tmp#1##0", 1 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = sub i64 %"#rec##0", 1 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = call ccc ptr @wybe_malloc(i32 8) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#4##0", ptr %"tmp#3##0", i64 8, i1 0) + %"tmp#5##0" = ptrtoint ptr %"tmp#4##0" to i64 + %"tmp#6##0" = add i64 %"tmp#5##0", 1 + %"tmp#7##0" = add i64 %"tmp#6##0", -1 + %"tmp#8##0" = inttoptr i64 %"tmp#7##0" to ptr + store double %"#field##0", ptr %"tmp#8##0" + %"tmp#9##0" = insertvalue {i64, i1} undef, i64 %"tmp#6##0", 0 + %"tmp#10##0" = insertvalue {i64, i1} %"tmp#9##0", i1 1, 1 + ret {i64, i1} %"tmp#10##0" +if.else.0: + %"tmp#11##0" = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 + %"tmp#12##0" = insertvalue {i64, i1} %"tmp#11##0", i1 0, 1 + ret {i64, i1} %"tmp#12##0" +} + +define external fastcc i64 @"multictr.number.int<0>"(i64 %"int_value##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 8) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"int_value##0", ptr %"tmp#1##0" + ret i64 %"#rec##0" +} + +define external fastcc {i64, i1} @"multictr.number.int<1>"(i64 %"#result##0") { + %"tmp#1##0" = and i64 %"#result##0", 1 + %"tmp#0##0" = icmp eq i64 %"tmp#1##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = inttoptr i64 %"#result##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#2##0" + %"tmp#4##0" = insertvalue {i64, i1} undef, i64 %"tmp#3##0", 0 + %"tmp#5##0" = insertvalue {i64, i1} %"tmp#4##0", i1 1, 1 + ret {i64, i1} %"tmp#5##0" +if.else.0: + %"tmp#6##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#7##0" = insertvalue {i64, i1} %"tmp#6##0", i1 0, 1 + ret {i64, i1} %"tmp#7##0" +} + +define external fastcc {i64, i1} @"multictr.number.int_value<0>"(i64 %"#rec##0") { + %"tmp#1##0" = and i64 %"#rec##0", 1 + %"tmp#0##0" = icmp eq i64 %"tmp#1##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#2##0" + %"tmp#4##0" = insertvalue {i64, i1} undef, i64 %"tmp#3##0", 0 + %"tmp#5##0" = insertvalue {i64, i1} %"tmp#4##0", i1 1, 1 + ret {i64, i1} %"tmp#5##0" +if.else.0: + %"tmp#6##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#7##0" = insertvalue {i64, i1} %"tmp#6##0", i1 0, 1 + ret {i64, i1} %"tmp#7##0" +} + +define external fastcc {i64, i1} @"multictr.number.int_value<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#1##0" = and i64 %"#rec##0", 1 + %"tmp#0##0" = icmp eq i64 %"tmp#1##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#3##0" = call ccc ptr @wybe_malloc(i32 8) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#3##0", ptr %"tmp#2##0", i64 8, i1 0) + %"tmp#4##0" = ptrtoint ptr %"tmp#3##0" to i64 + %"tmp#5##0" = inttoptr i64 %"tmp#4##0" to ptr + store i64 %"#field##0", ptr %"tmp#5##0" + %"tmp#6##0" = insertvalue {i64, i1} undef, i64 %"tmp#4##0", 0 + %"tmp#7##0" = insertvalue {i64, i1} %"tmp#6##0", i1 1, 1 + ret {i64, i1} %"tmp#7##0" +if.else.0: + %"tmp#8##0" = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 + %"tmp#9##0" = insertvalue {i64, i1} %"tmp#8##0", i1 0, 1 + ret {i64, i1} %"tmp#9##0" +} + +define external fastcc i1 @"multictr.number.~=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#0##0" = tail call fastcc i1 @"multictr.number.=<0>"(i64 %"#left##0", i64 %"#right##0") + %"tmp#1##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#1##0" } + -------------------------------------------------- Module multictr.perhaps representation : 64 bit unsigned @@ -5983,7 +5705,7 @@ proc content > public {inline} (0 calls) content([#rec##0:multictr.perhaps], ?#rec##2:multictr.perhaps, #field##0:multictr.maybe_int)<{}; {}; {}>: AliasPairs: [] InterestingCallProperties: [] - foreign llvm move(~#field##0:multictr.perhaps, ?#rec##2:multictr.perhaps) @multictr:nn:nn + foreign lpvm cast(~#field##0:multictr.maybe_int, ?#rec##2:multictr.perhaps) @multictr:nn:nn proc perhaps > public {inline} (0 calls) @@ -5991,7 +5713,7 @@ proc perhaps > public {inline} (0 calls) perhaps(content##0:multictr.maybe_int, ?#result##2:multictr.perhaps)<{}; {}; {}>: AliasPairs: [] InterestingCallProperties: [] - foreign llvm move(~content##0:multictr.perhaps, ?#result##2:multictr.perhaps) @multictr:nn:nn + foreign lpvm cast(~content##0:multictr.maybe_int, ?#result##2:multictr.perhaps) @multictr:nn:nn proc perhaps > public {inline} (0 calls) 1: multictr.perhaps.perhaps<1> perhaps(?content##0:multictr.maybe_int, #result##0:multictr.perhaps)<{}; {}; {}>: @@ -6010,55 +5732,42 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'multictr.perhaps' - - +source_filename = "!ROOT!/final-dump/multictr.wybe" +target triple ???? -declare external ccc i8* @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i1 @"multictr.perhaps.=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = icmp eq i64 %"#left##0", %"#right##0" - ret i1 %0 +define external fastcc i1 @"multictr.perhaps.=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#1##0" = icmp eq i64 %"#left##0", %"#right##0" + ret i1 %"tmp#1##0" } - -define external fastcc i64 @"multictr.perhaps.content<0>"(i64 %"#rec##0") alwaysinline { -entry: - ret i64 %"#rec##0" +define external fastcc i64 @"multictr.perhaps.content<0>"(i64 %"#rec##0") { + ret i64 %"#rec##0" } - -define external fastcc i64 @"multictr.perhaps.content<1>"(i64 %"#field##0") alwaysinline { -entry: - ret i64 %"#field##0" +define external fastcc i64 @"multictr.perhaps.content<1>"(i64 %"#field##0") { + ret i64 %"#field##0" } - -define external fastcc i64 @"multictr.perhaps.perhaps<0>"(i64 %"content##0") alwaysinline { -entry: - ret i64 %"content##0" +define external fastcc i64 @"multictr.perhaps.perhaps<0>"(i64 %"content##0") { + ret i64 %"content##0" } - -define external fastcc i64 @"multictr.perhaps.perhaps<1>"(i64 %"#result##0") alwaysinline { -entry: - ret i64 %"#result##0" +define external fastcc i64 @"multictr.perhaps.perhaps<1>"(i64 %"#result##0") { + ret i64 %"#result##0" } - -define external fastcc i1 @"multictr.perhaps.~=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = icmp eq i64 %"#left##0", %"#right##0" - %1 = xor i1 %0, 1 - ret i1 %1 +define external fastcc i1 @"multictr.perhaps.~=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#0##0" = icmp eq i64 %"#left##0", %"#right##0" + %"tmp#3##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#3##0" } + -------------------------------------------------- Module multictr.rank representation : 4 bit unsigned @@ -6206,112 +5915,81 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'multictr.rank' +source_filename = "!ROOT!/final-dump/multictr.wybe" +target triple ???? - - - -declare external ccc i8* @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i1 @"multictr.rank.=<0>"(i4 %"#left##0", i4 %"#right##0") alwaysinline { -entry: - %0 = icmp eq i4 %"#left##0", %"#right##0" - ret i1 %0 +define external fastcc i1 @"multictr.rank.=<0>"(i4 %"#left##0", i4 %"#right##0") { + %"tmp#1##0" = icmp eq i4 %"#left##0", %"#right##0" + ret i1 %"tmp#1##0" } - -define external fastcc i4 @"multictr.rank.ace<0>"() alwaysinline { -entry: - ret i4 12 +define external fastcc i4 @"multictr.rank.ace<0>"() { + ret i4 12 } - -define external fastcc i4 @"multictr.rank.jack<0>"() alwaysinline { -entry: - ret i4 9 +define external fastcc i4 @"multictr.rank.jack<0>"() { + ret i4 9 } - -define external fastcc i4 @"multictr.rank.king<0>"() alwaysinline { -entry: - ret i4 11 +define external fastcc i4 @"multictr.rank.king<0>"() { + ret i4 11 } - -define external fastcc i4 @"multictr.rank.queen<0>"() alwaysinline { -entry: - ret i4 10 +define external fastcc i4 @"multictr.rank.queen<0>"() { + ret i4 10 } - -define external fastcc i4 @"multictr.rank.r10<0>"() alwaysinline { -entry: - ret i4 8 +define external fastcc i4 @"multictr.rank.r10<0>"() { + ret i4 8 } - -define external fastcc i4 @"multictr.rank.r2<0>"() alwaysinline { -entry: - ret i4 0 +define external fastcc i4 @"multictr.rank.r2<0>"() { + ret i4 0 } - -define external fastcc i4 @"multictr.rank.r3<0>"() alwaysinline { -entry: - ret i4 1 +define external fastcc i4 @"multictr.rank.r3<0>"() { + ret i4 1 } - -define external fastcc i4 @"multictr.rank.r4<0>"() alwaysinline { -entry: - ret i4 2 +define external fastcc i4 @"multictr.rank.r4<0>"() { + ret i4 2 } - -define external fastcc i4 @"multictr.rank.r5<0>"() alwaysinline { -entry: - ret i4 3 +define external fastcc i4 @"multictr.rank.r5<0>"() { + ret i4 3 } - -define external fastcc i4 @"multictr.rank.r6<0>"() alwaysinline { -entry: - ret i4 4 +define external fastcc i4 @"multictr.rank.r6<0>"() { + ret i4 4 } - -define external fastcc i4 @"multictr.rank.r7<0>"() alwaysinline { -entry: - ret i4 5 +define external fastcc i4 @"multictr.rank.r7<0>"() { + ret i4 5 } - -define external fastcc i4 @"multictr.rank.r8<0>"() alwaysinline { -entry: - ret i4 6 +define external fastcc i4 @"multictr.rank.r8<0>"() { + ret i4 6 } - -define external fastcc i4 @"multictr.rank.r9<0>"() alwaysinline { -entry: - ret i4 7 +define external fastcc i4 @"multictr.rank.r9<0>"() { + ret i4 7 } - -define external fastcc i1 @"multictr.rank.~=<0>"(i4 %"#left##0", i4 %"#right##0") alwaysinline { -entry: - %0 = icmp eq i4 %"#left##0", %"#right##0" - %1 = xor i1 %0, 1 - ret i1 %1 +define external fastcc i1 @"multictr.rank.~=<0>"(i4 %"#left##0", i4 %"#right##0") { + %"tmp#0##0" = icmp eq i4 %"#left##0", %"#right##0" + %"tmp#3##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#3##0" } + -------------------------------------------------- Module multictr.simple - representation : address + representation : pointer public submods : public resources: public procs : multictr.simple.=<0> @@ -6644,360 +6322,323 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'multictr.simple' - - - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i1 @"multictr.simple.=<0>"(i64 %"#left##0", i64 %"#right##0") { -entry: - %0 = icmp ne i64 %"#left##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = and i64 %"#left##0", 1 - %2 = icmp eq i64 %1, 0 - br i1 %2, label %if.then1, label %if.else1 -if.else: - %29 = icmp eq i64 %"#right##0", 0 - ret i1 %29 -if.then1: - %3 = inttoptr i64 %"#left##0" to i64* - %4 = load i64, i64* %3 - %5 = icmp ne i64 %"#right##0", 0 - br i1 %5, label %if.then2, label %if.else2 -if.else1: - %11 = icmp eq i64 %1, 1 - br i1 %11, label %if.then4, label %if.else4 -if.then2: - %6 = and i64 %"#right##0", 1 - %7 = icmp eq i64 %6, 0 - br i1 %7, label %if.then3, label %if.else3 -if.else2: - ret i1 0 -if.then3: - %8 = inttoptr i64 %"#right##0" to i64* - %9 = load i64, i64* %8 - %10 = icmp eq i64 %4, %9 - ret i1 %10 -if.else3: - ret i1 0 -if.then4: - %12 = add i64 %"#left##0", -1 - %13 = inttoptr i64 %12 to i64* - %14 = load i64, i64* %13 - %15 = add i64 %"#left##0", 7 - %16 = inttoptr i64 %15 to i64* - %17 = load i64, i64* %16 - %18 = icmp ne i64 %"#right##0", 0 - br i1 %18, label %if.then5, label %if.else5 -if.else4: - ret i1 0 -if.then5: - %19 = and i64 %"#right##0", 1 - %20 = icmp eq i64 %19, 1 - br i1 %20, label %if.then6, label %if.else6 -if.else5: - ret i1 0 -if.then6: - %21 = add i64 %"#right##0", -1 - %22 = inttoptr i64 %21 to i64* - %23 = load i64, i64* %22 - %24 = add i64 %"#right##0", 7 - %25 = inttoptr i64 %24 to i64* - %26 = load i64, i64* %25 - %27 = icmp eq i64 %14, %23 - br i1 %27, label %if.then7, label %if.else7 -if.else6: - ret i1 0 -if.then7: - %28 = icmp eq i64 %17, %26 - ret i1 %28 -if.else7: - ret i1 0 -} - - -define external fastcc i64 @"multictr.simple.one<0>"(i64 %"one_field##0") alwaysinline { -entry: - %0 = trunc i64 8 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"one_field##0", i64* %3 - ret i64 %2 -} - - -define external fastcc {i64, i1} @"multictr.simple.one<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#result##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = and i64 %"#result##0", 1 - %2 = icmp eq i64 %1, 0 - br i1 %2, label %if.then1, label %if.else1 -if.else: - %9 = insertvalue {i64, i1} undef, i64 undef, 0 - %10 = insertvalue {i64, i1} %9, i1 0, 1 - ret {i64, i1} %10 -if.then1: - %3 = inttoptr i64 %"#result##0" to i64* - %4 = load i64, i64* %3 - %5 = insertvalue {i64, i1} undef, i64 %4, 0 - %6 = insertvalue {i64, i1} %5, i1 1, 1 - ret {i64, i1} %6 -if.else1: - %7 = insertvalue {i64, i1} undef, i64 undef, 0 - %8 = insertvalue {i64, i1} %7, i1 0, 1 - ret {i64, i1} %8 -} - - -define external fastcc {i64, i1} @"multictr.simple.one_field<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = and i64 %"#rec##0", 1 - %2 = icmp eq i64 %1, 0 - br i1 %2, label %if.then1, label %if.else1 -if.else: - %9 = insertvalue {i64, i1} undef, i64 undef, 0 - %10 = insertvalue {i64, i1} %9, i1 0, 1 - ret {i64, i1} %10 -if.then1: - %3 = inttoptr i64 %"#rec##0" to i64* - %4 = load i64, i64* %3 - %5 = insertvalue {i64, i1} undef, i64 %4, 0 - %6 = insertvalue {i64, i1} %5, i1 1, 1 - ret {i64, i1} %6 -if.else1: - %7 = insertvalue {i64, i1} undef, i64 undef, 0 - %8 = insertvalue {i64, i1} %7, i1 0, 1 - ret {i64, i1} %8 -} - - -define external fastcc {i64, i1} @"multictr.simple.one_field<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = and i64 %"#rec##0", 1 - %2 = icmp eq i64 %1, 0 - br i1 %2, label %if.then1, label %if.else1 -if.else: - %14 = insertvalue {i64, i1} undef, i64 0, 0 - %15 = insertvalue {i64, i1} %14, i1 0, 1 - ret {i64, i1} %15 -if.then1: - %3 = trunc i64 8 to i32 - %4 = tail call ccc i8* @wybe_malloc(i32 %3) - %5 = ptrtoint i8* %4 to i64 - %6 = inttoptr i64 %5 to i8* - %7 = inttoptr i64 %"#rec##0" to i8* - %8 = trunc i64 8 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %6, i8* %7, i32 %8, i1 0) - %9 = inttoptr i64 %5 to i64* - store i64 %"#field##0", i64* %9 - %10 = insertvalue {i64, i1} undef, i64 %5, 0 - %11 = insertvalue {i64, i1} %10, i1 1, 1 - ret {i64, i1} %11 -if.else1: - %12 = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 - %13 = insertvalue {i64, i1} %12, i1 0, 1 - ret {i64, i1} %13 -} - - -define external fastcc i64 @"multictr.simple.two<0>"(i64 %"two_field1##0", i64 %"two_field2##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"two_field1##0", i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"two_field2##0", i64* %5 - %6 = or i64 %2, 1 - ret i64 %6 -} - - -define external fastcc {i64, i64, i1} @"multictr.simple.two<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#result##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = and i64 %"#result##0", 1 - %2 = icmp eq i64 %1, 1 - br i1 %2, label %if.then1, label %if.else1 -if.else: - %15 = insertvalue {i64, i64, i1} undef, i64 undef, 0 - %16 = insertvalue {i64, i64, i1} %15, i64 undef, 1 - %17 = insertvalue {i64, i64, i1} %16, i1 0, 2 - ret {i64, i64, i1} %17 -if.then1: - %3 = add i64 %"#result##0", -1 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = add i64 %"#result##0", 7 - %7 = inttoptr i64 %6 to i64* - %8 = load i64, i64* %7 - %9 = insertvalue {i64, i64, i1} undef, i64 %5, 0 - %10 = insertvalue {i64, i64, i1} %9, i64 %8, 1 - %11 = insertvalue {i64, i64, i1} %10, i1 1, 2 - ret {i64, i64, i1} %11 -if.else1: - %12 = insertvalue {i64, i64, i1} undef, i64 undef, 0 - %13 = insertvalue {i64, i64, i1} %12, i64 undef, 1 - %14 = insertvalue {i64, i64, i1} %13, i1 0, 2 - ret {i64, i64, i1} %14 -} - - -define external fastcc {i64, i1} @"multictr.simple.two_field1<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = and i64 %"#rec##0", 1 - %2 = icmp eq i64 %1, 1 - br i1 %2, label %if.then1, label %if.else1 -if.else: - %10 = insertvalue {i64, i1} undef, i64 undef, 0 - %11 = insertvalue {i64, i1} %10, i1 0, 1 - ret {i64, i1} %11 -if.then1: - %3 = add i64 %"#rec##0", -1 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = insertvalue {i64, i1} undef, i64 %5, 0 - %7 = insertvalue {i64, i1} %6, i1 1, 1 - ret {i64, i1} %7 -if.else1: - %8 = insertvalue {i64, i1} undef, i64 undef, 0 - %9 = insertvalue {i64, i1} %8, i1 0, 1 - ret {i64, i1} %9 -} - - -define external fastcc {i64, i1} @"multictr.simple.two_field1<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = and i64 %"#rec##0", 1 - %2 = icmp eq i64 %1, 1 - br i1 %2, label %if.then1, label %if.else1 -if.else: - %17 = insertvalue {i64, i1} undef, i64 0, 0 - %18 = insertvalue {i64, i1} %17, i1 0, 1 - ret {i64, i1} %18 -if.then1: - %3 = trunc i64 16 to i32 - %4 = tail call ccc i8* @wybe_malloc(i32 %3) - %5 = ptrtoint i8* %4 to i64 - %6 = add i64 %5, 1 - %7 = sub i64 %"#rec##0", 1 - %8 = inttoptr i64 %5 to i8* - %9 = inttoptr i64 %7 to i8* - %10 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %8, i8* %9, i32 %10, i1 0) - %11 = add i64 %6, -1 - %12 = inttoptr i64 %11 to i64* - store i64 %"#field##0", i64* %12 - %13 = insertvalue {i64, i1} undef, i64 %6, 0 - %14 = insertvalue {i64, i1} %13, i1 1, 1 - ret {i64, i1} %14 -if.else1: - %15 = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 - %16 = insertvalue {i64, i1} %15, i1 0, 1 - ret {i64, i1} %16 -} - - -define external fastcc {i64, i1} @"multictr.simple.two_field2<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = and i64 %"#rec##0", 1 - %2 = icmp eq i64 %1, 1 - br i1 %2, label %if.then1, label %if.else1 -if.else: - %10 = insertvalue {i64, i1} undef, i64 undef, 0 - %11 = insertvalue {i64, i1} %10, i1 0, 1 - ret {i64, i1} %11 -if.then1: - %3 = add i64 %"#rec##0", 7 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = insertvalue {i64, i1} undef, i64 %5, 0 - %7 = insertvalue {i64, i1} %6, i1 1, 1 - ret {i64, i1} %7 -if.else1: - %8 = insertvalue {i64, i1} undef, i64 undef, 0 - %9 = insertvalue {i64, i1} %8, i1 0, 1 - ret {i64, i1} %9 -} - - -define external fastcc {i64, i1} @"multictr.simple.two_field2<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = and i64 %"#rec##0", 1 - %2 = icmp eq i64 %1, 1 - br i1 %2, label %if.then1, label %if.else1 -if.else: - %17 = insertvalue {i64, i1} undef, i64 0, 0 - %18 = insertvalue {i64, i1} %17, i1 0, 1 - ret {i64, i1} %18 -if.then1: - %3 = trunc i64 16 to i32 - %4 = tail call ccc i8* @wybe_malloc(i32 %3) - %5 = ptrtoint i8* %4 to i64 - %6 = add i64 %5, 1 - %7 = sub i64 %"#rec##0", 1 - %8 = inttoptr i64 %5 to i8* - %9 = inttoptr i64 %7 to i8* - %10 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %8, i8* %9, i32 %10, i1 0) - %11 = add i64 %6, 7 - %12 = inttoptr i64 %11 to i64* - store i64 %"#field##0", i64* %12 - %13 = insertvalue {i64, i1} undef, i64 %6, 0 - %14 = insertvalue {i64, i1} %13, i1 1, 1 - ret {i64, i1} %14 -if.else1: - %15 = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 - %16 = insertvalue {i64, i1} %15, i1 0, 1 - ret {i64, i1} %16 -} - - -define external fastcc i64 @"multictr.simple.zero<0>"() alwaysinline { -entry: - ret i64 0 -} - - -define external fastcc i1 @"multictr.simple.~=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = tail call fastcc i1 @"multictr.simple.=<0>"(i64 %"#left##0", i64 %"#right##0") - %1 = xor i1 %0, 1 - ret i1 %1 +source_filename = "!ROOT!/final-dump/multictr.wybe" +target triple ???? + + +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc i1 @"multictr.simple.=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#0##0" = icmp ne i64 %"#left##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#11##0" = and i64 %"#left##0", 1 + %"tmp#12##0" = icmp eq i64 %"tmp#11##0", 0 + br i1 %"tmp#12##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#31##0" = inttoptr i64 %"#left##0" to ptr + %"#left#one_field##0" = load i64, ptr %"tmp#31##0" + %"tmp#26##0" = icmp ne i64 %"#right##0", 0 + br i1 %"tmp#26##0", label %if.then.2, label %if.else.2 +if.then.2: + %"tmp#27##0" = and i64 %"#right##0", 1 + %"tmp#28##0" = icmp eq i64 %"tmp#27##0", 0 + br i1 %"tmp#28##0", label %if.then.3, label %if.else.3 +if.then.3: + %"tmp#32##0" = inttoptr i64 %"#right##0" to ptr + %"#right#one_field##0" = load i64, ptr %"tmp#32##0" + %"tmp#33##0" = icmp eq i64 %"#left#one_field##0", %"#right#one_field##0" + ret i1 %"tmp#33##0" +if.else.3: + ret i1 0 +if.else.2: + ret i1 0 +if.else.1: + %"tmp#16##0" = icmp eq i64 %"tmp#11##0", 1 + br i1 %"tmp#16##0", label %if.then.4, label %if.else.4 +if.then.4: + %"tmp#34##0" = add i64 %"#left##0", -1 + %"tmp#35##0" = inttoptr i64 %"tmp#34##0" to ptr + %"#left#two_field1##0" = load i64, ptr %"tmp#35##0" + %"tmp#36##0" = add i64 %"#left##0", 7 + %"tmp#37##0" = inttoptr i64 %"tmp#36##0" to ptr + %"#left#two_field2##0" = load i64, ptr %"tmp#37##0" + %"tmp#18##0" = icmp ne i64 %"#right##0", 0 + br i1 %"tmp#18##0", label %if.then.5, label %if.else.5 +if.then.5: + %"tmp#19##0" = and i64 %"#right##0", 1 + %"tmp#20##0" = icmp eq i64 %"tmp#19##0", 1 + br i1 %"tmp#20##0", label %if.then.6, label %if.else.6 +if.then.6: + %"tmp#38##0" = add i64 %"#right##0", -1 + %"tmp#39##0" = inttoptr i64 %"tmp#38##0" to ptr + %"#right#two_field1##0" = load i64, ptr %"tmp#39##0" + %"tmp#40##0" = add i64 %"#right##0", 7 + %"tmp#41##0" = inttoptr i64 %"tmp#40##0" to ptr + %"#right#two_field2##0" = load i64, ptr %"tmp#41##0" + %"tmp#5##0" = icmp eq i64 %"#left#two_field1##0", %"#right#two_field1##0" + br i1 %"tmp#5##0", label %if.then.7, label %if.else.7 +if.then.7: + %"tmp#42##0" = icmp eq i64 %"#left#two_field2##0", %"#right#two_field2##0" + ret i1 %"tmp#42##0" +if.else.7: + ret i1 0 +if.else.6: + ret i1 0 +if.else.5: + ret i1 0 +if.else.4: + ret i1 0 +if.else.0: + %"tmp#43##0" = icmp eq i64 %"#right##0", 0 + ret i1 %"tmp#43##0" +} + +define external fastcc i64 @"multictr.simple.one<0>"(i64 %"one_field##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 8) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"one_field##0", ptr %"tmp#1##0" + ret i64 %"#rec##0" +} + +define external fastcc {i64, i1} @"multictr.simple.one<1>"(i64 %"#result##0") { + %"tmp#0##0" = icmp ne i64 %"#result##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = and i64 %"#result##0", 1 + %"tmp#1##0" = icmp eq i64 %"tmp#2##0", 0 + br i1 %"tmp#1##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#3##0" = inttoptr i64 %"#result##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#3##0" + %"tmp#5##0" = insertvalue {i64, i1} undef, i64 %"tmp#4##0", 0 + %"tmp#6##0" = insertvalue {i64, i1} %"tmp#5##0", i1 1, 1 + ret {i64, i1} %"tmp#6##0" +if.else.1: + %"tmp#7##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#8##0" = insertvalue {i64, i1} %"tmp#7##0", i1 0, 1 + ret {i64, i1} %"tmp#8##0" +if.else.0: + %"tmp#9##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#10##0" = insertvalue {i64, i1} %"tmp#9##0", i1 0, 1 + ret {i64, i1} %"tmp#10##0" +} + +define external fastcc {i64, i1} @"multictr.simple.one_field<0>"(i64 %"#rec##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = and i64 %"#rec##0", 1 + %"tmp#1##0" = icmp eq i64 %"tmp#2##0", 0 + br i1 %"tmp#1##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#3##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#3##0" + %"tmp#5##0" = insertvalue {i64, i1} undef, i64 %"tmp#4##0", 0 + %"tmp#6##0" = insertvalue {i64, i1} %"tmp#5##0", i1 1, 1 + ret {i64, i1} %"tmp#6##0" +if.else.1: + %"tmp#7##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#8##0" = insertvalue {i64, i1} %"tmp#7##0", i1 0, 1 + ret {i64, i1} %"tmp#8##0" +if.else.0: + %"tmp#9##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#10##0" = insertvalue {i64, i1} %"tmp#9##0", i1 0, 1 + ret {i64, i1} %"tmp#10##0" +} + +define external fastcc {i64, i1} @"multictr.simple.one_field<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = and i64 %"#rec##0", 1 + %"tmp#1##0" = icmp eq i64 %"tmp#2##0", 0 + br i1 %"tmp#1##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#3##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#4##0" = call ccc ptr @wybe_malloc(i32 8) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#4##0", ptr %"tmp#3##0", i64 8, i1 0) + %"tmp#5##0" = ptrtoint ptr %"tmp#4##0" to i64 + %"tmp#6##0" = inttoptr i64 %"tmp#5##0" to ptr + store i64 %"#field##0", ptr %"tmp#6##0" + %"tmp#7##0" = insertvalue {i64, i1} undef, i64 %"tmp#5##0", 0 + %"tmp#8##0" = insertvalue {i64, i1} %"tmp#7##0", i1 1, 1 + ret {i64, i1} %"tmp#8##0" +if.else.1: + %"tmp#9##0" = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 + %"tmp#10##0" = insertvalue {i64, i1} %"tmp#9##0", i1 0, 1 + ret {i64, i1} %"tmp#10##0" +if.else.0: + %"tmp#11##0" = insertvalue {i64, i1} undef, i64 0, 0 + %"tmp#12##0" = insertvalue {i64, i1} %"tmp#11##0", i1 0, 1 + ret {i64, i1} %"tmp#12##0" +} + +define external fastcc i64 @"multictr.simple.two<0>"(i64 %"two_field1##0", i64 %"two_field2##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 16) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"two_field1##0", ptr %"tmp#1##0" + %"tmp#2##0" = add i64 %"#rec##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"two_field2##0", ptr %"tmp#3##0" + %"tmp#4##0" = or i64 %"#rec##0", 1 + ret i64 %"tmp#4##0" +} + +define external fastcc {i64, i64, i1} @"multictr.simple.two<1>"(i64 %"#result##0") { + %"tmp#0##0" = icmp ne i64 %"#result##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = and i64 %"#result##0", 1 + %"tmp#1##0" = icmp eq i64 %"tmp#2##0", 1 + br i1 %"tmp#1##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#3##0" = add i64 %"#result##0", -1 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#4##0" + %"tmp#6##0" = add i64 %"#result##0", 7 + %"tmp#7##0" = inttoptr i64 %"tmp#6##0" to ptr + %"tmp#8##0" = load i64, ptr %"tmp#7##0" + %"tmp#9##0" = insertvalue {i64, i64, i1} undef, i64 %"tmp#5##0", 0 + %"tmp#10##0" = insertvalue {i64, i64, i1} %"tmp#9##0", i64 %"tmp#8##0", 1 + %"tmp#11##0" = insertvalue {i64, i64, i1} %"tmp#10##0", i1 1, 2 + ret {i64, i64, i1} %"tmp#11##0" +if.else.1: + %"tmp#12##0" = insertvalue {i64, i64, i1} undef, i64 undef, 0 + %"tmp#13##0" = insertvalue {i64, i64, i1} %"tmp#12##0", i64 undef, 1 + %"tmp#14##0" = insertvalue {i64, i64, i1} %"tmp#13##0", i1 0, 2 + ret {i64, i64, i1} %"tmp#14##0" +if.else.0: + %"tmp#15##0" = insertvalue {i64, i64, i1} undef, i64 undef, 0 + %"tmp#16##0" = insertvalue {i64, i64, i1} %"tmp#15##0", i64 undef, 1 + %"tmp#17##0" = insertvalue {i64, i64, i1} %"tmp#16##0", i1 0, 2 + ret {i64, i64, i1} %"tmp#17##0" +} + +define external fastcc {i64, i1} @"multictr.simple.two_field1<0>"(i64 %"#rec##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = and i64 %"#rec##0", 1 + %"tmp#1##0" = icmp eq i64 %"tmp#2##0", 1 + br i1 %"tmp#1##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#3##0" = add i64 %"#rec##0", -1 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#4##0" + %"tmp#6##0" = insertvalue {i64, i1} undef, i64 %"tmp#5##0", 0 + %"tmp#7##0" = insertvalue {i64, i1} %"tmp#6##0", i1 1, 1 + ret {i64, i1} %"tmp#7##0" +if.else.1: + %"tmp#8##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#9##0" = insertvalue {i64, i1} %"tmp#8##0", i1 0, 1 + ret {i64, i1} %"tmp#9##0" +if.else.0: + %"tmp#10##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#11##0" = insertvalue {i64, i1} %"tmp#10##0", i1 0, 1 + ret {i64, i1} %"tmp#11##0" +} + +define external fastcc {i64, i1} @"multictr.simple.two_field1<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = and i64 %"#rec##0", 1 + %"tmp#1##0" = icmp eq i64 %"tmp#2##0", 1 + br i1 %"tmp#1##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#3##0" = sub i64 %"#rec##0", 1 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + %"tmp#5##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#5##0", ptr %"tmp#4##0", i64 16, i1 0) + %"tmp#6##0" = ptrtoint ptr %"tmp#5##0" to i64 + %"tmp#7##0" = add i64 %"tmp#6##0", 1 + %"tmp#8##0" = add i64 %"tmp#7##0", -1 + %"tmp#9##0" = inttoptr i64 %"tmp#8##0" to ptr + store i64 %"#field##0", ptr %"tmp#9##0" + %"tmp#10##0" = insertvalue {i64, i1} undef, i64 %"tmp#7##0", 0 + %"tmp#11##0" = insertvalue {i64, i1} %"tmp#10##0", i1 1, 1 + ret {i64, i1} %"tmp#11##0" +if.else.1: + %"tmp#12##0" = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 + %"tmp#13##0" = insertvalue {i64, i1} %"tmp#12##0", i1 0, 1 + ret {i64, i1} %"tmp#13##0" +if.else.0: + %"tmp#14##0" = insertvalue {i64, i1} undef, i64 0, 0 + %"tmp#15##0" = insertvalue {i64, i1} %"tmp#14##0", i1 0, 1 + ret {i64, i1} %"tmp#15##0" +} + +define external fastcc {i64, i1} @"multictr.simple.two_field2<0>"(i64 %"#rec##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = and i64 %"#rec##0", 1 + %"tmp#1##0" = icmp eq i64 %"tmp#2##0", 1 + br i1 %"tmp#1##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#3##0" = add i64 %"#rec##0", 7 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#4##0" + %"tmp#6##0" = insertvalue {i64, i1} undef, i64 %"tmp#5##0", 0 + %"tmp#7##0" = insertvalue {i64, i1} %"tmp#6##0", i1 1, 1 + ret {i64, i1} %"tmp#7##0" +if.else.1: + %"tmp#8##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#9##0" = insertvalue {i64, i1} %"tmp#8##0", i1 0, 1 + ret {i64, i1} %"tmp#9##0" +if.else.0: + %"tmp#10##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#11##0" = insertvalue {i64, i1} %"tmp#10##0", i1 0, 1 + ret {i64, i1} %"tmp#11##0" +} + +define external fastcc {i64, i1} @"multictr.simple.two_field2<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = and i64 %"#rec##0", 1 + %"tmp#1##0" = icmp eq i64 %"tmp#2##0", 1 + br i1 %"tmp#1##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#3##0" = sub i64 %"#rec##0", 1 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + %"tmp#5##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#5##0", ptr %"tmp#4##0", i64 16, i1 0) + %"tmp#6##0" = ptrtoint ptr %"tmp#5##0" to i64 + %"tmp#7##0" = add i64 %"tmp#6##0", 1 + %"tmp#8##0" = add i64 %"tmp#7##0", 7 + %"tmp#9##0" = inttoptr i64 %"tmp#8##0" to ptr + store i64 %"#field##0", ptr %"tmp#9##0" + %"tmp#10##0" = insertvalue {i64, i1} undef, i64 %"tmp#7##0", 0 + %"tmp#11##0" = insertvalue {i64, i1} %"tmp#10##0", i1 1, 1 + ret {i64, i1} %"tmp#11##0" +if.else.1: + %"tmp#12##0" = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 + %"tmp#13##0" = insertvalue {i64, i1} %"tmp#12##0", i1 0, 1 + ret {i64, i1} %"tmp#13##0" +if.else.0: + %"tmp#14##0" = insertvalue {i64, i1} undef, i64 0, 0 + %"tmp#15##0" = insertvalue {i64, i1} %"tmp#14##0", i1 0, 1 + ret {i64, i1} %"tmp#15##0" +} + +define external fastcc i64 @"multictr.simple.zero<0>"() { + ret i64 0 +} + +define external fastcc i1 @"multictr.simple.~=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#0##0" = tail call fastcc i1 @"multictr.simple.=<0>"(i64 %"#left##0", i64 %"#right##0") + %"tmp#1##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#1##0" } + -------------------------------------------------- Module multictr.suit representation : 2 bit unsigned @@ -7064,55 +6705,42 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'multictr.suit' - - +source_filename = "!ROOT!/final-dump/multictr.wybe" +target triple ???? -declare external ccc i8* @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i1 @"multictr.suit.=<0>"(i2 %"#left##0", i2 %"#right##0") alwaysinline { -entry: - %0 = icmp eq i2 %"#left##0", %"#right##0" - ret i1 %0 +define external fastcc i1 @"multictr.suit.=<0>"(i2 %"#left##0", i2 %"#right##0") { + %"tmp#1##0" = icmp eq i2 %"#left##0", %"#right##0" + ret i1 %"tmp#1##0" } - -define external fastcc i2 @"multictr.suit.clubs<0>"() alwaysinline { -entry: - ret i2 0 +define external fastcc i2 @"multictr.suit.clubs<0>"() { + ret i2 0 } - -define external fastcc i2 @"multictr.suit.diamonds<0>"() alwaysinline { -entry: - ret i2 1 +define external fastcc i2 @"multictr.suit.diamonds<0>"() { + ret i2 1 } - -define external fastcc i2 @"multictr.suit.hearts<0>"() alwaysinline { -entry: - ret i2 2 +define external fastcc i2 @"multictr.suit.hearts<0>"() { + ret i2 2 } - -define external fastcc i2 @"multictr.suit.spades<0>"() alwaysinline { -entry: - ret i2 3 +define external fastcc i2 @"multictr.suit.spades<0>"() { + ret i2 3 } - -define external fastcc i1 @"multictr.suit.~=<0>"(i2 %"#left##0", i2 %"#right##0") alwaysinline { -entry: - %0 = icmp eq i2 %"#left##0", %"#right##0" - %1 = xor i1 %0, 1 - ret i1 %1 +define external fastcc i1 @"multictr.suit.~=<0>"(i2 %"#left##0", i2 %"#right##0") { + %"tmp#0##0" = icmp eq i2 %"#left##0", %"#right##0" + %"tmp#3##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#3##0" } + -------------------------------------------------- Module multictr.unit representation : 0 bit unsigned @@ -7151,31 +6779,23 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'multictr.unit' - - +source_filename = "!ROOT!/final-dump/multictr.wybe" +target triple ???? -declare external ccc i8* @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i1 @"multictr.unit.=<0>"() alwaysinline { -entry: - ret i1 1 +define external fastcc i1 @"multictr.unit.=<0>"() { + ret i1 1 } - -define external fastcc void @"multictr.unit.unit<0>"() alwaysinline { -entry: - ret void +define external fastcc void @"multictr.unit.unit<0>"() { + ret void } - -define external fastcc i1 @"multictr.unit.~=<0>"() alwaysinline { -entry: - ret i1 0 +define external fastcc i1 @"multictr.unit.~=<0>"() { + ret i1 0 } diff --git a/test-cases/final-dump/multictr2.exp b/test-cases/final-dump/multictr2.exp index 2ccbd465f..2d6cee31c 100644 --- a/test-cases/final-dump/multictr2.exp +++ b/test-cases/final-dump/multictr2.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module multictr2 representation : (not a type) public submods : t -> multictr2.t @@ -157,173 +160,134 @@ print_t(x##0:multictr2.t)<{<>}; {<>}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'multictr2' - - - - -@multictr2.3 = constant {i64, i64} { i64 1, i64 ptrtoint ([?? x i8]* @multictr2.2 to i64) } - - -@multictr2.17 = constant {i64, i64} { i64 2, i64 ptrtoint ([?? x i8]* @multictr2.16 to i64) } - - -@multictr2.1 = constant {i64, i64} { i64 4, i64 ptrtoint ([?? x i8]* @multictr2.0 to i64) } - - -@multictr2.11 = constant {i64, i64} { i64 4, i64 ptrtoint ([?? x i8]* @multictr2.10 to i64) } - - -@multictr2.13 = constant {i64, i64} { i64 4, i64 ptrtoint ([?? x i8]* @multictr2.12 to i64) } - - -@multictr2.15 = constant {i64, i64} { i64 4, i64 ptrtoint ([?? x i8]* @multictr2.14 to i64) } - - -@multictr2.5 = constant {i64, i64} { i64 4, i64 ptrtoint ([?? x i8]* @multictr2.4 to i64) } - - -@multictr2.7 = constant {i64, i64} { i64 4, i64 ptrtoint ([?? x i8]* @multictr2.6 to i64) } - - -@multictr2.9 = constant {i64, i64} { i64 4, i64 ptrtoint ([?? x i8]* @multictr2.8 to i64) } - - -@multictr2.2 = constant [?? x i8] c")\00" - - -@multictr2.16 = constant [?? x i8] c", \00" - - -@multictr2.0 = constant [?? x i8] c"c01(\00" - - -@multictr2.4 = constant [?? x i8] c"c03(\00" - - -@multictr2.6 = constant [?? x i8] c"c04(\00" - - -@multictr2.8 = constant [?? x i8] c"c05(\00" - - -@multictr2.10 = constant [?? x i8] c"c06(\00" - - -@multictr2.12 = constant [?? x i8] c"c07(\00" - - -@multictr2.14 = constant [?? x i8] c"c08(\00" - - -declare external ccc void @putchar(i8) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc void @print_float(double) - - -declare external ccc void @print_int(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"multictr2.print_t<0>"(i64 %"x##0") { -entry: - %0 = and i64 %"x##0", 7 - switch i64 %0, label %switch.8.7 [i64 0, label %switch.8.0 i64 1, label %switch.8.1 i64 2, label %switch.8.2 i64 3, label %switch.8.3 i64 4, label %switch.8.4 i64 5, label %switch.8.5 i64 6, label %switch.8.6 i64 7, label %switch.8.7] -switch.8.0: - %1 = inttoptr i64 %"x##0" to i64* - %2 = load i64, i64* %1 - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @multictr2.1, i32 0, i32 0) to i64)) - tail call ccc void @print_int(i64 %2) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @multictr2.3, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - ret void -switch.8.1: - %3 = add i64 %"x##0", -1 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @multictr2.5, i32 0, i32 0) to i64)) - tail call ccc void @print_int(i64 %5) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @multictr2.3, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - ret void -switch.8.2: - %6 = add i64 %"x##0", -2 - %7 = inttoptr i64 %6 to i64* - %8 = load i64, i64* %7 - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @multictr2.5, i32 0, i32 0) to i64)) - tail call ccc void @print_int(i64 %8) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @multictr2.3, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - ret void -switch.8.3: - %9 = add i64 %"x##0", -3 - %10 = inttoptr i64 %9 to i64* - %11 = load i64, i64* %10 - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @multictr2.7, i32 0, i32 0) to i64)) - tail call ccc void @print_int(i64 %11) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @multictr2.3, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - ret void -switch.8.4: - %12 = add i64 %"x##0", -4 - %13 = inttoptr i64 %12 to i64* - %14 = load i64, i64* %13 - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @multictr2.9, i32 0, i32 0) to i64)) - tail call ccc void @print_int(i64 %14) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @multictr2.3, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - ret void -switch.8.5: - %15 = add i64 %"x##0", -5 - %16 = inttoptr i64 %15 to i64* - %17 = load i64, i64* %16 - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @multictr2.11, i32 0, i32 0) to i64)) - tail call ccc void @print_int(i64 %17) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @multictr2.3, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - ret void -switch.8.6: - %18 = add i64 %"x##0", -6 - %19 = inttoptr i64 %18 to i64* - %20 = load i64, i64* %19 - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @multictr2.13, i32 0, i32 0) to i64)) - tail call ccc void @print_int(i64 %20) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @multictr2.3, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - ret void -switch.8.7: - %21 = add i64 %"x##0", -7 - %22 = inttoptr i64 %21 to i64* - %23 = load i64, i64* %22 - %24 = add i64 %"x##0", 1 - %25 = inttoptr i64 %24 to i64* - %26 = load i64, i64* %25 - %27 = add i64 %"x##0", 9 - %28 = inttoptr i64 %27 to double* - %29 = load double, double* %28 - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @multictr2.15, i32 0, i32 0) to i64)) - tail call ccc void @print_int(i64 %23) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @multictr2.17, i32 0, i32 0) to i64)) - tail call ccc void @print_int(i64 %26) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @multictr2.17, i32 0, i32 0) to i64)) - tail call ccc void @print_float(double %29) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @multictr2.3, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - ret void +source_filename = "!ROOT!/final-dump/multictr2.wybe" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c")\00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c", \00", align 8 +@"cstring#2" = private unnamed_addr constant [ ?? x i8 ] c"c01(\00", align 8 +@"cstring#3" = private unnamed_addr constant [ ?? x i8 ] c"c03(\00", align 8 +@"cstring#4" = private unnamed_addr constant [ ?? x i8 ] c"c04(\00", align 8 +@"cstring#5" = private unnamed_addr constant [ ?? x i8 ] c"c05(\00", align 8 +@"cstring#6" = private unnamed_addr constant [ ?? x i8 ] c"c06(\00", align 8 +@"cstring#7" = private unnamed_addr constant [ ?? x i8 ] c"c07(\00", align 8 +@"cstring#8" = private unnamed_addr constant [ ?? x i8 ] c"c08(\00", align 8 +@"string#9" = private unnamed_addr constant {i64, i64} { i64 1, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +@"string#10" = private unnamed_addr constant {i64, i64} { i64 2, i64 ptrtoint( ptr @"cstring#1" to i64 ) }, align 8 +@"string#11" = private unnamed_addr constant {i64, i64} { i64 4, i64 ptrtoint( ptr @"cstring#2" to i64 ) }, align 8 +@"string#12" = private unnamed_addr constant {i64, i64} { i64 4, i64 ptrtoint( ptr @"cstring#3" to i64 ) }, align 8 +@"string#13" = private unnamed_addr constant {i64, i64} { i64 4, i64 ptrtoint( ptr @"cstring#4" to i64 ) }, align 8 +@"string#14" = private unnamed_addr constant {i64, i64} { i64 4, i64 ptrtoint( ptr @"cstring#5" to i64 ) }, align 8 +@"string#15" = private unnamed_addr constant {i64, i64} { i64 4, i64 ptrtoint( ptr @"cstring#6" to i64 ) }, align 8 +@"string#16" = private unnamed_addr constant {i64, i64} { i64 4, i64 ptrtoint( ptr @"cstring#7" to i64 ) }, align 8 +@"string#17" = private unnamed_addr constant {i64, i64} { i64 4, i64 ptrtoint( ptr @"cstring#8" to i64 ) }, align 8 + +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @print_float(double) +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"multictr2.print_t<0>"(i64 %"x##0") { + %"tmp#9##0" = and i64 %"x##0", 7 + switch i64 %"tmp#9##0", label %case.7.switch.0 [ + i64 0, label %case.0.switch.0 + i64 1, label %case.1.switch.0 + i64 2, label %case.2.switch.0 + i64 3, label %case.3.switch.0 + i64 4, label %case.4.switch.0 + i64 5, label %case.5.switch.0 + i64 6, label %case.6.switch.0 + i64 7, label %case.7.switch.0 ] +case.0.switch.0: + %"tmp#80##0" = inttoptr i64 %"x##0" to ptr + %"a##0" = load i64, ptr %"tmp#80##0" + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#11" to i64 )) + call ccc void @print_int(i64 %"a##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#9" to i64 )) + call ccc void @putchar(i8 10) + ret void +case.1.switch.0: + %"tmp#81##0" = add i64 %"x##0", -1 + %"tmp#82##0" = inttoptr i64 %"tmp#81##0" to ptr + %"a##1" = load i64, ptr %"tmp#82##0" + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#12" to i64 )) + call ccc void @print_int(i64 %"a##1") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#9" to i64 )) + call ccc void @putchar(i8 10) + ret void +case.2.switch.0: + %"tmp#83##0" = add i64 %"x##0", -2 + %"tmp#84##0" = inttoptr i64 %"tmp#83##0" to ptr + %"a##2" = load i64, ptr %"tmp#84##0" + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#12" to i64 )) + call ccc void @print_int(i64 %"a##2") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#9" to i64 )) + call ccc void @putchar(i8 10) + ret void +case.3.switch.0: + %"tmp#85##0" = add i64 %"x##0", -3 + %"tmp#86##0" = inttoptr i64 %"tmp#85##0" to ptr + %"a##3" = load i64, ptr %"tmp#86##0" + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#13" to i64 )) + call ccc void @print_int(i64 %"a##3") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#9" to i64 )) + call ccc void @putchar(i8 10) + ret void +case.4.switch.0: + %"tmp#87##0" = add i64 %"x##0", -4 + %"tmp#88##0" = inttoptr i64 %"tmp#87##0" to ptr + %"a##4" = load i64, ptr %"tmp#88##0" + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#14" to i64 )) + call ccc void @print_int(i64 %"a##4") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#9" to i64 )) + call ccc void @putchar(i8 10) + ret void +case.5.switch.0: + %"tmp#89##0" = add i64 %"x##0", -5 + %"tmp#90##0" = inttoptr i64 %"tmp#89##0" to ptr + %"a##5" = load i64, ptr %"tmp#90##0" + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#15" to i64 )) + call ccc void @print_int(i64 %"a##5") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#9" to i64 )) + call ccc void @putchar(i8 10) + ret void +case.6.switch.0: + %"tmp#91##0" = add i64 %"x##0", -6 + %"tmp#92##0" = inttoptr i64 %"tmp#91##0" to ptr + %"a##6" = load i64, ptr %"tmp#92##0" + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#16" to i64 )) + call ccc void @print_int(i64 %"a##6") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#9" to i64 )) + call ccc void @putchar(i8 10) + ret void +case.7.switch.0: + %"tmp#93##0" = add i64 %"x##0", -7 + %"tmp#94##0" = inttoptr i64 %"tmp#93##0" to ptr + %"a##7" = load i64, ptr %"tmp#94##0" + %"tmp#95##0" = add i64 %"x##0", 1 + %"tmp#96##0" = inttoptr i64 %"tmp#95##0" to ptr + %"b##0" = load i64, ptr %"tmp#96##0" + %"tmp#97##0" = add i64 %"x##0", 9 + %"tmp#98##0" = inttoptr i64 %"tmp#97##0" to ptr + %"c##0" = load double, ptr %"tmp#98##0" + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#17" to i64 )) + call ccc void @print_int(i64 %"a##7") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#10" to i64 )) + call ccc void @print_int(i64 %"b##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#10" to i64 )) + call ccc void @print_float(double %"c##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#9" to i64 )) + call ccc void @putchar(i8 10) + ret void } + -------------------------------------------------- Module multictr2.t - representation : address + representation : pointer public submods : public resources: public procs : multictr2.t.=<0> @@ -493,7 +457,7 @@ proc = > public (1 calls) foreign llvm move(0:wybe.bool, ?#success##0:wybe.bool) 1: - foreign llvm fcmp_eq(~#left#f08_c##0:wybe.float, ~#right#f08_c##0:wybe.float, ?#success##0:wybe.bool) @float:nn:nn + foreign llvm fcmp_oeq(~#left#f08_c##0:wybe.float, ~#right#f08_c##0:wybe.float, ?#success##0:wybe.bool) @float:nn:nn @@ -1063,896 +1027,789 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'multictr2.t' - - - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i1 @"multictr2.t.=<0>"(i64 %"#left##0", i64 %"#right##0") { -entry: - %0 = and i64 %"#left##0", 7 - switch i64 %0, label %switch.8.7 [i64 0, label %switch.8.0 i64 1, label %switch.8.1 i64 2, label %switch.8.2 i64 3, label %switch.8.3 i64 4, label %switch.8.4 i64 5, label %switch.8.5 i64 6, label %switch.8.6 i64 7, label %switch.8.7] -switch.8.0: - %1 = inttoptr i64 %"#left##0" to i64* - %2 = load i64, i64* %1 - %3 = and i64 %"#right##0", 7 - %4 = icmp eq i64 %3, 0 - br i1 %4, label %if.then, label %if.else -switch.8.1: - %8 = add i64 %"#left##0", -1 - %9 = inttoptr i64 %8 to i64* - %10 = load i64, i64* %9 - %11 = and i64 %"#right##0", 7 - %12 = icmp eq i64 %11, 1 - br i1 %12, label %if.then1, label %if.else1 -switch.8.2: - %17 = add i64 %"#left##0", -2 - %18 = inttoptr i64 %17 to i64* - %19 = load i64, i64* %18 - %20 = and i64 %"#right##0", 7 - %21 = icmp eq i64 %20, 2 - br i1 %21, label %if.then2, label %if.else2 -switch.8.3: - %26 = add i64 %"#left##0", -3 - %27 = inttoptr i64 %26 to i64* - %28 = load i64, i64* %27 - %29 = and i64 %"#right##0", 7 - %30 = icmp eq i64 %29, 3 - br i1 %30, label %if.then3, label %if.else3 -switch.8.4: - %35 = add i64 %"#left##0", -4 - %36 = inttoptr i64 %35 to i64* - %37 = load i64, i64* %36 - %38 = and i64 %"#right##0", 7 - %39 = icmp eq i64 %38, 4 - br i1 %39, label %if.then4, label %if.else4 -switch.8.5: - %44 = add i64 %"#left##0", -5 - %45 = inttoptr i64 %44 to i64* - %46 = load i64, i64* %45 - %47 = and i64 %"#right##0", 7 - %48 = icmp eq i64 %47, 5 - br i1 %48, label %if.then5, label %if.else5 -switch.8.6: - %53 = add i64 %"#left##0", -6 - %54 = inttoptr i64 %53 to i64* - %55 = load i64, i64* %54 - %56 = and i64 %"#right##0", 7 - %57 = icmp eq i64 %56, 6 - br i1 %57, label %if.then6, label %if.else6 -switch.8.7: - %62 = add i64 %"#left##0", -7 - %63 = inttoptr i64 %62 to i64* - %64 = load i64, i64* %63 - %65 = add i64 %"#left##0", 1 - %66 = inttoptr i64 %65 to i64* - %67 = load i64, i64* %66 - %68 = add i64 %"#left##0", 9 - %69 = inttoptr i64 %68 to double* - %70 = load double, double* %69 - %71 = and i64 %"#right##0", 7 - %72 = icmp eq i64 %71, 7 - br i1 %72, label %if.then7, label %if.else7 -if.then: - %5 = inttoptr i64 %"#right##0" to i64* - %6 = load i64, i64* %5 - %7 = icmp eq i64 %2, %6 - ret i1 %7 -if.else: - ret i1 0 -if.then1: - %13 = add i64 %"#right##0", -1 - %14 = inttoptr i64 %13 to i64* - %15 = load i64, i64* %14 - %16 = icmp eq i64 %10, %15 - ret i1 %16 -if.else1: - ret i1 0 -if.then2: - %22 = add i64 %"#right##0", -2 - %23 = inttoptr i64 %22 to i64* - %24 = load i64, i64* %23 - %25 = icmp eq i64 %19, %24 - ret i1 %25 -if.else2: - ret i1 0 -if.then3: - %31 = add i64 %"#right##0", -3 - %32 = inttoptr i64 %31 to i64* - %33 = load i64, i64* %32 - %34 = icmp eq i64 %28, %33 - ret i1 %34 -if.else3: - ret i1 0 -if.then4: - %40 = add i64 %"#right##0", -4 - %41 = inttoptr i64 %40 to i64* - %42 = load i64, i64* %41 - %43 = icmp eq i64 %37, %42 - ret i1 %43 -if.else4: - ret i1 0 -if.then5: - %49 = add i64 %"#right##0", -5 - %50 = inttoptr i64 %49 to i64* - %51 = load i64, i64* %50 - %52 = icmp eq i64 %46, %51 - ret i1 %52 -if.else5: - ret i1 0 -if.then6: - %58 = add i64 %"#right##0", -6 - %59 = inttoptr i64 %58 to i64* - %60 = load i64, i64* %59 - %61 = icmp eq i64 %55, %60 - ret i1 %61 -if.else6: - ret i1 0 -if.then7: - %73 = add i64 %"#right##0", -7 - %74 = inttoptr i64 %73 to i64* - %75 = load i64, i64* %74 - %76 = add i64 %"#right##0", 1 - %77 = inttoptr i64 %76 to i64* - %78 = load i64, i64* %77 - %79 = add i64 %"#right##0", 9 - %80 = inttoptr i64 %79 to double* - %81 = load double, double* %80 - %82 = icmp eq i64 %64, %75 - br i1 %82, label %if.then8, label %if.else8 -if.else7: - ret i1 0 -if.then8: - %83 = icmp eq i64 %67, %78 - br i1 %83, label %if.then9, label %if.else9 -if.else8: - ret i1 0 -if.then9: - %84 = fcmp oeq double %70, %81 - ret i1 %84 -if.else9: - ret i1 0 +source_filename = "!ROOT!/final-dump/multictr2.wybe" +target triple ???? + + +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc i1 @"multictr2.t.=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#28##0" = and i64 %"#left##0", 7 + switch i64 %"tmp#28##0", label %case.7.switch.0 [ + i64 0, label %case.0.switch.0 + i64 1, label %case.1.switch.0 + i64 2, label %case.2.switch.0 + i64 3, label %case.3.switch.0 + i64 4, label %case.4.switch.0 + i64 5, label %case.5.switch.0 + i64 6, label %case.6.switch.0 + i64 7, label %case.7.switch.0 ] +case.0.switch.0: + %"tmp#95##0" = inttoptr i64 %"#left##0" to ptr + %"#left#f01##0" = load i64, ptr %"tmp#95##0" + %"tmp#91##0" = and i64 %"#right##0", 7 + %"tmp#92##0" = icmp eq i64 %"tmp#91##0", 0 + br i1 %"tmp#92##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#96##0" = inttoptr i64 %"#right##0" to ptr + %"#right#f01##0" = load i64, ptr %"tmp#96##0" + %"tmp#97##0" = icmp eq i64 %"#left#f01##0", %"#right#f01##0" + ret i1 %"tmp#97##0" +if.else.1: + ret i1 0 +case.1.switch.0: + %"tmp#98##0" = add i64 %"#left##0", -1 + %"tmp#99##0" = inttoptr i64 %"tmp#98##0" to ptr + %"#left#f02##0" = load i64, ptr %"tmp#99##0" + %"tmp#86##0" = and i64 %"#right##0", 7 + %"tmp#87##0" = icmp eq i64 %"tmp#86##0", 1 + br i1 %"tmp#87##0", label %if.then.2, label %if.else.2 +if.then.2: + %"tmp#100##0" = add i64 %"#right##0", -1 + %"tmp#101##0" = inttoptr i64 %"tmp#100##0" to ptr + %"#right#f02##0" = load i64, ptr %"tmp#101##0" + %"tmp#102##0" = icmp eq i64 %"#left#f02##0", %"#right#f02##0" + ret i1 %"tmp#102##0" +if.else.2: + ret i1 0 +case.2.switch.0: + %"tmp#103##0" = add i64 %"#left##0", -2 + %"tmp#104##0" = inttoptr i64 %"tmp#103##0" to ptr + %"#left#f03##0" = load i64, ptr %"tmp#104##0" + %"tmp#81##0" = and i64 %"#right##0", 7 + %"tmp#82##0" = icmp eq i64 %"tmp#81##0", 2 + br i1 %"tmp#82##0", label %if.then.3, label %if.else.3 +if.then.3: + %"tmp#105##0" = add i64 %"#right##0", -2 + %"tmp#106##0" = inttoptr i64 %"tmp#105##0" to ptr + %"#right#f03##0" = load i64, ptr %"tmp#106##0" + %"tmp#107##0" = icmp eq i64 %"#left#f03##0", %"#right#f03##0" + ret i1 %"tmp#107##0" +if.else.3: + ret i1 0 +case.3.switch.0: + %"tmp#108##0" = add i64 %"#left##0", -3 + %"tmp#109##0" = inttoptr i64 %"tmp#108##0" to ptr + %"#left#f04##0" = load i64, ptr %"tmp#109##0" + %"tmp#76##0" = and i64 %"#right##0", 7 + %"tmp#77##0" = icmp eq i64 %"tmp#76##0", 3 + br i1 %"tmp#77##0", label %if.then.4, label %if.else.4 +if.then.4: + %"tmp#110##0" = add i64 %"#right##0", -3 + %"tmp#111##0" = inttoptr i64 %"tmp#110##0" to ptr + %"#right#f04##0" = load i64, ptr %"tmp#111##0" + %"tmp#112##0" = icmp eq i64 %"#left#f04##0", %"#right#f04##0" + ret i1 %"tmp#112##0" +if.else.4: + ret i1 0 +case.4.switch.0: + %"tmp#113##0" = add i64 %"#left##0", -4 + %"tmp#114##0" = inttoptr i64 %"tmp#113##0" to ptr + %"#left#f05##0" = load i64, ptr %"tmp#114##0" + %"tmp#71##0" = and i64 %"#right##0", 7 + %"tmp#72##0" = icmp eq i64 %"tmp#71##0", 4 + br i1 %"tmp#72##0", label %if.then.5, label %if.else.5 +if.then.5: + %"tmp#115##0" = add i64 %"#right##0", -4 + %"tmp#116##0" = inttoptr i64 %"tmp#115##0" to ptr + %"#right#f05##0" = load i64, ptr %"tmp#116##0" + %"tmp#117##0" = icmp eq i64 %"#left#f05##0", %"#right#f05##0" + ret i1 %"tmp#117##0" +if.else.5: + ret i1 0 +case.5.switch.0: + %"tmp#118##0" = add i64 %"#left##0", -5 + %"tmp#119##0" = inttoptr i64 %"tmp#118##0" to ptr + %"#left#f06##0" = load i64, ptr %"tmp#119##0" + %"tmp#66##0" = and i64 %"#right##0", 7 + %"tmp#67##0" = icmp eq i64 %"tmp#66##0", 5 + br i1 %"tmp#67##0", label %if.then.6, label %if.else.6 +if.then.6: + %"tmp#120##0" = add i64 %"#right##0", -5 + %"tmp#121##0" = inttoptr i64 %"tmp#120##0" to ptr + %"#right#f06##0" = load i64, ptr %"tmp#121##0" + %"tmp#122##0" = icmp eq i64 %"#left#f06##0", %"#right#f06##0" + ret i1 %"tmp#122##0" +if.else.6: + ret i1 0 +case.6.switch.0: + %"tmp#123##0" = add i64 %"#left##0", -6 + %"tmp#124##0" = inttoptr i64 %"tmp#123##0" to ptr + %"#left#f07##0" = load i64, ptr %"tmp#124##0" + %"tmp#61##0" = and i64 %"#right##0", 7 + %"tmp#62##0" = icmp eq i64 %"tmp#61##0", 6 + br i1 %"tmp#62##0", label %if.then.7, label %if.else.7 +if.then.7: + %"tmp#125##0" = add i64 %"#right##0", -6 + %"tmp#126##0" = inttoptr i64 %"tmp#125##0" to ptr + %"#right#f07##0" = load i64, ptr %"tmp#126##0" + %"tmp#127##0" = icmp eq i64 %"#left#f07##0", %"#right#f07##0" + ret i1 %"tmp#127##0" +if.else.7: + ret i1 0 +case.7.switch.0: + %"tmp#128##0" = add i64 %"#left##0", -7 + %"tmp#129##0" = inttoptr i64 %"tmp#128##0" to ptr + %"#left#f08_a##0" = load i64, ptr %"tmp#129##0" + %"tmp#130##0" = add i64 %"#left##0", 1 + %"tmp#131##0" = inttoptr i64 %"tmp#130##0" to ptr + %"#left#f08_b##0" = load i64, ptr %"tmp#131##0" + %"tmp#132##0" = add i64 %"#left##0", 9 + %"tmp#133##0" = inttoptr i64 %"tmp#132##0" to ptr + %"#left#f08_c##0" = load double, ptr %"tmp#133##0" + %"tmp#52##0" = and i64 %"#right##0", 7 + %"tmp#53##0" = icmp eq i64 %"tmp#52##0", 7 + br i1 %"tmp#53##0", label %if.then.8, label %if.else.8 +if.then.8: + %"tmp#134##0" = add i64 %"#right##0", -7 + %"tmp#135##0" = inttoptr i64 %"tmp#134##0" to ptr + %"#right#f08_a##0" = load i64, ptr %"tmp#135##0" + %"tmp#136##0" = add i64 %"#right##0", 1 + %"tmp#137##0" = inttoptr i64 %"tmp#136##0" to ptr + %"#right#f08_b##0" = load i64, ptr %"tmp#137##0" + %"tmp#138##0" = add i64 %"#right##0", 9 + %"tmp#139##0" = inttoptr i64 %"tmp#138##0" to ptr + %"#right#f08_c##0" = load double, ptr %"tmp#139##0" + %"tmp#16##0" = icmp eq i64 %"#left#f08_a##0", %"#right#f08_a##0" + br i1 %"tmp#16##0", label %if.then.9, label %if.else.9 +if.then.9: + %"tmp#17##0" = icmp eq i64 %"#left#f08_b##0", %"#right#f08_b##0" + br i1 %"tmp#17##0", label %if.then.10, label %if.else.10 +if.then.10: + %"tmp#140##0" = fcmp oeq double %"#left#f08_c##0", %"#right#f08_c##0" + ret i1 %"tmp#140##0" +if.else.10: + ret i1 0 +if.else.9: + ret i1 0 +if.else.8: + ret i1 0 } - -define external fastcc i64 @"multictr2.t.c01<0>"(i64 %"f01##0") alwaysinline { -entry: - %0 = trunc i64 8 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"f01##0", i64* %3 - ret i64 %2 +define external fastcc i64 @"multictr2.t.c01<0>"(i64 %"f01##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 8) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"f01##0", ptr %"tmp#1##0" + ret i64 %"#rec##0" } - -define external fastcc {i64, i1} @"multictr2.t.c01<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = and i64 %"#result##0", 7 - %1 = icmp eq i64 %0, 0 - br i1 %1, label %if.then, label %if.else -if.then: - %2 = inttoptr i64 %"#result##0" to i64* - %3 = load i64, i64* %2 - %4 = insertvalue {i64, i1} undef, i64 %3, 0 - %5 = insertvalue {i64, i1} %4, i1 1, 1 - ret {i64, i1} %5 -if.else: - %6 = insertvalue {i64, i1} undef, i64 undef, 0 - %7 = insertvalue {i64, i1} %6, i1 0, 1 - ret {i64, i1} %7 +define external fastcc {i64, i1} @"multictr2.t.c01<1>"(i64 %"#result##0") { + %"tmp#1##0" = and i64 %"#result##0", 7 + %"tmp#0##0" = icmp eq i64 %"tmp#1##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = inttoptr i64 %"#result##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#2##0" + %"tmp#4##0" = insertvalue {i64, i1} undef, i64 %"tmp#3##0", 0 + %"tmp#5##0" = insertvalue {i64, i1} %"tmp#4##0", i1 1, 1 + ret {i64, i1} %"tmp#5##0" +if.else.0: + %"tmp#6##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#7##0" = insertvalue {i64, i1} %"tmp#6##0", i1 0, 1 + ret {i64, i1} %"tmp#7##0" } - -define external fastcc i64 @"multictr2.t.c02<0>"(i64 %"f02##0") alwaysinline { -entry: - %0 = trunc i64 8 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"f02##0", i64* %3 - %4 = or i64 %2, 1 - ret i64 %4 +define external fastcc i64 @"multictr2.t.c02<0>"(i64 %"f02##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 8) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"f02##0", ptr %"tmp#1##0" + %"tmp#2##0" = or i64 %"#rec##0", 1 + ret i64 %"tmp#2##0" } - -define external fastcc {i64, i1} @"multictr2.t.c02<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = and i64 %"#result##0", 7 - %1 = icmp eq i64 %0, 1 - br i1 %1, label %if.then, label %if.else -if.then: - %2 = add i64 %"#result##0", -1 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = insertvalue {i64, i1} undef, i64 %4, 0 - %6 = insertvalue {i64, i1} %5, i1 1, 1 - ret {i64, i1} %6 -if.else: - %7 = insertvalue {i64, i1} undef, i64 undef, 0 - %8 = insertvalue {i64, i1} %7, i1 0, 1 - ret {i64, i1} %8 +define external fastcc {i64, i1} @"multictr2.t.c02<1>"(i64 %"#result##0") { + %"tmp#1##0" = and i64 %"#result##0", 7 + %"tmp#0##0" = icmp eq i64 %"tmp#1##0", 1 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = add i64 %"#result##0", -1 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#3##0" + %"tmp#5##0" = insertvalue {i64, i1} undef, i64 %"tmp#4##0", 0 + %"tmp#6##0" = insertvalue {i64, i1} %"tmp#5##0", i1 1, 1 + ret {i64, i1} %"tmp#6##0" +if.else.0: + %"tmp#7##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#8##0" = insertvalue {i64, i1} %"tmp#7##0", i1 0, 1 + ret {i64, i1} %"tmp#8##0" } - -define external fastcc i64 @"multictr2.t.c03<0>"(i64 %"f03##0") alwaysinline { -entry: - %0 = trunc i64 8 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"f03##0", i64* %3 - %4 = or i64 %2, 2 - ret i64 %4 +define external fastcc i64 @"multictr2.t.c03<0>"(i64 %"f03##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 8) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"f03##0", ptr %"tmp#1##0" + %"tmp#2##0" = or i64 %"#rec##0", 2 + ret i64 %"tmp#2##0" } - -define external fastcc {i64, i1} @"multictr2.t.c03<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = and i64 %"#result##0", 7 - %1 = icmp eq i64 %0, 2 - br i1 %1, label %if.then, label %if.else -if.then: - %2 = add i64 %"#result##0", -2 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = insertvalue {i64, i1} undef, i64 %4, 0 - %6 = insertvalue {i64, i1} %5, i1 1, 1 - ret {i64, i1} %6 -if.else: - %7 = insertvalue {i64, i1} undef, i64 undef, 0 - %8 = insertvalue {i64, i1} %7, i1 0, 1 - ret {i64, i1} %8 +define external fastcc {i64, i1} @"multictr2.t.c03<1>"(i64 %"#result##0") { + %"tmp#1##0" = and i64 %"#result##0", 7 + %"tmp#0##0" = icmp eq i64 %"tmp#1##0", 2 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = add i64 %"#result##0", -2 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#3##0" + %"tmp#5##0" = insertvalue {i64, i1} undef, i64 %"tmp#4##0", 0 + %"tmp#6##0" = insertvalue {i64, i1} %"tmp#5##0", i1 1, 1 + ret {i64, i1} %"tmp#6##0" +if.else.0: + %"tmp#7##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#8##0" = insertvalue {i64, i1} %"tmp#7##0", i1 0, 1 + ret {i64, i1} %"tmp#8##0" } - -define external fastcc i64 @"multictr2.t.c04<0>"(i64 %"f04##0") alwaysinline { -entry: - %0 = trunc i64 8 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"f04##0", i64* %3 - %4 = or i64 %2, 3 - ret i64 %4 +define external fastcc i64 @"multictr2.t.c04<0>"(i64 %"f04##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 8) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"f04##0", ptr %"tmp#1##0" + %"tmp#2##0" = or i64 %"#rec##0", 3 + ret i64 %"tmp#2##0" } - -define external fastcc {i64, i1} @"multictr2.t.c04<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = and i64 %"#result##0", 7 - %1 = icmp eq i64 %0, 3 - br i1 %1, label %if.then, label %if.else -if.then: - %2 = add i64 %"#result##0", -3 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = insertvalue {i64, i1} undef, i64 %4, 0 - %6 = insertvalue {i64, i1} %5, i1 1, 1 - ret {i64, i1} %6 -if.else: - %7 = insertvalue {i64, i1} undef, i64 undef, 0 - %8 = insertvalue {i64, i1} %7, i1 0, 1 - ret {i64, i1} %8 +define external fastcc {i64, i1} @"multictr2.t.c04<1>"(i64 %"#result##0") { + %"tmp#1##0" = and i64 %"#result##0", 7 + %"tmp#0##0" = icmp eq i64 %"tmp#1##0", 3 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = add i64 %"#result##0", -3 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#3##0" + %"tmp#5##0" = insertvalue {i64, i1} undef, i64 %"tmp#4##0", 0 + %"tmp#6##0" = insertvalue {i64, i1} %"tmp#5##0", i1 1, 1 + ret {i64, i1} %"tmp#6##0" +if.else.0: + %"tmp#7##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#8##0" = insertvalue {i64, i1} %"tmp#7##0", i1 0, 1 + ret {i64, i1} %"tmp#8##0" } - -define external fastcc i64 @"multictr2.t.c05<0>"(i64 %"f05##0") alwaysinline { -entry: - %0 = trunc i64 8 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"f05##0", i64* %3 - %4 = or i64 %2, 4 - ret i64 %4 +define external fastcc i64 @"multictr2.t.c05<0>"(i64 %"f05##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 8) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"f05##0", ptr %"tmp#1##0" + %"tmp#2##0" = or i64 %"#rec##0", 4 + ret i64 %"tmp#2##0" } - -define external fastcc {i64, i1} @"multictr2.t.c05<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = and i64 %"#result##0", 7 - %1 = icmp eq i64 %0, 4 - br i1 %1, label %if.then, label %if.else -if.then: - %2 = add i64 %"#result##0", -4 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = insertvalue {i64, i1} undef, i64 %4, 0 - %6 = insertvalue {i64, i1} %5, i1 1, 1 - ret {i64, i1} %6 -if.else: - %7 = insertvalue {i64, i1} undef, i64 undef, 0 - %8 = insertvalue {i64, i1} %7, i1 0, 1 - ret {i64, i1} %8 +define external fastcc {i64, i1} @"multictr2.t.c05<1>"(i64 %"#result##0") { + %"tmp#1##0" = and i64 %"#result##0", 7 + %"tmp#0##0" = icmp eq i64 %"tmp#1##0", 4 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = add i64 %"#result##0", -4 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#3##0" + %"tmp#5##0" = insertvalue {i64, i1} undef, i64 %"tmp#4##0", 0 + %"tmp#6##0" = insertvalue {i64, i1} %"tmp#5##0", i1 1, 1 + ret {i64, i1} %"tmp#6##0" +if.else.0: + %"tmp#7##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#8##0" = insertvalue {i64, i1} %"tmp#7##0", i1 0, 1 + ret {i64, i1} %"tmp#8##0" } - -define external fastcc i64 @"multictr2.t.c06<0>"(i64 %"f06##0") alwaysinline { -entry: - %0 = trunc i64 8 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"f06##0", i64* %3 - %4 = or i64 %2, 5 - ret i64 %4 +define external fastcc i64 @"multictr2.t.c06<0>"(i64 %"f06##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 8) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"f06##0", ptr %"tmp#1##0" + %"tmp#2##0" = or i64 %"#rec##0", 5 + ret i64 %"tmp#2##0" } - -define external fastcc {i64, i1} @"multictr2.t.c06<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = and i64 %"#result##0", 7 - %1 = icmp eq i64 %0, 5 - br i1 %1, label %if.then, label %if.else -if.then: - %2 = add i64 %"#result##0", -5 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = insertvalue {i64, i1} undef, i64 %4, 0 - %6 = insertvalue {i64, i1} %5, i1 1, 1 - ret {i64, i1} %6 -if.else: - %7 = insertvalue {i64, i1} undef, i64 undef, 0 - %8 = insertvalue {i64, i1} %7, i1 0, 1 - ret {i64, i1} %8 +define external fastcc {i64, i1} @"multictr2.t.c06<1>"(i64 %"#result##0") { + %"tmp#1##0" = and i64 %"#result##0", 7 + %"tmp#0##0" = icmp eq i64 %"tmp#1##0", 5 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = add i64 %"#result##0", -5 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#3##0" + %"tmp#5##0" = insertvalue {i64, i1} undef, i64 %"tmp#4##0", 0 + %"tmp#6##0" = insertvalue {i64, i1} %"tmp#5##0", i1 1, 1 + ret {i64, i1} %"tmp#6##0" +if.else.0: + %"tmp#7##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#8##0" = insertvalue {i64, i1} %"tmp#7##0", i1 0, 1 + ret {i64, i1} %"tmp#8##0" } - -define external fastcc i64 @"multictr2.t.c07<0>"(i64 %"f07##0") alwaysinline { -entry: - %0 = trunc i64 8 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"f07##0", i64* %3 - %4 = or i64 %2, 6 - ret i64 %4 +define external fastcc i64 @"multictr2.t.c07<0>"(i64 %"f07##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 8) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"f07##0", ptr %"tmp#1##0" + %"tmp#2##0" = or i64 %"#rec##0", 6 + ret i64 %"tmp#2##0" } - -define external fastcc {i64, i1} @"multictr2.t.c07<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = and i64 %"#result##0", 7 - %1 = icmp eq i64 %0, 6 - br i1 %1, label %if.then, label %if.else -if.then: - %2 = add i64 %"#result##0", -6 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = insertvalue {i64, i1} undef, i64 %4, 0 - %6 = insertvalue {i64, i1} %5, i1 1, 1 - ret {i64, i1} %6 -if.else: - %7 = insertvalue {i64, i1} undef, i64 undef, 0 - %8 = insertvalue {i64, i1} %7, i1 0, 1 - ret {i64, i1} %8 +define external fastcc {i64, i1} @"multictr2.t.c07<1>"(i64 %"#result##0") { + %"tmp#1##0" = and i64 %"#result##0", 7 + %"tmp#0##0" = icmp eq i64 %"tmp#1##0", 6 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = add i64 %"#result##0", -6 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#3##0" + %"tmp#5##0" = insertvalue {i64, i1} undef, i64 %"tmp#4##0", 0 + %"tmp#6##0" = insertvalue {i64, i1} %"tmp#5##0", i1 1, 1 + ret {i64, i1} %"tmp#6##0" +if.else.0: + %"tmp#7##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#8##0" = insertvalue {i64, i1} %"tmp#7##0", i1 0, 1 + ret {i64, i1} %"tmp#8##0" } - -define external fastcc i64 @"multictr2.t.c08<0>"(i64 %"f08_a##0", i64 %"f08_b##0", double %"f08_c##0") alwaysinline { -entry: - %0 = trunc i64 24 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"f08_a##0", i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"f08_b##0", i64* %5 - %6 = add i64 %2, 16 - %7 = inttoptr i64 %6 to double* - store double %"f08_c##0", double* %7 - %8 = or i64 %2, 7 - ret i64 %8 +define external fastcc i64 @"multictr2.t.c08<0>"(i64 %"f08_a##0", i64 %"f08_b##0", double %"f08_c##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 24) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"f08_a##0", ptr %"tmp#1##0" + %"tmp#2##0" = add i64 %"#rec##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"f08_b##0", ptr %"tmp#3##0" + %"tmp#4##0" = add i64 %"#rec##0", 16 + %"tmp#5##0" = inttoptr i64 %"tmp#4##0" to ptr + store double %"f08_c##0", ptr %"tmp#5##0" + %"tmp#6##0" = or i64 %"#rec##0", 7 + ret i64 %"tmp#6##0" } - -define external fastcc {i64, i64, double, i1} @"multictr2.t.c08<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = and i64 %"#result##0", 7 - %1 = icmp eq i64 %0, 7 - br i1 %1, label %if.then, label %if.else -if.then: - %2 = add i64 %"#result##0", -7 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = add i64 %"#result##0", 1 - %6 = inttoptr i64 %5 to i64* - %7 = load i64, i64* %6 - %8 = add i64 %"#result##0", 9 - %9 = inttoptr i64 %8 to double* - %10 = load double, double* %9 - %11 = insertvalue {i64, i64, double, i1} undef, i64 %4, 0 - %12 = insertvalue {i64, i64, double, i1} %11, i64 %7, 1 - %13 = insertvalue {i64, i64, double, i1} %12, double %10, 2 - %14 = insertvalue {i64, i64, double, i1} %13, i1 1, 3 - ret {i64, i64, double, i1} %14 -if.else: - %15 = insertvalue {i64, i64, double, i1} undef, i64 undef, 0 - %16 = insertvalue {i64, i64, double, i1} %15, i64 undef, 1 - %17 = insertvalue {i64, i64, double, i1} %16, double undef, 2 - %18 = insertvalue {i64, i64, double, i1} %17, i1 0, 3 - ret {i64, i64, double, i1} %18 +define external fastcc {i64, i64, double, i1} @"multictr2.t.c08<1>"(i64 %"#result##0") { + %"tmp#1##0" = and i64 %"#result##0", 7 + %"tmp#0##0" = icmp eq i64 %"tmp#1##0", 7 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = add i64 %"#result##0", -7 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#3##0" + %"tmp#5##0" = add i64 %"#result##0", 1 + %"tmp#6##0" = inttoptr i64 %"tmp#5##0" to ptr + %"tmp#7##0" = load i64, ptr %"tmp#6##0" + %"tmp#8##0" = add i64 %"#result##0", 9 + %"tmp#9##0" = inttoptr i64 %"tmp#8##0" to ptr + %"tmp#10##0" = load double, ptr %"tmp#9##0" + %"tmp#11##0" = insertvalue {i64, i64, double, i1} undef, i64 %"tmp#4##0", 0 + %"tmp#12##0" = insertvalue {i64, i64, double, i1} %"tmp#11##0", i64 %"tmp#7##0", 1 + %"tmp#13##0" = insertvalue {i64, i64, double, i1} %"tmp#12##0", double %"tmp#10##0", 2 + %"tmp#14##0" = insertvalue {i64, i64, double, i1} %"tmp#13##0", i1 1, 3 + ret {i64, i64, double, i1} %"tmp#14##0" +if.else.0: + %"tmp#15##0" = insertvalue {i64, i64, double, i1} undef, i64 undef, 0 + %"tmp#16##0" = insertvalue {i64, i64, double, i1} %"tmp#15##0", i64 undef, 1 + %"tmp#17##0" = insertvalue {i64, i64, double, i1} %"tmp#16##0", double undef, 2 + %"tmp#18##0" = insertvalue {i64, i64, double, i1} %"tmp#17##0", i1 0, 3 + ret {i64, i64, double, i1} %"tmp#18##0" } - -define external fastcc {i64, i1} @"multictr2.t.f01<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = and i64 %"#rec##0", 7 - %1 = icmp eq i64 %0, 0 - br i1 %1, label %if.then, label %if.else -if.then: - %2 = inttoptr i64 %"#rec##0" to i64* - %3 = load i64, i64* %2 - %4 = insertvalue {i64, i1} undef, i64 %3, 0 - %5 = insertvalue {i64, i1} %4, i1 1, 1 - ret {i64, i1} %5 -if.else: - %6 = insertvalue {i64, i1} undef, i64 undef, 0 - %7 = insertvalue {i64, i1} %6, i1 0, 1 - ret {i64, i1} %7 +define external fastcc {i64, i1} @"multictr2.t.f01<0>"(i64 %"#rec##0") { + %"tmp#1##0" = and i64 %"#rec##0", 7 + %"tmp#0##0" = icmp eq i64 %"tmp#1##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#2##0" + %"tmp#4##0" = insertvalue {i64, i1} undef, i64 %"tmp#3##0", 0 + %"tmp#5##0" = insertvalue {i64, i1} %"tmp#4##0", i1 1, 1 + ret {i64, i1} %"tmp#5##0" +if.else.0: + %"tmp#6##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#7##0" = insertvalue {i64, i1} %"tmp#6##0", i1 0, 1 + ret {i64, i1} %"tmp#7##0" } - -define external fastcc {i64, i1} @"multictr2.t.f01<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = and i64 %"#rec##0", 7 - %1 = icmp eq i64 %0, 0 - br i1 %1, label %if.then, label %if.else -if.then: - %2 = trunc i64 8 to i32 - %3 = tail call ccc i8* @wybe_malloc(i32 %2) - %4 = ptrtoint i8* %3 to i64 - %5 = inttoptr i64 %4 to i8* - %6 = inttoptr i64 %"#rec##0" to i8* - %7 = trunc i64 8 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %5, i8* %6, i32 %7, i1 0) - %8 = inttoptr i64 %4 to i64* - store i64 %"#field##0", i64* %8 - %9 = insertvalue {i64, i1} undef, i64 %4, 0 - %10 = insertvalue {i64, i1} %9, i1 1, 1 - ret {i64, i1} %10 -if.else: - %11 = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 - %12 = insertvalue {i64, i1} %11, i1 0, 1 - ret {i64, i1} %12 +define external fastcc {i64, i1} @"multictr2.t.f01<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#1##0" = and i64 %"#rec##0", 7 + %"tmp#0##0" = icmp eq i64 %"tmp#1##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#3##0" = call ccc ptr @wybe_malloc(i32 8) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#3##0", ptr %"tmp#2##0", i64 8, i1 0) + %"tmp#4##0" = ptrtoint ptr %"tmp#3##0" to i64 + %"tmp#5##0" = inttoptr i64 %"tmp#4##0" to ptr + store i64 %"#field##0", ptr %"tmp#5##0" + %"tmp#6##0" = insertvalue {i64, i1} undef, i64 %"tmp#4##0", 0 + %"tmp#7##0" = insertvalue {i64, i1} %"tmp#6##0", i1 1, 1 + ret {i64, i1} %"tmp#7##0" +if.else.0: + %"tmp#8##0" = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 + %"tmp#9##0" = insertvalue {i64, i1} %"tmp#8##0", i1 0, 1 + ret {i64, i1} %"tmp#9##0" } - -define external fastcc {i64, i1} @"multictr2.t.f02<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = and i64 %"#rec##0", 7 - %1 = icmp eq i64 %0, 1 - br i1 %1, label %if.then, label %if.else -if.then: - %2 = add i64 %"#rec##0", -1 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = insertvalue {i64, i1} undef, i64 %4, 0 - %6 = insertvalue {i64, i1} %5, i1 1, 1 - ret {i64, i1} %6 -if.else: - %7 = insertvalue {i64, i1} undef, i64 undef, 0 - %8 = insertvalue {i64, i1} %7, i1 0, 1 - ret {i64, i1} %8 +define external fastcc {i64, i1} @"multictr2.t.f02<0>"(i64 %"#rec##0") { + %"tmp#1##0" = and i64 %"#rec##0", 7 + %"tmp#0##0" = icmp eq i64 %"tmp#1##0", 1 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = add i64 %"#rec##0", -1 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#3##0" + %"tmp#5##0" = insertvalue {i64, i1} undef, i64 %"tmp#4##0", 0 + %"tmp#6##0" = insertvalue {i64, i1} %"tmp#5##0", i1 1, 1 + ret {i64, i1} %"tmp#6##0" +if.else.0: + %"tmp#7##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#8##0" = insertvalue {i64, i1} %"tmp#7##0", i1 0, 1 + ret {i64, i1} %"tmp#8##0" } - -define external fastcc {i64, i1} @"multictr2.t.f02<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = and i64 %"#rec##0", 7 - %1 = icmp eq i64 %0, 1 - br i1 %1, label %if.then, label %if.else -if.then: - %2 = trunc i64 8 to i32 - %3 = tail call ccc i8* @wybe_malloc(i32 %2) - %4 = ptrtoint i8* %3 to i64 - %5 = add i64 %4, 1 - %6 = sub i64 %"#rec##0", 1 - %7 = inttoptr i64 %4 to i8* - %8 = inttoptr i64 %6 to i8* - %9 = trunc i64 8 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %7, i8* %8, i32 %9, i1 0) - %10 = add i64 %5, -1 - %11 = inttoptr i64 %10 to i64* - store i64 %"#field##0", i64* %11 - %12 = insertvalue {i64, i1} undef, i64 %5, 0 - %13 = insertvalue {i64, i1} %12, i1 1, 1 - ret {i64, i1} %13 -if.else: - %14 = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 - %15 = insertvalue {i64, i1} %14, i1 0, 1 - ret {i64, i1} %15 +define external fastcc {i64, i1} @"multictr2.t.f02<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#1##0" = and i64 %"#rec##0", 7 + %"tmp#0##0" = icmp eq i64 %"tmp#1##0", 1 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = sub i64 %"#rec##0", 1 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = call ccc ptr @wybe_malloc(i32 8) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#4##0", ptr %"tmp#3##0", i64 8, i1 0) + %"tmp#5##0" = ptrtoint ptr %"tmp#4##0" to i64 + %"tmp#6##0" = add i64 %"tmp#5##0", 1 + %"tmp#7##0" = add i64 %"tmp#6##0", -1 + %"tmp#8##0" = inttoptr i64 %"tmp#7##0" to ptr + store i64 %"#field##0", ptr %"tmp#8##0" + %"tmp#9##0" = insertvalue {i64, i1} undef, i64 %"tmp#6##0", 0 + %"tmp#10##0" = insertvalue {i64, i1} %"tmp#9##0", i1 1, 1 + ret {i64, i1} %"tmp#10##0" +if.else.0: + %"tmp#11##0" = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 + %"tmp#12##0" = insertvalue {i64, i1} %"tmp#11##0", i1 0, 1 + ret {i64, i1} %"tmp#12##0" } - -define external fastcc {i64, i1} @"multictr2.t.f03<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = and i64 %"#rec##0", 7 - %1 = icmp eq i64 %0, 2 - br i1 %1, label %if.then, label %if.else -if.then: - %2 = add i64 %"#rec##0", -2 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = insertvalue {i64, i1} undef, i64 %4, 0 - %6 = insertvalue {i64, i1} %5, i1 1, 1 - ret {i64, i1} %6 -if.else: - %7 = insertvalue {i64, i1} undef, i64 undef, 0 - %8 = insertvalue {i64, i1} %7, i1 0, 1 - ret {i64, i1} %8 +define external fastcc {i64, i1} @"multictr2.t.f03<0>"(i64 %"#rec##0") { + %"tmp#1##0" = and i64 %"#rec##0", 7 + %"tmp#0##0" = icmp eq i64 %"tmp#1##0", 2 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = add i64 %"#rec##0", -2 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#3##0" + %"tmp#5##0" = insertvalue {i64, i1} undef, i64 %"tmp#4##0", 0 + %"tmp#6##0" = insertvalue {i64, i1} %"tmp#5##0", i1 1, 1 + ret {i64, i1} %"tmp#6##0" +if.else.0: + %"tmp#7##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#8##0" = insertvalue {i64, i1} %"tmp#7##0", i1 0, 1 + ret {i64, i1} %"tmp#8##0" } - -define external fastcc {i64, i1} @"multictr2.t.f03<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = and i64 %"#rec##0", 7 - %1 = icmp eq i64 %0, 2 - br i1 %1, label %if.then, label %if.else -if.then: - %2 = trunc i64 8 to i32 - %3 = tail call ccc i8* @wybe_malloc(i32 %2) - %4 = ptrtoint i8* %3 to i64 - %5 = add i64 %4, 2 - %6 = sub i64 %"#rec##0", 2 - %7 = inttoptr i64 %4 to i8* - %8 = inttoptr i64 %6 to i8* - %9 = trunc i64 8 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %7, i8* %8, i32 %9, i1 0) - %10 = add i64 %5, -2 - %11 = inttoptr i64 %10 to i64* - store i64 %"#field##0", i64* %11 - %12 = insertvalue {i64, i1} undef, i64 %5, 0 - %13 = insertvalue {i64, i1} %12, i1 1, 1 - ret {i64, i1} %13 -if.else: - %14 = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 - %15 = insertvalue {i64, i1} %14, i1 0, 1 - ret {i64, i1} %15 +define external fastcc {i64, i1} @"multictr2.t.f03<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#1##0" = and i64 %"#rec##0", 7 + %"tmp#0##0" = icmp eq i64 %"tmp#1##0", 2 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = sub i64 %"#rec##0", 2 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = call ccc ptr @wybe_malloc(i32 8) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#4##0", ptr %"tmp#3##0", i64 8, i1 0) + %"tmp#5##0" = ptrtoint ptr %"tmp#4##0" to i64 + %"tmp#6##0" = add i64 %"tmp#5##0", 2 + %"tmp#7##0" = add i64 %"tmp#6##0", -2 + %"tmp#8##0" = inttoptr i64 %"tmp#7##0" to ptr + store i64 %"#field##0", ptr %"tmp#8##0" + %"tmp#9##0" = insertvalue {i64, i1} undef, i64 %"tmp#6##0", 0 + %"tmp#10##0" = insertvalue {i64, i1} %"tmp#9##0", i1 1, 1 + ret {i64, i1} %"tmp#10##0" +if.else.0: + %"tmp#11##0" = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 + %"tmp#12##0" = insertvalue {i64, i1} %"tmp#11##0", i1 0, 1 + ret {i64, i1} %"tmp#12##0" } - -define external fastcc {i64, i1} @"multictr2.t.f04<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = and i64 %"#rec##0", 7 - %1 = icmp eq i64 %0, 3 - br i1 %1, label %if.then, label %if.else -if.then: - %2 = add i64 %"#rec##0", -3 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = insertvalue {i64, i1} undef, i64 %4, 0 - %6 = insertvalue {i64, i1} %5, i1 1, 1 - ret {i64, i1} %6 -if.else: - %7 = insertvalue {i64, i1} undef, i64 undef, 0 - %8 = insertvalue {i64, i1} %7, i1 0, 1 - ret {i64, i1} %8 +define external fastcc {i64, i1} @"multictr2.t.f04<0>"(i64 %"#rec##0") { + %"tmp#1##0" = and i64 %"#rec##0", 7 + %"tmp#0##0" = icmp eq i64 %"tmp#1##0", 3 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = add i64 %"#rec##0", -3 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#3##0" + %"tmp#5##0" = insertvalue {i64, i1} undef, i64 %"tmp#4##0", 0 + %"tmp#6##0" = insertvalue {i64, i1} %"tmp#5##0", i1 1, 1 + ret {i64, i1} %"tmp#6##0" +if.else.0: + %"tmp#7##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#8##0" = insertvalue {i64, i1} %"tmp#7##0", i1 0, 1 + ret {i64, i1} %"tmp#8##0" } - -define external fastcc {i64, i1} @"multictr2.t.f04<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = and i64 %"#rec##0", 7 - %1 = icmp eq i64 %0, 3 - br i1 %1, label %if.then, label %if.else -if.then: - %2 = trunc i64 8 to i32 - %3 = tail call ccc i8* @wybe_malloc(i32 %2) - %4 = ptrtoint i8* %3 to i64 - %5 = add i64 %4, 3 - %6 = sub i64 %"#rec##0", 3 - %7 = inttoptr i64 %4 to i8* - %8 = inttoptr i64 %6 to i8* - %9 = trunc i64 8 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %7, i8* %8, i32 %9, i1 0) - %10 = add i64 %5, -3 - %11 = inttoptr i64 %10 to i64* - store i64 %"#field##0", i64* %11 - %12 = insertvalue {i64, i1} undef, i64 %5, 0 - %13 = insertvalue {i64, i1} %12, i1 1, 1 - ret {i64, i1} %13 -if.else: - %14 = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 - %15 = insertvalue {i64, i1} %14, i1 0, 1 - ret {i64, i1} %15 +define external fastcc {i64, i1} @"multictr2.t.f04<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#1##0" = and i64 %"#rec##0", 7 + %"tmp#0##0" = icmp eq i64 %"tmp#1##0", 3 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = sub i64 %"#rec##0", 3 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = call ccc ptr @wybe_malloc(i32 8) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#4##0", ptr %"tmp#3##0", i64 8, i1 0) + %"tmp#5##0" = ptrtoint ptr %"tmp#4##0" to i64 + %"tmp#6##0" = add i64 %"tmp#5##0", 3 + %"tmp#7##0" = add i64 %"tmp#6##0", -3 + %"tmp#8##0" = inttoptr i64 %"tmp#7##0" to ptr + store i64 %"#field##0", ptr %"tmp#8##0" + %"tmp#9##0" = insertvalue {i64, i1} undef, i64 %"tmp#6##0", 0 + %"tmp#10##0" = insertvalue {i64, i1} %"tmp#9##0", i1 1, 1 + ret {i64, i1} %"tmp#10##0" +if.else.0: + %"tmp#11##0" = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 + %"tmp#12##0" = insertvalue {i64, i1} %"tmp#11##0", i1 0, 1 + ret {i64, i1} %"tmp#12##0" } - -define external fastcc {i64, i1} @"multictr2.t.f05<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = and i64 %"#rec##0", 7 - %1 = icmp eq i64 %0, 4 - br i1 %1, label %if.then, label %if.else -if.then: - %2 = add i64 %"#rec##0", -4 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = insertvalue {i64, i1} undef, i64 %4, 0 - %6 = insertvalue {i64, i1} %5, i1 1, 1 - ret {i64, i1} %6 -if.else: - %7 = insertvalue {i64, i1} undef, i64 undef, 0 - %8 = insertvalue {i64, i1} %7, i1 0, 1 - ret {i64, i1} %8 +define external fastcc {i64, i1} @"multictr2.t.f05<0>"(i64 %"#rec##0") { + %"tmp#1##0" = and i64 %"#rec##0", 7 + %"tmp#0##0" = icmp eq i64 %"tmp#1##0", 4 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = add i64 %"#rec##0", -4 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#3##0" + %"tmp#5##0" = insertvalue {i64, i1} undef, i64 %"tmp#4##0", 0 + %"tmp#6##0" = insertvalue {i64, i1} %"tmp#5##0", i1 1, 1 + ret {i64, i1} %"tmp#6##0" +if.else.0: + %"tmp#7##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#8##0" = insertvalue {i64, i1} %"tmp#7##0", i1 0, 1 + ret {i64, i1} %"tmp#8##0" } - -define external fastcc {i64, i1} @"multictr2.t.f05<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = and i64 %"#rec##0", 7 - %1 = icmp eq i64 %0, 4 - br i1 %1, label %if.then, label %if.else -if.then: - %2 = trunc i64 8 to i32 - %3 = tail call ccc i8* @wybe_malloc(i32 %2) - %4 = ptrtoint i8* %3 to i64 - %5 = add i64 %4, 4 - %6 = sub i64 %"#rec##0", 4 - %7 = inttoptr i64 %4 to i8* - %8 = inttoptr i64 %6 to i8* - %9 = trunc i64 8 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %7, i8* %8, i32 %9, i1 0) - %10 = add i64 %5, -4 - %11 = inttoptr i64 %10 to i64* - store i64 %"#field##0", i64* %11 - %12 = insertvalue {i64, i1} undef, i64 %5, 0 - %13 = insertvalue {i64, i1} %12, i1 1, 1 - ret {i64, i1} %13 -if.else: - %14 = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 - %15 = insertvalue {i64, i1} %14, i1 0, 1 - ret {i64, i1} %15 +define external fastcc {i64, i1} @"multictr2.t.f05<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#1##0" = and i64 %"#rec##0", 7 + %"tmp#0##0" = icmp eq i64 %"tmp#1##0", 4 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = sub i64 %"#rec##0", 4 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = call ccc ptr @wybe_malloc(i32 8) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#4##0", ptr %"tmp#3##0", i64 8, i1 0) + %"tmp#5##0" = ptrtoint ptr %"tmp#4##0" to i64 + %"tmp#6##0" = add i64 %"tmp#5##0", 4 + %"tmp#7##0" = add i64 %"tmp#6##0", -4 + %"tmp#8##0" = inttoptr i64 %"tmp#7##0" to ptr + store i64 %"#field##0", ptr %"tmp#8##0" + %"tmp#9##0" = insertvalue {i64, i1} undef, i64 %"tmp#6##0", 0 + %"tmp#10##0" = insertvalue {i64, i1} %"tmp#9##0", i1 1, 1 + ret {i64, i1} %"tmp#10##0" +if.else.0: + %"tmp#11##0" = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 + %"tmp#12##0" = insertvalue {i64, i1} %"tmp#11##0", i1 0, 1 + ret {i64, i1} %"tmp#12##0" } - -define external fastcc {i64, i1} @"multictr2.t.f06<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = and i64 %"#rec##0", 7 - %1 = icmp eq i64 %0, 5 - br i1 %1, label %if.then, label %if.else -if.then: - %2 = add i64 %"#rec##0", -5 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = insertvalue {i64, i1} undef, i64 %4, 0 - %6 = insertvalue {i64, i1} %5, i1 1, 1 - ret {i64, i1} %6 -if.else: - %7 = insertvalue {i64, i1} undef, i64 undef, 0 - %8 = insertvalue {i64, i1} %7, i1 0, 1 - ret {i64, i1} %8 +define external fastcc {i64, i1} @"multictr2.t.f06<0>"(i64 %"#rec##0") { + %"tmp#1##0" = and i64 %"#rec##0", 7 + %"tmp#0##0" = icmp eq i64 %"tmp#1##0", 5 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = add i64 %"#rec##0", -5 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#3##0" + %"tmp#5##0" = insertvalue {i64, i1} undef, i64 %"tmp#4##0", 0 + %"tmp#6##0" = insertvalue {i64, i1} %"tmp#5##0", i1 1, 1 + ret {i64, i1} %"tmp#6##0" +if.else.0: + %"tmp#7##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#8##0" = insertvalue {i64, i1} %"tmp#7##0", i1 0, 1 + ret {i64, i1} %"tmp#8##0" } - -define external fastcc {i64, i1} @"multictr2.t.f06<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = and i64 %"#rec##0", 7 - %1 = icmp eq i64 %0, 5 - br i1 %1, label %if.then, label %if.else -if.then: - %2 = trunc i64 8 to i32 - %3 = tail call ccc i8* @wybe_malloc(i32 %2) - %4 = ptrtoint i8* %3 to i64 - %5 = add i64 %4, 5 - %6 = sub i64 %"#rec##0", 5 - %7 = inttoptr i64 %4 to i8* - %8 = inttoptr i64 %6 to i8* - %9 = trunc i64 8 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %7, i8* %8, i32 %9, i1 0) - %10 = add i64 %5, -5 - %11 = inttoptr i64 %10 to i64* - store i64 %"#field##0", i64* %11 - %12 = insertvalue {i64, i1} undef, i64 %5, 0 - %13 = insertvalue {i64, i1} %12, i1 1, 1 - ret {i64, i1} %13 -if.else: - %14 = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 - %15 = insertvalue {i64, i1} %14, i1 0, 1 - ret {i64, i1} %15 +define external fastcc {i64, i1} @"multictr2.t.f06<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#1##0" = and i64 %"#rec##0", 7 + %"tmp#0##0" = icmp eq i64 %"tmp#1##0", 5 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = sub i64 %"#rec##0", 5 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = call ccc ptr @wybe_malloc(i32 8) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#4##0", ptr %"tmp#3##0", i64 8, i1 0) + %"tmp#5##0" = ptrtoint ptr %"tmp#4##0" to i64 + %"tmp#6##0" = add i64 %"tmp#5##0", 5 + %"tmp#7##0" = add i64 %"tmp#6##0", -5 + %"tmp#8##0" = inttoptr i64 %"tmp#7##0" to ptr + store i64 %"#field##0", ptr %"tmp#8##0" + %"tmp#9##0" = insertvalue {i64, i1} undef, i64 %"tmp#6##0", 0 + %"tmp#10##0" = insertvalue {i64, i1} %"tmp#9##0", i1 1, 1 + ret {i64, i1} %"tmp#10##0" +if.else.0: + %"tmp#11##0" = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 + %"tmp#12##0" = insertvalue {i64, i1} %"tmp#11##0", i1 0, 1 + ret {i64, i1} %"tmp#12##0" } - -define external fastcc {i64, i1} @"multictr2.t.f07<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = and i64 %"#rec##0", 7 - %1 = icmp eq i64 %0, 6 - br i1 %1, label %if.then, label %if.else -if.then: - %2 = add i64 %"#rec##0", -6 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = insertvalue {i64, i1} undef, i64 %4, 0 - %6 = insertvalue {i64, i1} %5, i1 1, 1 - ret {i64, i1} %6 -if.else: - %7 = insertvalue {i64, i1} undef, i64 undef, 0 - %8 = insertvalue {i64, i1} %7, i1 0, 1 - ret {i64, i1} %8 +define external fastcc {i64, i1} @"multictr2.t.f07<0>"(i64 %"#rec##0") { + %"tmp#1##0" = and i64 %"#rec##0", 7 + %"tmp#0##0" = icmp eq i64 %"tmp#1##0", 6 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = add i64 %"#rec##0", -6 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#3##0" + %"tmp#5##0" = insertvalue {i64, i1} undef, i64 %"tmp#4##0", 0 + %"tmp#6##0" = insertvalue {i64, i1} %"tmp#5##0", i1 1, 1 + ret {i64, i1} %"tmp#6##0" +if.else.0: + %"tmp#7##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#8##0" = insertvalue {i64, i1} %"tmp#7##0", i1 0, 1 + ret {i64, i1} %"tmp#8##0" } - -define external fastcc {i64, i1} @"multictr2.t.f07<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = and i64 %"#rec##0", 7 - %1 = icmp eq i64 %0, 6 - br i1 %1, label %if.then, label %if.else -if.then: - %2 = trunc i64 8 to i32 - %3 = tail call ccc i8* @wybe_malloc(i32 %2) - %4 = ptrtoint i8* %3 to i64 - %5 = add i64 %4, 6 - %6 = sub i64 %"#rec##0", 6 - %7 = inttoptr i64 %4 to i8* - %8 = inttoptr i64 %6 to i8* - %9 = trunc i64 8 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %7, i8* %8, i32 %9, i1 0) - %10 = add i64 %5, -6 - %11 = inttoptr i64 %10 to i64* - store i64 %"#field##0", i64* %11 - %12 = insertvalue {i64, i1} undef, i64 %5, 0 - %13 = insertvalue {i64, i1} %12, i1 1, 1 - ret {i64, i1} %13 -if.else: - %14 = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 - %15 = insertvalue {i64, i1} %14, i1 0, 1 - ret {i64, i1} %15 +define external fastcc {i64, i1} @"multictr2.t.f07<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#1##0" = and i64 %"#rec##0", 7 + %"tmp#0##0" = icmp eq i64 %"tmp#1##0", 6 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = sub i64 %"#rec##0", 6 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = call ccc ptr @wybe_malloc(i32 8) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#4##0", ptr %"tmp#3##0", i64 8, i1 0) + %"tmp#5##0" = ptrtoint ptr %"tmp#4##0" to i64 + %"tmp#6##0" = add i64 %"tmp#5##0", 6 + %"tmp#7##0" = add i64 %"tmp#6##0", -6 + %"tmp#8##0" = inttoptr i64 %"tmp#7##0" to ptr + store i64 %"#field##0", ptr %"tmp#8##0" + %"tmp#9##0" = insertvalue {i64, i1} undef, i64 %"tmp#6##0", 0 + %"tmp#10##0" = insertvalue {i64, i1} %"tmp#9##0", i1 1, 1 + ret {i64, i1} %"tmp#10##0" +if.else.0: + %"tmp#11##0" = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 + %"tmp#12##0" = insertvalue {i64, i1} %"tmp#11##0", i1 0, 1 + ret {i64, i1} %"tmp#12##0" } - -define external fastcc {i64, i1} @"multictr2.t.f08_a<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = and i64 %"#rec##0", 7 - %1 = icmp eq i64 %0, 7 - br i1 %1, label %if.then, label %if.else -if.then: - %2 = add i64 %"#rec##0", -7 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = insertvalue {i64, i1} undef, i64 %4, 0 - %6 = insertvalue {i64, i1} %5, i1 1, 1 - ret {i64, i1} %6 -if.else: - %7 = insertvalue {i64, i1} undef, i64 undef, 0 - %8 = insertvalue {i64, i1} %7, i1 0, 1 - ret {i64, i1} %8 +define external fastcc {i64, i1} @"multictr2.t.f08_a<0>"(i64 %"#rec##0") { + %"tmp#1##0" = and i64 %"#rec##0", 7 + %"tmp#0##0" = icmp eq i64 %"tmp#1##0", 7 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = add i64 %"#rec##0", -7 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#3##0" + %"tmp#5##0" = insertvalue {i64, i1} undef, i64 %"tmp#4##0", 0 + %"tmp#6##0" = insertvalue {i64, i1} %"tmp#5##0", i1 1, 1 + ret {i64, i1} %"tmp#6##0" +if.else.0: + %"tmp#7##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#8##0" = insertvalue {i64, i1} %"tmp#7##0", i1 0, 1 + ret {i64, i1} %"tmp#8##0" } - -define external fastcc {i64, i1} @"multictr2.t.f08_a<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = and i64 %"#rec##0", 7 - %1 = icmp eq i64 %0, 7 - br i1 %1, label %if.then, label %if.else -if.then: - %2 = trunc i64 24 to i32 - %3 = tail call ccc i8* @wybe_malloc(i32 %2) - %4 = ptrtoint i8* %3 to i64 - %5 = add i64 %4, 7 - %6 = sub i64 %"#rec##0", 7 - %7 = inttoptr i64 %4 to i8* - %8 = inttoptr i64 %6 to i8* - %9 = trunc i64 24 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %7, i8* %8, i32 %9, i1 0) - %10 = add i64 %5, -7 - %11 = inttoptr i64 %10 to i64* - store i64 %"#field##0", i64* %11 - %12 = insertvalue {i64, i1} undef, i64 %5, 0 - %13 = insertvalue {i64, i1} %12, i1 1, 1 - ret {i64, i1} %13 -if.else: - %14 = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 - %15 = insertvalue {i64, i1} %14, i1 0, 1 - ret {i64, i1} %15 +define external fastcc {i64, i1} @"multictr2.t.f08_a<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#1##0" = and i64 %"#rec##0", 7 + %"tmp#0##0" = icmp eq i64 %"tmp#1##0", 7 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = sub i64 %"#rec##0", 7 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = call ccc ptr @wybe_malloc(i32 24) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#4##0", ptr %"tmp#3##0", i64 24, i1 0) + %"tmp#5##0" = ptrtoint ptr %"tmp#4##0" to i64 + %"tmp#6##0" = add i64 %"tmp#5##0", 7 + %"tmp#7##0" = add i64 %"tmp#6##0", -7 + %"tmp#8##0" = inttoptr i64 %"tmp#7##0" to ptr + store i64 %"#field##0", ptr %"tmp#8##0" + %"tmp#9##0" = insertvalue {i64, i1} undef, i64 %"tmp#6##0", 0 + %"tmp#10##0" = insertvalue {i64, i1} %"tmp#9##0", i1 1, 1 + ret {i64, i1} %"tmp#10##0" +if.else.0: + %"tmp#11##0" = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 + %"tmp#12##0" = insertvalue {i64, i1} %"tmp#11##0", i1 0, 1 + ret {i64, i1} %"tmp#12##0" } - -define external fastcc {i64, i1} @"multictr2.t.f08_b<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = and i64 %"#rec##0", 7 - %1 = icmp eq i64 %0, 7 - br i1 %1, label %if.then, label %if.else -if.then: - %2 = add i64 %"#rec##0", 1 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = insertvalue {i64, i1} undef, i64 %4, 0 - %6 = insertvalue {i64, i1} %5, i1 1, 1 - ret {i64, i1} %6 -if.else: - %7 = insertvalue {i64, i1} undef, i64 undef, 0 - %8 = insertvalue {i64, i1} %7, i1 0, 1 - ret {i64, i1} %8 +define external fastcc {i64, i1} @"multictr2.t.f08_b<0>"(i64 %"#rec##0") { + %"tmp#1##0" = and i64 %"#rec##0", 7 + %"tmp#0##0" = icmp eq i64 %"tmp#1##0", 7 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = add i64 %"#rec##0", 1 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#3##0" + %"tmp#5##0" = insertvalue {i64, i1} undef, i64 %"tmp#4##0", 0 + %"tmp#6##0" = insertvalue {i64, i1} %"tmp#5##0", i1 1, 1 + ret {i64, i1} %"tmp#6##0" +if.else.0: + %"tmp#7##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#8##0" = insertvalue {i64, i1} %"tmp#7##0", i1 0, 1 + ret {i64, i1} %"tmp#8##0" } - -define external fastcc {i64, i1} @"multictr2.t.f08_b<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = and i64 %"#rec##0", 7 - %1 = icmp eq i64 %0, 7 - br i1 %1, label %if.then, label %if.else -if.then: - %2 = trunc i64 24 to i32 - %3 = tail call ccc i8* @wybe_malloc(i32 %2) - %4 = ptrtoint i8* %3 to i64 - %5 = add i64 %4, 7 - %6 = sub i64 %"#rec##0", 7 - %7 = inttoptr i64 %4 to i8* - %8 = inttoptr i64 %6 to i8* - %9 = trunc i64 24 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %7, i8* %8, i32 %9, i1 0) - %10 = add i64 %5, 1 - %11 = inttoptr i64 %10 to i64* - store i64 %"#field##0", i64* %11 - %12 = insertvalue {i64, i1} undef, i64 %5, 0 - %13 = insertvalue {i64, i1} %12, i1 1, 1 - ret {i64, i1} %13 -if.else: - %14 = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 - %15 = insertvalue {i64, i1} %14, i1 0, 1 - ret {i64, i1} %15 +define external fastcc {i64, i1} @"multictr2.t.f08_b<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#1##0" = and i64 %"#rec##0", 7 + %"tmp#0##0" = icmp eq i64 %"tmp#1##0", 7 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = sub i64 %"#rec##0", 7 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = call ccc ptr @wybe_malloc(i32 24) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#4##0", ptr %"tmp#3##0", i64 24, i1 0) + %"tmp#5##0" = ptrtoint ptr %"tmp#4##0" to i64 + %"tmp#6##0" = add i64 %"tmp#5##0", 7 + %"tmp#7##0" = add i64 %"tmp#6##0", 1 + %"tmp#8##0" = inttoptr i64 %"tmp#7##0" to ptr + store i64 %"#field##0", ptr %"tmp#8##0" + %"tmp#9##0" = insertvalue {i64, i1} undef, i64 %"tmp#6##0", 0 + %"tmp#10##0" = insertvalue {i64, i1} %"tmp#9##0", i1 1, 1 + ret {i64, i1} %"tmp#10##0" +if.else.0: + %"tmp#11##0" = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 + %"tmp#12##0" = insertvalue {i64, i1} %"tmp#11##0", i1 0, 1 + ret {i64, i1} %"tmp#12##0" } - -define external fastcc {double, i1} @"multictr2.t.f08_c<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = and i64 %"#rec##0", 7 - %1 = icmp eq i64 %0, 7 - br i1 %1, label %if.then, label %if.else -if.then: - %2 = add i64 %"#rec##0", 9 - %3 = inttoptr i64 %2 to double* - %4 = load double, double* %3 - %5 = insertvalue {double, i1} undef, double %4, 0 - %6 = insertvalue {double, i1} %5, i1 1, 1 - ret {double, i1} %6 -if.else: - %7 = insertvalue {double, i1} undef, double undef, 0 - %8 = insertvalue {double, i1} %7, i1 0, 1 - ret {double, i1} %8 +define external fastcc {double, i1} @"multictr2.t.f08_c<0>"(i64 %"#rec##0") { + %"tmp#1##0" = and i64 %"#rec##0", 7 + %"tmp#0##0" = icmp eq i64 %"tmp#1##0", 7 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = add i64 %"#rec##0", 9 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = load double, ptr %"tmp#3##0" + %"tmp#5##0" = insertvalue {double, i1} undef, double %"tmp#4##0", 0 + %"tmp#6##0" = insertvalue {double, i1} %"tmp#5##0", i1 1, 1 + ret {double, i1} %"tmp#6##0" +if.else.0: + %"tmp#7##0" = insertvalue {double, i1} undef, double undef, 0 + %"tmp#8##0" = insertvalue {double, i1} %"tmp#7##0", i1 0, 1 + ret {double, i1} %"tmp#8##0" } - -define external fastcc {i64, i1} @"multictr2.t.f08_c<1>"(i64 %"#rec##0", double %"#field##0") alwaysinline { -entry: - %0 = and i64 %"#rec##0", 7 - %1 = icmp eq i64 %0, 7 - br i1 %1, label %if.then, label %if.else -if.then: - %2 = trunc i64 24 to i32 - %3 = tail call ccc i8* @wybe_malloc(i32 %2) - %4 = ptrtoint i8* %3 to i64 - %5 = add i64 %4, 7 - %6 = sub i64 %"#rec##0", 7 - %7 = inttoptr i64 %4 to i8* - %8 = inttoptr i64 %6 to i8* - %9 = trunc i64 24 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %7, i8* %8, i32 %9, i1 0) - %10 = add i64 %5, 9 - %11 = inttoptr i64 %10 to double* - store double %"#field##0", double* %11 - %12 = insertvalue {i64, i1} undef, i64 %5, 0 - %13 = insertvalue {i64, i1} %12, i1 1, 1 - ret {i64, i1} %13 -if.else: - %14 = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 - %15 = insertvalue {i64, i1} %14, i1 0, 1 - ret {i64, i1} %15 +define external fastcc {i64, i1} @"multictr2.t.f08_c<1>"(i64 %"#rec##0", double %"#field##0") { + %"tmp#1##0" = and i64 %"#rec##0", 7 + %"tmp#0##0" = icmp eq i64 %"tmp#1##0", 7 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = sub i64 %"#rec##0", 7 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = call ccc ptr @wybe_malloc(i32 24) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#4##0", ptr %"tmp#3##0", i64 24, i1 0) + %"tmp#5##0" = ptrtoint ptr %"tmp#4##0" to i64 + %"tmp#6##0" = add i64 %"tmp#5##0", 7 + %"tmp#7##0" = add i64 %"tmp#6##0", 9 + %"tmp#8##0" = inttoptr i64 %"tmp#7##0" to ptr + store double %"#field##0", ptr %"tmp#8##0" + %"tmp#9##0" = insertvalue {i64, i1} undef, i64 %"tmp#6##0", 0 + %"tmp#10##0" = insertvalue {i64, i1} %"tmp#9##0", i1 1, 1 + ret {i64, i1} %"tmp#10##0" +if.else.0: + %"tmp#11##0" = insertvalue {i64, i1} undef, i64 %"#rec##0", 0 + %"tmp#12##0" = insertvalue {i64, i1} %"tmp#11##0", i1 0, 1 + ret {i64, i1} %"tmp#12##0" } - -define external fastcc i1 @"multictr2.t.~=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = tail call fastcc i1 @"multictr2.t.=<0>"(i64 %"#left##0", i64 %"#right##0") - %1 = xor i1 %0, 1 - ret i1 %1 +define external fastcc i1 @"multictr2.t.~=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#0##0" = tail call fastcc i1 @"multictr2.t.=<0>"(i64 %"#left##0", i64 %"#right##0") + %"tmp#1##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#1##0" } diff --git a/test-cases/final-dump/mutual_res_a.exp b/test-cases/final-dump/mutual_res_a.exp index a48b38bfd..de9c929b3 100644 --- a/test-cases/final-dump/mutual_res_a.exp +++ b/test-cases/final-dump/mutual_res_a.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module mutual_res_a representation : (not a type) public submods : @@ -13,19 +16,16 @@ AFTER EVERYTHING: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'mutual_res_a' - - - - -@"resource#mutual_res_a.a_res" = global i64 undef +source_filename = "!ROOT!/final-dump/mutual_res_a.wybe" +target triple ???? -declare external ccc i8* @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) +@"resource#mutual_res_a.a_res" = global i64 undef - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) -------------------------------------------------- Module mutual_res_b representation : (not a type) @@ -40,16 +40,12 @@ declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'mutual_res_b' - - - - -@"resource#mutual_res_b.b_res" = global i8 undef - - -declare external ccc i8* @wybe_malloc(i32) +source_filename = "!ROOT!/final-dump/mutual_res_b.wybe" +target triple ???? -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) +@"resource#mutual_res_b.b_res" = global i8 undef diff --git a/test-cases/final-dump/mutual_res_b.exp b/test-cases/final-dump/mutual_res_b.exp index a48b38bfd..de9c929b3 100644 --- a/test-cases/final-dump/mutual_res_b.exp +++ b/test-cases/final-dump/mutual_res_b.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module mutual_res_a representation : (not a type) public submods : @@ -13,19 +16,16 @@ AFTER EVERYTHING: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'mutual_res_a' - - - - -@"resource#mutual_res_a.a_res" = global i64 undef +source_filename = "!ROOT!/final-dump/mutual_res_a.wybe" +target triple ???? -declare external ccc i8* @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) +@"resource#mutual_res_a.a_res" = global i64 undef - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) -------------------------------------------------- Module mutual_res_b representation : (not a type) @@ -40,16 +40,12 @@ declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'mutual_res_b' - - - - -@"resource#mutual_res_b.b_res" = global i8 undef - - -declare external ccc i8* @wybe_malloc(i32) +source_filename = "!ROOT!/final-dump/mutual_res_b.wybe" +target triple ???? -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) +@"resource#mutual_res_b.b_res" = global i8 undef diff --git a/test-cases/final-dump/mutual_type.exp b/test-cases/final-dump/mutual_type.exp index e6574bfe2..933cc7adf 100644 --- a/test-cases/final-dump/mutual_type.exp +++ b/test-cases/final-dump/mutual_type.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module mutual_type representation : (not a type) public submods : @@ -15,19 +18,18 @@ AFTER EVERYTHING: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'mutual_type' +source_filename = "!ROOT!/final-dump/mutual_type.wybe" +target triple ???? - +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) -------------------------------------------------- Module mutual_type.a - representation : address + representation : pointer public submods : public resources: public procs : mutual_type.a.=<0> @@ -186,186 +188,161 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'mutual_type.a' - - - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i1 @"mutual_type.a.=<0>"(i64 %"#left##0", i64 %"#right##0") { -entry: - %0 = icmp ne i64 %"#left##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"#left##0" to i64* - %2 = load i64, i64* %1 - %3 = add i64 %"#left##0", 8 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = icmp ne i64 %"#right##0", 0 - br i1 %6, label %if.then1, label %if.else1 -if.else: - %14 = icmp eq i64 %"#right##0", 0 - ret i1 %14 -if.then1: - %7 = inttoptr i64 %"#right##0" to i64* - %8 = load i64, i64* %7 - %9 = add i64 %"#right##0", 8 - %10 = inttoptr i64 %9 to i64* - %11 = load i64, i64* %10 - %12 = icmp eq i64 %2, %8 - br i1 %12, label %if.then2, label %if.else2 -if.else1: - ret i1 0 -if.then2: - %13 = musttail call fastcc i1 @"mutual_type.b.=<0>"(i64 %5, i64 %11) - ret i1 %13 -if.else2: - ret i1 0 +source_filename = "!ROOT!/final-dump/mutual_type.wybe" +target triple ???? + + +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc i1 @"mutual_type.a.=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#0##0" = icmp ne i64 %"#left##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#12##0" = inttoptr i64 %"#left##0" to ptr + %"#left#ahead##0" = load i64, ptr %"tmp#12##0" + %"tmp#13##0" = add i64 %"#left##0", 8 + %"tmp#14##0" = inttoptr i64 %"tmp#13##0" to ptr + %"#left#atail##0" = load i64, ptr %"tmp#14##0" + %"tmp#9##0" = icmp ne i64 %"#right##0", 0 + br i1 %"tmp#9##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#15##0" = inttoptr i64 %"#right##0" to ptr + %"#right#ahead##0" = load i64, ptr %"tmp#15##0" + %"tmp#16##0" = add i64 %"#right##0", 8 + %"tmp#17##0" = inttoptr i64 %"tmp#16##0" to ptr + %"#right#atail##0" = load i64, ptr %"tmp#17##0" + %"tmp#4##0" = icmp eq i64 %"#left#ahead##0", %"#right#ahead##0" + br i1 %"tmp#4##0", label %if.then.2, label %if.else.2 +if.then.2: + %"tmp#18##0" = tail call fastcc i1 @"mutual_type.b.=<0>"(i64 %"#left#atail##0", i64 %"#right#atail##0") + ret i1 %"tmp#18##0" +if.else.2: + ret i1 0 +if.else.1: + ret i1 0 +if.else.0: + %"tmp#19##0" = icmp eq i64 %"#right##0", 0 + ret i1 %"tmp#19##0" } - -define external fastcc i64 @"mutual_type.a.a<0>"(i64 %"ahead##0", i64 %"atail##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"ahead##0", i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"atail##0", i64* %5 - ret i64 %2 +define external fastcc i64 @"mutual_type.a.a<0>"(i64 %"ahead##0", i64 %"atail##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 16) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"ahead##0", ptr %"tmp#1##0" + %"tmp#2##0" = add i64 %"#rec##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"atail##0", ptr %"tmp#3##0" + ret i64 %"#rec##0" } - -define external fastcc {i64, i64, i1} @"mutual_type.a.a<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#result##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"#result##0" to i64* - %2 = load i64, i64* %1 - %3 = add i64 %"#result##0", 8 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = insertvalue {i64, i64, i1} undef, i64 %2, 0 - %7 = insertvalue {i64, i64, i1} %6, i64 %5, 1 - %8 = insertvalue {i64, i64, i1} %7, i1 1, 2 - ret {i64, i64, i1} %8 -if.else: - %9 = insertvalue {i64, i64, i1} undef, i64 undef, 0 - %10 = insertvalue {i64, i64, i1} %9, i64 undef, 1 - %11 = insertvalue {i64, i64, i1} %10, i1 0, 2 - ret {i64, i64, i1} %11 +define external fastcc {i64, i64, i1} @"mutual_type.a.a<1>"(i64 %"#result##0") { + %"tmp#0##0" = icmp ne i64 %"#result##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = inttoptr i64 %"#result##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + %"tmp#3##0" = add i64 %"#result##0", 8 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#4##0" + %"tmp#6##0" = insertvalue {i64, i64, i1} undef, i64 %"tmp#2##0", 0 + %"tmp#7##0" = insertvalue {i64, i64, i1} %"tmp#6##0", i64 %"tmp#5##0", 1 + %"tmp#8##0" = insertvalue {i64, i64, i1} %"tmp#7##0", i1 1, 2 + ret {i64, i64, i1} %"tmp#8##0" +if.else.0: + %"tmp#9##0" = insertvalue {i64, i64, i1} undef, i64 undef, 0 + %"tmp#10##0" = insertvalue {i64, i64, i1} %"tmp#9##0", i64 undef, 1 + %"tmp#11##0" = insertvalue {i64, i64, i1} %"tmp#10##0", i1 0, 2 + ret {i64, i64, i1} %"tmp#11##0" } - -define external fastcc {i64, i1} @"mutual_type.a.ahead<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"#rec##0" to i64* - %2 = load i64, i64* %1 - %3 = insertvalue {i64, i1} undef, i64 %2, 0 - %4 = insertvalue {i64, i1} %3, i1 1, 1 - ret {i64, i1} %4 -if.else: - %5 = insertvalue {i64, i1} undef, i64 undef, 0 - %6 = insertvalue {i64, i1} %5, i1 0, 1 - ret {i64, i1} %6 +define external fastcc {i64, i1} @"mutual_type.a.ahead<0>"(i64 %"#rec##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + %"tmp#3##0" = insertvalue {i64, i1} undef, i64 %"tmp#2##0", 0 + %"tmp#4##0" = insertvalue {i64, i1} %"tmp#3##0", i1 1, 1 + ret {i64, i1} %"tmp#4##0" +if.else.0: + %"tmp#5##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#6##0" = insertvalue {i64, i1} %"tmp#5##0", i1 0, 1 + ret {i64, i1} %"tmp#6##0" } - -define external fastcc {i64, i1} @"mutual_type.a.ahead<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = trunc i64 16 to i32 - %2 = tail call ccc i8* @wybe_malloc(i32 %1) - %3 = ptrtoint i8* %2 to i64 - %4 = inttoptr i64 %3 to i8* - %5 = inttoptr i64 %"#rec##0" to i8* - %6 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %4, i8* %5, i32 %6, i1 0) - %7 = inttoptr i64 %3 to i64* - store i64 %"#field##0", i64* %7 - %8 = insertvalue {i64, i1} undef, i64 %3, 0 - %9 = insertvalue {i64, i1} %8, i1 1, 1 - ret {i64, i1} %9 -if.else: - %10 = insertvalue {i64, i1} undef, i64 0, 0 - %11 = insertvalue {i64, i1} %10, i1 0, 1 - ret {i64, i1} %11 +define external fastcc {i64, i1} @"mutual_type.a.ahead<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#2##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#2##0", ptr %"tmp#1##0", i64 16, i1 0) + %"tmp#3##0" = ptrtoint ptr %"tmp#2##0" to i64 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 %"#field##0", ptr %"tmp#4##0" + %"tmp#5##0" = insertvalue {i64, i1} undef, i64 %"tmp#3##0", 0 + %"tmp#6##0" = insertvalue {i64, i1} %"tmp#5##0", i1 1, 1 + ret {i64, i1} %"tmp#6##0" +if.else.0: + %"tmp#7##0" = insertvalue {i64, i1} undef, i64 0, 0 + %"tmp#8##0" = insertvalue {i64, i1} %"tmp#7##0", i1 0, 1 + ret {i64, i1} %"tmp#8##0" } - -define external fastcc {i64, i1} @"mutual_type.a.atail<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = add i64 %"#rec##0", 8 - %2 = inttoptr i64 %1 to i64* - %3 = load i64, i64* %2 - %4 = insertvalue {i64, i1} undef, i64 %3, 0 - %5 = insertvalue {i64, i1} %4, i1 1, 1 - ret {i64, i1} %5 -if.else: - %6 = insertvalue {i64, i1} undef, i64 undef, 0 - %7 = insertvalue {i64, i1} %6, i1 0, 1 - ret {i64, i1} %7 +define external fastcc {i64, i1} @"mutual_type.a.atail<0>"(i64 %"#rec##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = add i64 %"#rec##0", 8 + %"tmp#2##0" = inttoptr i64 %"tmp#1##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#2##0" + %"tmp#4##0" = insertvalue {i64, i1} undef, i64 %"tmp#3##0", 0 + %"tmp#5##0" = insertvalue {i64, i1} %"tmp#4##0", i1 1, 1 + ret {i64, i1} %"tmp#5##0" +if.else.0: + %"tmp#6##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#7##0" = insertvalue {i64, i1} %"tmp#6##0", i1 0, 1 + ret {i64, i1} %"tmp#7##0" } - -define external fastcc {i64, i1} @"mutual_type.a.atail<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = trunc i64 16 to i32 - %2 = tail call ccc i8* @wybe_malloc(i32 %1) - %3 = ptrtoint i8* %2 to i64 - %4 = inttoptr i64 %3 to i8* - %5 = inttoptr i64 %"#rec##0" to i8* - %6 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %4, i8* %5, i32 %6, i1 0) - %7 = add i64 %3, 8 - %8 = inttoptr i64 %7 to i64* - store i64 %"#field##0", i64* %8 - %9 = insertvalue {i64, i1} undef, i64 %3, 0 - %10 = insertvalue {i64, i1} %9, i1 1, 1 - ret {i64, i1} %10 -if.else: - %11 = insertvalue {i64, i1} undef, i64 0, 0 - %12 = insertvalue {i64, i1} %11, i1 0, 1 - ret {i64, i1} %12 +define external fastcc {i64, i1} @"mutual_type.a.atail<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#2##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#2##0", ptr %"tmp#1##0", i64 16, i1 0) + %"tmp#3##0" = ptrtoint ptr %"tmp#2##0" to i64 + %"tmp#4##0" = add i64 %"tmp#3##0", 8 + %"tmp#5##0" = inttoptr i64 %"tmp#4##0" to ptr + store i64 %"#field##0", ptr %"tmp#5##0" + %"tmp#6##0" = insertvalue {i64, i1} undef, i64 %"tmp#3##0", 0 + %"tmp#7##0" = insertvalue {i64, i1} %"tmp#6##0", i1 1, 1 + ret {i64, i1} %"tmp#7##0" +if.else.0: + %"tmp#8##0" = insertvalue {i64, i1} undef, i64 0, 0 + %"tmp#9##0" = insertvalue {i64, i1} %"tmp#8##0", i1 0, 1 + ret {i64, i1} %"tmp#9##0" } - -define external fastcc i64 @"mutual_type.a.no_a<0>"() alwaysinline { -entry: - ret i64 0 +define external fastcc i64 @"mutual_type.a.no_a<0>"() { + ret i64 0 } - -define external fastcc i1 @"mutual_type.a.~=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = tail call fastcc i1 @"mutual_type.a.=<0>"(i64 %"#left##0", i64 %"#right##0") - %1 = xor i1 %0, 1 - ret i1 %1 +define external fastcc i1 @"mutual_type.a.~=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#0##0" = tail call fastcc i1 @"mutual_type.a.=<0>"(i64 %"#left##0", i64 %"#right##0") + %"tmp#1##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#1##0" } + -------------------------------------------------- Module mutual_type.b - representation : address + representation : pointer public submods : public resources: public procs : mutual_type.b.=<0> @@ -524,180 +501,154 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'mutual_type.b' - - - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i1 @"mutual_type.b.=<0>"(i64 %"#left##0", i64 %"#right##0") { -entry: - %0 = icmp ne i64 %"#left##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"#left##0" to i64* - %2 = load i64, i64* %1 - %3 = add i64 %"#left##0", 8 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = icmp ne i64 %"#right##0", 0 - br i1 %6, label %if.then1, label %if.else1 -if.else: - %14 = icmp eq i64 %"#right##0", 0 - ret i1 %14 -if.then1: - %7 = inttoptr i64 %"#right##0" to i64* - %8 = load i64, i64* %7 - %9 = add i64 %"#right##0", 8 - %10 = inttoptr i64 %9 to i64* - %11 = load i64, i64* %10 - %12 = icmp eq i64 %2, %8 - br i1 %12, label %if.then2, label %if.else2 -if.else1: - ret i1 0 -if.then2: - %13 = musttail call fastcc i1 @"mutual_type.a.=<0>"(i64 %5, i64 %11) - ret i1 %13 -if.else2: - ret i1 0 +source_filename = "!ROOT!/final-dump/mutual_type.wybe" +target triple ???? + + +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc i1 @"mutual_type.b.=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#0##0" = icmp ne i64 %"#left##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#12##0" = inttoptr i64 %"#left##0" to ptr + %"#left#bhead##0" = load i64, ptr %"tmp#12##0" + %"tmp#13##0" = add i64 %"#left##0", 8 + %"tmp#14##0" = inttoptr i64 %"tmp#13##0" to ptr + %"#left#btail##0" = load i64, ptr %"tmp#14##0" + %"tmp#9##0" = icmp ne i64 %"#right##0", 0 + br i1 %"tmp#9##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#15##0" = inttoptr i64 %"#right##0" to ptr + %"#right#bhead##0" = load i64, ptr %"tmp#15##0" + %"tmp#16##0" = add i64 %"#right##0", 8 + %"tmp#17##0" = inttoptr i64 %"tmp#16##0" to ptr + %"#right#btail##0" = load i64, ptr %"tmp#17##0" + %"tmp#4##0" = icmp eq i64 %"#left#bhead##0", %"#right#bhead##0" + br i1 %"tmp#4##0", label %if.then.2, label %if.else.2 +if.then.2: + %"tmp#18##0" = tail call fastcc i1 @"mutual_type.a.=<0>"(i64 %"#left#btail##0", i64 %"#right#btail##0") + ret i1 %"tmp#18##0" +if.else.2: + ret i1 0 +if.else.1: + ret i1 0 +if.else.0: + %"tmp#19##0" = icmp eq i64 %"#right##0", 0 + ret i1 %"tmp#19##0" } - -define external fastcc i64 @"mutual_type.b.b<0>"(i64 %"bhead##0", i64 %"btail##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"bhead##0", i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"btail##0", i64* %5 - ret i64 %2 +define external fastcc i64 @"mutual_type.b.b<0>"(i64 %"bhead##0", i64 %"btail##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 16) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"bhead##0", ptr %"tmp#1##0" + %"tmp#2##0" = add i64 %"#rec##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"btail##0", ptr %"tmp#3##0" + ret i64 %"#rec##0" } - -define external fastcc {i64, i64, i1} @"mutual_type.b.b<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#result##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"#result##0" to i64* - %2 = load i64, i64* %1 - %3 = add i64 %"#result##0", 8 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = insertvalue {i64, i64, i1} undef, i64 %2, 0 - %7 = insertvalue {i64, i64, i1} %6, i64 %5, 1 - %8 = insertvalue {i64, i64, i1} %7, i1 1, 2 - ret {i64, i64, i1} %8 -if.else: - %9 = insertvalue {i64, i64, i1} undef, i64 undef, 0 - %10 = insertvalue {i64, i64, i1} %9, i64 undef, 1 - %11 = insertvalue {i64, i64, i1} %10, i1 0, 2 - ret {i64, i64, i1} %11 +define external fastcc {i64, i64, i1} @"mutual_type.b.b<1>"(i64 %"#result##0") { + %"tmp#0##0" = icmp ne i64 %"#result##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = inttoptr i64 %"#result##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + %"tmp#3##0" = add i64 %"#result##0", 8 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#4##0" + %"tmp#6##0" = insertvalue {i64, i64, i1} undef, i64 %"tmp#2##0", 0 + %"tmp#7##0" = insertvalue {i64, i64, i1} %"tmp#6##0", i64 %"tmp#5##0", 1 + %"tmp#8##0" = insertvalue {i64, i64, i1} %"tmp#7##0", i1 1, 2 + ret {i64, i64, i1} %"tmp#8##0" +if.else.0: + %"tmp#9##0" = insertvalue {i64, i64, i1} undef, i64 undef, 0 + %"tmp#10##0" = insertvalue {i64, i64, i1} %"tmp#9##0", i64 undef, 1 + %"tmp#11##0" = insertvalue {i64, i64, i1} %"tmp#10##0", i1 0, 2 + ret {i64, i64, i1} %"tmp#11##0" } - -define external fastcc {i64, i1} @"mutual_type.b.bhead<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"#rec##0" to i64* - %2 = load i64, i64* %1 - %3 = insertvalue {i64, i1} undef, i64 %2, 0 - %4 = insertvalue {i64, i1} %3, i1 1, 1 - ret {i64, i1} %4 -if.else: - %5 = insertvalue {i64, i1} undef, i64 undef, 0 - %6 = insertvalue {i64, i1} %5, i1 0, 1 - ret {i64, i1} %6 +define external fastcc {i64, i1} @"mutual_type.b.bhead<0>"(i64 %"#rec##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + %"tmp#3##0" = insertvalue {i64, i1} undef, i64 %"tmp#2##0", 0 + %"tmp#4##0" = insertvalue {i64, i1} %"tmp#3##0", i1 1, 1 + ret {i64, i1} %"tmp#4##0" +if.else.0: + %"tmp#5##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#6##0" = insertvalue {i64, i1} %"tmp#5##0", i1 0, 1 + ret {i64, i1} %"tmp#6##0" } - -define external fastcc {i64, i1} @"mutual_type.b.bhead<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = trunc i64 16 to i32 - %2 = tail call ccc i8* @wybe_malloc(i32 %1) - %3 = ptrtoint i8* %2 to i64 - %4 = inttoptr i64 %3 to i8* - %5 = inttoptr i64 %"#rec##0" to i8* - %6 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %4, i8* %5, i32 %6, i1 0) - %7 = inttoptr i64 %3 to i64* - store i64 %"#field##0", i64* %7 - %8 = insertvalue {i64, i1} undef, i64 %3, 0 - %9 = insertvalue {i64, i1} %8, i1 1, 1 - ret {i64, i1} %9 -if.else: - %10 = insertvalue {i64, i1} undef, i64 0, 0 - %11 = insertvalue {i64, i1} %10, i1 0, 1 - ret {i64, i1} %11 +define external fastcc {i64, i1} @"mutual_type.b.bhead<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#2##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#2##0", ptr %"tmp#1##0", i64 16, i1 0) + %"tmp#3##0" = ptrtoint ptr %"tmp#2##0" to i64 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 %"#field##0", ptr %"tmp#4##0" + %"tmp#5##0" = insertvalue {i64, i1} undef, i64 %"tmp#3##0", 0 + %"tmp#6##0" = insertvalue {i64, i1} %"tmp#5##0", i1 1, 1 + ret {i64, i1} %"tmp#6##0" +if.else.0: + %"tmp#7##0" = insertvalue {i64, i1} undef, i64 0, 0 + %"tmp#8##0" = insertvalue {i64, i1} %"tmp#7##0", i1 0, 1 + ret {i64, i1} %"tmp#8##0" } - -define external fastcc {i64, i1} @"mutual_type.b.btail<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = add i64 %"#rec##0", 8 - %2 = inttoptr i64 %1 to i64* - %3 = load i64, i64* %2 - %4 = insertvalue {i64, i1} undef, i64 %3, 0 - %5 = insertvalue {i64, i1} %4, i1 1, 1 - ret {i64, i1} %5 -if.else: - %6 = insertvalue {i64, i1} undef, i64 undef, 0 - %7 = insertvalue {i64, i1} %6, i1 0, 1 - ret {i64, i1} %7 +define external fastcc {i64, i1} @"mutual_type.b.btail<0>"(i64 %"#rec##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = add i64 %"#rec##0", 8 + %"tmp#2##0" = inttoptr i64 %"tmp#1##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#2##0" + %"tmp#4##0" = insertvalue {i64, i1} undef, i64 %"tmp#3##0", 0 + %"tmp#5##0" = insertvalue {i64, i1} %"tmp#4##0", i1 1, 1 + ret {i64, i1} %"tmp#5##0" +if.else.0: + %"tmp#6##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#7##0" = insertvalue {i64, i1} %"tmp#6##0", i1 0, 1 + ret {i64, i1} %"tmp#7##0" } - -define external fastcc {i64, i1} @"mutual_type.b.btail<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = trunc i64 16 to i32 - %2 = tail call ccc i8* @wybe_malloc(i32 %1) - %3 = ptrtoint i8* %2 to i64 - %4 = inttoptr i64 %3 to i8* - %5 = inttoptr i64 %"#rec##0" to i8* - %6 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %4, i8* %5, i32 %6, i1 0) - %7 = add i64 %3, 8 - %8 = inttoptr i64 %7 to i64* - store i64 %"#field##0", i64* %8 - %9 = insertvalue {i64, i1} undef, i64 %3, 0 - %10 = insertvalue {i64, i1} %9, i1 1, 1 - ret {i64, i1} %10 -if.else: - %11 = insertvalue {i64, i1} undef, i64 0, 0 - %12 = insertvalue {i64, i1} %11, i1 0, 1 - ret {i64, i1} %12 +define external fastcc {i64, i1} @"mutual_type.b.btail<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#2##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#2##0", ptr %"tmp#1##0", i64 16, i1 0) + %"tmp#3##0" = ptrtoint ptr %"tmp#2##0" to i64 + %"tmp#4##0" = add i64 %"tmp#3##0", 8 + %"tmp#5##0" = inttoptr i64 %"tmp#4##0" to ptr + store i64 %"#field##0", ptr %"tmp#5##0" + %"tmp#6##0" = insertvalue {i64, i1} undef, i64 %"tmp#3##0", 0 + %"tmp#7##0" = insertvalue {i64, i1} %"tmp#6##0", i1 1, 1 + ret {i64, i1} %"tmp#7##0" +if.else.0: + %"tmp#8##0" = insertvalue {i64, i1} undef, i64 0, 0 + %"tmp#9##0" = insertvalue {i64, i1} %"tmp#8##0", i1 0, 1 + ret {i64, i1} %"tmp#9##0" } - -define external fastcc i64 @"mutual_type.b.no_b<0>"() alwaysinline { -entry: - ret i64 0 +define external fastcc i64 @"mutual_type.b.no_b<0>"() { + ret i64 0 } - -define external fastcc i1 @"mutual_type.b.~=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = tail call fastcc i1 @"mutual_type.b.=<0>"(i64 %"#left##0", i64 %"#right##0") - %1 = xor i1 %0, 1 - ret i1 %1 +define external fastcc i1 @"mutual_type.b.~=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#0##0" = tail call fastcc i1 @"mutual_type.b.=<0>"(i64 %"#left##0", i64 %"#right##0") + %"tmp#1##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#1##0" } diff --git a/test-cases/final-dump/mytree.exp b/test-cases/final-dump/mytree.exp index 137008862..cd14195a7 100644 --- a/test-cases/final-dump/mytree.exp +++ b/test-cases/final-dump/mytree.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module mytree representation : (not a type) public submods : tree -> mytree.tree @@ -57,74 +60,53 @@ printTree1(t##0:mytree.tree, prefix##0:wybe.string, ?prefix##3:wybe.string)<{<"(i64) +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @print_int(i64) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"mytree.printTree<0>"(i64 %"t##0") alwaysinline { -entry: - %0 = tail call fastcc i64 @"mytree.printTree1<0>"(i64 %"t##0", i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @mytree.1, i32 0, i32 0) to i64)) - musttail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @mytree.3, i32 0, i32 0) to i64)) - ret void +define external fastcc void @"mytree.printTree<0>"(i64 %"t##0") { + %"prefix##1" = tail call fastcc i64 @"mytree.printTree1<0>"(i64 %"t##0", i64 ptrtoint( ptr @"string#4" to i64 )) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#5" to i64 )) + ret void } - -define external fastcc i64 @"mytree.printTree1<0>"(i64 %"t##0", i64 %"prefix##0") { -entry: - %0 = icmp ne i64 %"t##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"t##0" to i64* - %2 = load i64, i64* %1 - %3 = add i64 %"t##0", 8 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = add i64 %"t##0", 16 - %7 = inttoptr i64 %6 to i64* - %8 = load i64, i64* %7 - %9 = tail call fastcc i64 @"mytree.printTree1<0>"(i64 %2, i64 %"prefix##0") - tail call fastcc void @"wybe.string.print<0>"(i64 %9) - tail call ccc void @print_int(i64 %5) - %10 = musttail call fastcc i64 @"mytree.printTree1<0>"(i64 %8, i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @mytree.5, i32 0, i32 0) to i64)) - ret i64 %10 -if.else: - ret i64 %"prefix##0" +define external fastcc i64 @"mytree.printTree1<0>"(i64 %"t##0", i64 %"prefix##0") { + %"tmp#2##0" = icmp ne i64 %"t##0", 0 + br i1 %"tmp#2##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#6##0" = inttoptr i64 %"t##0" to ptr + %"l##0" = load i64, ptr %"tmp#6##0" + %"tmp#7##0" = add i64 %"t##0", 8 + %"tmp#8##0" = inttoptr i64 %"tmp#7##0" to ptr + %"k##0" = load i64, ptr %"tmp#8##0" + %"tmp#9##0" = add i64 %"t##0", 16 + %"tmp#10##0" = inttoptr i64 %"tmp#9##0" to ptr + %"r##0" = load i64, ptr %"tmp#10##0" + %"prefix##1" = tail call fastcc i64 @"mytree.printTree1<0>"(i64 %"l##0", i64 %"prefix##0") + tail call fastcc void @"wybe.string.print<0>"(i64 %"prefix##1") + call ccc void @print_int(i64 %"k##0") + %"tmp#11##0" = tail call fastcc i64 @"mytree.printTree1<0>"(i64 %"r##0", i64 ptrtoint( ptr @"string#3" to i64 )) + ret i64 %"tmp#11##0" +if.else.0: + ret i64 %"prefix##0" } + -------------------------------------------------- Module mytree.tree - representation : address + representation : pointer public submods : public resources: public procs : mytree.tree.=<0> @@ -329,242 +311,209 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'mytree.tree' - - - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i1 @"mytree.tree.=<0>"(i64 %"#left##0", i64 %"#right##0") { -entry: - %0 = icmp ne i64 %"#left##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"#left##0" to i64* - %2 = load i64, i64* %1 - %3 = add i64 %"#left##0", 8 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = add i64 %"#left##0", 16 - %7 = inttoptr i64 %6 to i64* - %8 = load i64, i64* %7 - %9 = icmp ne i64 %"#right##0", 0 - br i1 %9, label %if.then1, label %if.else1 -if.else: - %21 = icmp eq i64 %"#right##0", 0 - ret i1 %21 -if.then1: - %10 = inttoptr i64 %"#right##0" to i64* - %11 = load i64, i64* %10 - %12 = add i64 %"#right##0", 8 - %13 = inttoptr i64 %12 to i64* - %14 = load i64, i64* %13 - %15 = add i64 %"#right##0", 16 - %16 = inttoptr i64 %15 to i64* - %17 = load i64, i64* %16 - %18 = tail call fastcc i1 @"mytree.tree.=<0>"(i64 %2, i64 %11) - br i1 %18, label %if.then2, label %if.else2 -if.else1: - ret i1 0 -if.then2: - %19 = icmp eq i64 %5, %14 - br i1 %19, label %if.then3, label %if.else3 -if.else2: - ret i1 0 -if.then3: - %20 = musttail call fastcc i1 @"mytree.tree.=<0>"(i64 %8, i64 %17) - ret i1 %20 -if.else3: - ret i1 0 +source_filename = "!ROOT!/final-dump/mytree.wybe" +target triple ???? + + +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc i1 @"mytree.tree.=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#0##0" = icmp ne i64 %"#left##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#13##0" = inttoptr i64 %"#left##0" to ptr + %"#left#left##0" = load i64, ptr %"tmp#13##0" + %"tmp#14##0" = add i64 %"#left##0", 8 + %"tmp#15##0" = inttoptr i64 %"tmp#14##0" to ptr + %"#left#key##0" = load i64, ptr %"tmp#15##0" + %"tmp#16##0" = add i64 %"#left##0", 16 + %"tmp#17##0" = inttoptr i64 %"tmp#16##0" to ptr + %"#left#right##0" = load i64, ptr %"tmp#17##0" + %"tmp#10##0" = icmp ne i64 %"#right##0", 0 + br i1 %"tmp#10##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#18##0" = inttoptr i64 %"#right##0" to ptr + %"#right#left##0" = load i64, ptr %"tmp#18##0" + %"tmp#19##0" = add i64 %"#right##0", 8 + %"tmp#20##0" = inttoptr i64 %"tmp#19##0" to ptr + %"#right#key##0" = load i64, ptr %"tmp#20##0" + %"tmp#21##0" = add i64 %"#right##0", 16 + %"tmp#22##0" = inttoptr i64 %"tmp#21##0" to ptr + %"#right#right##0" = load i64, ptr %"tmp#22##0" + %"tmp#4##0" = tail call fastcc i1 @"mytree.tree.=<0>"(i64 %"#left#left##0", i64 %"#right#left##0") + br i1 %"tmp#4##0", label %if.then.2, label %if.else.2 +if.then.2: + %"tmp#5##0" = icmp eq i64 %"#left#key##0", %"#right#key##0" + br i1 %"tmp#5##0", label %if.then.3, label %if.else.3 +if.then.3: + %"tmp#23##0" = tail call fastcc i1 @"mytree.tree.=<0>"(i64 %"#left#right##0", i64 %"#right#right##0") + ret i1 %"tmp#23##0" +if.else.3: + ret i1 0 +if.else.2: + ret i1 0 +if.else.1: + ret i1 0 +if.else.0: + %"tmp#24##0" = icmp eq i64 %"#right##0", 0 + ret i1 %"tmp#24##0" } - -define external fastcc i64 @"mytree.tree.empty<0>"() alwaysinline { -entry: - ret i64 0 +define external fastcc i64 @"mytree.tree.empty<0>"() { + ret i64 0 } - -define external fastcc {i64, i1} @"mytree.tree.key<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = add i64 %"#rec##0", 8 - %2 = inttoptr i64 %1 to i64* - %3 = load i64, i64* %2 - %4 = insertvalue {i64, i1} undef, i64 %3, 0 - %5 = insertvalue {i64, i1} %4, i1 1, 1 - ret {i64, i1} %5 -if.else: - %6 = insertvalue {i64, i1} undef, i64 undef, 0 - %7 = insertvalue {i64, i1} %6, i1 0, 1 - ret {i64, i1} %7 +define external fastcc {i64, i1} @"mytree.tree.key<0>"(i64 %"#rec##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = add i64 %"#rec##0", 8 + %"tmp#2##0" = inttoptr i64 %"tmp#1##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#2##0" + %"tmp#4##0" = insertvalue {i64, i1} undef, i64 %"tmp#3##0", 0 + %"tmp#5##0" = insertvalue {i64, i1} %"tmp#4##0", i1 1, 1 + ret {i64, i1} %"tmp#5##0" +if.else.0: + %"tmp#6##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#7##0" = insertvalue {i64, i1} %"tmp#6##0", i1 0, 1 + ret {i64, i1} %"tmp#7##0" } - -define external fastcc {i64, i1} @"mytree.tree.key<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = trunc i64 24 to i32 - %2 = tail call ccc i8* @wybe_malloc(i32 %1) - %3 = ptrtoint i8* %2 to i64 - %4 = inttoptr i64 %3 to i8* - %5 = inttoptr i64 %"#rec##0" to i8* - %6 = trunc i64 24 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %4, i8* %5, i32 %6, i1 0) - %7 = add i64 %3, 8 - %8 = inttoptr i64 %7 to i64* - store i64 %"#field##0", i64* %8 - %9 = insertvalue {i64, i1} undef, i64 %3, 0 - %10 = insertvalue {i64, i1} %9, i1 1, 1 - ret {i64, i1} %10 -if.else: - %11 = insertvalue {i64, i1} undef, i64 0, 0 - %12 = insertvalue {i64, i1} %11, i1 0, 1 - ret {i64, i1} %12 +define external fastcc {i64, i1} @"mytree.tree.key<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#2##0" = call ccc ptr @wybe_malloc(i32 24) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#2##0", ptr %"tmp#1##0", i64 24, i1 0) + %"tmp#3##0" = ptrtoint ptr %"tmp#2##0" to i64 + %"tmp#4##0" = add i64 %"tmp#3##0", 8 + %"tmp#5##0" = inttoptr i64 %"tmp#4##0" to ptr + store i64 %"#field##0", ptr %"tmp#5##0" + %"tmp#6##0" = insertvalue {i64, i1} undef, i64 %"tmp#3##0", 0 + %"tmp#7##0" = insertvalue {i64, i1} %"tmp#6##0", i1 1, 1 + ret {i64, i1} %"tmp#7##0" +if.else.0: + %"tmp#8##0" = insertvalue {i64, i1} undef, i64 0, 0 + %"tmp#9##0" = insertvalue {i64, i1} %"tmp#8##0", i1 0, 1 + ret {i64, i1} %"tmp#9##0" } - -define external fastcc {i64, i1} @"mytree.tree.left<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"#rec##0" to i64* - %2 = load i64, i64* %1 - %3 = insertvalue {i64, i1} undef, i64 %2, 0 - %4 = insertvalue {i64, i1} %3, i1 1, 1 - ret {i64, i1} %4 -if.else: - %5 = insertvalue {i64, i1} undef, i64 undef, 0 - %6 = insertvalue {i64, i1} %5, i1 0, 1 - ret {i64, i1} %6 +define external fastcc {i64, i1} @"mytree.tree.left<0>"(i64 %"#rec##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + %"tmp#3##0" = insertvalue {i64, i1} undef, i64 %"tmp#2##0", 0 + %"tmp#4##0" = insertvalue {i64, i1} %"tmp#3##0", i1 1, 1 + ret {i64, i1} %"tmp#4##0" +if.else.0: + %"tmp#5##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#6##0" = insertvalue {i64, i1} %"tmp#5##0", i1 0, 1 + ret {i64, i1} %"tmp#6##0" } - -define external fastcc {i64, i1} @"mytree.tree.left<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = trunc i64 24 to i32 - %2 = tail call ccc i8* @wybe_malloc(i32 %1) - %3 = ptrtoint i8* %2 to i64 - %4 = inttoptr i64 %3 to i8* - %5 = inttoptr i64 %"#rec##0" to i8* - %6 = trunc i64 24 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %4, i8* %5, i32 %6, i1 0) - %7 = inttoptr i64 %3 to i64* - store i64 %"#field##0", i64* %7 - %8 = insertvalue {i64, i1} undef, i64 %3, 0 - %9 = insertvalue {i64, i1} %8, i1 1, 1 - ret {i64, i1} %9 -if.else: - %10 = insertvalue {i64, i1} undef, i64 0, 0 - %11 = insertvalue {i64, i1} %10, i1 0, 1 - ret {i64, i1} %11 +define external fastcc {i64, i1} @"mytree.tree.left<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#2##0" = call ccc ptr @wybe_malloc(i32 24) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#2##0", ptr %"tmp#1##0", i64 24, i1 0) + %"tmp#3##0" = ptrtoint ptr %"tmp#2##0" to i64 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 %"#field##0", ptr %"tmp#4##0" + %"tmp#5##0" = insertvalue {i64, i1} undef, i64 %"tmp#3##0", 0 + %"tmp#6##0" = insertvalue {i64, i1} %"tmp#5##0", i1 1, 1 + ret {i64, i1} %"tmp#6##0" +if.else.0: + %"tmp#7##0" = insertvalue {i64, i1} undef, i64 0, 0 + %"tmp#8##0" = insertvalue {i64, i1} %"tmp#7##0", i1 0, 1 + ret {i64, i1} %"tmp#8##0" } - -define external fastcc i64 @"mytree.tree.node<0>"(i64 %"left##0", i64 %"key##0", i64 %"right##0") alwaysinline { -entry: - %0 = trunc i64 24 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"left##0", i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"key##0", i64* %5 - %6 = add i64 %2, 16 - %7 = inttoptr i64 %6 to i64* - store i64 %"right##0", i64* %7 - ret i64 %2 +define external fastcc i64 @"mytree.tree.node<0>"(i64 %"left##0", i64 %"key##0", i64 %"right##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 24) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"left##0", ptr %"tmp#1##0" + %"tmp#2##0" = add i64 %"#rec##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"key##0", ptr %"tmp#3##0" + %"tmp#4##0" = add i64 %"#rec##0", 16 + %"tmp#5##0" = inttoptr i64 %"tmp#4##0" to ptr + store i64 %"right##0", ptr %"tmp#5##0" + ret i64 %"#rec##0" } - -define external fastcc {i64, i64, i64, i1} @"mytree.tree.node<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#result##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"#result##0" to i64* - %2 = load i64, i64* %1 - %3 = add i64 %"#result##0", 8 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = add i64 %"#result##0", 16 - %7 = inttoptr i64 %6 to i64* - %8 = load i64, i64* %7 - %9 = insertvalue {i64, i64, i64, i1} undef, i64 %2, 0 - %10 = insertvalue {i64, i64, i64, i1} %9, i64 %5, 1 - %11 = insertvalue {i64, i64, i64, i1} %10, i64 %8, 2 - %12 = insertvalue {i64, i64, i64, i1} %11, i1 1, 3 - ret {i64, i64, i64, i1} %12 -if.else: - %13 = insertvalue {i64, i64, i64, i1} undef, i64 undef, 0 - %14 = insertvalue {i64, i64, i64, i1} %13, i64 undef, 1 - %15 = insertvalue {i64, i64, i64, i1} %14, i64 undef, 2 - %16 = insertvalue {i64, i64, i64, i1} %15, i1 0, 3 - ret {i64, i64, i64, i1} %16 +define external fastcc {i64, i64, i64, i1} @"mytree.tree.node<1>"(i64 %"#result##0") { + %"tmp#0##0" = icmp ne i64 %"#result##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = inttoptr i64 %"#result##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + %"tmp#3##0" = add i64 %"#result##0", 8 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#4##0" + %"tmp#6##0" = add i64 %"#result##0", 16 + %"tmp#7##0" = inttoptr i64 %"tmp#6##0" to ptr + %"tmp#8##0" = load i64, ptr %"tmp#7##0" + %"tmp#9##0" = insertvalue {i64, i64, i64, i1} undef, i64 %"tmp#2##0", 0 + %"tmp#10##0" = insertvalue {i64, i64, i64, i1} %"tmp#9##0", i64 %"tmp#5##0", 1 + %"tmp#11##0" = insertvalue {i64, i64, i64, i1} %"tmp#10##0", i64 %"tmp#8##0", 2 + %"tmp#12##0" = insertvalue {i64, i64, i64, i1} %"tmp#11##0", i1 1, 3 + ret {i64, i64, i64, i1} %"tmp#12##0" +if.else.0: + %"tmp#13##0" = insertvalue {i64, i64, i64, i1} undef, i64 undef, 0 + %"tmp#14##0" = insertvalue {i64, i64, i64, i1} %"tmp#13##0", i64 undef, 1 + %"tmp#15##0" = insertvalue {i64, i64, i64, i1} %"tmp#14##0", i64 undef, 2 + %"tmp#16##0" = insertvalue {i64, i64, i64, i1} %"tmp#15##0", i1 0, 3 + ret {i64, i64, i64, i1} %"tmp#16##0" } - -define external fastcc {i64, i1} @"mytree.tree.right<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = add i64 %"#rec##0", 16 - %2 = inttoptr i64 %1 to i64* - %3 = load i64, i64* %2 - %4 = insertvalue {i64, i1} undef, i64 %3, 0 - %5 = insertvalue {i64, i1} %4, i1 1, 1 - ret {i64, i1} %5 -if.else: - %6 = insertvalue {i64, i1} undef, i64 undef, 0 - %7 = insertvalue {i64, i1} %6, i1 0, 1 - ret {i64, i1} %7 +define external fastcc {i64, i1} @"mytree.tree.right<0>"(i64 %"#rec##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = add i64 %"#rec##0", 16 + %"tmp#2##0" = inttoptr i64 %"tmp#1##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#2##0" + %"tmp#4##0" = insertvalue {i64, i1} undef, i64 %"tmp#3##0", 0 + %"tmp#5##0" = insertvalue {i64, i1} %"tmp#4##0", i1 1, 1 + ret {i64, i1} %"tmp#5##0" +if.else.0: + %"tmp#6##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#7##0" = insertvalue {i64, i1} %"tmp#6##0", i1 0, 1 + ret {i64, i1} %"tmp#7##0" } - -define external fastcc {i64, i1} @"mytree.tree.right<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = trunc i64 24 to i32 - %2 = tail call ccc i8* @wybe_malloc(i32 %1) - %3 = ptrtoint i8* %2 to i64 - %4 = inttoptr i64 %3 to i8* - %5 = inttoptr i64 %"#rec##0" to i8* - %6 = trunc i64 24 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %4, i8* %5, i32 %6, i1 0) - %7 = add i64 %3, 16 - %8 = inttoptr i64 %7 to i64* - store i64 %"#field##0", i64* %8 - %9 = insertvalue {i64, i1} undef, i64 %3, 0 - %10 = insertvalue {i64, i1} %9, i1 1, 1 - ret {i64, i1} %10 -if.else: - %11 = insertvalue {i64, i1} undef, i64 0, 0 - %12 = insertvalue {i64, i1} %11, i1 0, 1 - ret {i64, i1} %12 +define external fastcc {i64, i1} @"mytree.tree.right<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#2##0" = call ccc ptr @wybe_malloc(i32 24) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#2##0", ptr %"tmp#1##0", i64 24, i1 0) + %"tmp#3##0" = ptrtoint ptr %"tmp#2##0" to i64 + %"tmp#4##0" = add i64 %"tmp#3##0", 16 + %"tmp#5##0" = inttoptr i64 %"tmp#4##0" to ptr + store i64 %"#field##0", ptr %"tmp#5##0" + %"tmp#6##0" = insertvalue {i64, i1} undef, i64 %"tmp#3##0", 0 + %"tmp#7##0" = insertvalue {i64, i1} %"tmp#6##0", i1 1, 1 + ret {i64, i1} %"tmp#7##0" +if.else.0: + %"tmp#8##0" = insertvalue {i64, i1} undef, i64 0, 0 + %"tmp#9##0" = insertvalue {i64, i1} %"tmp#8##0", i1 0, 1 + ret {i64, i1} %"tmp#9##0" } - -define external fastcc i1 @"mytree.tree.~=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = tail call fastcc i1 @"mytree.tree.=<0>"(i64 %"#left##0", i64 %"#right##0") - %1 = xor i1 %0, 1 - ret i1 %1 +define external fastcc i1 @"mytree.tree.~=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#0##0" = tail call fastcc i1 @"mytree.tree.=<0>"(i64 %"#left##0", i64 %"#right##0") + %"tmp#1##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#1##0" } diff --git a/test-cases/final-dump/need.exp b/test-cases/final-dump/need.exp index c27d659ae..80ce6cbeb 100644 --- a/test-cases/final-dump/need.exp +++ b/test-cases/final-dump/need.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module need representation : (not a type) public submods : @@ -61,68 +64,57 @@ need(stmt##0:{impure}())<{}; {}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'need' - - - - -declare external ccc i8* @wybe_malloc(i32) +source_filename = "!ROOT!/final-dump/need.wybe" +target triple ???? -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) - -define external fastcc void @"need.<0>"() alwaysinline { -entry: - musttail call fastcc void @"need.#anon#1<0>"() - ret void +define external fastcc void @"need.<0>"() { + tail call fastcc void @"need.#anon#1<0>"() + ret void } - -define external fastcc void @"need.#anon#1<0>"() alwaysinline { -entry: - %0 = alloca i64 - call fastcc void @"need.iota<0>"(i64 1000, i64* %0) - ret void +define external fastcc void @"need.#anon#1<0>"() { + %"tmp#1##0" = alloca i8, i64 8, align 8 + call fastcc void @"need.iota<0>"(i64 1000, ptr %"tmp#1##0") + %"l##0" = load i64, ptr %"tmp#1##0" + ret void } - -define external fastcc void @"need.#anon#1<1>"(i64 %"#env##0") alwaysinline { -entry: - %0 = alloca i64 - call fastcc void @"need.iota<0>"(i64 1000, i64* %0) - ret void +define external fastcc void @"need.#anon#1<1>"(i64 %"#env##0") { + %"tmp#1##0" = alloca i8, i64 8, align 8 + call fastcc void @"need.iota<0>"(i64 1000, ptr %"tmp#1##0") + %"tmp#0##0" = load i64, ptr %"tmp#1##0" + ret void } - -define external fastcc void @"need.iota<0>"(i64 %"n##0", i64* %"#result##0") { -entry: - %0 = icmp sle i64 %"n##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - store i64 0, i64* %"#result##0" - ret void -if.else: - %1 = sub i64 %"n##0", 1 - %2 = trunc i64 16 to i32 - %3 = tail call ccc i8* @wybe_malloc(i32 %2) - %4 = ptrtoint i8* %3 to i64 - %5 = inttoptr i64 %4 to i64* - store i64 %"n##0", i64* %5 - %6 = add i64 %4, 8 - %7 = inttoptr i64 %6 to i64* - store i64 %4, i64* %"#result##0" - musttail call fastcc void @"need.iota<0>"(i64 %1, i64* %7) - ret void +define external fastcc void @"need.iota<0>"(i64 %"n##0", ptr %"tmp#14##0") { + %"tmp#5##0" = icmp sle i64 %"n##0", 0 + br i1 %"tmp#5##0", label %if.then.0, label %if.else.0 +if.then.0: + store i64 0, ptr %"tmp#14##0" + ret void +if.else.0: + %"tmp#4##0" = sub i64 %"n##0", 1 + %"tmp#15##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#12##0" = ptrtoint ptr %"tmp#15##0" to i64 + %"tmp#16##0" = inttoptr i64 %"tmp#12##0" to ptr + store i64 %"n##0", ptr %"tmp#16##0" + store i64 %"tmp#12##0", ptr %"tmp#14##0" + %"tmp#17##0" = add i64 %"tmp#12##0", 8 + %"tmp#18##0" = inttoptr i64 %"tmp#17##0" to ptr + musttail call fastcc void @"need.iota<0>"(i64 %"tmp#4##0", ptr %"tmp#18##0") + ret void } - -define external fastcc void @"need.need<0>"(i64 %"stmt##0") alwaysinline { -entry: - %0 = inttoptr i64 %"stmt##0" to i64* - %1 = load i64, i64* %0 - %2 = inttoptr i64 %1 to void (i64)* - tail call fastcc void %2(i64 %"stmt##0") - ret void +define external fastcc void @"need.need<0>"(i64 %"stmt##0") { + %"tmp#1##0" = inttoptr i64 %"stmt##0" to ptr + %"tmp#0##0" = load ptr, ptr %"tmp#1##0" + tail call fastcc void %"tmp#0##0"(i64 %"stmt##0") + ret void } diff --git a/test-cases/final-dump/nested_if.exp b/test-cases/final-dump/nested_if.exp index c3160f0e6..786e40eb6 100644 --- a/test-cases/final-dump/nested_if.exp +++ b/test-cases/final-dump/nested_if.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module nested_if representation : (not a type) public submods : @@ -51,72 +54,48 @@ nested_if(i##0:wybe.int)<{<>}; {<>}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'nested_if' - - - - -@nested_if.5 = constant {i64, i64} { i64 3, i64 ptrtoint ([?? x i8]* @nested_if.4 to i64) } - - -@nested_if.1 = constant {i64, i64} { i64 4, i64 ptrtoint ([?? x i8]* @nested_if.0 to i64) } - - -@nested_if.7 = constant {i64, i64} { i64 5, i64 ptrtoint ([?? x i8]* @nested_if.6 to i64) } - - -@nested_if.3 = constant {i64, i64} { i64 20, i64 ptrtoint ([?? x i8]* @nested_if.2 to i64) } - - -@nested_if.2 = constant [?? x i8] c"one thousand and one\00" - - -@nested_if.6 = constant [?? x i8] c"other\00" - - -@nested_if.4 = constant [?? x i8] c"two\00" - - -@nested_if.0 = constant [?? x i8] c"zero\00" - - -declare external ccc void @putchar(i8) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"nested_if.nested_if<0>"(i64 %"i##0") { -entry: - %0 = icmp eq i64 %"i##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @nested_if.1, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - ret void -if.else: - %1 = icmp eq i64 %"i##0", 1001 - br i1 %1, label %if.then1, label %if.else1 -if.then1: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @nested_if.3, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - ret void -if.else1: - %2 = icmp eq i64 %"i##0", 2 - br i1 %2, label %if.then2, label %if.else2 -if.then2: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @nested_if.5, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - ret void -if.else2: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @nested_if.7, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - ret void +source_filename = "!ROOT!/final-dump/nested_if.wybe" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c"one thousand and one\00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c"other\00", align 8 +@"cstring#2" = private unnamed_addr constant [ ?? x i8 ] c"two\00", align 8 +@"cstring#3" = private unnamed_addr constant [ ?? x i8 ] c"zero\00", align 8 +@"string#4" = private unnamed_addr constant {i64, i64} { i64 20, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +@"string#5" = private unnamed_addr constant {i64, i64} { i64 5, i64 ptrtoint( ptr @"cstring#1" to i64 ) }, align 8 +@"string#6" = private unnamed_addr constant {i64, i64} { i64 3, i64 ptrtoint( ptr @"cstring#2" to i64 ) }, align 8 +@"string#7" = private unnamed_addr constant {i64, i64} { i64 4, i64 ptrtoint( ptr @"cstring#3" to i64 ) }, align 8 + +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"nested_if.nested_if<0>"(i64 %"i##0") { + %"tmp#3##0" = icmp eq i64 %"i##0", 0 + br i1 %"tmp#3##0", label %if.then.0, label %if.else.0 +if.then.0: + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#7" to i64 )) + call ccc void @putchar(i8 10) + ret void +if.else.0: + %"tmp#2##0" = icmp eq i64 %"i##0", 1001 + br i1 %"tmp#2##0", label %if.then.1, label %if.else.1 +if.then.1: + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#4" to i64 )) + call ccc void @putchar(i8 10) + ret void +if.else.1: + %"tmp#1##0" = icmp eq i64 %"i##0", 2 + br i1 %"tmp#1##0", label %if.then.2, label %if.else.2 +if.then.2: + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#6" to i64 )) + call ccc void @putchar(i8 10) + ret void +if.else.2: + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#5" to i64 )) + call ccc void @putchar(i8 10) + ret void } diff --git a/test-cases/final-dump/nested_loop.exp b/test-cases/final-dump/nested_loop.exp index c19226e16..3ff327cb2 100644 --- a/test-cases/final-dump/nested_loop.exp +++ b/test-cases/final-dump/nested_loop.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module nested_loop representation : (not a type) public submods : @@ -54,62 +57,42 @@ proc #cont#2 > {inline,semipure} (2 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'nested_loop' - - - - -@nested_loop.1 = constant {i64, i64} { i64 5, i64 ptrtoint ([?? x i8]* @nested_loop.0 to i64) } - - -@nested_loop.3 = constant {i64, i64} { i64 5, i64 ptrtoint ([?? x i8]* @nested_loop.2 to i64) } - - -@nested_loop.2 = constant [?? x i8] c"Inner\00" - - -@nested_loop.0 = constant [?? x i8] c"Outer\00" - - -declare external ccc void @putchar(i8) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"nested_loop.<0>"() { -entry: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @nested_loop.1, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @nested_loop.3, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - musttail call fastcc void @"nested_loop.#cont#2<0>"() - ret void +source_filename = "!ROOT!/final-dump/nested_loop.wybe" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c"Inner\00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c"Outer\00", align 8 +@"string#2" = private unnamed_addr constant {i64, i64} { i64 5, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +@"string#3" = private unnamed_addr constant {i64, i64} { i64 5, i64 ptrtoint( ptr @"cstring#1" to i64 ) }, align 8 + +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"nested_loop.<0>"() { + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#3" to i64 )) + call ccc void @putchar(i8 10) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#2" to i64 )) + call ccc void @putchar(i8 10) + tail call fastcc void @"nested_loop.#cont#2<0>"() + ret void } - -define external fastcc void @"nested_loop.#cont#1<0>"() alwaysinline { -entry: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @nested_loop.1, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @nested_loop.3, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - musttail call fastcc void @"nested_loop.#cont#2<0>"() - ret void +define external fastcc void @"nested_loop.#cont#1<0>"() { + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#3" to i64 )) + call ccc void @putchar(i8 10) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#2" to i64 )) + call ccc void @putchar(i8 10) + tail call fastcc void @"nested_loop.#cont#2<0>"() + ret void } - -define external fastcc void @"nested_loop.#cont#2<0>"() alwaysinline { -entry: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @nested_loop.3, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - musttail call fastcc void @"nested_loop.#cont#2<0>"() - ret void +define external fastcc void @"nested_loop.#cont#2<0>"() { + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#2" to i64 )) + call ccc void @putchar(i8 10) + tail call fastcc void @"nested_loop.#cont#2<0>"() + ret void } diff --git a/test-cases/final-dump/numbers.exp b/test-cases/final-dump/numbers.exp index 4d7338fa1..aef26bbcb 100644 --- a/test-cases/final-dump/numbers.exp +++ b/test-cases/final-dump/numbers.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module numbers representation : (not a type) public submods : @@ -49,55 +52,39 @@ toCelsius(f##0:wybe.float, ?#result##0:wybe.float)<{}; {}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'numbers' +source_filename = "!ROOT!/final-dump/numbers.wybe" +target triple ???? - - - -@numbers.1 = constant {i64, i64} { i64 29, i64 ptrtoint ([?? x i8]* @numbers.0 to i64) } - - -@numbers.0 = constant [?? x i8] c"Numbers has been initialised.\00" - - -declare external ccc void @putchar(i8) +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c"Numbers has been initialised.\00", align 8 +@"string#1" = private unnamed_addr constant {i64, i64} { i64 29, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"numbers.<0>"() alwaysinline { -entry: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @numbers.1, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"numbers.<0>"() { + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#1" to i64 )) + call ccc void @putchar(i8 10) + ret void } - -define external fastcc i64 @"numbers.factorial<0>"(i64 %"n##0") { -entry: - %0 = icmp sle i64 %"n##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - ret i64 1 -if.else: - %1 = sub i64 %"n##0", 1 - %2 = tail call fastcc i64 @"numbers.factorial<0>"(i64 %1) - %3 = mul i64 %"n##0", %2 - ret i64 %3 +define external fastcc i64 @"numbers.factorial<0>"(i64 %"n##0") { + %"tmp#4##0" = icmp sle i64 %"n##0", 0 + br i1 %"tmp#4##0", label %if.then.0, label %if.else.0 +if.then.0: + ret i64 1 +if.else.0: + %"tmp#3##0" = sub i64 %"n##0", 1 + %"tmp#2##0" = tail call fastcc i64 @"numbers.factorial<0>"(i64 %"tmp#3##0") + %"tmp#11##0" = mul i64 %"n##0", %"tmp#2##0" + ret i64 %"tmp#11##0" } - -define external fastcc double @"numbers.toCelsius<0>"(double %"f##0") alwaysinline { -entry: - %0 = fsub double %"f##0", 3.200000e1 - %1 = fdiv double %0, 1.800000e0 - ret double %1 +define external fastcc double @"numbers.toCelsius<0>"(double %"f##0") { + %"tmp#1##0" = fsub double %"f##0", 32.0 + %"tmp#6##0" = fdiv double %"tmp#1##0", 1.8 + ret double %"tmp#6##0" } diff --git a/test-cases/final-dump/out_global_overwritten.exp b/test-cases/final-dump/out_global_overwritten.exp index 5cab94a00..882dfe74f 100644 --- a/test-cases/final-dump/out_global_overwritten.exp +++ b/test-cases/final-dump/out_global_overwritten.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module out_global_overwritten representation : (not a type) public submods : @@ -32,40 +35,28 @@ out()<{}; {<>}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'out_global_overwritten' - - - - -@"resource#out_global_overwritten.res" = global i64 undef - - -declare external ccc void @putchar(i8) +source_filename = "!ROOT!/final-dump/out_global_overwritten.wybe" +target triple ???? -declare external ccc void @print_int(i64) +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) +@"resource#out_global_overwritten.res" = global i64 undef - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"out_global_overwritten.<0>"() { -entry: - %0 = load i64, i64* @"resource#out_global_overwritten.res" - tail call fastcc void @"out_global_overwritten.out<0>"() - tail call ccc void @print_int(i64 10) - tail call ccc void @putchar(i8 10) - store i64 %0, i64* @"resource#out_global_overwritten.res" - ret void +define external fastcc void @"out_global_overwritten.<0>"() { + %"tmp#0##0" = load i64, ptr @"resource#out_global_overwritten.res" + tail call fastcc void @"out_global_overwritten.out<0>"() + call ccc void @print_int(i64 10) + call ccc void @putchar(i8 10) + store i64 %"tmp#0##0", ptr @"resource#out_global_overwritten.res" + ret void } - -define external fastcc void @"out_global_overwritten.out<0>"() noinline { -entry: - store i64 11, i64* @"resource#out_global_overwritten.res" - ret void +define external fastcc void @"out_global_overwritten.out<0>"() { + store i64 11, ptr @"resource#out_global_overwritten.res" + ret void } diff --git a/test-cases/final-dump/out_only_global_flow.exp b/test-cases/final-dump/out_only_global_flow.exp index dde1b6565..50d4aeace 100644 --- a/test-cases/final-dump/out_only_global_flow.exp +++ b/test-cases/final-dump/out_only_global_flow.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module out_only_global_flow representation : (not a type) public submods : @@ -33,41 +36,29 @@ out()<{}; {<>}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'out_only_global_flow' - - - - -@"resource#out_only_global_flow.res" = global i64 undef - - -declare external ccc void @putchar(i8) +source_filename = "!ROOT!/final-dump/out_only_global_flow.wybe" +target triple ???? -declare external ccc void @print_int(i64) +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) +@"resource#out_only_global_flow.res" = global i64 undef - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"out_only_global_flow.<0>"() { -entry: - %0 = load i64, i64* @"resource#out_only_global_flow.res" - tail call fastcc void @"out_only_global_flow.out<0>"() - %1 = load i64, i64* @"resource#out_only_global_flow.res" - tail call ccc void @print_int(i64 %1) - tail call ccc void @putchar(i8 10) - store i64 %0, i64* @"resource#out_only_global_flow.res" - ret void +define external fastcc void @"out_only_global_flow.<0>"() { + %"tmp#0##0" = load i64, ptr @"resource#out_only_global_flow.res" + tail call fastcc void @"out_only_global_flow.out<0>"() + %"res##1" = load i64, ptr @"resource#out_only_global_flow.res" + call ccc void @print_int(i64 %"res##1") + call ccc void @putchar(i8 10) + store i64 %"tmp#0##0", ptr @"resource#out_only_global_flow.res" + ret void } - -define external fastcc void @"out_only_global_flow.out<0>"() noinline { -entry: - store i64 11, i64* @"resource#out_only_global_flow.res" - ret void +define external fastcc void @"out_only_global_flow.out<0>"() { + store i64 11, ptr @"resource#out_only_global_flow.res" + ret void } diff --git a/test-cases/final-dump/person1.exp b/test-cases/final-dump/person1.exp index e1cd3bfb3..4e6231ad6 100644 --- a/test-cases/final-dump/person1.exp +++ b/test-cases/final-dump/person1.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module person1 representation : (not a type) public submods : person -> person1.person @@ -28,35 +31,26 @@ module top-level code > public {inline,semipure} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'person1' +source_filename = "!ROOT!/final-dump/person1.wybe" +target triple ???? - - - -@person1.1 = constant {i64, i64} { i64 4, i64 ptrtoint ([?? x i8]* @person1.0 to i64) } - - -@person1.0 = constant [?? x i8] c"Wang\00" - +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c"Wang\00", align 8 +@"string#1" = private unnamed_addr constant {i64, i64} { i64 4, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 -declare external fastcc void @"wybe.string.print<0>"(i64) +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"person1.<0>"() alwaysinline { -entry: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @person1.1, i32 0, i32 0) to i64)) - ret void +define external fastcc void @"person1.<0>"() { + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#1" to i64 )) + ret void } + -------------------------------------------------- Module person1.person - representation : address + representation : pointer public submods : public resources: public procs : person1.person.=<0> @@ -162,141 +156,115 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'person1.person' - - - - -declare external fastcc i2 @"wybe.string.<=>#cont#2<0>"(i2, i64, i64, i64, i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i1 @"person1.person.=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %"#right##0" to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = tail call fastcc i2 @"wybe.string.<=>#cont#2<0>"(i2 1, i64 %1, i64 %6, i64 %1, i64 %6) - %11 = icmp eq i2 %10, 1 - br i1 %11, label %if.then, label %if.else -if.then: - %12 = tail call fastcc i2 @"wybe.string.<=>#cont#2<0>"(i2 1, i64 %4, i64 %9, i64 %4, i64 %9) - %13 = icmp eq i2 %12, 1 - ret i1 %13 -if.else: - ret i1 0 +source_filename = "!ROOT!/final-dump/person1.wybe" +target triple ???? + + +declare external fastcc i2 @"wybe.string.<=>#cont#2<0>"(i2, i64, i64, i64, i64) +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc i1 @"person1.person.=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#11##0" = inttoptr i64 %"#left##0" to ptr + %"#left#firstname##0" = load i64, ptr %"tmp#11##0" + %"tmp#12##0" = add i64 %"#left##0", 8 + %"tmp#13##0" = inttoptr i64 %"tmp#12##0" to ptr + %"#left#lastname##0" = load i64, ptr %"tmp#13##0" + %"tmp#14##0" = inttoptr i64 %"#right##0" to ptr + %"#right#firstname##0" = load i64, ptr %"tmp#14##0" + %"tmp#15##0" = add i64 %"#right##0", 8 + %"tmp#16##0" = inttoptr i64 %"tmp#15##0" to ptr + %"#right#lastname##0" = load i64, ptr %"tmp#16##0" + %"tmp#7##0" = tail call fastcc i2 @"wybe.string.<=>#cont#2<0>"(i2 1, i64 %"#left#firstname##0", i64 %"#right#firstname##0", i64 %"#left#firstname##0", i64 %"#right#firstname##0") + %"tmp#1##0" = icmp eq i2 %"tmp#7##0", 1 + br i1 %"tmp#1##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#10##0" = tail call fastcc i2 @"wybe.string.<=>#cont#2<0>"(i2 1, i64 %"#left#lastname##0", i64 %"#right#lastname##0", i64 %"#left#lastname##0", i64 %"#right#lastname##0") + %"tmp#17##0" = icmp eq i2 %"tmp#10##0", 1 + ret i1 %"tmp#17##0" +if.else.0: + ret i1 0 } - -define external fastcc i64 @"person1.person.firstname<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#rec##0" to i64* - %1 = load i64, i64* %0 - ret i64 %1 +define external fastcc i64 @"person1.person.firstname<0>"(i64 %"#rec##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + ret i64 %"tmp#1##0" } - -define external fastcc i64 @"person1.person.firstname<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = inttoptr i64 %2 to i64* - store i64 %"#field##0", i64* %6 - ret i64 %2 +define external fastcc i64 @"person1.person.firstname<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"#field##0", ptr %"tmp#3##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"person1.person.lastname<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = add i64 %"#rec##0", 8 - %1 = inttoptr i64 %0 to i64* - %2 = load i64, i64* %1 - ret i64 %2 +define external fastcc i64 @"person1.person.lastname<0>"(i64 %"#rec##0") { + %"tmp#0##0" = add i64 %"#rec##0", 8 + %"tmp#1##0" = inttoptr i64 %"tmp#0##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"person1.person.lastname<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = add i64 %2, 8 - %7 = inttoptr i64 %6 to i64* - store i64 %"#field##0", i64* %7 - ret i64 %2 +define external fastcc i64 @"person1.person.lastname<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = add i64 %"tmp#2##0", 8 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 %"#field##0", ptr %"tmp#4##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"person1.person.person<0>"(i64 %"firstname##0", i64 %"lastname##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"firstname##0", i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"lastname##0", i64* %5 - ret i64 %2 +define external fastcc i64 @"person1.person.person<0>"(i64 %"firstname##0", i64 %"lastname##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 16) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"firstname##0", ptr %"tmp#1##0" + %"tmp#2##0" = add i64 %"#rec##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"lastname##0", ptr %"tmp#3##0" + ret i64 %"#rec##0" } - -define external fastcc {i64, i64} @"person1.person.person<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#result##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#result##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = insertvalue {i64, i64} undef, i64 %1, 0 - %6 = insertvalue {i64, i64} %5, i64 %4, 1 - ret {i64, i64} %6 +define external fastcc {i64, i64} @"person1.person.person<1>"(i64 %"#result##0") { + %"tmp#0##0" = inttoptr i64 %"#result##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + %"tmp#2##0" = add i64 %"#result##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#3##0" + %"tmp#5##0" = insertvalue {i64, i64} undef, i64 %"tmp#1##0", 0 + %"tmp#6##0" = insertvalue {i64, i64} %"tmp#5##0", i64 %"tmp#4##0", 1 + ret {i64, i64} %"tmp#6##0" } - -define external fastcc i1 @"person1.person.~=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %"#right##0" to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = tail call fastcc i2 @"wybe.string.<=>#cont#2<0>"(i2 1, i64 %1, i64 %6, i64 %1, i64 %6) - %11 = icmp eq i2 %10, 1 - br i1 %11, label %if.then, label %if.else -if.then: - %12 = tail call fastcc i2 @"wybe.string.<=>#cont#2<0>"(i2 1, i64 %4, i64 %9, i64 %4, i64 %9) - %13 = icmp eq i2 %12, 1 - %14 = xor i1 %13, 1 - ret i1 %14 -if.else: - %15 = xor i1 0, 1 - ret i1 %15 +define external fastcc i1 @"person1.person.~=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#10##0" = inttoptr i64 %"#left##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#10##0" + %"tmp#11##0" = add i64 %"#left##0", 8 + %"tmp#12##0" = inttoptr i64 %"tmp#11##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#12##0" + %"tmp#13##0" = inttoptr i64 %"#right##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#13##0" + %"tmp#14##0" = add i64 %"#right##0", 8 + %"tmp#15##0" = inttoptr i64 %"tmp#14##0" to ptr + %"tmp#6##0" = load i64, ptr %"tmp#15##0" + %"tmp#7##0" = tail call fastcc i2 @"wybe.string.<=>#cont#2<0>"(i2 1, i64 %"tmp#3##0", i64 %"tmp#5##0", i64 %"tmp#3##0", i64 %"tmp#5##0") + %"tmp#8##0" = icmp eq i2 %"tmp#7##0", 1 + br i1 %"tmp#8##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#9##0" = tail call fastcc i2 @"wybe.string.<=>#cont#2<0>"(i2 1, i64 %"tmp#4##0", i64 %"tmp#6##0", i64 %"tmp#4##0", i64 %"tmp#6##0") + %"tmp#0##0" = icmp eq i2 %"tmp#9##0", 1 + %"tmp#16##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#16##0" +if.else.0: + %"tmp#17##0" = xor i1 0, 1 + ret i1 %"tmp#17##0" } diff --git a/test-cases/final-dump/person2.exp b/test-cases/final-dump/person2.exp index e08ae7778..bc7ac3acb 100644 --- a/test-cases/final-dump/person2.exp +++ b/test-cases/final-dump/person2.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module person2 representation : (not a type) public submods : person -> person2.person @@ -29,36 +32,27 @@ module top-level code > public {inline,semipure} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'person2' +source_filename = "!ROOT!/final-dump/person2.wybe" +target triple ???? - - - -@person2.1 = constant {i64, i64} { i64 5, i64 ptrtoint ([?? x i8]* @person2.0 to i64) } - - -@person2.0 = constant [?? x i8] c"Smith\00" - +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c"Smith\00", align 8 +@"string#1" = private unnamed_addr constant {i64, i64} { i64 5, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 -declare external fastcc void @"wybe.string.print<0>"(i64) +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"person2.<0>"() alwaysinline { -entry: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @person2.1, i32 0, i32 0) to i64)) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @person2.1, i32 0, i32 0) to i64)) - ret void +define external fastcc void @"person2.<0>"() { + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#1" to i64 )) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#1" to i64 )) + ret void } + -------------------------------------------------- Module person2.person - representation : address + representation : pointer public submods : public resources: public procs : person2.person.=<0> @@ -164,141 +158,115 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'person2.person' - - - - -declare external fastcc i2 @"wybe.string.<=>#cont#2<0>"(i2, i64, i64, i64, i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i1 @"person2.person.=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %"#right##0" to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = tail call fastcc i2 @"wybe.string.<=>#cont#2<0>"(i2 1, i64 %1, i64 %6, i64 %1, i64 %6) - %11 = icmp eq i2 %10, 1 - br i1 %11, label %if.then, label %if.else -if.then: - %12 = tail call fastcc i2 @"wybe.string.<=>#cont#2<0>"(i2 1, i64 %4, i64 %9, i64 %4, i64 %9) - %13 = icmp eq i2 %12, 1 - ret i1 %13 -if.else: - ret i1 0 +source_filename = "!ROOT!/final-dump/person2.wybe" +target triple ???? + + +declare external fastcc i2 @"wybe.string.<=>#cont#2<0>"(i2, i64, i64, i64, i64) +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc i1 @"person2.person.=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#11##0" = inttoptr i64 %"#left##0" to ptr + %"#left#firstname##0" = load i64, ptr %"tmp#11##0" + %"tmp#12##0" = add i64 %"#left##0", 8 + %"tmp#13##0" = inttoptr i64 %"tmp#12##0" to ptr + %"#left#lastname##0" = load i64, ptr %"tmp#13##0" + %"tmp#14##0" = inttoptr i64 %"#right##0" to ptr + %"#right#firstname##0" = load i64, ptr %"tmp#14##0" + %"tmp#15##0" = add i64 %"#right##0", 8 + %"tmp#16##0" = inttoptr i64 %"tmp#15##0" to ptr + %"#right#lastname##0" = load i64, ptr %"tmp#16##0" + %"tmp#7##0" = tail call fastcc i2 @"wybe.string.<=>#cont#2<0>"(i2 1, i64 %"#left#firstname##0", i64 %"#right#firstname##0", i64 %"#left#firstname##0", i64 %"#right#firstname##0") + %"tmp#1##0" = icmp eq i2 %"tmp#7##0", 1 + br i1 %"tmp#1##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#10##0" = tail call fastcc i2 @"wybe.string.<=>#cont#2<0>"(i2 1, i64 %"#left#lastname##0", i64 %"#right#lastname##0", i64 %"#left#lastname##0", i64 %"#right#lastname##0") + %"tmp#17##0" = icmp eq i2 %"tmp#10##0", 1 + ret i1 %"tmp#17##0" +if.else.0: + ret i1 0 } - -define external fastcc i64 @"person2.person.firstname<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#rec##0" to i64* - %1 = load i64, i64* %0 - ret i64 %1 +define external fastcc i64 @"person2.person.firstname<0>"(i64 %"#rec##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + ret i64 %"tmp#1##0" } - -define external fastcc i64 @"person2.person.firstname<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = inttoptr i64 %2 to i64* - store i64 %"#field##0", i64* %6 - ret i64 %2 +define external fastcc i64 @"person2.person.firstname<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"#field##0", ptr %"tmp#3##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"person2.person.lastname<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = add i64 %"#rec##0", 8 - %1 = inttoptr i64 %0 to i64* - %2 = load i64, i64* %1 - ret i64 %2 +define external fastcc i64 @"person2.person.lastname<0>"(i64 %"#rec##0") { + %"tmp#0##0" = add i64 %"#rec##0", 8 + %"tmp#1##0" = inttoptr i64 %"tmp#0##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"person2.person.lastname<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = add i64 %2, 8 - %7 = inttoptr i64 %6 to i64* - store i64 %"#field##0", i64* %7 - ret i64 %2 +define external fastcc i64 @"person2.person.lastname<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = add i64 %"tmp#2##0", 8 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 %"#field##0", ptr %"tmp#4##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"person2.person.person<0>"(i64 %"firstname##0", i64 %"lastname##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"firstname##0", i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"lastname##0", i64* %5 - ret i64 %2 +define external fastcc i64 @"person2.person.person<0>"(i64 %"firstname##0", i64 %"lastname##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 16) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"firstname##0", ptr %"tmp#1##0" + %"tmp#2##0" = add i64 %"#rec##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"lastname##0", ptr %"tmp#3##0" + ret i64 %"#rec##0" } - -define external fastcc {i64, i64} @"person2.person.person<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#result##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#result##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = insertvalue {i64, i64} undef, i64 %1, 0 - %6 = insertvalue {i64, i64} %5, i64 %4, 1 - ret {i64, i64} %6 +define external fastcc {i64, i64} @"person2.person.person<1>"(i64 %"#result##0") { + %"tmp#0##0" = inttoptr i64 %"#result##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + %"tmp#2##0" = add i64 %"#result##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#3##0" + %"tmp#5##0" = insertvalue {i64, i64} undef, i64 %"tmp#1##0", 0 + %"tmp#6##0" = insertvalue {i64, i64} %"tmp#5##0", i64 %"tmp#4##0", 1 + ret {i64, i64} %"tmp#6##0" } - -define external fastcc i1 @"person2.person.~=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %"#right##0" to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = tail call fastcc i2 @"wybe.string.<=>#cont#2<0>"(i2 1, i64 %1, i64 %6, i64 %1, i64 %6) - %11 = icmp eq i2 %10, 1 - br i1 %11, label %if.then, label %if.else -if.then: - %12 = tail call fastcc i2 @"wybe.string.<=>#cont#2<0>"(i2 1, i64 %4, i64 %9, i64 %4, i64 %9) - %13 = icmp eq i2 %12, 1 - %14 = xor i1 %13, 1 - ret i1 %14 -if.else: - %15 = xor i1 0, 1 - ret i1 %15 +define external fastcc i1 @"person2.person.~=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#10##0" = inttoptr i64 %"#left##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#10##0" + %"tmp#11##0" = add i64 %"#left##0", 8 + %"tmp#12##0" = inttoptr i64 %"tmp#11##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#12##0" + %"tmp#13##0" = inttoptr i64 %"#right##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#13##0" + %"tmp#14##0" = add i64 %"#right##0", 8 + %"tmp#15##0" = inttoptr i64 %"tmp#14##0" to ptr + %"tmp#6##0" = load i64, ptr %"tmp#15##0" + %"tmp#7##0" = tail call fastcc i2 @"wybe.string.<=>#cont#2<0>"(i2 1, i64 %"tmp#3##0", i64 %"tmp#5##0", i64 %"tmp#3##0", i64 %"tmp#5##0") + %"tmp#8##0" = icmp eq i2 %"tmp#7##0", 1 + br i1 %"tmp#8##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#9##0" = tail call fastcc i2 @"wybe.string.<=>#cont#2<0>"(i2 1, i64 %"tmp#4##0", i64 %"tmp#6##0", i64 %"tmp#4##0", i64 %"tmp#6##0") + %"tmp#0##0" = icmp eq i2 %"tmp#9##0", 1 + %"tmp#16##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#16##0" +if.else.0: + %"tmp#17##0" = xor i1 0, 1 + ret i1 %"tmp#17##0" } diff --git a/test-cases/final-dump/person3.exp b/test-cases/final-dump/person3.exp index 78f2696f7..734eca7bf 100644 --- a/test-cases/final-dump/person3.exp +++ b/test-cases/final-dump/person3.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module person3 representation : (not a type) public submods : person -> person3.person @@ -29,42 +32,29 @@ module top-level code > public {inline,semipure} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'person3' +source_filename = "!ROOT!/final-dump/person3.wybe" +target triple ???? - - - -@person3.3 = constant {i64, i64} { i64 4, i64 ptrtoint ([?? x i8]* @person3.2 to i64) } - - -@person3.1 = constant {i64, i64} { i64 5, i64 ptrtoint ([?? x i8]* @person3.0 to i64) } - - -@person3.0 = constant [?? x i8] c"Smith\00" - - -@person3.2 = constant [?? x i8] c"Wang\00" - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c"Smith\00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c"Wang\00", align 8 +@"string#2" = private unnamed_addr constant {i64, i64} { i64 5, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +@"string#3" = private unnamed_addr constant {i64, i64} { i64 4, i64 ptrtoint( ptr @"cstring#1" to i64 ) }, align 8 +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -define external fastcc void @"person3.<0>"() alwaysinline { -entry: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @person3.1, i32 0, i32 0) to i64)) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @person3.3, i32 0, i32 0) to i64)) - ret void +define external fastcc void @"person3.<0>"() { + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#2" to i64 )) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#3" to i64 )) + ret void } + -------------------------------------------------- Module person3.person - representation : address + representation : pointer public submods : public resources: public procs : person3.person.=<0> @@ -170,141 +160,115 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'person3.person' - - - - -declare external fastcc i2 @"wybe.string.<=>#cont#2<0>"(i2, i64, i64, i64, i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i1 @"person3.person.=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %"#right##0" to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = tail call fastcc i2 @"wybe.string.<=>#cont#2<0>"(i2 1, i64 %1, i64 %6, i64 %1, i64 %6) - %11 = icmp eq i2 %10, 1 - br i1 %11, label %if.then, label %if.else -if.then: - %12 = tail call fastcc i2 @"wybe.string.<=>#cont#2<0>"(i2 1, i64 %4, i64 %9, i64 %4, i64 %9) - %13 = icmp eq i2 %12, 1 - ret i1 %13 -if.else: - ret i1 0 +source_filename = "!ROOT!/final-dump/person3.wybe" +target triple ???? + + +declare external fastcc i2 @"wybe.string.<=>#cont#2<0>"(i2, i64, i64, i64, i64) +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc i1 @"person3.person.=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#11##0" = inttoptr i64 %"#left##0" to ptr + %"#left#firstname##0" = load i64, ptr %"tmp#11##0" + %"tmp#12##0" = add i64 %"#left##0", 8 + %"tmp#13##0" = inttoptr i64 %"tmp#12##0" to ptr + %"#left#lastname##0" = load i64, ptr %"tmp#13##0" + %"tmp#14##0" = inttoptr i64 %"#right##0" to ptr + %"#right#firstname##0" = load i64, ptr %"tmp#14##0" + %"tmp#15##0" = add i64 %"#right##0", 8 + %"tmp#16##0" = inttoptr i64 %"tmp#15##0" to ptr + %"#right#lastname##0" = load i64, ptr %"tmp#16##0" + %"tmp#7##0" = tail call fastcc i2 @"wybe.string.<=>#cont#2<0>"(i2 1, i64 %"#left#firstname##0", i64 %"#right#firstname##0", i64 %"#left#firstname##0", i64 %"#right#firstname##0") + %"tmp#1##0" = icmp eq i2 %"tmp#7##0", 1 + br i1 %"tmp#1##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#10##0" = tail call fastcc i2 @"wybe.string.<=>#cont#2<0>"(i2 1, i64 %"#left#lastname##0", i64 %"#right#lastname##0", i64 %"#left#lastname##0", i64 %"#right#lastname##0") + %"tmp#17##0" = icmp eq i2 %"tmp#10##0", 1 + ret i1 %"tmp#17##0" +if.else.0: + ret i1 0 } - -define external fastcc i64 @"person3.person.firstname<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#rec##0" to i64* - %1 = load i64, i64* %0 - ret i64 %1 +define external fastcc i64 @"person3.person.firstname<0>"(i64 %"#rec##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + ret i64 %"tmp#1##0" } - -define external fastcc i64 @"person3.person.firstname<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = inttoptr i64 %2 to i64* - store i64 %"#field##0", i64* %6 - ret i64 %2 +define external fastcc i64 @"person3.person.firstname<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"#field##0", ptr %"tmp#3##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"person3.person.lastname<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = add i64 %"#rec##0", 8 - %1 = inttoptr i64 %0 to i64* - %2 = load i64, i64* %1 - ret i64 %2 +define external fastcc i64 @"person3.person.lastname<0>"(i64 %"#rec##0") { + %"tmp#0##0" = add i64 %"#rec##0", 8 + %"tmp#1##0" = inttoptr i64 %"tmp#0##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"person3.person.lastname<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = add i64 %2, 8 - %7 = inttoptr i64 %6 to i64* - store i64 %"#field##0", i64* %7 - ret i64 %2 +define external fastcc i64 @"person3.person.lastname<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = add i64 %"tmp#2##0", 8 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 %"#field##0", ptr %"tmp#4##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"person3.person.person<0>"(i64 %"firstname##0", i64 %"lastname##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"firstname##0", i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"lastname##0", i64* %5 - ret i64 %2 +define external fastcc i64 @"person3.person.person<0>"(i64 %"firstname##0", i64 %"lastname##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 16) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"firstname##0", ptr %"tmp#1##0" + %"tmp#2##0" = add i64 %"#rec##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"lastname##0", ptr %"tmp#3##0" + ret i64 %"#rec##0" } - -define external fastcc {i64, i64} @"person3.person.person<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#result##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#result##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = insertvalue {i64, i64} undef, i64 %1, 0 - %6 = insertvalue {i64, i64} %5, i64 %4, 1 - ret {i64, i64} %6 +define external fastcc {i64, i64} @"person3.person.person<1>"(i64 %"#result##0") { + %"tmp#0##0" = inttoptr i64 %"#result##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + %"tmp#2##0" = add i64 %"#result##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#3##0" + %"tmp#5##0" = insertvalue {i64, i64} undef, i64 %"tmp#1##0", 0 + %"tmp#6##0" = insertvalue {i64, i64} %"tmp#5##0", i64 %"tmp#4##0", 1 + ret {i64, i64} %"tmp#6##0" } - -define external fastcc i1 @"person3.person.~=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %"#right##0" to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = tail call fastcc i2 @"wybe.string.<=>#cont#2<0>"(i2 1, i64 %1, i64 %6, i64 %1, i64 %6) - %11 = icmp eq i2 %10, 1 - br i1 %11, label %if.then, label %if.else -if.then: - %12 = tail call fastcc i2 @"wybe.string.<=>#cont#2<0>"(i2 1, i64 %4, i64 %9, i64 %4, i64 %9) - %13 = icmp eq i2 %12, 1 - %14 = xor i1 %13, 1 - ret i1 %14 -if.else: - %15 = xor i1 0, 1 - ret i1 %15 +define external fastcc i1 @"person3.person.~=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#10##0" = inttoptr i64 %"#left##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#10##0" + %"tmp#11##0" = add i64 %"#left##0", 8 + %"tmp#12##0" = inttoptr i64 %"tmp#11##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#12##0" + %"tmp#13##0" = inttoptr i64 %"#right##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#13##0" + %"tmp#14##0" = add i64 %"#right##0", 8 + %"tmp#15##0" = inttoptr i64 %"tmp#14##0" to ptr + %"tmp#6##0" = load i64, ptr %"tmp#15##0" + %"tmp#7##0" = tail call fastcc i2 @"wybe.string.<=>#cont#2<0>"(i2 1, i64 %"tmp#3##0", i64 %"tmp#5##0", i64 %"tmp#3##0", i64 %"tmp#5##0") + %"tmp#8##0" = icmp eq i2 %"tmp#7##0", 1 + br i1 %"tmp#8##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#9##0" = tail call fastcc i2 @"wybe.string.<=>#cont#2<0>"(i2 1, i64 %"tmp#4##0", i64 %"tmp#6##0", i64 %"tmp#4##0", i64 %"tmp#6##0") + %"tmp#0##0" = icmp eq i2 %"tmp#9##0", 1 + %"tmp#16##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#16##0" +if.else.0: + %"tmp#17##0" = xor i1 0, 1 + ret i1 %"tmp#17##0" } diff --git a/test-cases/final-dump/person4.exp b/test-cases/final-dump/person4.exp index fc73f53c7..34f2bc18a 100644 --- a/test-cases/final-dump/person4.exp +++ b/test-cases/final-dump/person4.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module person4 representation : (not a type) public submods : person -> person4.person @@ -29,42 +32,29 @@ module top-level code > public {inline,semipure} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'person4' +source_filename = "!ROOT!/final-dump/person4.wybe" +target triple ???? - - - -@person4.1 = constant {i64, i64} { i64 4, i64 ptrtoint ([?? x i8]* @person4.0 to i64) } - - -@person4.3 = constant {i64, i64} { i64 5, i64 ptrtoint ([?? x i8]* @person4.2 to i64) } - - -@person4.2 = constant [?? x i8] c"Smith\00" - - -@person4.0 = constant [?? x i8] c"Wang\00" - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c"Smith\00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c"Wang\00", align 8 +@"string#2" = private unnamed_addr constant {i64, i64} { i64 5, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +@"string#3" = private unnamed_addr constant {i64, i64} { i64 4, i64 ptrtoint( ptr @"cstring#1" to i64 ) }, align 8 +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -define external fastcc void @"person4.<0>"() alwaysinline { -entry: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @person4.1, i32 0, i32 0) to i64)) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @person4.3, i32 0, i32 0) to i64)) - ret void +define external fastcc void @"person4.<0>"() { + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#3" to i64 )) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#2" to i64 )) + ret void } + -------------------------------------------------- Module person4.person - representation : address + representation : pointer public submods : public resources: public procs : person4.person.=<0> @@ -170,141 +160,115 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'person4.person' - - - - -declare external fastcc i2 @"wybe.string.<=>#cont#2<0>"(i2, i64, i64, i64, i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i1 @"person4.person.=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %"#right##0" to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = tail call fastcc i2 @"wybe.string.<=>#cont#2<0>"(i2 1, i64 %1, i64 %6, i64 %1, i64 %6) - %11 = icmp eq i2 %10, 1 - br i1 %11, label %if.then, label %if.else -if.then: - %12 = tail call fastcc i2 @"wybe.string.<=>#cont#2<0>"(i2 1, i64 %4, i64 %9, i64 %4, i64 %9) - %13 = icmp eq i2 %12, 1 - ret i1 %13 -if.else: - ret i1 0 +source_filename = "!ROOT!/final-dump/person4.wybe" +target triple ???? + + +declare external fastcc i2 @"wybe.string.<=>#cont#2<0>"(i2, i64, i64, i64, i64) +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc i1 @"person4.person.=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#11##0" = inttoptr i64 %"#left##0" to ptr + %"#left#firstname##0" = load i64, ptr %"tmp#11##0" + %"tmp#12##0" = add i64 %"#left##0", 8 + %"tmp#13##0" = inttoptr i64 %"tmp#12##0" to ptr + %"#left#lastname##0" = load i64, ptr %"tmp#13##0" + %"tmp#14##0" = inttoptr i64 %"#right##0" to ptr + %"#right#firstname##0" = load i64, ptr %"tmp#14##0" + %"tmp#15##0" = add i64 %"#right##0", 8 + %"tmp#16##0" = inttoptr i64 %"tmp#15##0" to ptr + %"#right#lastname##0" = load i64, ptr %"tmp#16##0" + %"tmp#7##0" = tail call fastcc i2 @"wybe.string.<=>#cont#2<0>"(i2 1, i64 %"#left#firstname##0", i64 %"#right#firstname##0", i64 %"#left#firstname##0", i64 %"#right#firstname##0") + %"tmp#1##0" = icmp eq i2 %"tmp#7##0", 1 + br i1 %"tmp#1##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#10##0" = tail call fastcc i2 @"wybe.string.<=>#cont#2<0>"(i2 1, i64 %"#left#lastname##0", i64 %"#right#lastname##0", i64 %"#left#lastname##0", i64 %"#right#lastname##0") + %"tmp#17##0" = icmp eq i2 %"tmp#10##0", 1 + ret i1 %"tmp#17##0" +if.else.0: + ret i1 0 } - -define external fastcc i64 @"person4.person.firstname<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#rec##0" to i64* - %1 = load i64, i64* %0 - ret i64 %1 +define external fastcc i64 @"person4.person.firstname<0>"(i64 %"#rec##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + ret i64 %"tmp#1##0" } - -define external fastcc i64 @"person4.person.firstname<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = inttoptr i64 %2 to i64* - store i64 %"#field##0", i64* %6 - ret i64 %2 +define external fastcc i64 @"person4.person.firstname<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"#field##0", ptr %"tmp#3##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"person4.person.lastname<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = add i64 %"#rec##0", 8 - %1 = inttoptr i64 %0 to i64* - %2 = load i64, i64* %1 - ret i64 %2 +define external fastcc i64 @"person4.person.lastname<0>"(i64 %"#rec##0") { + %"tmp#0##0" = add i64 %"#rec##0", 8 + %"tmp#1##0" = inttoptr i64 %"tmp#0##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"person4.person.lastname<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = add i64 %2, 8 - %7 = inttoptr i64 %6 to i64* - store i64 %"#field##0", i64* %7 - ret i64 %2 +define external fastcc i64 @"person4.person.lastname<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = add i64 %"tmp#2##0", 8 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 %"#field##0", ptr %"tmp#4##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"person4.person.person<0>"(i64 %"firstname##0", i64 %"lastname##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"firstname##0", i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"lastname##0", i64* %5 - ret i64 %2 +define external fastcc i64 @"person4.person.person<0>"(i64 %"firstname##0", i64 %"lastname##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 16) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"firstname##0", ptr %"tmp#1##0" + %"tmp#2##0" = add i64 %"#rec##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"lastname##0", ptr %"tmp#3##0" + ret i64 %"#rec##0" } - -define external fastcc {i64, i64} @"person4.person.person<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#result##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#result##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = insertvalue {i64, i64} undef, i64 %1, 0 - %6 = insertvalue {i64, i64} %5, i64 %4, 1 - ret {i64, i64} %6 +define external fastcc {i64, i64} @"person4.person.person<1>"(i64 %"#result##0") { + %"tmp#0##0" = inttoptr i64 %"#result##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + %"tmp#2##0" = add i64 %"#result##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#3##0" + %"tmp#5##0" = insertvalue {i64, i64} undef, i64 %"tmp#1##0", 0 + %"tmp#6##0" = insertvalue {i64, i64} %"tmp#5##0", i64 %"tmp#4##0", 1 + ret {i64, i64} %"tmp#6##0" } - -define external fastcc i1 @"person4.person.~=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %"#right##0" to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = tail call fastcc i2 @"wybe.string.<=>#cont#2<0>"(i2 1, i64 %1, i64 %6, i64 %1, i64 %6) - %11 = icmp eq i2 %10, 1 - br i1 %11, label %if.then, label %if.else -if.then: - %12 = tail call fastcc i2 @"wybe.string.<=>#cont#2<0>"(i2 1, i64 %4, i64 %9, i64 %4, i64 %9) - %13 = icmp eq i2 %12, 1 - %14 = xor i1 %13, 1 - ret i1 %14 -if.else: - %15 = xor i1 0, 1 - ret i1 %15 +define external fastcc i1 @"person4.person.~=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#10##0" = inttoptr i64 %"#left##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#10##0" + %"tmp#11##0" = add i64 %"#left##0", 8 + %"tmp#12##0" = inttoptr i64 %"tmp#11##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#12##0" + %"tmp#13##0" = inttoptr i64 %"#right##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#13##0" + %"tmp#14##0" = add i64 %"#right##0", 8 + %"tmp#15##0" = inttoptr i64 %"tmp#14##0" to ptr + %"tmp#6##0" = load i64, ptr %"tmp#15##0" + %"tmp#7##0" = tail call fastcc i2 @"wybe.string.<=>#cont#2<0>"(i2 1, i64 %"tmp#3##0", i64 %"tmp#5##0", i64 %"tmp#3##0", i64 %"tmp#5##0") + %"tmp#8##0" = icmp eq i2 %"tmp#7##0", 1 + br i1 %"tmp#8##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#9##0" = tail call fastcc i2 @"wybe.string.<=>#cont#2<0>"(i2 1, i64 %"tmp#4##0", i64 %"tmp#6##0", i64 %"tmp#4##0", i64 %"tmp#6##0") + %"tmp#0##0" = icmp eq i2 %"tmp#9##0", 1 + %"tmp#16##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#16##0" +if.else.0: + %"tmp#17##0" = xor i1 0, 1 + ret i1 %"tmp#17##0" } diff --git a/test-cases/final-dump/person5.exp b/test-cases/final-dump/person5.exp index a8f996582..129ed7afa 100644 --- a/test-cases/final-dump/person5.exp +++ b/test-cases/final-dump/person5.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module person5 representation : (not a type) public submods : person -> person5.person @@ -38,68 +41,48 @@ update_both(p1##0:person5.person, ?p1##1:person5.person, p2##0:person5.person, ? LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'person5' +source_filename = "!ROOT!/final-dump/person5.wybe" +target triple ???? - - - -@person5.1 = constant {i64, i64} { i64 3, i64 ptrtoint ([?? x i8]* @person5.0 to i64) } - - -@person5.3 = constant {i64, i64} { i64 3, i64 ptrtoint ([?? x i8]* @person5.2 to i64) } - - -@person5.0 = constant [?? x i8] c"Amy\00" +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c"Amy\00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c"Bob\00", align 8 +@"string#2" = private unnamed_addr constant {i64, i64} { i64 3, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +@"string#3" = private unnamed_addr constant {i64, i64} { i64 3, i64 ptrtoint( ptr @"cstring#1" to i64 ) }, align 8 +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -@person5.2 = constant [?? x i8] c"Bob\00" - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"person5.<0>"() alwaysinline { -entry: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @person5.1, i32 0, i32 0) to i64)) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @person5.3, i32 0, i32 0) to i64)) - ret void +define external fastcc void @"person5.<0>"() { + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#2" to i64 )) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#3" to i64 )) + ret void } - -define external fastcc {i64, i64} @"person5.update_both<0>"(i64 %"p1##0", i64 %"p2##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"p1##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = inttoptr i64 %2 to i64* - store i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @person5.1, i32 0, i32 0) to i64), i64* %6 - %7 = trunc i64 16 to i32 - %8 = tail call ccc i8* @wybe_malloc(i32 %7) - %9 = ptrtoint i8* %8 to i64 - %10 = inttoptr i64 %9 to i8* - %11 = inttoptr i64 %"p2##0" to i8* - %12 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %10, i8* %11, i32 %12, i1 0) - %13 = inttoptr i64 %9 to i64* - store i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @person5.3, i32 0, i32 0) to i64), i64* %13 - %14 = insertvalue {i64, i64} undef, i64 %2, 0 - %15 = insertvalue {i64, i64} %14, i64 %9, 1 - ret {i64, i64} %15 +define external fastcc {i64, i64} @"person5.update_both<0>"(i64 %"p1##0", i64 %"p2##0") { + %"tmp#4##0" = inttoptr i64 %"p1##0" to ptr + %"tmp#5##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#5##0", ptr %"tmp#4##0", i64 16, i1 0) + %"tmp#6##0" = ptrtoint ptr %"tmp#5##0" to i64 + %"tmp#7##0" = inttoptr i64 %"tmp#6##0" to ptr + store i64 ptrtoint( ptr @"string#2" to i64 ), ptr %"tmp#7##0" + %"tmp#8##0" = inttoptr i64 %"p2##0" to ptr + %"tmp#9##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#9##0", ptr %"tmp#8##0", i64 16, i1 0) + %"tmp#10##0" = ptrtoint ptr %"tmp#9##0" to i64 + %"tmp#11##0" = inttoptr i64 %"tmp#10##0" to ptr + store i64 ptrtoint( ptr @"string#3" to i64 ), ptr %"tmp#11##0" + %"tmp#12##0" = insertvalue {i64, i64} undef, i64 %"tmp#6##0", 0 + %"tmp#13##0" = insertvalue {i64, i64} %"tmp#12##0", i64 %"tmp#10##0", 1 + ret {i64, i64} %"tmp#13##0" } + -------------------------------------------------- Module person5.person - representation : address + representation : pointer public submods : public resources: public procs : person5.person.=<0> @@ -205,141 +188,115 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'person5.person' - - - - -declare external fastcc i2 @"wybe.string.<=>#cont#2<0>"(i2, i64, i64, i64, i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i1 @"person5.person.=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %"#right##0" to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = tail call fastcc i2 @"wybe.string.<=>#cont#2<0>"(i2 1, i64 %1, i64 %6, i64 %1, i64 %6) - %11 = icmp eq i2 %10, 1 - br i1 %11, label %if.then, label %if.else -if.then: - %12 = tail call fastcc i2 @"wybe.string.<=>#cont#2<0>"(i2 1, i64 %4, i64 %9, i64 %4, i64 %9) - %13 = icmp eq i2 %12, 1 - ret i1 %13 -if.else: - ret i1 0 +source_filename = "!ROOT!/final-dump/person5.wybe" +target triple ???? + + +declare external fastcc i2 @"wybe.string.<=>#cont#2<0>"(i2, i64, i64, i64, i64) +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc i1 @"person5.person.=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#11##0" = inttoptr i64 %"#left##0" to ptr + %"#left#firstname##0" = load i64, ptr %"tmp#11##0" + %"tmp#12##0" = add i64 %"#left##0", 8 + %"tmp#13##0" = inttoptr i64 %"tmp#12##0" to ptr + %"#left#lastname##0" = load i64, ptr %"tmp#13##0" + %"tmp#14##0" = inttoptr i64 %"#right##0" to ptr + %"#right#firstname##0" = load i64, ptr %"tmp#14##0" + %"tmp#15##0" = add i64 %"#right##0", 8 + %"tmp#16##0" = inttoptr i64 %"tmp#15##0" to ptr + %"#right#lastname##0" = load i64, ptr %"tmp#16##0" + %"tmp#7##0" = tail call fastcc i2 @"wybe.string.<=>#cont#2<0>"(i2 1, i64 %"#left#firstname##0", i64 %"#right#firstname##0", i64 %"#left#firstname##0", i64 %"#right#firstname##0") + %"tmp#1##0" = icmp eq i2 %"tmp#7##0", 1 + br i1 %"tmp#1##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#10##0" = tail call fastcc i2 @"wybe.string.<=>#cont#2<0>"(i2 1, i64 %"#left#lastname##0", i64 %"#right#lastname##0", i64 %"#left#lastname##0", i64 %"#right#lastname##0") + %"tmp#17##0" = icmp eq i2 %"tmp#10##0", 1 + ret i1 %"tmp#17##0" +if.else.0: + ret i1 0 } - -define external fastcc i64 @"person5.person.firstname<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#rec##0" to i64* - %1 = load i64, i64* %0 - ret i64 %1 +define external fastcc i64 @"person5.person.firstname<0>"(i64 %"#rec##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + ret i64 %"tmp#1##0" } - -define external fastcc i64 @"person5.person.firstname<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = inttoptr i64 %2 to i64* - store i64 %"#field##0", i64* %6 - ret i64 %2 +define external fastcc i64 @"person5.person.firstname<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"#field##0", ptr %"tmp#3##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"person5.person.lastname<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = add i64 %"#rec##0", 8 - %1 = inttoptr i64 %0 to i64* - %2 = load i64, i64* %1 - ret i64 %2 +define external fastcc i64 @"person5.person.lastname<0>"(i64 %"#rec##0") { + %"tmp#0##0" = add i64 %"#rec##0", 8 + %"tmp#1##0" = inttoptr i64 %"tmp#0##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"person5.person.lastname<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = add i64 %2, 8 - %7 = inttoptr i64 %6 to i64* - store i64 %"#field##0", i64* %7 - ret i64 %2 +define external fastcc i64 @"person5.person.lastname<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = add i64 %"tmp#2##0", 8 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 %"#field##0", ptr %"tmp#4##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"person5.person.person<0>"(i64 %"firstname##0", i64 %"lastname##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"firstname##0", i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"lastname##0", i64* %5 - ret i64 %2 +define external fastcc i64 @"person5.person.person<0>"(i64 %"firstname##0", i64 %"lastname##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 16) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"firstname##0", ptr %"tmp#1##0" + %"tmp#2##0" = add i64 %"#rec##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"lastname##0", ptr %"tmp#3##0" + ret i64 %"#rec##0" } - -define external fastcc {i64, i64} @"person5.person.person<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#result##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#result##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = insertvalue {i64, i64} undef, i64 %1, 0 - %6 = insertvalue {i64, i64} %5, i64 %4, 1 - ret {i64, i64} %6 +define external fastcc {i64, i64} @"person5.person.person<1>"(i64 %"#result##0") { + %"tmp#0##0" = inttoptr i64 %"#result##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + %"tmp#2##0" = add i64 %"#result##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#3##0" + %"tmp#5##0" = insertvalue {i64, i64} undef, i64 %"tmp#1##0", 0 + %"tmp#6##0" = insertvalue {i64, i64} %"tmp#5##0", i64 %"tmp#4##0", 1 + ret {i64, i64} %"tmp#6##0" } - -define external fastcc i1 @"person5.person.~=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %"#right##0" to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = tail call fastcc i2 @"wybe.string.<=>#cont#2<0>"(i2 1, i64 %1, i64 %6, i64 %1, i64 %6) - %11 = icmp eq i2 %10, 1 - br i1 %11, label %if.then, label %if.else -if.then: - %12 = tail call fastcc i2 @"wybe.string.<=>#cont#2<0>"(i2 1, i64 %4, i64 %9, i64 %4, i64 %9) - %13 = icmp eq i2 %12, 1 - %14 = xor i1 %13, 1 - ret i1 %14 -if.else: - %15 = xor i1 0, 1 - ret i1 %15 +define external fastcc i1 @"person5.person.~=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#10##0" = inttoptr i64 %"#left##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#10##0" + %"tmp#11##0" = add i64 %"#left##0", 8 + %"tmp#12##0" = inttoptr i64 %"tmp#11##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#12##0" + %"tmp#13##0" = inttoptr i64 %"#right##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#13##0" + %"tmp#14##0" = add i64 %"#right##0", 8 + %"tmp#15##0" = inttoptr i64 %"tmp#14##0" to ptr + %"tmp#6##0" = load i64, ptr %"tmp#15##0" + %"tmp#7##0" = tail call fastcc i2 @"wybe.string.<=>#cont#2<0>"(i2 1, i64 %"tmp#3##0", i64 %"tmp#5##0", i64 %"tmp#3##0", i64 %"tmp#5##0") + %"tmp#8##0" = icmp eq i2 %"tmp#7##0", 1 + br i1 %"tmp#8##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#9##0" = tail call fastcc i2 @"wybe.string.<=>#cont#2<0>"(i2 1, i64 %"tmp#4##0", i64 %"tmp#6##0", i64 %"tmp#4##0", i64 %"tmp#6##0") + %"tmp#0##0" = icmp eq i2 %"tmp#9##0", 1 + %"tmp#16##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#16##0" +if.else.0: + %"tmp#17##0" = xor i1 0, 1 + ret i1 %"tmp#17##0" } diff --git a/test-cases/final-dump/position.exp b/test-cases/final-dump/position.exp index 6ed734603..b97047ee2 100644 --- a/test-cases/final-dump/position.exp +++ b/test-cases/final-dump/position.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module position representation : (not a type) public submods : position -> position.position @@ -41,63 +44,42 @@ printPosition(pos##0:position.position)<{<>}; {<>}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'position' - - - - -@position.3 = constant {i64, i64} { i64 1, i64 ptrtoint ([?? x i8]* @position.2 to i64) } - - -@position.5 = constant {i64, i64} { i64 1, i64 ptrtoint ([?? x i8]* @position.4 to i64) } - - -@position.1 = constant {i64, i64} { i64 2, i64 ptrtoint ([?? x i8]* @position.0 to i64) } - - -@position.0 = constant [?? x i8] c" (\00" - - -@position.4 = constant [?? x i8] c")\00" - - -@position.2 = constant [?? x i8] c",\00" - - -declare external ccc void @putchar(i8) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc void @print_int(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"position.printPosition<0>"(i64 %"pos##0") { -entry: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @position.1, i32 0, i32 0) to i64)) - %0 = inttoptr i64 %"pos##0" to i64* - %1 = load i64, i64* %0 - tail call ccc void @print_int(i64 %1) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @position.3, i32 0, i32 0) to i64)) - %2 = add i64 %"pos##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - tail call ccc void @print_int(i64 %4) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @position.5, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - ret void +source_filename = "!ROOT!/final-dump/position.wybe" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c" (\00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c")\00", align 8 +@"cstring#2" = private unnamed_addr constant [ ?? x i8 ] c",\00", align 8 +@"string#3" = private unnamed_addr constant {i64, i64} { i64 2, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +@"string#4" = private unnamed_addr constant {i64, i64} { i64 1, i64 ptrtoint( ptr @"cstring#1" to i64 ) }, align 8 +@"string#5" = private unnamed_addr constant {i64, i64} { i64 1, i64 ptrtoint( ptr @"cstring#2" to i64 ) }, align 8 + +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"position.printPosition<0>"(i64 %"pos##0") { + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#3" to i64 )) + %"tmp#13##0" = inttoptr i64 %"pos##0" to ptr + %"tmp#0##0" = load i64, ptr %"tmp#13##0" + call ccc void @print_int(i64 %"tmp#0##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#5" to i64 )) + %"tmp#14##0" = add i64 %"pos##0", 8 + %"tmp#15##0" = inttoptr i64 %"tmp#14##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#15##0" + call ccc void @print_int(i64 %"tmp#1##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#4" to i64 )) + call ccc void @putchar(i8 10) + ret void } + -------------------------------------------------- Module position.position - representation : address + representation : pointer public submods : public resources: public procs : position.position.=<0> @@ -199,134 +181,110 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'position.position' - - - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i1 @"position.position.=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %"#right##0" to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = icmp eq i64 %1, %6 - br i1 %10, label %if.then, label %if.else -if.then: - %11 = icmp eq i64 %4, %9 - ret i1 %11 -if.else: - ret i1 0 +source_filename = "!ROOT!/final-dump/position.wybe" +target triple ???? + + +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc i1 @"position.position.=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#9##0" = inttoptr i64 %"#left##0" to ptr + %"#left#x##0" = load i64, ptr %"tmp#9##0" + %"tmp#10##0" = add i64 %"#left##0", 8 + %"tmp#11##0" = inttoptr i64 %"tmp#10##0" to ptr + %"#left#y##0" = load i64, ptr %"tmp#11##0" + %"tmp#12##0" = inttoptr i64 %"#right##0" to ptr + %"#right#x##0" = load i64, ptr %"tmp#12##0" + %"tmp#13##0" = add i64 %"#right##0", 8 + %"tmp#14##0" = inttoptr i64 %"tmp#13##0" to ptr + %"#right#y##0" = load i64, ptr %"tmp#14##0" + %"tmp#1##0" = icmp eq i64 %"#left#x##0", %"#right#x##0" + br i1 %"tmp#1##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#15##0" = icmp eq i64 %"#left#y##0", %"#right#y##0" + ret i1 %"tmp#15##0" +if.else.0: + ret i1 0 } - -define external fastcc i64 @"position.position.position<0>"(i64 %"x##0", i64 %"y##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"x##0", i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"y##0", i64* %5 - ret i64 %2 +define external fastcc i64 @"position.position.position<0>"(i64 %"x##0", i64 %"y##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 16) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"x##0", ptr %"tmp#1##0" + %"tmp#2##0" = add i64 %"#rec##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"y##0", ptr %"tmp#3##0" + ret i64 %"#rec##0" } - -define external fastcc {i64, i64} @"position.position.position<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#result##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#result##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = insertvalue {i64, i64} undef, i64 %1, 0 - %6 = insertvalue {i64, i64} %5, i64 %4, 1 - ret {i64, i64} %6 +define external fastcc {i64, i64} @"position.position.position<1>"(i64 %"#result##0") { + %"tmp#0##0" = inttoptr i64 %"#result##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + %"tmp#2##0" = add i64 %"#result##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#3##0" + %"tmp#5##0" = insertvalue {i64, i64} undef, i64 %"tmp#1##0", 0 + %"tmp#6##0" = insertvalue {i64, i64} %"tmp#5##0", i64 %"tmp#4##0", 1 + ret {i64, i64} %"tmp#6##0" } - -define external fastcc i64 @"position.position.x<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#rec##0" to i64* - %1 = load i64, i64* %0 - ret i64 %1 +define external fastcc i64 @"position.position.x<0>"(i64 %"#rec##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + ret i64 %"tmp#1##0" } - -define external fastcc i64 @"position.position.x<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = inttoptr i64 %2 to i64* - store i64 %"#field##0", i64* %6 - ret i64 %2 +define external fastcc i64 @"position.position.x<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"#field##0", ptr %"tmp#3##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"position.position.y<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = add i64 %"#rec##0", 8 - %1 = inttoptr i64 %0 to i64* - %2 = load i64, i64* %1 - ret i64 %2 +define external fastcc i64 @"position.position.y<0>"(i64 %"#rec##0") { + %"tmp#0##0" = add i64 %"#rec##0", 8 + %"tmp#1##0" = inttoptr i64 %"tmp#0##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"position.position.y<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = add i64 %2, 8 - %7 = inttoptr i64 %6 to i64* - store i64 %"#field##0", i64* %7 - ret i64 %2 +define external fastcc i64 @"position.position.y<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = add i64 %"tmp#2##0", 8 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 %"#field##0", ptr %"tmp#4##0" + ret i64 %"tmp#2##0" } - -define external fastcc i1 @"position.position.~=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %"#right##0" to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = icmp eq i64 %1, %6 - br i1 %10, label %if.then, label %if.else -if.then: - %11 = icmp eq i64 %4, %9 - %12 = xor i1 %11, 1 - ret i1 %12 -if.else: - %13 = xor i1 0, 1 - ret i1 %13 +define external fastcc i1 @"position.position.~=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#8##0" = inttoptr i64 %"#left##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#8##0" + %"tmp#9##0" = add i64 %"#left##0", 8 + %"tmp#10##0" = inttoptr i64 %"tmp#9##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#10##0" + %"tmp#11##0" = inttoptr i64 %"#right##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#11##0" + %"tmp#12##0" = add i64 %"#right##0", 8 + %"tmp#13##0" = inttoptr i64 %"tmp#12##0" to ptr + %"tmp#6##0" = load i64, ptr %"tmp#13##0" + %"tmp#7##0" = icmp eq i64 %"tmp#3##0", %"tmp#5##0" + br i1 %"tmp#7##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#0##0" = icmp eq i64 %"tmp#4##0", %"tmp#6##0" + %"tmp#14##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#14##0" +if.else.0: + %"tmp#15##0" = xor i1 0, 1 + ret i1 %"tmp#15##0" } diff --git a/test-cases/final-dump/position1.exp b/test-cases/final-dump/position1.exp index 69c189ee7..53085f6b5 100644 --- a/test-cases/final-dump/position1.exp +++ b/test-cases/final-dump/position1.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module position representation : (not a type) public submods : position -> position.position @@ -41,63 +44,42 @@ printPosition(pos##0:position.position)<{<>}; {<>}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'position' - - - - -@position.3 = constant {i64, i64} { i64 1, i64 ptrtoint ([?? x i8]* @position.2 to i64) } - - -@position.5 = constant {i64, i64} { i64 1, i64 ptrtoint ([?? x i8]* @position.4 to i64) } - - -@position.1 = constant {i64, i64} { i64 2, i64 ptrtoint ([?? x i8]* @position.0 to i64) } - - -@position.0 = constant [?? x i8] c" (\00" - - -@position.4 = constant [?? x i8] c")\00" - - -@position.2 = constant [?? x i8] c",\00" - - -declare external ccc void @putchar(i8) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc void @print_int(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"position.printPosition<0>"(i64 %"pos##0") { -entry: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @position.1, i32 0, i32 0) to i64)) - %0 = inttoptr i64 %"pos##0" to i64* - %1 = load i64, i64* %0 - tail call ccc void @print_int(i64 %1) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @position.3, i32 0, i32 0) to i64)) - %2 = add i64 %"pos##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - tail call ccc void @print_int(i64 %4) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @position.5, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - ret void +source_filename = "!ROOT!/final-dump/position.wybe" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c" (\00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c")\00", align 8 +@"cstring#2" = private unnamed_addr constant [ ?? x i8 ] c",\00", align 8 +@"string#3" = private unnamed_addr constant {i64, i64} { i64 2, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +@"string#4" = private unnamed_addr constant {i64, i64} { i64 1, i64 ptrtoint( ptr @"cstring#1" to i64 ) }, align 8 +@"string#5" = private unnamed_addr constant {i64, i64} { i64 1, i64 ptrtoint( ptr @"cstring#2" to i64 ) }, align 8 + +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"position.printPosition<0>"(i64 %"pos##0") { + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#3" to i64 )) + %"tmp#13##0" = inttoptr i64 %"pos##0" to ptr + %"tmp#0##0" = load i64, ptr %"tmp#13##0" + call ccc void @print_int(i64 %"tmp#0##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#5" to i64 )) + %"tmp#14##0" = add i64 %"pos##0", 8 + %"tmp#15##0" = inttoptr i64 %"tmp#14##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#15##0" + call ccc void @print_int(i64 %"tmp#1##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#4" to i64 )) + call ccc void @putchar(i8 10) + ret void } + -------------------------------------------------- Module position.position - representation : address + representation : pointer public submods : public resources: public procs : position.position.=<0> @@ -199,137 +181,114 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'position.position' - - - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i1 @"position.position.=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %"#right##0" to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = icmp eq i64 %1, %6 - br i1 %10, label %if.then, label %if.else -if.then: - %11 = icmp eq i64 %4, %9 - ret i1 %11 -if.else: - ret i1 0 +source_filename = "!ROOT!/final-dump/position.wybe" +target triple ???? + + +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc i1 @"position.position.=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#9##0" = inttoptr i64 %"#left##0" to ptr + %"#left#x##0" = load i64, ptr %"tmp#9##0" + %"tmp#10##0" = add i64 %"#left##0", 8 + %"tmp#11##0" = inttoptr i64 %"tmp#10##0" to ptr + %"#left#y##0" = load i64, ptr %"tmp#11##0" + %"tmp#12##0" = inttoptr i64 %"#right##0" to ptr + %"#right#x##0" = load i64, ptr %"tmp#12##0" + %"tmp#13##0" = add i64 %"#right##0", 8 + %"tmp#14##0" = inttoptr i64 %"tmp#13##0" to ptr + %"#right#y##0" = load i64, ptr %"tmp#14##0" + %"tmp#1##0" = icmp eq i64 %"#left#x##0", %"#right#x##0" + br i1 %"tmp#1##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#15##0" = icmp eq i64 %"#left#y##0", %"#right#y##0" + ret i1 %"tmp#15##0" +if.else.0: + ret i1 0 } - -define external fastcc i64 @"position.position.position<0>"(i64 %"x##0", i64 %"y##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"x##0", i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"y##0", i64* %5 - ret i64 %2 +define external fastcc i64 @"position.position.position<0>"(i64 %"x##0", i64 %"y##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 16) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"x##0", ptr %"tmp#1##0" + %"tmp#2##0" = add i64 %"#rec##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"y##0", ptr %"tmp#3##0" + ret i64 %"#rec##0" } - -define external fastcc {i64, i64} @"position.position.position<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#result##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#result##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = insertvalue {i64, i64} undef, i64 %1, 0 - %6 = insertvalue {i64, i64} %5, i64 %4, 1 - ret {i64, i64} %6 +define external fastcc {i64, i64} @"position.position.position<1>"(i64 %"#result##0") { + %"tmp#0##0" = inttoptr i64 %"#result##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + %"tmp#2##0" = add i64 %"#result##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#3##0" + %"tmp#5##0" = insertvalue {i64, i64} undef, i64 %"tmp#1##0", 0 + %"tmp#6##0" = insertvalue {i64, i64} %"tmp#5##0", i64 %"tmp#4##0", 1 + ret {i64, i64} %"tmp#6##0" } - -define external fastcc i64 @"position.position.x<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#rec##0" to i64* - %1 = load i64, i64* %0 - ret i64 %1 +define external fastcc i64 @"position.position.x<0>"(i64 %"#rec##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + ret i64 %"tmp#1##0" } - -define external fastcc i64 @"position.position.x<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = inttoptr i64 %2 to i64* - store i64 %"#field##0", i64* %6 - ret i64 %2 +define external fastcc i64 @"position.position.x<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"#field##0", ptr %"tmp#3##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"position.position.y<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = add i64 %"#rec##0", 8 - %1 = inttoptr i64 %0 to i64* - %2 = load i64, i64* %1 - ret i64 %2 +define external fastcc i64 @"position.position.y<0>"(i64 %"#rec##0") { + %"tmp#0##0" = add i64 %"#rec##0", 8 + %"tmp#1##0" = inttoptr i64 %"tmp#0##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"position.position.y<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = add i64 %2, 8 - %7 = inttoptr i64 %6 to i64* - store i64 %"#field##0", i64* %7 - ret i64 %2 +define external fastcc i64 @"position.position.y<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = add i64 %"tmp#2##0", 8 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 %"#field##0", ptr %"tmp#4##0" + ret i64 %"tmp#2##0" } - -define external fastcc i1 @"position.position.~=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %"#right##0" to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = icmp eq i64 %1, %6 - br i1 %10, label %if.then, label %if.else -if.then: - %11 = icmp eq i64 %4, %9 - %12 = xor i1 %11, 1 - ret i1 %12 -if.else: - %13 = xor i1 0, 1 - ret i1 %13 +define external fastcc i1 @"position.position.~=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#8##0" = inttoptr i64 %"#left##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#8##0" + %"tmp#9##0" = add i64 %"#left##0", 8 + %"tmp#10##0" = inttoptr i64 %"tmp#9##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#10##0" + %"tmp#11##0" = inttoptr i64 %"#right##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#11##0" + %"tmp#12##0" = add i64 %"#right##0", 8 + %"tmp#13##0" = inttoptr i64 %"tmp#12##0" to ptr + %"tmp#6##0" = load i64, ptr %"tmp#13##0" + %"tmp#7##0" = icmp eq i64 %"tmp#3##0", %"tmp#5##0" + br i1 %"tmp#7##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#0##0" = icmp eq i64 %"tmp#4##0", %"tmp#6##0" + %"tmp#14##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#14##0" +if.else.0: + %"tmp#15##0" = xor i1 0, 1 + ret i1 %"tmp#15##0" } + -------------------------------------------------- Module position1 representation : (not a type) @@ -355,44 +314,32 @@ module top-level code > public {semipure} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'position1' - - - - -@position1.1 = constant {i64, i64} { i64 21, i64 ptrtoint ([?? x i8]* @position1.0 to i64) } - - -@position1.0 = constant [?? x i8] c"expect posA(111,112):\00" - - -declare external fastcc void @"position.printPosition<0>"(i64) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"position1.<0>"() { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 111, i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 222, i64* %5 - %6 = add i64 %2, 8 - %7 = inttoptr i64 %6 to i64* - store i64 112, i64* %7 - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @position1.1, i32 0, i32 0) to i64)) - tail call fastcc void @"position.printPosition<0>"(i64 %2) - ret void +source_filename = "!ROOT!/final-dump/position1.wybe" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c"expect posA(111,112):\00", align 8 +@"string#1" = private unnamed_addr constant {i64, i64} { i64 21, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 + +declare external fastcc void @"position.printPosition<0>"(i64) +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"position1.<0>"() { + %"tmp#12##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#4##0" = ptrtoint ptr %"tmp#12##0" to i64 + %"tmp#13##0" = inttoptr i64 %"tmp#4##0" to ptr + store i64 111, ptr %"tmp#13##0" + %"tmp#14##0" = add i64 %"tmp#4##0", 8 + %"tmp#15##0" = inttoptr i64 %"tmp#14##0" to ptr + store i64 222, ptr %"tmp#15##0" + %"tmp#16##0" = add i64 %"tmp#4##0", 8 + %"tmp#17##0" = inttoptr i64 %"tmp#16##0" to ptr + store i64 112, ptr %"tmp#17##0" + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#1" to i64 )) + tail call fastcc void @"position.printPosition<0>"(i64 %"tmp#4##0") + ret void } diff --git a/test-cases/final-dump/position2.exp b/test-cases/final-dump/position2.exp index a8789cd83..3ee4d2a4a 100644 --- a/test-cases/final-dump/position2.exp +++ b/test-cases/final-dump/position2.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module position representation : (not a type) public submods : position -> position.position @@ -41,63 +44,42 @@ printPosition(pos##0:position.position)<{<>}; {<>}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'position' - - - - -@position.3 = constant {i64, i64} { i64 1, i64 ptrtoint ([?? x i8]* @position.2 to i64) } - - -@position.5 = constant {i64, i64} { i64 1, i64 ptrtoint ([?? x i8]* @position.4 to i64) } - - -@position.1 = constant {i64, i64} { i64 2, i64 ptrtoint ([?? x i8]* @position.0 to i64) } - - -@position.0 = constant [?? x i8] c" (\00" - - -@position.4 = constant [?? x i8] c")\00" - - -@position.2 = constant [?? x i8] c",\00" - - -declare external ccc void @putchar(i8) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc void @print_int(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"position.printPosition<0>"(i64 %"pos##0") { -entry: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @position.1, i32 0, i32 0) to i64)) - %0 = inttoptr i64 %"pos##0" to i64* - %1 = load i64, i64* %0 - tail call ccc void @print_int(i64 %1) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @position.3, i32 0, i32 0) to i64)) - %2 = add i64 %"pos##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - tail call ccc void @print_int(i64 %4) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @position.5, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - ret void +source_filename = "!ROOT!/final-dump/position.wybe" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c" (\00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c")\00", align 8 +@"cstring#2" = private unnamed_addr constant [ ?? x i8 ] c",\00", align 8 +@"string#3" = private unnamed_addr constant {i64, i64} { i64 2, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +@"string#4" = private unnamed_addr constant {i64, i64} { i64 1, i64 ptrtoint( ptr @"cstring#1" to i64 ) }, align 8 +@"string#5" = private unnamed_addr constant {i64, i64} { i64 1, i64 ptrtoint( ptr @"cstring#2" to i64 ) }, align 8 + +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"position.printPosition<0>"(i64 %"pos##0") { + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#3" to i64 )) + %"tmp#13##0" = inttoptr i64 %"pos##0" to ptr + %"tmp#0##0" = load i64, ptr %"tmp#13##0" + call ccc void @print_int(i64 %"tmp#0##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#5" to i64 )) + %"tmp#14##0" = add i64 %"pos##0", 8 + %"tmp#15##0" = inttoptr i64 %"tmp#14##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#15##0" + call ccc void @print_int(i64 %"tmp#1##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#4" to i64 )) + call ccc void @putchar(i8 10) + ret void } + -------------------------------------------------- Module position.position - representation : address + representation : pointer public submods : public resources: public procs : position.position.=<0> @@ -199,137 +181,114 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'position.position' - - - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i1 @"position.position.=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %"#right##0" to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = icmp eq i64 %1, %6 - br i1 %10, label %if.then, label %if.else -if.then: - %11 = icmp eq i64 %4, %9 - ret i1 %11 -if.else: - ret i1 0 +source_filename = "!ROOT!/final-dump/position.wybe" +target triple ???? + + +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc i1 @"position.position.=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#9##0" = inttoptr i64 %"#left##0" to ptr + %"#left#x##0" = load i64, ptr %"tmp#9##0" + %"tmp#10##0" = add i64 %"#left##0", 8 + %"tmp#11##0" = inttoptr i64 %"tmp#10##0" to ptr + %"#left#y##0" = load i64, ptr %"tmp#11##0" + %"tmp#12##0" = inttoptr i64 %"#right##0" to ptr + %"#right#x##0" = load i64, ptr %"tmp#12##0" + %"tmp#13##0" = add i64 %"#right##0", 8 + %"tmp#14##0" = inttoptr i64 %"tmp#13##0" to ptr + %"#right#y##0" = load i64, ptr %"tmp#14##0" + %"tmp#1##0" = icmp eq i64 %"#left#x##0", %"#right#x##0" + br i1 %"tmp#1##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#15##0" = icmp eq i64 %"#left#y##0", %"#right#y##0" + ret i1 %"tmp#15##0" +if.else.0: + ret i1 0 } - -define external fastcc i64 @"position.position.position<0>"(i64 %"x##0", i64 %"y##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"x##0", i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"y##0", i64* %5 - ret i64 %2 +define external fastcc i64 @"position.position.position<0>"(i64 %"x##0", i64 %"y##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 16) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"x##0", ptr %"tmp#1##0" + %"tmp#2##0" = add i64 %"#rec##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"y##0", ptr %"tmp#3##0" + ret i64 %"#rec##0" } - -define external fastcc {i64, i64} @"position.position.position<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#result##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#result##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = insertvalue {i64, i64} undef, i64 %1, 0 - %6 = insertvalue {i64, i64} %5, i64 %4, 1 - ret {i64, i64} %6 +define external fastcc {i64, i64} @"position.position.position<1>"(i64 %"#result##0") { + %"tmp#0##0" = inttoptr i64 %"#result##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + %"tmp#2##0" = add i64 %"#result##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#3##0" + %"tmp#5##0" = insertvalue {i64, i64} undef, i64 %"tmp#1##0", 0 + %"tmp#6##0" = insertvalue {i64, i64} %"tmp#5##0", i64 %"tmp#4##0", 1 + ret {i64, i64} %"tmp#6##0" } - -define external fastcc i64 @"position.position.x<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#rec##0" to i64* - %1 = load i64, i64* %0 - ret i64 %1 +define external fastcc i64 @"position.position.x<0>"(i64 %"#rec##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + ret i64 %"tmp#1##0" } - -define external fastcc i64 @"position.position.x<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = inttoptr i64 %2 to i64* - store i64 %"#field##0", i64* %6 - ret i64 %2 +define external fastcc i64 @"position.position.x<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"#field##0", ptr %"tmp#3##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"position.position.y<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = add i64 %"#rec##0", 8 - %1 = inttoptr i64 %0 to i64* - %2 = load i64, i64* %1 - ret i64 %2 +define external fastcc i64 @"position.position.y<0>"(i64 %"#rec##0") { + %"tmp#0##0" = add i64 %"#rec##0", 8 + %"tmp#1##0" = inttoptr i64 %"tmp#0##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"position.position.y<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = add i64 %2, 8 - %7 = inttoptr i64 %6 to i64* - store i64 %"#field##0", i64* %7 - ret i64 %2 +define external fastcc i64 @"position.position.y<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = add i64 %"tmp#2##0", 8 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 %"#field##0", ptr %"tmp#4##0" + ret i64 %"tmp#2##0" } - -define external fastcc i1 @"position.position.~=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %"#right##0" to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = icmp eq i64 %1, %6 - br i1 %10, label %if.then, label %if.else -if.then: - %11 = icmp eq i64 %4, %9 - %12 = xor i1 %11, 1 - ret i1 %12 -if.else: - %13 = xor i1 0, 1 - ret i1 %13 +define external fastcc i1 @"position.position.~=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#8##0" = inttoptr i64 %"#left##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#8##0" + %"tmp#9##0" = add i64 %"#left##0", 8 + %"tmp#10##0" = inttoptr i64 %"tmp#9##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#10##0" + %"tmp#11##0" = inttoptr i64 %"#right##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#11##0" + %"tmp#12##0" = add i64 %"#right##0", 8 + %"tmp#13##0" = inttoptr i64 %"tmp#12##0" to ptr + %"tmp#6##0" = load i64, ptr %"tmp#13##0" + %"tmp#7##0" = icmp eq i64 %"tmp#3##0", %"tmp#5##0" + br i1 %"tmp#7##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#0##0" = icmp eq i64 %"tmp#4##0", %"tmp#6##0" + %"tmp#14##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#14##0" +if.else.0: + %"tmp#15##0" = xor i1 0, 1 + ret i1 %"tmp#15##0" } + -------------------------------------------------- Module position2 representation : (not a type) @@ -362,68 +321,47 @@ module top-level code > public {semipure} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'position2' - - - - -@position2.1 = constant {i64, i64} { i64 21, i64 ptrtoint ([?? x i8]* @position2.0 to i64) } - - -@position2.5 = constant {i64, i64} { i64 21, i64 ptrtoint ([?? x i8]* @position2.4 to i64) } - - -@position2.3 = constant {i64, i64} { i64 23, i64 ptrtoint ([?? x i8]* @position2.2 to i64) } - - -@position2.2 = constant [?? x i8] c"expect posA(111,20000):\00" - - -@position2.0 = constant [?? x i8] c"expect posA(111,222):\00" - - -@position2.4 = constant [?? x i8] c"expect posB(333,222):\00" - - -declare external fastcc void @"position.printPosition<0>"(i64) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"position2.<0>"() { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 111, i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 222, i64* %5 - %6 = trunc i64 16 to i32 - %7 = tail call ccc i8* @wybe_malloc(i32 %6) - %8 = ptrtoint i8* %7 to i64 - %9 = inttoptr i64 %8 to i64* - store i64 333, i64* %9 - %10 = add i64 %8, 8 - %11 = inttoptr i64 %10 to i64* - store i64 222, i64* %11 - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @position2.1, i32 0, i32 0) to i64)) - tail call fastcc void @"position.printPosition<0>"(i64 %2) - %12 = add i64 %2, 8 - %13 = inttoptr i64 %12 to i64* - store i64 20000, i64* %13 - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @position2.3, i32 0, i32 0) to i64)) - tail call fastcc void @"position.printPosition<0>"(i64 %2) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @position2.5, i32 0, i32 0) to i64)) - tail call fastcc void @"position.printPosition<0>"(i64 %8) - ret void +source_filename = "!ROOT!/final-dump/position2.wybe" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c"expect posA(111,20000):\00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c"expect posA(111,222):\00", align 8 +@"cstring#2" = private unnamed_addr constant [ ?? x i8 ] c"expect posB(333,222):\00", align 8 +@"string#3" = private unnamed_addr constant {i64, i64} { i64 23, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +@"string#4" = private unnamed_addr constant {i64, i64} { i64 21, i64 ptrtoint( ptr @"cstring#1" to i64 ) }, align 8 +@"string#5" = private unnamed_addr constant {i64, i64} { i64 21, i64 ptrtoint( ptr @"cstring#2" to i64 ) }, align 8 + +declare external fastcc void @"position.printPosition<0>"(i64) +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"position2.<0>"() { + %"tmp#14##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#5##0" = ptrtoint ptr %"tmp#14##0" to i64 + %"tmp#15##0" = inttoptr i64 %"tmp#5##0" to ptr + store i64 111, ptr %"tmp#15##0" + %"tmp#16##0" = add i64 %"tmp#5##0", 8 + %"tmp#17##0" = inttoptr i64 %"tmp#16##0" to ptr + store i64 222, ptr %"tmp#17##0" + %"tmp#18##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#10##0" = ptrtoint ptr %"tmp#18##0" to i64 + %"tmp#19##0" = inttoptr i64 %"tmp#10##0" to ptr + store i64 333, ptr %"tmp#19##0" + %"tmp#20##0" = add i64 %"tmp#10##0", 8 + %"tmp#21##0" = inttoptr i64 %"tmp#20##0" to ptr + store i64 222, ptr %"tmp#21##0" + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#4" to i64 )) + tail call fastcc void @"position.printPosition<0>"(i64 %"tmp#5##0") + %"tmp#22##0" = add i64 %"tmp#5##0", 8 + %"tmp#23##0" = inttoptr i64 %"tmp#22##0" to ptr + store i64 20000, ptr %"tmp#23##0" + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#3" to i64 )) + tail call fastcc void @"position.printPosition<0>"(i64 %"tmp#5##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#5" to i64 )) + tail call fastcc void @"position.printPosition<0>"(i64 %"tmp#10##0") + ret void } diff --git a/test-cases/final-dump/position_float.exp b/test-cases/final-dump/position_float.exp index 70ddc71c3..8142dfb44 100644 --- a/test-cases/final-dump/position_float.exp +++ b/test-cases/final-dump/position_float.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module position_float representation : (not a type) public submods : position -> position_float.position @@ -21,19 +24,18 @@ AFTER EVERYTHING: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'position_float' +source_filename = "!ROOT!/final-dump/position_float.wybe" +target triple ???? - - - -declare external ccc i8* @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) -------------------------------------------------- Module position_float.position - representation : address + representation : pointer public submods : public resources: public procs : position_float.position.=<0> @@ -58,13 +60,13 @@ proc = > public {inline} (1 calls) foreign lpvm access(~#left##0:position_float.position, 8:wybe.int, 16:wybe.int, 0:wybe.int, ?#left#y##0:wybe.float) @position_float:nn:nn foreign lpvm access(#right##0:position_float.position, 0:wybe.int, 16:wybe.int, 0:wybe.int, ?#right#x##0:wybe.float) @position_float:nn:nn foreign lpvm access(~#right##0:position_float.position, 8:wybe.int, 16:wybe.int, 0:wybe.int, ?#right#y##0:wybe.float) @position_float:nn:nn - foreign llvm fcmp_eq(~#left#x##0:wybe.float, ~#right#x##0:wybe.float, ?tmp#1##0:wybe.bool) @float:nn:nn + foreign llvm fcmp_oeq(~#left#x##0:wybe.float, ~#right#x##0:wybe.float, ?tmp#1##0:wybe.bool) @float:nn:nn case ~tmp#1##0:wybe.bool of 0: foreign llvm move(0:wybe.bool, ?#success##0:wybe.bool) 1: - foreign llvm fcmp_eq(~#left#y##0:wybe.float, ~#right#y##0:wybe.float, ?#success##0:wybe.bool) @float:nn:nn + foreign llvm fcmp_oeq(~#left#y##0:wybe.float, ~#right#y##0:wybe.float, ?#success##0:wybe.bool) @float:nn:nn @@ -122,147 +124,123 @@ proc ~= > public {inline} (0 calls) foreign lpvm access(~#left##0:position_float.position, 8:wybe.int, 16:wybe.int, 0:wybe.int, ?tmp#4##0:wybe.float) @position_float:nn:nn foreign lpvm access(#right##0:position_float.position, 0:wybe.int, 16:wybe.int, 0:wybe.int, ?tmp#5##0:wybe.float) @position_float:nn:nn foreign lpvm access(~#right##0:position_float.position, 8:wybe.int, 16:wybe.int, 0:wybe.int, ?tmp#6##0:wybe.float) @position_float:nn:nn - foreign llvm fcmp_eq(~tmp#3##0:wybe.float, ~tmp#5##0:wybe.float, ?tmp#7##0:wybe.bool) @float:nn:nn + foreign llvm fcmp_oeq(~tmp#3##0:wybe.float, ~tmp#5##0:wybe.float, ?tmp#7##0:wybe.bool) @float:nn:nn case ~tmp#7##0:wybe.bool of 0: foreign llvm move(0:wybe.bool, ?tmp#0##0:wybe.bool) foreign llvm xor(~tmp#0##0:wybe.bool, 1:wybe.bool, ?#success##0:wybe.bool) 1: - foreign llvm fcmp_eq(~tmp#4##0:wybe.float, ~tmp#6##0:wybe.float, ?tmp#0##0:wybe.bool) @float:nn:nn + foreign llvm fcmp_oeq(~tmp#4##0:wybe.float, ~tmp#6##0:wybe.float, ?tmp#0##0:wybe.bool) @float:nn:nn foreign llvm xor(~tmp#0##0:wybe.bool, 1:wybe.bool, ?#success##0:wybe.bool) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'position_float.position' - - - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i1 @"position_float.position.=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to double* - %1 = load double, double* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to double* - %4 = load double, double* %3 - %5 = inttoptr i64 %"#right##0" to double* - %6 = load double, double* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to double* - %9 = load double, double* %8 - %10 = fcmp oeq double %1, %6 - br i1 %10, label %if.then, label %if.else -if.then: - %11 = fcmp oeq double %4, %9 - ret i1 %11 -if.else: - ret i1 0 +source_filename = "!ROOT!/final-dump/position_float.wybe" +target triple ???? + + +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc i1 @"position_float.position.=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#9##0" = inttoptr i64 %"#left##0" to ptr + %"#left#x##0" = load double, ptr %"tmp#9##0" + %"tmp#10##0" = add i64 %"#left##0", 8 + %"tmp#11##0" = inttoptr i64 %"tmp#10##0" to ptr + %"#left#y##0" = load double, ptr %"tmp#11##0" + %"tmp#12##0" = inttoptr i64 %"#right##0" to ptr + %"#right#x##0" = load double, ptr %"tmp#12##0" + %"tmp#13##0" = add i64 %"#right##0", 8 + %"tmp#14##0" = inttoptr i64 %"tmp#13##0" to ptr + %"#right#y##0" = load double, ptr %"tmp#14##0" + %"tmp#1##0" = fcmp oeq double %"#left#x##0", %"#right#x##0" + br i1 %"tmp#1##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#15##0" = fcmp oeq double %"#left#y##0", %"#right#y##0" + ret i1 %"tmp#15##0" +if.else.0: + ret i1 0 } - -define external fastcc i64 @"position_float.position.position<0>"(double %"x##0", double %"y##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to double* - store double %"x##0", double* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to double* - store double %"y##0", double* %5 - ret i64 %2 +define external fastcc i64 @"position_float.position.position<0>"(double %"x##0", double %"y##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 16) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store double %"x##0", ptr %"tmp#1##0" + %"tmp#2##0" = add i64 %"#rec##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store double %"y##0", ptr %"tmp#3##0" + ret i64 %"#rec##0" } - -define external fastcc {double, double} @"position_float.position.position<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#result##0" to double* - %1 = load double, double* %0 - %2 = add i64 %"#result##0", 8 - %3 = inttoptr i64 %2 to double* - %4 = load double, double* %3 - %5 = insertvalue {double, double} undef, double %1, 0 - %6 = insertvalue {double, double} %5, double %4, 1 - ret {double, double} %6 +define external fastcc {double, double} @"position_float.position.position<1>"(i64 %"#result##0") { + %"tmp#0##0" = inttoptr i64 %"#result##0" to ptr + %"tmp#1##0" = load double, ptr %"tmp#0##0" + %"tmp#2##0" = add i64 %"#result##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = load double, ptr %"tmp#3##0" + %"tmp#5##0" = insertvalue {double, double} undef, double %"tmp#1##0", 0 + %"tmp#6##0" = insertvalue {double, double} %"tmp#5##0", double %"tmp#4##0", 1 + ret {double, double} %"tmp#6##0" } - -define external fastcc double @"position_float.position.x<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#rec##0" to double* - %1 = load double, double* %0 - ret double %1 +define external fastcc double @"position_float.position.x<0>"(i64 %"#rec##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = load double, ptr %"tmp#0##0" + ret double %"tmp#1##0" } - -define external fastcc i64 @"position_float.position.x<1>"(i64 %"#rec##0", double %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = inttoptr i64 %2 to double* - store double %"#field##0", double* %6 - ret i64 %2 +define external fastcc i64 @"position_float.position.x<1>"(i64 %"#rec##0", double %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store double %"#field##0", ptr %"tmp#3##0" + ret i64 %"tmp#2##0" } - -define external fastcc double @"position_float.position.y<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = add i64 %"#rec##0", 8 - %1 = inttoptr i64 %0 to double* - %2 = load double, double* %1 - ret double %2 +define external fastcc double @"position_float.position.y<0>"(i64 %"#rec##0") { + %"tmp#0##0" = add i64 %"#rec##0", 8 + %"tmp#1##0" = inttoptr i64 %"tmp#0##0" to ptr + %"tmp#2##0" = load double, ptr %"tmp#1##0" + ret double %"tmp#2##0" } - -define external fastcc i64 @"position_float.position.y<1>"(i64 %"#rec##0", double %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = add i64 %2, 8 - %7 = inttoptr i64 %6 to double* - store double %"#field##0", double* %7 - ret i64 %2 +define external fastcc i64 @"position_float.position.y<1>"(i64 %"#rec##0", double %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = add i64 %"tmp#2##0", 8 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + store double %"#field##0", ptr %"tmp#4##0" + ret i64 %"tmp#2##0" } - -define external fastcc i1 @"position_float.position.~=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to double* - %1 = load double, double* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to double* - %4 = load double, double* %3 - %5 = inttoptr i64 %"#right##0" to double* - %6 = load double, double* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to double* - %9 = load double, double* %8 - %10 = fcmp oeq double %1, %6 - br i1 %10, label %if.then, label %if.else -if.then: - %11 = fcmp oeq double %4, %9 - %12 = xor i1 %11, 1 - ret i1 %12 -if.else: - %13 = xor i1 0, 1 - ret i1 %13 +define external fastcc i1 @"position_float.position.~=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#8##0" = inttoptr i64 %"#left##0" to ptr + %"tmp#3##0" = load double, ptr %"tmp#8##0" + %"tmp#9##0" = add i64 %"#left##0", 8 + %"tmp#10##0" = inttoptr i64 %"tmp#9##0" to ptr + %"tmp#4##0" = load double, ptr %"tmp#10##0" + %"tmp#11##0" = inttoptr i64 %"#right##0" to ptr + %"tmp#5##0" = load double, ptr %"tmp#11##0" + %"tmp#12##0" = add i64 %"#right##0", 8 + %"tmp#13##0" = inttoptr i64 %"tmp#12##0" to ptr + %"tmp#6##0" = load double, ptr %"tmp#13##0" + %"tmp#7##0" = fcmp oeq double %"tmp#3##0", %"tmp#5##0" + br i1 %"tmp#7##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#0##0" = fcmp oeq double %"tmp#4##0", %"tmp#6##0" + %"tmp#14##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#14##0" +if.else.0: + %"tmp#15##0" = xor i1 0, 1 + ret i1 %"tmp#15##0" } diff --git a/test-cases/final-dump/proc_allin.exp b/test-cases/final-dump/proc_allin.exp index d2d242bd5..8bc7fe015 100644 --- a/test-cases/final-dump/proc_allin.exp +++ b/test-cases/final-dump/proc_allin.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module proc_allin representation : (not a type) public submods : @@ -17,19 +20,15 @@ nada([x##0:wybe.int], [y##0:wybe.int])<{}; {}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'proc_allin' +source_filename = "!ROOT!/final-dump/proc_allin.wybe" +target triple ???? - - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -define external fastcc void @"proc_allin.nada<0>"() alwaysinline { -entry: - ret void +define external fastcc void @"proc_allin.nada<0>"() { + ret void } diff --git a/test-cases/final-dump/proc_beer.exp b/test-cases/final-dump/proc_beer.exp index 0b97c4c4e..f512c5f3f 100644 --- a/test-cases/final-dump/proc_beer.exp +++ b/test-cases/final-dump/proc_beer.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module proc_beer representation : (not a type) public submods : @@ -65,69 +68,49 @@ beer99#cont#2(count##0:wybe.int)<{<>}; {<>}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'proc_beer' +source_filename = "!ROOT!/final-dump/proc_beer.wybe" +target triple ???? - - - -@proc_beer.1 = constant {i64, i64} { i64 28, i64 ptrtoint ([?? x i8]* @proc_beer.0 to i64) } - - -@proc_beer.0 = constant [?? x i8] c" bottles of beer on the wall\00" - - -declare external ccc void @putchar(i8) - - -declare external fastcc void @"wybe.string.print<0>"(i64) +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c" bottles of beer on the wall\00", align 8 +@"string#1" = private unnamed_addr constant {i64, i64} { i64 28, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -declare external ccc void @print_int(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"proc_beer.<0>"() alwaysinline { -entry: - tail call fastcc void @"proc_beer.beer99#cont#1<0>"(i64 99) - ret void +define external fastcc void @"proc_beer.<0>"() { + tail call fastcc void @"proc_beer.beer99#cont#1<0>"(i64 99) + ret void } - -define external fastcc void @"proc_beer.beer99<0>"() alwaysinline { -entry: - tail call fastcc void @"proc_beer.beer99#cont#1<0>"(i64 99) - ret void +define external fastcc void @"proc_beer.beer99<0>"() { + tail call fastcc void @"proc_beer.beer99#cont#1<0>"(i64 99) + ret void } - -define external fastcc void @"proc_beer.beer99#cont#1<0>"(i64 %"count##0") { -entry: - %0 = icmp sge i64 %"count##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - tail call ccc void @print_int(i64 %"count##0") - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @proc_beer.1, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - %1 = sub i64 %"count##0", 1 - musttail call fastcc void @"proc_beer.beer99#cont#1<0>"(i64 %1) - ret void -if.else: - ret void +define external fastcc void @"proc_beer.beer99#cont#1<0>"(i64 %"count##0") { + %"tmp#0##0" = icmp sge i64 %"count##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + call ccc void @print_int(i64 %"count##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#1" to i64 )) + call ccc void @putchar(i8 10) + %"tmp#8##0" = sub i64 %"count##0", 1 + tail call fastcc void @"proc_beer.beer99#cont#1<0>"(i64 %"tmp#8##0") + ret void +if.else.0: + ret void } - -define external fastcc void @"proc_beer.beer99#cont#2<0>"(i64 %"count##0") alwaysinline { -entry: - tail call ccc void @print_int(i64 %"count##0") - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @proc_beer.1, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - %0 = sub i64 %"count##0", 1 - musttail call fastcc void @"proc_beer.beer99#cont#1<0>"(i64 %0) - ret void +define external fastcc void @"proc_beer.beer99#cont#2<0>"(i64 %"count##0") { + call ccc void @print_int(i64 %"count##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#1" to i64 )) + call ccc void @putchar(i8 10) + %"count##1" = sub i64 %"count##0", 1 + tail call fastcc void @"proc_beer.beer99#cont#1<0>"(i64 %"count##1") + ret void } diff --git a/test-cases/final-dump/proc_factorial.exp b/test-cases/final-dump/proc_factorial.exp index 5edc2c5bb..f78f568db 100644 --- a/test-cases/final-dump/proc_factorial.exp +++ b/test-cases/final-dump/proc_factorial.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module proc_factorial representation : (not a type) public submods : @@ -58,58 +61,44 @@ factorial#cont#2(n##0:wybe.int, result##0:wybe.int, ?result##2:wybe.int)<{}; {}; LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'proc_factorial' - - - - -declare external ccc void @putchar(i8) - - -declare external ccc void @print_int(i64) +source_filename = "!ROOT!/final-dump/proc_factorial.wybe" +target triple ???? -declare external ccc i8* @wybe_malloc(i32) +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"proc_factorial.<0>"() { -entry: - %0 = tail call fastcc i64 @"proc_factorial.factorial#cont#1<0>"(i64 5, i64 1) - tail call ccc void @print_int(i64 %0) - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"proc_factorial.<0>"() { + %"tmp#0##0" = tail call fastcc i64 @"proc_factorial.factorial#cont#1<0>"(i64 5, i64 1) + call ccc void @print_int(i64 %"tmp#0##0") + call ccc void @putchar(i8 10) + ret void } - -define external fastcc i64 @"proc_factorial.factorial<0>"(i64 %"n##0") alwaysinline { -entry: - %0 = tail call fastcc i64 @"proc_factorial.factorial#cont#1<0>"(i64 %"n##0", i64 1) - ret i64 %0 +define external fastcc i64 @"proc_factorial.factorial<0>"(i64 %"n##0") { + %"tmp#3##0" = tail call fastcc i64 @"proc_factorial.factorial#cont#1<0>"(i64 %"n##0", i64 1) + ret i64 %"tmp#3##0" } - -define external fastcc i64 @"proc_factorial.factorial#cont#1<0>"(i64 %"n##0", i64 %"result##0") { -entry: - %0 = icmp sgt i64 %"n##0", 1 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = mul i64 %"n##0", %"result##0" - %2 = sub i64 %"n##0", 1 - %3 = musttail call fastcc i64 @"proc_factorial.factorial#cont#1<0>"(i64 %2, i64 %1) - ret i64 %3 -if.else: - ret i64 %"result##0" +define external fastcc i64 @"proc_factorial.factorial#cont#1<0>"(i64 %"n##0", i64 %"result##0") { + %"tmp#2##0" = icmp sgt i64 %"n##0", 1 + br i1 %"tmp#2##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#7##0" = mul i64 %"n##0", %"result##0" + %"tmp#8##0" = sub i64 %"n##0", 1 + %"tmp#9##0" = tail call fastcc i64 @"proc_factorial.factorial#cont#1<0>"(i64 %"tmp#8##0", i64 %"tmp#7##0") + ret i64 %"tmp#9##0" +if.else.0: + ret i64 %"result##0" } - -define external fastcc i64 @"proc_factorial.factorial#cont#2<0>"(i64 %"n##0", i64 %"result##0") alwaysinline { -entry: - %0 = mul i64 %"n##0", %"result##0" - %1 = sub i64 %"n##0", 1 - %2 = musttail call fastcc i64 @"proc_factorial.factorial#cont#1<0>"(i64 %1, i64 %0) - ret i64 %2 +define external fastcc i64 @"proc_factorial.factorial#cont#2<0>"(i64 %"n##0", i64 %"result##0") { + %"tmp#0##0" = mul i64 %"n##0", %"result##0" + %"tmp#1##0" = sub i64 %"n##0", 1 + %"tmp#6##0" = tail call fastcc i64 @"proc_factorial.factorial#cont#1<0>"(i64 %"tmp#1##0", i64 %"tmp#0##0") + ret i64 %"tmp#6##0" } diff --git a/test-cases/final-dump/proc_gcd.exp b/test-cases/final-dump/proc_gcd.exp index 414ff1aae..e204e8b79 100644 --- a/test-cases/final-dump/proc_gcd.exp +++ b/test-cases/final-dump/proc_gcd.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module proc_gcd representation : (not a type) public submods : @@ -72,68 +75,52 @@ mod(x##0:wybe.int, y##0:wybe.int, ?r##0:wybe.int)<{<>}; {<"() { -entry: - %0 = tail call fastcc i64 @"proc_gcd.gcd#cont#1<0>"(i64 18, i64 24) - tail call ccc void @print_int(i64 %0) - ret void +define external fastcc void @"proc_gcd.<0>"() { + %"r##0" = tail call fastcc i64 @"proc_gcd.gcd#cont#1<0>"(i64 18, i64 24) + call ccc void @print_int(i64 %"r##0") + ret void } - -define external fastcc i64 @"proc_gcd.gcd<0>"(i64 %"a##0", i64 %"b##0") alwaysinline { -entry: - %0 = musttail call fastcc i64 @"proc_gcd.gcd#cont#1<0>"(i64 %"a##0", i64 %"b##0") - ret i64 %0 +define external fastcc i64 @"proc_gcd.gcd<0>"(i64 %"a##0", i64 %"b##0") { + %"tmp#1##0" = tail call fastcc i64 @"proc_gcd.gcd#cont#1<0>"(i64 %"a##0", i64 %"b##0") + ret i64 %"tmp#1##0" } - -define external fastcc i64 @"proc_gcd.gcd#cont#1<0>"(i64 %"x##0", i64 %"y##0") { -entry: - %0 = icmp ne i64 %"y##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = tail call fastcc i64 @"proc_gcd.mod<0>"(i64 %"x##0", i64 %"y##0") - %2 = musttail call fastcc i64 @"proc_gcd.gcd#cont#1<0>"(i64 %"y##0", i64 %1) - ret i64 %2 -if.else: - ret i64 %"x##0" +define external fastcc i64 @"proc_gcd.gcd#cont#1<0>"(i64 %"x##0", i64 %"y##0") { + %"tmp#0##0" = icmp ne i64 %"y##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#6##0" = tail call fastcc i64 @"proc_gcd.mod<0>"(i64 %"x##0", i64 %"y##0") + %"tmp#7##0" = tail call fastcc i64 @"proc_gcd.gcd#cont#1<0>"(i64 %"y##0", i64 %"tmp#6##0") + ret i64 %"tmp#7##0" +if.else.0: + ret i64 %"x##0" } - -define external fastcc i64 @"proc_gcd.gcd#cont#2<0>"(i64 %"x##0", i64 %"y##0") alwaysinline { -entry: - %0 = tail call fastcc i64 @"proc_gcd.mod<0>"(i64 %"x##0", i64 %"y##0") - %1 = musttail call fastcc i64 @"proc_gcd.gcd#cont#1<0>"(i64 %"y##0", i64 %0) - ret i64 %1 +define external fastcc i64 @"proc_gcd.gcd#cont#2<0>"(i64 %"x##0", i64 %"y##0") { + %"y##1" = tail call fastcc i64 @"proc_gcd.mod<0>"(i64 %"x##0", i64 %"y##0") + %"tmp#0##0" = tail call fastcc i64 @"proc_gcd.gcd#cont#1<0>"(i64 %"y##0", i64 %"y##1") + ret i64 %"tmp#0##0" } - -define external fastcc i64 @"proc_gcd.mod<0>"(i64 %"x##0", i64 %"y##0") { -entry: - tail call ccc void @putchar(i8 120) - tail call ccc void @print_int(i64 %"x##0") - tail call ccc void @putchar(i8 32) - tail call ccc void @putchar(i8 121) - tail call ccc void @print_int(i64 %"y##0") - tail call ccc void @putchar(i8 10) - %0 = urem i64 %"x##0", %"y##0" - ret i64 %0 +define external fastcc i64 @"proc_gcd.mod<0>"(i64 %"x##0", i64 %"y##0") { + call ccc void @putchar(i8 120) + call ccc void @print_int(i64 %"x##0") + call ccc void @putchar(i8 32) + call ccc void @putchar(i8 121) + call ccc void @print_int(i64 %"y##0") + call ccc void @putchar(i8 10) + %"tmp#17##0" = urem i64 %"x##0", %"y##0" + ret i64 %"tmp#17##0" } diff --git a/test-cases/final-dump/proc_hello.exp b/test-cases/final-dump/proc_hello.exp index bb0d754e7..52aaab108 100644 --- a/test-cases/final-dump/proc_hello.exp +++ b/test-cases/final-dump/proc_hello.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module proc_hello representation : (not a type) public submods : @@ -21,33 +24,21 @@ print2([x##0:wybe.int], [y##0:wybe.int])<{<>}; {<>}; {}> LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'proc_hello' +source_filename = "!ROOT!/final-dump/proc_hello.wybe" +target triple ???? - - - -@proc_hello.1 = constant {i64, i64} { i64 12, i64 ptrtoint ([?? x i8]* @proc_hello.0 to i64) } - - -@proc_hello.0 = constant [?? x i8] c"hello, world\00" - - -declare external ccc void @putchar(i8) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c"hello, world\00", align 8 +@"string#1" = private unnamed_addr constant {i64, i64} { i64 12, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -define external fastcc void @"proc_hello.print2<0>"() alwaysinline { -entry: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @proc_hello.1, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"proc_hello.print2<0>"() { + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#1" to i64 )) + call ccc void @putchar(i8 10) + ret void } diff --git a/test-cases/final-dump/proc_print2.exp b/test-cases/final-dump/proc_print2.exp index 64cf3ebbe..a86ec7a07 100644 --- a/test-cases/final-dump/proc_print2.exp +++ b/test-cases/final-dump/proc_print2.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module proc_print2 representation : (not a type) public submods : @@ -21,24 +24,18 @@ print2(x##0:wybe.int, y##0:wybe.int)<{<>}; {<>}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'proc_print2' +source_filename = "!ROOT!/final-dump/proc_print2.wybe" +target triple ???? - - - -declare external ccc void @print_int(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) +declare external ccc void @print_int(i64) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -define external fastcc void @"proc_print2.print2<0>"(i64 %"x##0", i64 %"y##0") alwaysinline { -entry: - tail call ccc void @print_int(i64 %"x##0") - tail call ccc void @print_int(i64 %"y##0") - ret void +define external fastcc void @"proc_print2.print2<0>"(i64 %"x##0", i64 %"y##0") { + call ccc void @print_int(i64 %"x##0") + call ccc void @print_int(i64 %"y##0") + ret void } diff --git a/test-cases/final-dump/proc_yorn.exp b/test-cases/final-dump/proc_yorn.exp index 517669573..48f516232 100644 --- a/test-cases/final-dump/proc_yorn.exp +++ b/test-cases/final-dump/proc_yorn.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module proc_yorn representation : (not a type) public submods : @@ -85,104 +88,72 @@ yorn#cont#1(prompt##0:wybe.string, ?result##1:wybe.bool)<{<>}; {<"(i64) - - -declare external ccc i8 @read_char() - - -declare external fastcc void @"wybe.bool.print<0>"(i1) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"proc_yorn.<0>"() { -entry: - %0 = tail call fastcc i1 @"proc_yorn.yorn#cont#1<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @proc_yorn.1, i32 0, i32 0) to i64)) - tail call fastcc void @"wybe.bool.print<0>"(i1 %0) - tail call ccc void @putchar(i8 10) - ret void +source_filename = "!ROOT!/final-dump/proc_yorn.wybe" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c" (y/n) \00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c"Please answer 'yes' or 'no'.\00", align 8 +@"cstring#2" = private unnamed_addr constant [ ?? x i8 ] c"Well, yes or no?\00", align 8 +@"string#3" = private unnamed_addr constant {i64, i64} { i64 7, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +@"string#4" = private unnamed_addr constant {i64, i64} { i64 28, i64 ptrtoint( ptr @"cstring#1" to i64 ) }, align 8 +@"string#5" = private unnamed_addr constant {i64, i64} { i64 16, i64 ptrtoint( ptr @"cstring#2" to i64 ) }, align 8 + +declare external fastcc void @"wybe.bool.print<0>"(i1) +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @putchar(i8) +declare external ccc i8 @read_char() +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"proc_yorn.<0>"() { + %"r##0" = tail call fastcc i1 @"proc_yorn.yorn#cont#1<0>"(i64 ptrtoint( ptr @"string#5" to i64 )) + tail call fastcc void @"wybe.bool.print<0>"(i1 %"r##0") + call ccc void @putchar(i8 10) + ret void } - -define external fastcc i1 @"proc_yorn.is_yes<0>"(i8 %"ch##0") alwaysinline { -entry: - %0 = icmp ne i8 %"ch##0", 121 - %1 = icmp ne i8 %"ch##0", 89 - %2 = and i1 %0, %1 - %3 = xor i1 %2, 1 - ret i1 %3 +define external fastcc i1 @"proc_yorn.is_yes<0>"(i8 %"ch##0") { + %"tmp#2##0" = icmp ne i8 %"ch##0", 121 + %"tmp#3##0" = icmp ne i8 %"ch##0", 89 + %"tmp#1##0" = and i1 %"tmp#2##0", %"tmp#3##0" + %"tmp#11##0" = xor i1 %"tmp#1##0", 1 + ret i1 %"tmp#11##0" } - -define external fastcc i1 @"proc_yorn.is_yes_or_no<0>"(i8 %"ch##0") { -entry: - %0 = icmp ne i8 %"ch##0", 121 - %1 = icmp ne i8 %"ch##0", 89 - %2 = and i1 %0, %1 - %3 = xor i1 %2, 1 - %4 = icmp eq i8 %"ch##0", 110 - %5 = icmp eq i8 %"ch##0", 78 - %6 = or i1 %4, %5 - %7 = or i1 %3, %6 - ret i1 %7 +define external fastcc i1 @"proc_yorn.is_yes_or_no<0>"(i8 %"ch##0") { + %"tmp#6##0" = icmp ne i8 %"ch##0", 121 + %"tmp#7##0" = icmp ne i8 %"ch##0", 89 + %"tmp#8##0" = and i1 %"tmp#6##0", %"tmp#7##0" + %"tmp#1##0" = xor i1 %"tmp#8##0", 1 + %"tmp#3##0" = icmp eq i8 %"ch##0", 110 + %"tmp#4##0" = icmp eq i8 %"ch##0", 78 + %"tmp#2##0" = or i1 %"tmp#3##0", %"tmp#4##0" + %"tmp#17##0" = or i1 %"tmp#1##0", %"tmp#2##0" + ret i1 %"tmp#17##0" } - -define external fastcc i1 @"proc_yorn.yorn<0>"(i64 %"prompt##0") alwaysinline { -entry: - %0 = musttail call fastcc i1 @"proc_yorn.yorn#cont#1<0>"(i64 %"prompt##0") - ret i1 %0 +define external fastcc i1 @"proc_yorn.yorn<0>"(i64 %"prompt##0") { + %"tmp#2##0" = tail call fastcc i1 @"proc_yorn.yorn#cont#1<0>"(i64 %"prompt##0") + ret i1 %"tmp#2##0" } - -define external fastcc i1 @"proc_yorn.yorn#cont#1<0>"(i64 %"prompt##0") { -entry: - tail call fastcc void @"wybe.string.print<0>"(i64 %"prompt##0") - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @proc_yorn.3, i32 0, i32 0) to i64)) - %0 = tail call ccc i8 @read_char() - %1 = icmp ne i8 %0, 121 - %2 = icmp ne i8 %0, 89 - %3 = and i1 %1, %2 - %4 = xor i1 %3, 1 - %5 = tail call fastcc i1 @"proc_yorn.is_yes_or_no<0>"(i8 %0) - br i1 %5, label %if.then, label %if.else -if.then: - ret i1 %4 -if.else: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @proc_yorn.5, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - %6 = musttail call fastcc i1 @"proc_yorn.yorn#cont#1<0>"(i64 %"prompt##0") - ret i1 %6 +define external fastcc i1 @"proc_yorn.yorn#cont#1<0>"(i64 %"prompt##0") { + tail call fastcc void @"wybe.string.print<0>"(i64 %"prompt##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#3" to i64 )) + %"response##0" = call ccc i8 @read_char() + %"tmp#5##0" = icmp ne i8 %"response##0", 121 + %"tmp#6##0" = icmp ne i8 %"response##0", 89 + %"tmp#7##0" = and i1 %"tmp#5##0", %"tmp#6##0" + %"tmp#0##0" = xor i1 %"tmp#7##0", 1 + %"tmp#1##0" = tail call fastcc i1 @"proc_yorn.is_yes_or_no<0>"(i8 %"response##0") + br i1 %"tmp#1##0", label %if.then.0, label %if.else.0 +if.then.0: + ret i1 %"tmp#0##0" +if.else.0: + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#4" to i64 )) + call ccc void @putchar(i8 10) + %"tmp#11##0" = tail call fastcc i1 @"proc_yorn.yorn#cont#1<0>"(i64 %"prompt##0") + ret i1 %"tmp#11##0" } diff --git a/test-cases/final-dump/proc_yorn2.exp b/test-cases/final-dump/proc_yorn2.exp index 912d69338..f1f07097b 100644 --- a/test-cases/final-dump/proc_yorn2.exp +++ b/test-cases/final-dump/proc_yorn2.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module proc_yorn2 representation : (not a type) public submods : @@ -44,60 +47,40 @@ yorn#cont#1(prompt##0:wybe.string, ?result##1:wybe.bool)<{<>}; {<"(i64) +declare external ccc void @putchar(i8) +declare external ccc i8 @read_char() +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc i8 @read_char() - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i1 @"proc_yorn2.yorn<0>"(i64 %"prompt##0") alwaysinline { -entry: - %0 = musttail call fastcc i1 @"proc_yorn2.yorn#cont#1<0>"(i64 %"prompt##0") - ret i1 %0 +define external fastcc i1 @"proc_yorn2.yorn<0>"(i64 %"prompt##0") { + %"tmp#3##0" = tail call fastcc i1 @"proc_yorn2.yorn#cont#1<0>"(i64 %"prompt##0") + ret i1 %"tmp#3##0" } - -define external fastcc i1 @"proc_yorn2.yorn#cont#1<0>"(i64 %"prompt##0") { -entry: - tail call fastcc void @"wybe.string.print<0>"(i64 %"prompt##0") - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @proc_yorn2.1, i32 0, i32 0) to i64)) - %0 = tail call ccc i8 @read_char() - %1 = icmp eq i8 %0, 89 - %2 = icmp eq i8 %0, 78 - %3 = or i1 %1, %2 - br i1 %3, label %if.then, label %if.else -if.then: - ret i1 %1 -if.else: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @proc_yorn2.3, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - %4 = musttail call fastcc i1 @"proc_yorn2.yorn#cont#1<0>"(i64 %"prompt##0") - ret i1 %4 +define external fastcc i1 @"proc_yorn2.yorn#cont#1<0>"(i64 %"prompt##0") { + tail call fastcc void @"wybe.string.print<0>"(i64 %"prompt##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#2" to i64 )) + %"response##0" = call ccc i8 @read_char() + %"tmp#0##0" = icmp eq i8 %"response##0", 89 + %"tmp#1##0" = icmp eq i8 %"response##0", 78 + %"tmp#2##0" = or i1 %"tmp#0##0", %"tmp#1##0" + br i1 %"tmp#2##0", label %if.then.0, label %if.else.0 +if.then.0: + ret i1 %"tmp#0##0" +if.else.0: + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#3" to i64 )) + call ccc void @putchar(i8 10) + %"tmp#14##0" = tail call fastcc i1 @"proc_yorn2.yorn#cont#1<0>"(i64 %"prompt##0") + ret i1 %"tmp#14##0" } diff --git a/test-cases/final-dump/pub_importer.exp b/test-cases/final-dump/pub_importer.exp index 5c662b72c..00f0829f9 100644 --- a/test-cases/final-dump/pub_importer.exp +++ b/test-cases/final-dump/pub_importer.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module exporter representation : (not a type) public submods : @@ -27,36 +30,27 @@ three(?n##0:wybe.int)<{<>}; {}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'exporter' - - - - -@"resource#exporter.res" = global i64 undef - - -declare external ccc i64 @ipow(i64, i64) +source_filename = "!ROOT!/final-dump/exporter.wybe" +target triple ???? -declare external ccc i8* @wybe_malloc(i32) +declare external ccc i64 @ipow(i64, i64) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) +@"resource#exporter.res" = global i64 undef - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i64 @"exporter.fn<0>"(i64 %"i##0") alwaysinline { -entry: - %0 = tail call ccc i64 @ipow(i64 2, i64 %"i##0") - ret i64 %0 +define external fastcc i64 @"exporter.fn<0>"(i64 %"i##0") { + %"tmp#3##0" = call ccc i64 @ipow(i64 2, i64 %"i##0") + ret i64 %"tmp#3##0" } - -define external fastcc i64 @"exporter.three<0>"() alwaysinline { -entry: - %0 = load i64, i64* @"resource#exporter.res" - ret i64 %0 +define external fastcc i64 @"exporter.three<0>"() { + %"tmp#1##0" = load i64, ptr @"resource#exporter.res" + ret i64 %"tmp#1##0" } + -------------------------------------------------- Module pub_importer representation : (not a type) @@ -72,13 +66,11 @@ entry: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'pub_importer' - - - - -declare external ccc i8* @wybe_malloc(i32) +source_filename = "!ROOT!/final-dump/pub_importer.wybe" +target triple ???? -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) diff --git a/test-cases/final-dump/purity_warning.exp b/test-cases/final-dump/purity_warning.exp index f33eb38be..04828a4a1 100644 --- a/test-cases/final-dump/purity_warning.exp +++ b/test-cases/final-dump/purity_warning.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module purity_warning representation : (not a type) public submods : @@ -17,21 +20,17 @@ module top-level code > public {inline,semipure} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'purity_warning' +source_filename = "!ROOT!/final-dump/purity_warning.wybe" +target triple ???? - - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -define external fastcc void @"purity_warning.<0>"() alwaysinline { -entry: - ret void +define external fastcc void @"purity_warning.<0>"() { + ret void } final-dump/purity_warning.wybe:1:2: Calling proc wybe.list.length<0> with unneeded ! marker  diff --git a/test-cases/final-dump/representation.exp b/test-cases/final-dump/representation.exp index bdf9ce19e..daa511449 100644 --- a/test-cases/final-dump/representation.exp +++ b/test-cases/final-dump/representation.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module representation representation : 16 bit unsigned public submods : @@ -18,20 +21,16 @@ proc + > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'representation' +source_filename = "!ROOT!/final-dump/representation.wybe" +target triple ???? - - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -define external fastcc i16 @"representation.+<0>"(i16 %"x##0", i16 %"y##0") alwaysinline { -entry: - %0 = add i16 %"x##0", %"y##0" - ret i16 %0 +define external fastcc i16 @"representation.+<0>"(i16 %"x##0", i16 %"y##0") { + %"tmp#1##0" = add i16 %"x##0", %"y##0" + ret i16 %"tmp#1##0" } diff --git a/test-cases/final-dump/res_decl.exp b/test-cases/final-dump/res_decl.exp index 16ae017ff..7588a27b1 100644 --- a/test-cases/final-dump/res_decl.exp +++ b/test-cases/final-dump/res_decl.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module res_decl representation : (not a type) public submods : @@ -12,16 +15,12 @@ AFTER EVERYTHING: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'res_decl' - - - - -@"resource#res_decl.count" = global i64 undef - - -declare external ccc i8* @wybe_malloc(i32) +source_filename = "!ROOT!/final-dump/res_decl.wybe" +target triple ???? -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) +@"resource#res_decl.count" = global i64 undef diff --git a/test-cases/final-dump/resource_conflict_a.exp b/test-cases/final-dump/resource_conflict_a.exp index 5dc8f2824..318b23366 100644 --- a/test-cases/final-dump/resource_conflict_a.exp +++ b/test-cases/final-dump/resource_conflict_a.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module resource_conflict_a representation : (not a type) public submods : @@ -12,16 +15,12 @@ AFTER EVERYTHING: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'resource_conflict_a' - - - - -@"resource#resource_conflict_a.res" = global i64 undef - - -declare external ccc i8* @wybe_malloc(i32) +source_filename = "!ROOT!/final-dump/resource_conflict_a.wybe" +target triple ???? -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) +@"resource#resource_conflict_a.res" = global i64 undef diff --git a/test-cases/final-dump/resource_conflict_b.exp b/test-cases/final-dump/resource_conflict_b.exp index acc945871..aad4bb9a2 100644 --- a/test-cases/final-dump/resource_conflict_b.exp +++ b/test-cases/final-dump/resource_conflict_b.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module resource_conflict_b representation : (not a type) public submods : @@ -12,16 +15,12 @@ AFTER EVERYTHING: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'resource_conflict_b' - - - - -@"resource#resource_conflict_b.res" = global i8 undef - - -declare external ccc i8* @wybe_malloc(i32) +source_filename = "!ROOT!/final-dump/resource_conflict_b.wybe" +target triple ???? -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) +@"resource#resource_conflict_b.res" = global i8 undef diff --git a/test-cases/final-dump/resource_rollback.exp b/test-cases/final-dump/resource_rollback.exp index 687e42d7e..9eb443919 100644 --- a/test-cases/final-dump/resource_rollback.exp +++ b/test-cases/final-dump/resource_rollback.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module resource_rollback representation : (not a type) public submods : @@ -59,72 +62,52 @@ foo(?s##0:wybe.c_string, ?#success##0:wybe.bool, %call_source_location##0:wybe.c LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'resource_rollback' - - - - -@"resource#resource_rollback.res" = global i64 undef - - -@"resource#resource_rollback.ser" = global i64 undef - - -@resource_rollback.0 = constant [?? x i8] c"resource_rollback:15:7\00" - - -declare external ccc void @putchar(i8) - - -declare external ccc void @print_int(i64) - - -declare external ccc void @print_string(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"resource_rollback.<0>"() { -entry: - %0 = load i64, i64* @"resource#resource_rollback.res" - tail call ccc void @print_int(i64 %0) - tail call ccc void @putchar(i8 10) - %1 = tail call fastcc {i64, i1} @"resource_rollback.foo<0>"(i64 ptrtoint (i8* getelementptr inbounds ([?? x i8], [?? x i8]* @resource_rollback.0, i32 0, i32 0) to i64)) - %2 = extractvalue {i64, i1} %1, 0 - %3 = extractvalue {i64, i1} %1, 1 - br i1 %3, label %if.then, label %if.else -if.then: - tail call ccc void @print_string(i64 %2) - tail call ccc void @putchar(i8 10) - musttail call fastcc void @"resource_rollback.#cont#1<0>"() - ret void -if.else: - store i64 %0, i64* @"resource#resource_rollback.res" - musttail call fastcc void @"resource_rollback.#cont#1<0>"() - ret void +source_filename = "!ROOT!/final-dump/resource_rollback.wybe" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c"resource_rollback:15:7\00", align 8 + +declare external ccc void @print_int(i64) +declare external ccc void @print_string(i64) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) +@"resource#resource_rollback.res" = global i64 undef +@"resource#resource_rollback.ser" = global i64 undef + +define external fastcc void @"resource_rollback.<0>"() { + %"res##0" = load i64, ptr @"resource#resource_rollback.res" + call ccc void @print_int(i64 %"res##0") + call ccc void @putchar(i8 10) + %"tmp#13##0" = tail call fastcc {i64, i1} @"resource_rollback.foo<0>"(i64 ptrtoint( ptr @"cstring#0" to i64 )) + %"s##0" = extractvalue {i64, i1}%"tmp#13##0", 0 + %"tmp#4##0" = extractvalue {i64, i1}%"tmp#13##0", 1 + br i1 %"tmp#4##0", label %if.then.0, label %if.else.0 +if.then.0: + call ccc void @print_string(i64 %"s##0") + call ccc void @putchar(i8 10) + tail call fastcc void @"resource_rollback.#cont#1<0>"() + ret void +if.else.0: + store i64 %"res##0", ptr @"resource#resource_rollback.res" + tail call fastcc void @"resource_rollback.#cont#1<0>"() + ret void } - -define external fastcc void @"resource_rollback.#cont#1<0>"() { -entry: - %0 = load i64, i64* @"resource#resource_rollback.res" - tail call ccc void @print_int(i64 %0) - tail call ccc void @putchar(i8 10) - %1 = load i64, i64* @"resource#resource_rollback.ser" - tail call ccc void @print_int(i64 %1) - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"resource_rollback.#cont#1<0>"() { + %"res##0" = load i64, ptr @"resource#resource_rollback.res" + call ccc void @print_int(i64 %"res##0") + call ccc void @putchar(i8 10) + %"ser##0" = load i64, ptr @"resource#resource_rollback.ser" + call ccc void @print_int(i64 %"ser##0") + call ccc void @putchar(i8 10) + ret void } - -define external fastcc {i64, i1} @"resource_rollback.foo<0>"(i64 %"call_source_location##0") noinline { -entry: - %0 = insertvalue {i64, i1} undef, i64 %"call_source_location##0", 0 - %1 = insertvalue {i64, i1} %0, i1 0, 1 - ret {i64, i1} %1 +define external fastcc {i64, i1} @"resource_rollback.foo<0>"(i64 %"call_source_location##0") { + %"tmp#7##0" = insertvalue {i64, i1} undef, i64 %"call_source_location##0", 0 + %"tmp#8##0" = insertvalue {i64, i1} %"tmp#7##0", i1 0, 1 + ret {i64, i1} %"tmp#8##0" } diff --git a/test-cases/final-dump/resource_tmp_vars.exp b/test-cases/final-dump/resource_tmp_vars.exp index 1fb501318..95dba5583 100644 --- a/test-cases/final-dump/resource_tmp_vars.exp +++ b/test-cases/final-dump/resource_tmp_vars.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module resource_tmp_vars representation : (not a type) public submods : @@ -38,44 +41,32 @@ proc #cont#1 > {inline,semipure} (1 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'resource_tmp_vars' - - - - -@"resource#resource_tmp_vars.counter" = global i64 undef - - -declare external ccc void @putchar(i8) +source_filename = "!ROOT!/final-dump/resource_tmp_vars.wybe" +target triple ???? -declare external ccc void @print_int(i64) +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) +@"resource#resource_tmp_vars.counter" = global i64 undef - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"resource_tmp_vars.<0>"() { -entry: - %0 = load i64, i64* @"resource#resource_tmp_vars.counter" - tail call ccc void @print_int(i64 1) - tail call ccc void @putchar(i8 10) - tail call ccc void @print_int(i64 %0) - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"resource_tmp_vars.<0>"() { + %"tmp#1##0" = load i64, ptr @"resource#resource_tmp_vars.counter" + call ccc void @print_int(i64 1) + call ccc void @putchar(i8 10) + call ccc void @print_int(i64 %"tmp#1##0") + call ccc void @putchar(i8 10) + ret void } - -define external fastcc void @"resource_tmp_vars.#cont#1<0>"(i64 %"tmp#1##0") alwaysinline { -entry: - tail call ccc void @print_int(i64 1) - tail call ccc void @putchar(i8 10) - store i64 %"tmp#1##0", i64* @"resource#resource_tmp_vars.counter" - tail call ccc void @print_int(i64 %"tmp#1##0") - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"resource_tmp_vars.#cont#1<0>"(i64 %"tmp#1##0") { + call ccc void @print_int(i64 1) + call ccc void @putchar(i8 10) + store i64 %"tmp#1##0", ptr @"resource#resource_tmp_vars.counter" + call ccc void @print_int(i64 %"tmp#1##0") + call ccc void @putchar(i8 10) + ret void } diff --git a/test-cases/final-dump/save_restore_cond.exp b/test-cases/final-dump/save_restore_cond.exp index 25d684df1..f9ea84bb9 100644 --- a/test-cases/final-dump/save_restore_cond.exp +++ b/test-cases/final-dump/save_restore_cond.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module save_restore_cond representation : (not a type) public submods : @@ -31,30 +34,24 @@ suc(?#success##0:wybe.bool)<{}; {}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'save_restore_cond' +source_filename = "!ROOT!/final-dump/save_restore_cond.wybe" +target triple ???? - - - -declare external ccc i8* @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"save_restore_cond.<0>"() { -entry: - %0 = tail call fastcc i1 @"save_restore_cond.suc<0>"() - br i1 %0, label %if.then, label %if.else -if.then: - ret void -if.else: - ret void +define external fastcc void @"save_restore_cond.<0>"() { + %"tmp#0##0" = tail call fastcc i1 @"save_restore_cond.suc<0>"() + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + ret void +if.else.0: + ret void } - -define external fastcc i1 @"save_restore_cond.suc<0>"() noinline { -entry: - ret i1 1 +define external fastcc i1 @"save_restore_cond.suc<0>"() { + ret i1 1 } diff --git a/test-cases/final-dump/save_restore_disj.exp b/test-cases/final-dump/save_restore_disj.exp index 6a07a8aad..5b791f46f 100644 --- a/test-cases/final-dump/save_restore_disj.exp +++ b/test-cases/final-dump/save_restore_disj.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module save_restore_disj representation : (not a type) public submods : @@ -17,19 +20,15 @@ module top-level code > public {inline,semipure} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'save_restore_disj' +source_filename = "!ROOT!/final-dump/save_restore_disj.wybe" +target triple ???? - - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -define external fastcc void @"save_restore_disj.<0>"() alwaysinline { -entry: - ret void +define external fastcc void @"save_restore_disj.<0>"() { + ret void } diff --git a/test-cases/final-dump/simple_loop.exp b/test-cases/final-dump/simple_loop.exp index 5008fe0f6..a556ea0b4 100644 --- a/test-cases/final-dump/simple_loop.exp +++ b/test-cases/final-dump/simple_loop.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module simple_loop representation : (not a type) public submods : @@ -37,40 +40,30 @@ proc #cont#1 > {semipure} (2 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'simple_loop' +source_filename = "!ROOT!/final-dump/simple_loop.wybe" +target triple ???? - - - -declare external ccc void @putchar(i8) - - -declare external ccc i8 @read_char() +declare external ccc void @putchar(i8) +declare external ccc i8 @read_char() +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"simple_loop.<0>"() alwaysinline { -entry: - musttail call fastcc void @"simple_loop.#cont#1<0>"() - ret void +define external fastcc void @"simple_loop.<0>"() { + tail call fastcc void @"simple_loop.#cont#1<0>"() + ret void } - -define external fastcc void @"simple_loop.#cont#1<0>"() { -entry: - %0 = tail call ccc i8 @read_char() - %1 = icmp ne i8 %0, 97 - br i1 %1, label %if.then, label %if.else -if.then: - tail call ccc void @putchar(i8 %0) - musttail call fastcc void @"simple_loop.#cont#1<0>"() - ret void -if.else: - ret void +define external fastcc void @"simple_loop.#cont#1<0>"() { + %"c##0" = call ccc i8 @read_char() + %"tmp#0##0" = icmp ne i8 %"c##0", 97 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + call ccc void @putchar(i8 %"c##0") + tail call fastcc void @"simple_loop.#cont#1<0>"() + ret void +if.else.0: + ret void } diff --git a/test-cases/final-dump/sister_module.exp b/test-cases/final-dump/sister_module.exp index 82d6710fb..cb8e6d961 100644 --- a/test-cases/final-dump/sister_module.exp +++ b/test-cases/final-dump/sister_module.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module sister_module representation : (not a type) public submods : @@ -29,30 +32,25 @@ buzz(i##0:wybe.int, ?j##0:wybe.int)<{}; {}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'sister_module' +source_filename = "!ROOT!/final-dump/sister_module.wybe" +target triple ???? - - - -declare external ccc i8* @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i64 @"sister_module.baz<0>"(i64 %"i##0") alwaysinline { -entry: - %0 = musttail call fastcc i64 @"sister_module.m1.foo<0>"(i64 %"i##0") - ret i64 %0 +define external fastcc i64 @"sister_module.baz<0>"(i64 %"i##0") { + %"tmp#0##0" = tail call fastcc i64 @"sister_module.m1.foo<0>"(i64 %"i##0") + ret i64 %"tmp#0##0" } - -define external fastcc i64 @"sister_module.buzz<0>"(i64 %"i##0") alwaysinline { -entry: - %0 = musttail call fastcc i64 @"sister_module.m2.bar<0>"(i64 %"i##0") - ret i64 %0 +define external fastcc i64 @"sister_module.buzz<0>"(i64 %"i##0") { + %"tmp#0##0" = tail call fastcc i64 @"sister_module.m2.bar<0>"(i64 %"i##0") + ret i64 %"tmp#0##0" } + -------------------------------------------------- Module sister_module.m1 representation : (not a type) @@ -73,23 +71,20 @@ foo(i##0:wybe.int, ?j##0:wybe.int)<{}; {}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'sister_module.m1' +source_filename = "!ROOT!/final-dump/sister_module.wybe" +target triple ???? - +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i64 @"sister_module.m1.foo<0>"(i64 %"i##0") alwaysinline { -entry: - %0 = add i64 %"i##0", 1 - ret i64 %0 +define external fastcc i64 @"sister_module.m1.foo<0>"(i64 %"i##0") { + %"tmp#3##0" = add i64 %"i##0", 1 + ret i64 %"tmp#3##0" } + -------------------------------------------------- Module sister_module.m2 representation : (not a type) @@ -111,21 +106,17 @@ bar(i##0:wybe.int, ?j##0:wybe.int)<{}; {}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'sister_module.m2' +source_filename = "!ROOT!/final-dump/sister_module.wybe" +target triple ???? - - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -define external fastcc i64 @"sister_module.m2.bar<0>"(i64 %"i##0") alwaysinline { -entry: - %0 = add i64 %"i##0", 1 - %1 = musttail call fastcc i64 @"sister_module.m1.foo<0>"(i64 %0) - ret i64 %1 +define external fastcc i64 @"sister_module.m2.bar<0>"(i64 %"i##0") { + %"k##0" = add i64 %"i##0", 1 + %"tmp#2##0" = tail call fastcc i64 @"sister_module.m1.foo<0>"(i64 %"k##0") + ret i64 %"tmp#2##0" } diff --git a/test-cases/final-dump/specials.exp b/test-cases/final-dump/specials.exp index 42f6e7709..162beb646 100644 --- a/test-cases/final-dump/specials.exp +++ b/test-cases/final-dump/specials.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module specials representation : (not a type) public submods : @@ -81,70 +84,50 @@ show_location(%call_source_location##0:wybe.c_string)<{<>}; {<"(i64 %"call_source_column_number##0") alwaysinline { -entry: - tail call ccc void @print_int(i64 %"call_source_column_number##0") - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"specials.show_column<0>"(i64 %"call_source_column_number##0") { + call ccc void @print_int(i64 %"call_source_column_number##0") + call ccc void @putchar(i8 10) + ret void } - -define external fastcc void @"specials.show_file<0>"(i64 %"call_source_file_name##0") alwaysinline { -entry: - tail call ccc void @print_string(i64 %"call_source_file_name##0") - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"specials.show_file<0>"(i64 %"call_source_file_name##0") { + call ccc void @print_string(i64 %"call_source_file_name##0") + call ccc void @putchar(i8 10) + ret void } - -define external fastcc void @"specials.show_full_file<0>"(i64 %"call_source_file_full_name##0") alwaysinline { -entry: - tail call ccc void @print_string(i64 %"call_source_file_full_name##0") - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"specials.show_full_file<0>"(i64 %"call_source_file_full_name##0") { + call ccc void @print_string(i64 %"call_source_file_full_name##0") + call ccc void @putchar(i8 10) + ret void } - -define external fastcc void @"specials.show_full_location<0>"(i64 %"call_source_full_location##0") alwaysinline { -entry: - tail call ccc void @print_string(i64 %"call_source_full_location##0") - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"specials.show_full_location<0>"(i64 %"call_source_full_location##0") { + call ccc void @print_string(i64 %"call_source_full_location##0") + call ccc void @putchar(i8 10) + ret void } - -define external fastcc void @"specials.show_line<0>"(i64 %"call_source_line_number##0") alwaysinline { -entry: - tail call ccc void @print_int(i64 %"call_source_line_number##0") - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"specials.show_line<0>"(i64 %"call_source_line_number##0") { + call ccc void @print_int(i64 %"call_source_line_number##0") + call ccc void @putchar(i8 10) + ret void } - -define external fastcc void @"specials.show_location<0>"(i64 %"call_source_location##0") alwaysinline { -entry: - tail call ccc void @print_string(i64 %"call_source_location##0") - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"specials.show_location<0>"(i64 %"call_source_location##0") { + call ccc void @print_string(i64 %"call_source_location##0") + call ccc void @putchar(i8 10) + ret void } diff --git a/test-cases/final-dump/specials_one_module.exp b/test-cases/final-dump/specials_one_module.exp index f5a7fd59a..ef6f6a991 100644 --- a/test-cases/final-dump/specials_one_module.exp +++ b/test-cases/final-dump/specials_one_module.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module specials_one_module representation : (not a type) public submods : @@ -86,90 +89,60 @@ show_location(%call_source_location##0:wybe.c_string)<{<>}; {<"(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"specials_one_module.<0>"() { -entry: - tail call ccc void @print_string(i64 ptrtoint (i8* getelementptr inbounds ([?? x i8], [?? x i8]* @specials_one_module.0, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - tail call ccc void @print_int(i64 27) - tail call ccc void @putchar(i8 10) - tail call ccc void @print_int(i64 2) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"specials_one_module.indirect_call_location<0>"(i64 ptrtoint (i8* getelementptr inbounds ([?? x i8], [?? x i8]* @specials_one_module.1, i32 0, i32 0) to i64)) - ret void +source_filename = "!ROOT!/final-dump/specials_one_module.wybe" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c" (should be line 28)\00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c"specials_one_module\00", align 8 +@"cstring#2" = private unnamed_addr constant [ ?? x i8 ] c"specials_one_module:29:2\00", align 8 +@"string#3" = private unnamed_addr constant {i64, i64} { i64 20, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 + +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @print_int(i64) +declare external ccc void @print_string(i64) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"specials_one_module.<0>"() { + call ccc void @print_string(i64 ptrtoint( ptr @"cstring#1" to i64 )) + call ccc void @putchar(i8 10) + call ccc void @print_int(i64 27) + call ccc void @putchar(i8 10) + call ccc void @print_int(i64 2) + call ccc void @putchar(i8 10) + tail call fastcc void @"specials_one_module.indirect_call_location<0>"(i64 ptrtoint( ptr @"cstring#2" to i64 )) + ret void } - -define external fastcc void @"specials_one_module.indirect_call_location<0>"(i64 %"call_source_location##0") { -entry: - tail call ccc void @print_string(i64 %"call_source_location##0") - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @specials_one_module.3, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"specials_one_module.indirect_call_location<0>"(i64 %"call_source_location##0") { + call ccc void @print_string(i64 %"call_source_location##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#3" to i64 )) + call ccc void @putchar(i8 10) + ret void } - -define external fastcc void @"specials_one_module.show_column<0>"(i64 %"call_source_column_number##0") alwaysinline { -entry: - tail call ccc void @print_int(i64 %"call_source_column_number##0") - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"specials_one_module.show_column<0>"(i64 %"call_source_column_number##0") { + call ccc void @print_int(i64 %"call_source_column_number##0") + call ccc void @putchar(i8 10) + ret void } - -define external fastcc void @"specials_one_module.show_file<0>"(i64 %"call_source_file_name##0") alwaysinline { -entry: - tail call ccc void @print_string(i64 %"call_source_file_name##0") - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"specials_one_module.show_file<0>"(i64 %"call_source_file_name##0") { + call ccc void @print_string(i64 %"call_source_file_name##0") + call ccc void @putchar(i8 10) + ret void } - -define external fastcc void @"specials_one_module.show_line<0>"(i64 %"call_source_line_number##0") alwaysinline { -entry: - tail call ccc void @print_int(i64 %"call_source_line_number##0") - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"specials_one_module.show_line<0>"(i64 %"call_source_line_number##0") { + call ccc void @print_int(i64 %"call_source_line_number##0") + call ccc void @putchar(i8 10) + ret void } - -define external fastcc void @"specials_one_module.show_location<0>"(i64 %"call_source_location##0") alwaysinline { -entry: - musttail call fastcc void @"specials_one_module.indirect_call_location<0>"(i64 %"call_source_location##0") - ret void +define external fastcc void @"specials_one_module.show_location<0>"(i64 %"call_source_location##0") { + tail call fastcc void @"specials_one_module.indirect_call_location<0>"(i64 %"call_source_location##0") + ret void } diff --git a/test-cases/final-dump/specials_use.exp b/test-cases/final-dump/specials_use.exp index 868ea075d..796715aaa 100644 --- a/test-cases/final-dump/specials_use.exp +++ b/test-cases/final-dump/specials_use.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module specials representation : (not a type) public submods : @@ -81,73 +84,54 @@ show_location(%call_source_location##0:wybe.c_string)<{<>}; {<"(i64 %"call_source_column_number##0") alwaysinline { -entry: - tail call ccc void @print_int(i64 %"call_source_column_number##0") - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"specials.show_column<0>"(i64 %"call_source_column_number##0") { + call ccc void @print_int(i64 %"call_source_column_number##0") + call ccc void @putchar(i8 10) + ret void } - -define external fastcc void @"specials.show_file<0>"(i64 %"call_source_file_name##0") alwaysinline { -entry: - tail call ccc void @print_string(i64 %"call_source_file_name##0") - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"specials.show_file<0>"(i64 %"call_source_file_name##0") { + call ccc void @print_string(i64 %"call_source_file_name##0") + call ccc void @putchar(i8 10) + ret void } - -define external fastcc void @"specials.show_full_file<0>"(i64 %"call_source_file_full_name##0") alwaysinline { -entry: - tail call ccc void @print_string(i64 %"call_source_file_full_name##0") - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"specials.show_full_file<0>"(i64 %"call_source_file_full_name##0") { + call ccc void @print_string(i64 %"call_source_file_full_name##0") + call ccc void @putchar(i8 10) + ret void } - -define external fastcc void @"specials.show_full_location<0>"(i64 %"call_source_full_location##0") alwaysinline { -entry: - tail call ccc void @print_string(i64 %"call_source_full_location##0") - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"specials.show_full_location<0>"(i64 %"call_source_full_location##0") { + call ccc void @print_string(i64 %"call_source_full_location##0") + call ccc void @putchar(i8 10) + ret void } - -define external fastcc void @"specials.show_line<0>"(i64 %"call_source_line_number##0") alwaysinline { -entry: - tail call ccc void @print_int(i64 %"call_source_line_number##0") - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"specials.show_line<0>"(i64 %"call_source_line_number##0") { + call ccc void @print_int(i64 %"call_source_line_number##0") + call ccc void @putchar(i8 10) + ret void } - -define external fastcc void @"specials.show_location<0>"(i64 %"call_source_location##0") alwaysinline { -entry: - tail call ccc void @print_string(i64 %"call_source_location##0") - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"specials.show_location<0>"(i64 %"call_source_location##0") { + call ccc void @print_string(i64 %"call_source_location##0") + call ccc void @putchar(i8 10) + ret void } + -------------------------------------------------- Module specials_use representation : (not a type) @@ -181,52 +165,34 @@ module top-level code > public {semipure} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'specials_use' - - - - -@specials_use.1 = constant [?? x i8] c"!ROOT!/final-dump/specials_use.wybe\00" - - -@specials_use.3 = constant [?? x i8] c"!ROOT!/final-dump/specials_use.wybe:8:2\00" - - -@specials_use.0 = constant [?? x i8] c"specials_use\00" - - -@specials_use.2 = constant [?? x i8] c"specials_use:7:2\00" - - -declare external ccc void @putchar(i8) - - -declare external ccc void @print_string(i64) - - -declare external ccc void @print_int(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"specials_use.<0>"() { -entry: - tail call ccc void @print_string(i64 ptrtoint (i8* getelementptr inbounds ([?? x i8], [?? x i8]* @specials_use.0, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - tail call ccc void @print_string(i64 ptrtoint (i8* getelementptr inbounds ([?? x i8], [?? x i8]* @specials_use.1, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - tail call ccc void @print_int(i64 5) - tail call ccc void @putchar(i8 10) - tail call ccc void @print_int(i64 2) - tail call ccc void @putchar(i8 10) - tail call ccc void @print_string(i64 ptrtoint (i8* getelementptr inbounds ([?? x i8], [?? x i8]* @specials_use.2, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - tail call ccc void @print_string(i64 ptrtoint (i8* getelementptr inbounds ([?? x i8], [?? x i8]* @specials_use.3, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - ret void +source_filename = "!ROOT!/final-dump/specials_use.wybe" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c"!ROOT!/final-dump/specials_use.wybe\00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c"!ROOT!/final-dump/specials_use.wybe:8:2\00", align 8 +@"cstring#2" = private unnamed_addr constant [ ?? x i8 ] c"specials_use\00", align 8 +@"cstring#3" = private unnamed_addr constant [ ?? x i8 ] c"specials_use:7:2\00", align 8 + +declare external ccc void @print_int(i64) +declare external ccc void @print_string(i64) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"specials_use.<0>"() { + call ccc void @print_string(i64 ptrtoint( ptr @"cstring#2" to i64 )) + call ccc void @putchar(i8 10) + call ccc void @print_string(i64 ptrtoint( ptr @"cstring#0" to i64 )) + call ccc void @putchar(i8 10) + call ccc void @print_int(i64 5) + call ccc void @putchar(i8 10) + call ccc void @print_int(i64 2) + call ccc void @putchar(i8 10) + call ccc void @print_string(i64 ptrtoint( ptr @"cstring#3" to i64 )) + call ccc void @putchar(i8 10) + call ccc void @print_string(i64 ptrtoint( ptr @"cstring#1" to i64 )) + call ccc void @putchar(i8 10) + ret void } diff --git a/test-cases/final-dump/stmt_for.exp b/test-cases/final-dump/stmt_for.exp index 4517c2dfd..8f6b1d34a 100644 --- a/test-cases/final-dump/stmt_for.exp +++ b/test-cases/final-dump/stmt_for.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module stmt_for representation : (not a type) public submods : int_sequence -> stmt_for.int_sequence @@ -716,938 +719,776 @@ xrange(start##0:wybe.int, stride##0:wybe.int, end##0:wybe.int, ?#result##0:stmt_ LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'stmt_for' - - - - -@stmt_for.15 = constant {i64, i64} { i64 11, i64 ptrtoint ([?? x i8]* @stmt_for.14 to i64) } - - -@stmt_for.9 = constant {i64, i64} { i64 11, i64 ptrtoint ([?? x i8]* @stmt_for.8 to i64) } - - -@stmt_for.11 = constant {i64, i64} { i64 12, i64 ptrtoint ([?? x i8]* @stmt_for.10 to i64) } - - -@stmt_for.13 = constant {i64, i64} { i64 12, i64 ptrtoint ([?? x i8]* @stmt_for.12 to i64) } - - -@stmt_for.7 = constant {i64, i64} { i64 12, i64 ptrtoint ([?? x i8]* @stmt_for.6 to i64) } - - -@stmt_for.17 = constant {i64, i64} { i64 13, i64 ptrtoint ([?? x i8]* @stmt_for.16 to i64) } - - -@stmt_for.19 = constant {i64, i64} { i64 13, i64 ptrtoint ([?? x i8]* @stmt_for.18 to i64) } - - -@stmt_for.23 = constant {i64, i64} { i64 13, i64 ptrtoint ([?? x i8]* @stmt_for.22 to i64) } - - -@stmt_for.1 = constant {i64, i64} { i64 17, i64 ptrtoint ([?? x i8]* @stmt_for.0 to i64) } - - -@stmt_for.3 = constant {i64, i64} { i64 19, i64 ptrtoint ([?? x i8]* @stmt_for.2 to i64) } - - -@stmt_for.21 = constant {i64, i64} { i64 21, i64 ptrtoint ([?? x i8]* @stmt_for.20 to i64) } - - -@stmt_for.25 = constant {i64, i64} { i64 21, i64 ptrtoint ([?? x i8]* @stmt_for.24 to i64) } - - -@stmt_for.5 = constant {i64, i64} { i64 31, i64 ptrtoint ([?? x i8]* @stmt_for.4 to i64) } - - -@stmt_for.2 = constant [?? x i8] c"\0amultiple_generator\00" - - -@stmt_for.4 = constant [?? x i8] c"\0ashortest_generator_termination\00" - - -@stmt_for.6 = constant [?? x i8] c"\0ausing_break\00" - - -@stmt_for.22 = constant [?? x i8] c"\0ausing_irange\00" - - -@stmt_for.24 = constant [?? x i8] c"\0ausing_irange_reverse\00" - - -@stmt_for.8 = constant [?? x i8] c"\0ausing_next\00" - - -@stmt_for.16 = constant [?? x i8] c"\0ausing_unless\00" - - -@stmt_for.12 = constant [?? x i8] c"\0ausing_until\00" - - -@stmt_for.14 = constant [?? x i8] c"\0ausing_when\00" - - -@stmt_for.10 = constant [?? x i8] c"\0ausing_while\00" - - -@stmt_for.18 = constant [?? x i8] c"\0ausing_xrange\00" - - -@stmt_for.20 = constant [?? x i8] c"\0ausing_xrange_reverse\00" - - -@stmt_for.0 = constant [?? x i8] c"single_generator:\00" - - -declare external ccc void @putchar(i8) - - -declare external ccc void @print_int(i64) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"stmt_for.<0>"() { -entry: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @stmt_for.1, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"stmt_for.single_generator<0>"() - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @stmt_for.3, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"stmt_for.multiple_generator<0>"() - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @stmt_for.5, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"stmt_for.shortest_generator_termination<0>"() - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @stmt_for.7, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"stmt_for.using_break<0>"() - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @stmt_for.9, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"stmt_for.using_next<0>"() - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @stmt_for.11, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"stmt_for.using_while<0>"() - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @stmt_for.13, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"stmt_for.using_until<0>"() - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @stmt_for.15, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"stmt_for.using_when<0>"() - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @stmt_for.17, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"stmt_for.using_unless<0>"() - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @stmt_for.19, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - %0 = tail call fastcc i64 @"stmt_for.xrange<0>"(i64 1, i64 1, i64 10) - tail call fastcc void @"stmt_for.using_xrange#cont#1<0>"(i64 %0) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @stmt_for.21, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - %1 = tail call fastcc i64 @"stmt_for.xrange<0>"(i64 10, i64 -1, i64 1) - tail call fastcc void @"stmt_for.using_xrange_reverse#cont#1<0>"(i64 %1) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @stmt_for.23, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - %2 = tail call fastcc i64 @"stmt_for.irange<0>"(i64 1, i64 1, i64 10) - tail call fastcc void @"stmt_for.using_irange#cont#1<0>"(i64 %2) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @stmt_for.25, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - %3 = tail call fastcc i64 @"stmt_for.irange<0>"(i64 10, i64 -1, i64 1) - tail call fastcc void @"stmt_for.using_irange_reverse#cont#1<0>"(i64 %3) - ret void +source_filename = "!ROOT!/final-dump/stmt_for.wybe" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c"\0Amultiple_generator\00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c"\0Ashortest_generator_termination\00", align 8 +@"cstring#2" = private unnamed_addr constant [ ?? x i8 ] c"\0Ausing_break\00", align 8 +@"cstring#3" = private unnamed_addr constant [ ?? x i8 ] c"\0Ausing_irange\00", align 8 +@"cstring#4" = private unnamed_addr constant [ ?? x i8 ] c"\0Ausing_irange_reverse\00", align 8 +@"cstring#5" = private unnamed_addr constant [ ?? x i8 ] c"\0Ausing_next\00", align 8 +@"cstring#6" = private unnamed_addr constant [ ?? x i8 ] c"\0Ausing_unless\00", align 8 +@"cstring#7" = private unnamed_addr constant [ ?? x i8 ] c"\0Ausing_until\00", align 8 +@"cstring#8" = private unnamed_addr constant [ ?? x i8 ] c"\0Ausing_when\00", align 8 +@"cstring#9" = private unnamed_addr constant [ ?? x i8 ] c"\0Ausing_while\00", align 8 +@"cstring#10" = private unnamed_addr constant [ ?? x i8 ] c"\0Ausing_xrange\00", align 8 +@"cstring#11" = private unnamed_addr constant [ ?? x i8 ] c"\0Ausing_xrange_reverse\00", align 8 +@"cstring#12" = private unnamed_addr constant [ ?? x i8 ] c"single_generator:\00", align 8 +@"string#13" = private unnamed_addr constant {i64, i64} { i64 19, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +@"string#14" = private unnamed_addr constant {i64, i64} { i64 31, i64 ptrtoint( ptr @"cstring#1" to i64 ) }, align 8 +@"string#15" = private unnamed_addr constant {i64, i64} { i64 12, i64 ptrtoint( ptr @"cstring#2" to i64 ) }, align 8 +@"string#16" = private unnamed_addr constant {i64, i64} { i64 13, i64 ptrtoint( ptr @"cstring#3" to i64 ) }, align 8 +@"string#17" = private unnamed_addr constant {i64, i64} { i64 21, i64 ptrtoint( ptr @"cstring#4" to i64 ) }, align 8 +@"string#18" = private unnamed_addr constant {i64, i64} { i64 11, i64 ptrtoint( ptr @"cstring#5" to i64 ) }, align 8 +@"string#19" = private unnamed_addr constant {i64, i64} { i64 13, i64 ptrtoint( ptr @"cstring#6" to i64 ) }, align 8 +@"string#20" = private unnamed_addr constant {i64, i64} { i64 12, i64 ptrtoint( ptr @"cstring#7" to i64 ) }, align 8 +@"string#21" = private unnamed_addr constant {i64, i64} { i64 11, i64 ptrtoint( ptr @"cstring#8" to i64 ) }, align 8 +@"string#22" = private unnamed_addr constant {i64, i64} { i64 12, i64 ptrtoint( ptr @"cstring#9" to i64 ) }, align 8 +@"string#23" = private unnamed_addr constant {i64, i64} { i64 13, i64 ptrtoint( ptr @"cstring#10" to i64 ) }, align 8 +@"string#24" = private unnamed_addr constant {i64, i64} { i64 21, i64 ptrtoint( ptr @"cstring#11" to i64 ) }, align 8 +@"string#25" = private unnamed_addr constant {i64, i64} { i64 17, i64 ptrtoint( ptr @"cstring#12" to i64 ) }, align 8 + +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"stmt_for.<0>"() { + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#25" to i64 )) + call ccc void @putchar(i8 10) + tail call fastcc void @"stmt_for.single_generator<0>"() + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#13" to i64 )) + call ccc void @putchar(i8 10) + tail call fastcc void @"stmt_for.multiple_generator<0>"() + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#14" to i64 )) + call ccc void @putchar(i8 10) + tail call fastcc void @"stmt_for.shortest_generator_termination<0>"() + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#15" to i64 )) + call ccc void @putchar(i8 10) + tail call fastcc void @"stmt_for.using_break<0>"() + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#18" to i64 )) + call ccc void @putchar(i8 10) + tail call fastcc void @"stmt_for.using_next<0>"() + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#22" to i64 )) + call ccc void @putchar(i8 10) + tail call fastcc void @"stmt_for.using_while<0>"() + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#20" to i64 )) + call ccc void @putchar(i8 10) + tail call fastcc void @"stmt_for.using_until<0>"() + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#21" to i64 )) + call ccc void @putchar(i8 10) + tail call fastcc void @"stmt_for.using_when<0>"() + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#19" to i64 )) + call ccc void @putchar(i8 10) + tail call fastcc void @"stmt_for.using_unless<0>"() + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#23" to i64 )) + call ccc void @putchar(i8 10) + %"tmp#30##0" = tail call fastcc i64 @"stmt_for.xrange<0>"(i64 1, i64 1, i64 10) + tail call fastcc void @"stmt_for.using_xrange#cont#1<0>"(i64 %"tmp#30##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#24" to i64 )) + call ccc void @putchar(i8 10) + %"tmp#34##0" = tail call fastcc i64 @"stmt_for.xrange<0>"(i64 10, i64 -1, i64 1) + tail call fastcc void @"stmt_for.using_xrange_reverse#cont#1<0>"(i64 %"tmp#34##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#16" to i64 )) + call ccc void @putchar(i8 10) + %"tmp#38##0" = tail call fastcc i64 @"stmt_for.irange<0>"(i64 1, i64 1, i64 10) + tail call fastcc void @"stmt_for.using_irange#cont#1<0>"(i64 %"tmp#38##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#17" to i64 )) + call ccc void @putchar(i8 10) + %"tmp#42##0" = tail call fastcc i64 @"stmt_for.irange<0>"(i64 10, i64 -1, i64 1) + tail call fastcc void @"stmt_for.using_irange_reverse#cont#1<0>"(i64 %"tmp#42##0") + ret void } - -define external fastcc i64 @"stmt_for.irange<0>"(i64 %"start##0", i64 %"stride##0", i64 %"end##0") { -entry: - %0 = icmp slt i64 %"stride##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = sub i64 %"end##0", 1 - %2 = trunc i64 24 to i32 - %3 = tail call ccc i8* @wybe_malloc(i32 %2) - %4 = ptrtoint i8* %3 to i64 - %5 = inttoptr i64 %4 to i64* - store i64 %"start##0", i64* %5 - %6 = add i64 %4, 8 - %7 = inttoptr i64 %6 to i64* - store i64 %"stride##0", i64* %7 - %8 = add i64 %4, 16 - %9 = inttoptr i64 %8 to i64* - store i64 %1, i64* %9 - ret i64 %4 -if.else: - %10 = add i64 %"end##0", 1 - %11 = trunc i64 24 to i32 - %12 = tail call ccc i8* @wybe_malloc(i32 %11) - %13 = ptrtoint i8* %12 to i64 - %14 = inttoptr i64 %13 to i64* - store i64 %"start##0", i64* %14 - %15 = add i64 %13, 8 - %16 = inttoptr i64 %15 to i64* - store i64 %"stride##0", i64* %16 - %17 = add i64 %13, 16 - %18 = inttoptr i64 %17 to i64* - store i64 %10, i64* %18 - ret i64 %13 +define external fastcc i64 @"stmt_for.irange<0>"(i64 %"start##0", i64 %"stride##0", i64 %"end##0") { + %"tmp#4##0" = icmp slt i64 %"stride##0", 0 + br i1 %"tmp#4##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = sub i64 %"end##0", 1 + %"tmp#25##0" = call ccc ptr @wybe_malloc(i32 24) + %"tmp#21##0" = ptrtoint ptr %"tmp#25##0" to i64 + %"tmp#26##0" = inttoptr i64 %"tmp#21##0" to ptr + store i64 %"start##0", ptr %"tmp#26##0" + %"tmp#27##0" = add i64 %"tmp#21##0", 8 + %"tmp#28##0" = inttoptr i64 %"tmp#27##0" to ptr + store i64 %"stride##0", ptr %"tmp#28##0" + %"tmp#29##0" = add i64 %"tmp#21##0", 16 + %"tmp#30##0" = inttoptr i64 %"tmp#29##0" to ptr + store i64 %"tmp#2##0", ptr %"tmp#30##0" + ret i64 %"tmp#21##0" +if.else.0: + %"tmp#3##0" = add i64 %"end##0", 1 + %"tmp#31##0" = call ccc ptr @wybe_malloc(i32 24) + %"tmp#12##0" = ptrtoint ptr %"tmp#31##0" to i64 + %"tmp#32##0" = inttoptr i64 %"tmp#12##0" to ptr + store i64 %"start##0", ptr %"tmp#32##0" + %"tmp#33##0" = add i64 %"tmp#12##0", 8 + %"tmp#34##0" = inttoptr i64 %"tmp#33##0" to ptr + store i64 %"stride##0", ptr %"tmp#34##0" + %"tmp#35##0" = add i64 %"tmp#12##0", 16 + %"tmp#36##0" = inttoptr i64 %"tmp#35##0" to ptr + store i64 %"tmp#3##0", ptr %"tmp#36##0" + ret i64 %"tmp#12##0" } - -define external fastcc void @"stmt_for.multiple_generator<0>"() { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 3, i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 0, i64* %5 - %6 = trunc i64 16 to i32 - %7 = tail call ccc i8* @wybe_malloc(i32 %6) - %8 = ptrtoint i8* %7 to i64 - %9 = inttoptr i64 %8 to i64* - store i64 2, i64* %9 - %10 = add i64 %8, 8 - %11 = inttoptr i64 %10 to i64* - store i64 %2, i64* %11 - %12 = trunc i64 16 to i32 - %13 = tail call ccc i8* @wybe_malloc(i32 %12) - %14 = ptrtoint i8* %13 to i64 - %15 = inttoptr i64 %14 to i64* - store i64 1, i64* %15 - %16 = add i64 %14, 8 - %17 = inttoptr i64 %16 to i64* - store i64 %8, i64* %17 - %18 = trunc i64 16 to i32 - %19 = tail call ccc i8* @wybe_malloc(i32 %18) - %20 = ptrtoint i8* %19 to i64 - %21 = inttoptr i64 %20 to i64* - store i64 6, i64* %21 - %22 = add i64 %20, 8 - %23 = inttoptr i64 %22 to i64* - store i64 0, i64* %23 - %24 = trunc i64 16 to i32 - %25 = tail call ccc i8* @wybe_malloc(i32 %24) - %26 = ptrtoint i8* %25 to i64 - %27 = inttoptr i64 %26 to i64* - store i64 5, i64* %27 - %28 = add i64 %26, 8 - %29 = inttoptr i64 %28 to i64* - store i64 %20, i64* %29 - %30 = trunc i64 16 to i32 - %31 = tail call ccc i8* @wybe_malloc(i32 %30) - %32 = ptrtoint i8* %31 to i64 - %33 = inttoptr i64 %32 to i64* - store i64 4, i64* %33 - %34 = add i64 %32, 8 - %35 = inttoptr i64 %34 to i64* - store i64 %26, i64* %35 - tail call fastcc void @"stmt_for.multiple_generator#cont#1<0>"(i64 %14, i64 %32) - ret void +define external fastcc void @"stmt_for.multiple_generator<0>"() { + %"tmp#38##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#16##0" = ptrtoint ptr %"tmp#38##0" to i64 + %"tmp#39##0" = inttoptr i64 %"tmp#16##0" to ptr + store i64 3, ptr %"tmp#39##0" + %"tmp#40##0" = add i64 %"tmp#16##0", 8 + %"tmp#41##0" = inttoptr i64 %"tmp#40##0" to ptr + store i64 0, ptr %"tmp#41##0" + %"tmp#42##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#20##0" = ptrtoint ptr %"tmp#42##0" to i64 + %"tmp#43##0" = inttoptr i64 %"tmp#20##0" to ptr + store i64 2, ptr %"tmp#43##0" + %"tmp#44##0" = add i64 %"tmp#20##0", 8 + %"tmp#45##0" = inttoptr i64 %"tmp#44##0" to ptr + store i64 %"tmp#16##0", ptr %"tmp#45##0" + %"tmp#46##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#24##0" = ptrtoint ptr %"tmp#46##0" to i64 + %"tmp#47##0" = inttoptr i64 %"tmp#24##0" to ptr + store i64 1, ptr %"tmp#47##0" + %"tmp#48##0" = add i64 %"tmp#24##0", 8 + %"tmp#49##0" = inttoptr i64 %"tmp#48##0" to ptr + store i64 %"tmp#20##0", ptr %"tmp#49##0" + %"tmp#50##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#28##0" = ptrtoint ptr %"tmp#50##0" to i64 + %"tmp#51##0" = inttoptr i64 %"tmp#28##0" to ptr + store i64 6, ptr %"tmp#51##0" + %"tmp#52##0" = add i64 %"tmp#28##0", 8 + %"tmp#53##0" = inttoptr i64 %"tmp#52##0" to ptr + store i64 0, ptr %"tmp#53##0" + %"tmp#54##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#32##0" = ptrtoint ptr %"tmp#54##0" to i64 + %"tmp#55##0" = inttoptr i64 %"tmp#32##0" to ptr + store i64 5, ptr %"tmp#55##0" + %"tmp#56##0" = add i64 %"tmp#32##0", 8 + %"tmp#57##0" = inttoptr i64 %"tmp#56##0" to ptr + store i64 %"tmp#28##0", ptr %"tmp#57##0" + %"tmp#58##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#36##0" = ptrtoint ptr %"tmp#58##0" to i64 + %"tmp#59##0" = inttoptr i64 %"tmp#36##0" to ptr + store i64 4, ptr %"tmp#59##0" + %"tmp#60##0" = add i64 %"tmp#36##0", 8 + %"tmp#61##0" = inttoptr i64 %"tmp#60##0" to ptr + store i64 %"tmp#32##0", ptr %"tmp#61##0" + tail call fastcc void @"stmt_for.multiple_generator#cont#1<0>"(i64 %"tmp#24##0", i64 %"tmp#36##0") + ret void } - -define external fastcc void @"stmt_for.multiple_generator#cont#1<0>"(i64 %"tmp#8##0", i64 %"tmp#9##0") { -entry: - %0 = icmp ne i64 %"tmp#8##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"tmp#8##0" to i64* - %2 = load i64, i64* %1 - %3 = add i64 %"tmp#8##0", 8 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = icmp ne i64 %"tmp#9##0", 0 - br i1 %6, label %if.then1, label %if.else1 -if.else: - ret void -if.then1: - %7 = inttoptr i64 %"tmp#9##0" to i64* - %8 = load i64, i64* %7 - %9 = add i64 %"tmp#9##0", 8 - %10 = inttoptr i64 %9 to i64* - %11 = load i64, i64* %10 - tail call ccc void @print_int(i64 %2) - tail call ccc void @putchar(i8 10) - tail call ccc void @print_int(i64 %8) - tail call ccc void @putchar(i8 10) - musttail call fastcc void @"stmt_for.multiple_generator#cont#1<0>"(i64 %5, i64 %11) - ret void -if.else1: - ret void +define external fastcc void @"stmt_for.multiple_generator#cont#1<0>"(i64 %"tmp#8##0", i64 %"tmp#9##0") { + %"tmp#15##0" = icmp ne i64 %"tmp#8##0", 0 + br i1 %"tmp#15##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#26##0" = inttoptr i64 %"tmp#8##0" to ptr + %"i##0" = load i64, ptr %"tmp#26##0" + %"tmp#27##0" = add i64 %"tmp#8##0", 8 + %"tmp#28##0" = inttoptr i64 %"tmp#27##0" to ptr + %"tmp#8##1" = load i64, ptr %"tmp#28##0" + %"tmp#17##0" = icmp ne i64 %"tmp#9##0", 0 + br i1 %"tmp#17##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#29##0" = inttoptr i64 %"tmp#9##0" to ptr + %"j##0" = load i64, ptr %"tmp#29##0" + %"tmp#30##0" = add i64 %"tmp#9##0", 8 + %"tmp#31##0" = inttoptr i64 %"tmp#30##0" to ptr + %"tmp#9##1" = load i64, ptr %"tmp#31##0" + call ccc void @print_int(i64 %"i##0") + call ccc void @putchar(i8 10) + call ccc void @print_int(i64 %"j##0") + call ccc void @putchar(i8 10) + tail call fastcc void @"stmt_for.multiple_generator#cont#1<0>"(i64 %"tmp#8##1", i64 %"tmp#9##1") + ret void +if.else.1: + ret void +if.else.0: + ret void } - -define external fastcc i1 @"stmt_for.semi_det_for_loop<0>"() { -entry: - %0 = tail call fastcc i64 @"stmt_for.xrange<0>"(i64 0, i64 1, i64 10) - %1 = tail call fastcc i1 @"stmt_for.semi_det_for_loop#cont#1<0>"(i64 %0) - ret i1 %1 +define external fastcc i1 @"stmt_for.semi_det_for_loop<0>"() { + %"tmp#1##0" = tail call fastcc i64 @"stmt_for.xrange<0>"(i64 0, i64 1, i64 10) + %"tmp#5##0" = tail call fastcc i1 @"stmt_for.semi_det_for_loop#cont#1<0>"(i64 %"tmp#1##0") + ret i1 %"tmp#5##0" } - -define external fastcc i1 @"stmt_for.semi_det_for_loop#cont#1<0>"(i64 %"tmp#0##0") { -entry: - %0 = tail call fastcc {i64, i64, i1} @"stmt_for.int_sequence.[|]<0>"(i64 %"tmp#0##0") - %1 = extractvalue {i64, i64, i1} %0, 0 - %2 = extractvalue {i64, i64, i1} %0, 1 - %3 = extractvalue {i64, i64, i1} %0, 2 - br i1 %3, label %if.then, label %if.else -if.then: - %4 = icmp slt i64 %1, 5 - br i1 %4, label %if.then1, label %if.else1 -if.else: - ret i1 1 -if.then1: - %5 = musttail call fastcc i1 @"stmt_for.semi_det_for_loop#cont#1<0>"(i64 %2) - ret i1 %5 -if.else1: - ret i1 0 +define external fastcc i1 @"stmt_for.semi_det_for_loop#cont#1<0>"(i64 %"tmp#0##0") { + %"tmp#7##0" = tail call fastcc {i64, i64, i1} @"stmt_for.int_sequence.[|]<0>"(i64 %"tmp#0##0") + %"i##0" = extractvalue {i64, i64, i1}%"tmp#7##0", 0 + %"tmp#0##1" = extractvalue {i64, i64, i1}%"tmp#7##0", 1 + %"tmp#4##0" = extractvalue {i64, i64, i1}%"tmp#7##0", 2 + br i1 %"tmp#4##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#3##0" = icmp slt i64 %"i##0", 5 + br i1 %"tmp#3##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#8##0" = tail call fastcc i1 @"stmt_for.semi_det_for_loop#cont#1<0>"(i64 %"tmp#0##1") + ret i1 %"tmp#8##0" +if.else.1: + ret i1 0 +if.else.0: + ret i1 1 } - -define external fastcc void @"stmt_for.shortest_generator_termination<0>"() { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 4, i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 0, i64* %5 - %6 = trunc i64 16 to i32 - %7 = tail call ccc i8* @wybe_malloc(i32 %6) - %8 = ptrtoint i8* %7 to i64 - %9 = inttoptr i64 %8 to i64* - store i64 3, i64* %9 - %10 = add i64 %8, 8 - %11 = inttoptr i64 %10 to i64* - store i64 %2, i64* %11 - %12 = trunc i64 16 to i32 - %13 = tail call ccc i8* @wybe_malloc(i32 %12) - %14 = ptrtoint i8* %13 to i64 - %15 = inttoptr i64 %14 to i64* - store i64 2, i64* %15 - %16 = add i64 %14, 8 - %17 = inttoptr i64 %16 to i64* - store i64 %8, i64* %17 - %18 = trunc i64 16 to i32 - %19 = tail call ccc i8* @wybe_malloc(i32 %18) - %20 = ptrtoint i8* %19 to i64 - %21 = inttoptr i64 %20 to i64* - store i64 1, i64* %21 - %22 = add i64 %20, 8 - %23 = inttoptr i64 %22 to i64* - store i64 %14, i64* %23 - %24 = trunc i64 16 to i32 - %25 = tail call ccc i8* @wybe_malloc(i32 %24) - %26 = ptrtoint i8* %25 to i64 - %27 = inttoptr i64 %26 to i64* - store i64 5, i64* %27 - %28 = add i64 %26, 8 - %29 = inttoptr i64 %28 to i64* - store i64 0, i64* %29 - %30 = trunc i64 16 to i32 - %31 = tail call ccc i8* @wybe_malloc(i32 %30) - %32 = ptrtoint i8* %31 to i64 - %33 = inttoptr i64 %32 to i64* - store i64 4, i64* %33 - %34 = add i64 %32, 8 - %35 = inttoptr i64 %34 to i64* - store i64 %26, i64* %35 - tail call fastcc void @"stmt_for.shortest_generator_termination#cont#1<0>"(i64 %20, i64 %32) - ret void +define external fastcc void @"stmt_for.shortest_generator_termination<0>"() { + %"tmp#38##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#16##0" = ptrtoint ptr %"tmp#38##0" to i64 + %"tmp#39##0" = inttoptr i64 %"tmp#16##0" to ptr + store i64 4, ptr %"tmp#39##0" + %"tmp#40##0" = add i64 %"tmp#16##0", 8 + %"tmp#41##0" = inttoptr i64 %"tmp#40##0" to ptr + store i64 0, ptr %"tmp#41##0" + %"tmp#42##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#20##0" = ptrtoint ptr %"tmp#42##0" to i64 + %"tmp#43##0" = inttoptr i64 %"tmp#20##0" to ptr + store i64 3, ptr %"tmp#43##0" + %"tmp#44##0" = add i64 %"tmp#20##0", 8 + %"tmp#45##0" = inttoptr i64 %"tmp#44##0" to ptr + store i64 %"tmp#16##0", ptr %"tmp#45##0" + %"tmp#46##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#24##0" = ptrtoint ptr %"tmp#46##0" to i64 + %"tmp#47##0" = inttoptr i64 %"tmp#24##0" to ptr + store i64 2, ptr %"tmp#47##0" + %"tmp#48##0" = add i64 %"tmp#24##0", 8 + %"tmp#49##0" = inttoptr i64 %"tmp#48##0" to ptr + store i64 %"tmp#20##0", ptr %"tmp#49##0" + %"tmp#50##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#28##0" = ptrtoint ptr %"tmp#50##0" to i64 + %"tmp#51##0" = inttoptr i64 %"tmp#28##0" to ptr + store i64 1, ptr %"tmp#51##0" + %"tmp#52##0" = add i64 %"tmp#28##0", 8 + %"tmp#53##0" = inttoptr i64 %"tmp#52##0" to ptr + store i64 %"tmp#24##0", ptr %"tmp#53##0" + %"tmp#54##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#32##0" = ptrtoint ptr %"tmp#54##0" to i64 + %"tmp#55##0" = inttoptr i64 %"tmp#32##0" to ptr + store i64 5, ptr %"tmp#55##0" + %"tmp#56##0" = add i64 %"tmp#32##0", 8 + %"tmp#57##0" = inttoptr i64 %"tmp#56##0" to ptr + store i64 0, ptr %"tmp#57##0" + %"tmp#58##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#36##0" = ptrtoint ptr %"tmp#58##0" to i64 + %"tmp#59##0" = inttoptr i64 %"tmp#36##0" to ptr + store i64 4, ptr %"tmp#59##0" + %"tmp#60##0" = add i64 %"tmp#36##0", 8 + %"tmp#61##0" = inttoptr i64 %"tmp#60##0" to ptr + store i64 %"tmp#32##0", ptr %"tmp#61##0" + tail call fastcc void @"stmt_for.shortest_generator_termination#cont#1<0>"(i64 %"tmp#28##0", i64 %"tmp#36##0") + ret void } - -define external fastcc void @"stmt_for.shortest_generator_termination#cont#1<0>"(i64 %"tmp#8##0", i64 %"tmp#9##0") { -entry: - %0 = icmp ne i64 %"tmp#8##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"tmp#8##0" to i64* - %2 = load i64, i64* %1 - %3 = add i64 %"tmp#8##0", 8 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = icmp ne i64 %"tmp#9##0", 0 - br i1 %6, label %if.then1, label %if.else1 -if.else: - ret void -if.then1: - %7 = inttoptr i64 %"tmp#9##0" to i64* - %8 = load i64, i64* %7 - %9 = add i64 %"tmp#9##0", 8 - %10 = inttoptr i64 %9 to i64* - %11 = load i64, i64* %10 - tail call ccc void @print_int(i64 %2) - tail call ccc void @putchar(i8 10) - tail call ccc void @print_int(i64 %8) - tail call ccc void @putchar(i8 10) - musttail call fastcc void @"stmt_for.shortest_generator_termination#cont#1<0>"(i64 %5, i64 %11) - ret void -if.else1: - ret void +define external fastcc void @"stmt_for.shortest_generator_termination#cont#1<0>"(i64 %"tmp#8##0", i64 %"tmp#9##0") { + %"tmp#15##0" = icmp ne i64 %"tmp#8##0", 0 + br i1 %"tmp#15##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#26##0" = inttoptr i64 %"tmp#8##0" to ptr + %"i##0" = load i64, ptr %"tmp#26##0" + %"tmp#27##0" = add i64 %"tmp#8##0", 8 + %"tmp#28##0" = inttoptr i64 %"tmp#27##0" to ptr + %"tmp#8##1" = load i64, ptr %"tmp#28##0" + %"tmp#17##0" = icmp ne i64 %"tmp#9##0", 0 + br i1 %"tmp#17##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#29##0" = inttoptr i64 %"tmp#9##0" to ptr + %"j##0" = load i64, ptr %"tmp#29##0" + %"tmp#30##0" = add i64 %"tmp#9##0", 8 + %"tmp#31##0" = inttoptr i64 %"tmp#30##0" to ptr + %"tmp#9##1" = load i64, ptr %"tmp#31##0" + call ccc void @print_int(i64 %"i##0") + call ccc void @putchar(i8 10) + call ccc void @print_int(i64 %"j##0") + call ccc void @putchar(i8 10) + tail call fastcc void @"stmt_for.shortest_generator_termination#cont#1<0>"(i64 %"tmp#8##1", i64 %"tmp#9##1") + ret void +if.else.1: + ret void +if.else.0: + ret void } - -define external fastcc void @"stmt_for.single_generator<0>"() { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 3, i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 0, i64* %5 - %6 = trunc i64 16 to i32 - %7 = tail call ccc i8* @wybe_malloc(i32 %6) - %8 = ptrtoint i8* %7 to i64 - %9 = inttoptr i64 %8 to i64* - store i64 2, i64* %9 - %10 = add i64 %8, 8 - %11 = inttoptr i64 %10 to i64* - store i64 %2, i64* %11 - %12 = trunc i64 16 to i32 - %13 = tail call ccc i8* @wybe_malloc(i32 %12) - %14 = ptrtoint i8* %13 to i64 - %15 = inttoptr i64 %14 to i64* - store i64 1, i64* %15 - %16 = add i64 %14, 8 - %17 = inttoptr i64 %16 to i64* - store i64 %8, i64* %17 - tail call fastcc void @"stmt_for.single_generator#cont#1<0>"(i64 %14) - ret void +define external fastcc void @"stmt_for.single_generator<0>"() { + %"tmp#19##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#9##0" = ptrtoint ptr %"tmp#19##0" to i64 + %"tmp#20##0" = inttoptr i64 %"tmp#9##0" to ptr + store i64 3, ptr %"tmp#20##0" + %"tmp#21##0" = add i64 %"tmp#9##0", 8 + %"tmp#22##0" = inttoptr i64 %"tmp#21##0" to ptr + store i64 0, ptr %"tmp#22##0" + %"tmp#23##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#13##0" = ptrtoint ptr %"tmp#23##0" to i64 + %"tmp#24##0" = inttoptr i64 %"tmp#13##0" to ptr + store i64 2, ptr %"tmp#24##0" + %"tmp#25##0" = add i64 %"tmp#13##0", 8 + %"tmp#26##0" = inttoptr i64 %"tmp#25##0" to ptr + store i64 %"tmp#9##0", ptr %"tmp#26##0" + %"tmp#27##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#17##0" = ptrtoint ptr %"tmp#27##0" to i64 + %"tmp#28##0" = inttoptr i64 %"tmp#17##0" to ptr + store i64 1, ptr %"tmp#28##0" + %"tmp#29##0" = add i64 %"tmp#17##0", 8 + %"tmp#30##0" = inttoptr i64 %"tmp#29##0" to ptr + store i64 %"tmp#13##0", ptr %"tmp#30##0" + tail call fastcc void @"stmt_for.single_generator#cont#1<0>"(i64 %"tmp#17##0") + ret void } - -define external fastcc void @"stmt_for.single_generator#cont#1<0>"(i64 %"tmp#4##0") { -entry: - %0 = icmp ne i64 %"tmp#4##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"tmp#4##0" to i64* - %2 = load i64, i64* %1 - %3 = add i64 %"tmp#4##0", 8 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - tail call ccc void @print_int(i64 %2) - tail call ccc void @putchar(i8 10) - musttail call fastcc void @"stmt_for.single_generator#cont#1<0>"(i64 %5) - ret void -if.else: - ret void +define external fastcc void @"stmt_for.single_generator#cont#1<0>"(i64 %"tmp#4##0") { + %"tmp#8##0" = icmp ne i64 %"tmp#4##0", 0 + br i1 %"tmp#8##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#13##0" = inttoptr i64 %"tmp#4##0" to ptr + %"i##0" = load i64, ptr %"tmp#13##0" + %"tmp#14##0" = add i64 %"tmp#4##0", 8 + %"tmp#15##0" = inttoptr i64 %"tmp#14##0" to ptr + %"tmp#4##1" = load i64, ptr %"tmp#15##0" + call ccc void @print_int(i64 %"i##0") + call ccc void @putchar(i8 10) + tail call fastcc void @"stmt_for.single_generator#cont#1<0>"(i64 %"tmp#4##1") + ret void +if.else.0: + ret void } - -define external fastcc void @"stmt_for.using_break<0>"() { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 4, i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 0, i64* %5 - %6 = trunc i64 16 to i32 - %7 = tail call ccc i8* @wybe_malloc(i32 %6) - %8 = ptrtoint i8* %7 to i64 - %9 = inttoptr i64 %8 to i64* - store i64 3, i64* %9 - %10 = add i64 %8, 8 - %11 = inttoptr i64 %10 to i64* - store i64 %2, i64* %11 - %12 = trunc i64 16 to i32 - %13 = tail call ccc i8* @wybe_malloc(i32 %12) - %14 = ptrtoint i8* %13 to i64 - %15 = inttoptr i64 %14 to i64* - store i64 2, i64* %15 - %16 = add i64 %14, 8 - %17 = inttoptr i64 %16 to i64* - store i64 %8, i64* %17 - %18 = trunc i64 16 to i32 - %19 = tail call ccc i8* @wybe_malloc(i32 %18) - %20 = ptrtoint i8* %19 to i64 - %21 = inttoptr i64 %20 to i64* - store i64 1, i64* %21 - %22 = add i64 %20, 8 - %23 = inttoptr i64 %22 to i64* - store i64 %14, i64* %23 - tail call fastcc void @"stmt_for.using_break#cont#1<0>"(i64 %20) - ret void +define external fastcc void @"stmt_for.using_break<0>"() { + %"tmp#25##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#11##0" = ptrtoint ptr %"tmp#25##0" to i64 + %"tmp#26##0" = inttoptr i64 %"tmp#11##0" to ptr + store i64 4, ptr %"tmp#26##0" + %"tmp#27##0" = add i64 %"tmp#11##0", 8 + %"tmp#28##0" = inttoptr i64 %"tmp#27##0" to ptr + store i64 0, ptr %"tmp#28##0" + %"tmp#29##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#15##0" = ptrtoint ptr %"tmp#29##0" to i64 + %"tmp#30##0" = inttoptr i64 %"tmp#15##0" to ptr + store i64 3, ptr %"tmp#30##0" + %"tmp#31##0" = add i64 %"tmp#15##0", 8 + %"tmp#32##0" = inttoptr i64 %"tmp#31##0" to ptr + store i64 %"tmp#11##0", ptr %"tmp#32##0" + %"tmp#33##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#19##0" = ptrtoint ptr %"tmp#33##0" to i64 + %"tmp#34##0" = inttoptr i64 %"tmp#19##0" to ptr + store i64 2, ptr %"tmp#34##0" + %"tmp#35##0" = add i64 %"tmp#19##0", 8 + %"tmp#36##0" = inttoptr i64 %"tmp#35##0" to ptr + store i64 %"tmp#15##0", ptr %"tmp#36##0" + %"tmp#37##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#23##0" = ptrtoint ptr %"tmp#37##0" to i64 + %"tmp#38##0" = inttoptr i64 %"tmp#23##0" to ptr + store i64 1, ptr %"tmp#38##0" + %"tmp#39##0" = add i64 %"tmp#23##0", 8 + %"tmp#40##0" = inttoptr i64 %"tmp#39##0" to ptr + store i64 %"tmp#19##0", ptr %"tmp#40##0" + tail call fastcc void @"stmt_for.using_break#cont#1<0>"(i64 %"tmp#23##0") + ret void } - -define external fastcc void @"stmt_for.using_break#cont#1<0>"(i64 %"tmp#5##0") { -entry: - %0 = icmp ne i64 %"tmp#5##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"tmp#5##0" to i64* - %2 = load i64, i64* %1 - %3 = add i64 %"tmp#5##0", 8 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = icmp eq i64 %2, 3 - br i1 %6, label %if.then1, label %if.else1 -if.else: - ret void -if.then1: - ret void -if.else1: - tail call ccc void @print_int(i64 %2) - tail call ccc void @putchar(i8 10) - musttail call fastcc void @"stmt_for.using_break#cont#1<0>"(i64 %5) - ret void +define external fastcc void @"stmt_for.using_break#cont#1<0>"(i64 %"tmp#5##0") { + %"tmp#10##0" = icmp ne i64 %"tmp#5##0", 0 + br i1 %"tmp#10##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#17##0" = inttoptr i64 %"tmp#5##0" to ptr + %"i##0" = load i64, ptr %"tmp#17##0" + %"tmp#18##0" = add i64 %"tmp#5##0", 8 + %"tmp#19##0" = inttoptr i64 %"tmp#18##0" to ptr + %"tmp#5##1" = load i64, ptr %"tmp#19##0" + %"tmp#7##0" = icmp eq i64 %"i##0", 3 + br i1 %"tmp#7##0", label %if.then.1, label %if.else.1 +if.then.1: + ret void +if.else.1: + call ccc void @print_int(i64 %"i##0") + call ccc void @putchar(i8 10) + tail call fastcc void @"stmt_for.using_break#cont#1<0>"(i64 %"tmp#5##1") + ret void +if.else.0: + ret void } - -define external fastcc void @"stmt_for.using_irange<0>"() alwaysinline { -entry: - %0 = tail call fastcc i64 @"stmt_for.irange<0>"(i64 1, i64 1, i64 10) - tail call fastcc void @"stmt_for.using_irange#cont#1<0>"(i64 %0) - ret void +define external fastcc void @"stmt_for.using_irange<0>"() { + %"tmp#1##0" = tail call fastcc i64 @"stmt_for.irange<0>"(i64 1, i64 1, i64 10) + tail call fastcc void @"stmt_for.using_irange#cont#1<0>"(i64 %"tmp#1##0") + ret void } - -define external fastcc void @"stmt_for.using_irange#cont#1<0>"(i64 %"tmp#0##0") { -entry: - %0 = tail call fastcc {i64, i64, i1} @"stmt_for.int_sequence.[|]<0>"(i64 %"tmp#0##0") - %1 = extractvalue {i64, i64, i1} %0, 0 - %2 = extractvalue {i64, i64, i1} %0, 1 - %3 = extractvalue {i64, i64, i1} %0, 2 - br i1 %3, label %if.then, label %if.else -if.then: - tail call ccc void @print_int(i64 %1) - tail call ccc void @putchar(i8 10) - musttail call fastcc void @"stmt_for.using_irange#cont#1<0>"(i64 %2) - ret void -if.else: - ret void +define external fastcc void @"stmt_for.using_irange#cont#1<0>"(i64 %"tmp#0##0") { + %"tmp#8##0" = tail call fastcc {i64, i64, i1} @"stmt_for.int_sequence.[|]<0>"(i64 %"tmp#0##0") + %"i##0" = extractvalue {i64, i64, i1}%"tmp#8##0", 0 + %"tmp#0##1" = extractvalue {i64, i64, i1}%"tmp#8##0", 1 + %"tmp#3##0" = extractvalue {i64, i64, i1}%"tmp#8##0", 2 + br i1 %"tmp#3##0", label %if.then.0, label %if.else.0 +if.then.0: + call ccc void @print_int(i64 %"i##0") + call ccc void @putchar(i8 10) + tail call fastcc void @"stmt_for.using_irange#cont#1<0>"(i64 %"tmp#0##1") + ret void +if.else.0: + ret void } - -define external fastcc void @"stmt_for.using_irange_reverse<0>"() alwaysinline { -entry: - %0 = tail call fastcc i64 @"stmt_for.irange<0>"(i64 10, i64 -1, i64 1) - tail call fastcc void @"stmt_for.using_irange_reverse#cont#1<0>"(i64 %0) - ret void +define external fastcc void @"stmt_for.using_irange_reverse<0>"() { + %"tmp#1##0" = tail call fastcc i64 @"stmt_for.irange<0>"(i64 10, i64 -1, i64 1) + tail call fastcc void @"stmt_for.using_irange_reverse#cont#1<0>"(i64 %"tmp#1##0") + ret void } - -define external fastcc void @"stmt_for.using_irange_reverse#cont#1<0>"(i64 %"tmp#0##0") { -entry: - %0 = tail call fastcc {i64, i64, i1} @"stmt_for.int_sequence.[|]<0>"(i64 %"tmp#0##0") - %1 = extractvalue {i64, i64, i1} %0, 0 - %2 = extractvalue {i64, i64, i1} %0, 1 - %3 = extractvalue {i64, i64, i1} %0, 2 - br i1 %3, label %if.then, label %if.else -if.then: - tail call ccc void @print_int(i64 %1) - tail call ccc void @putchar(i8 10) - musttail call fastcc void @"stmt_for.using_irange_reverse#cont#1<0>"(i64 %2) - ret void -if.else: - ret void +define external fastcc void @"stmt_for.using_irange_reverse#cont#1<0>"(i64 %"tmp#0##0") { + %"tmp#8##0" = tail call fastcc {i64, i64, i1} @"stmt_for.int_sequence.[|]<0>"(i64 %"tmp#0##0") + %"i##0" = extractvalue {i64, i64, i1}%"tmp#8##0", 0 + %"tmp#0##1" = extractvalue {i64, i64, i1}%"tmp#8##0", 1 + %"tmp#3##0" = extractvalue {i64, i64, i1}%"tmp#8##0", 2 + br i1 %"tmp#3##0", label %if.then.0, label %if.else.0 +if.then.0: + call ccc void @print_int(i64 %"i##0") + call ccc void @putchar(i8 10) + tail call fastcc void @"stmt_for.using_irange_reverse#cont#1<0>"(i64 %"tmp#0##1") + ret void +if.else.0: + ret void } - -define external fastcc void @"stmt_for.using_next<0>"() { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 4, i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 0, i64* %5 - %6 = trunc i64 16 to i32 - %7 = tail call ccc i8* @wybe_malloc(i32 %6) - %8 = ptrtoint i8* %7 to i64 - %9 = inttoptr i64 %8 to i64* - store i64 3, i64* %9 - %10 = add i64 %8, 8 - %11 = inttoptr i64 %10 to i64* - store i64 %2, i64* %11 - %12 = trunc i64 16 to i32 - %13 = tail call ccc i8* @wybe_malloc(i32 %12) - %14 = ptrtoint i8* %13 to i64 - %15 = inttoptr i64 %14 to i64* - store i64 2, i64* %15 - %16 = add i64 %14, 8 - %17 = inttoptr i64 %16 to i64* - store i64 %8, i64* %17 - %18 = trunc i64 16 to i32 - %19 = tail call ccc i8* @wybe_malloc(i32 %18) - %20 = ptrtoint i8* %19 to i64 - %21 = inttoptr i64 %20 to i64* - store i64 1, i64* %21 - %22 = add i64 %20, 8 - %23 = inttoptr i64 %22 to i64* - store i64 %14, i64* %23 - tail call fastcc void @"stmt_for.using_next#cont#1<0>"(i64 %20) - ret void +define external fastcc void @"stmt_for.using_next<0>"() { + %"tmp#25##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#11##0" = ptrtoint ptr %"tmp#25##0" to i64 + %"tmp#26##0" = inttoptr i64 %"tmp#11##0" to ptr + store i64 4, ptr %"tmp#26##0" + %"tmp#27##0" = add i64 %"tmp#11##0", 8 + %"tmp#28##0" = inttoptr i64 %"tmp#27##0" to ptr + store i64 0, ptr %"tmp#28##0" + %"tmp#29##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#15##0" = ptrtoint ptr %"tmp#29##0" to i64 + %"tmp#30##0" = inttoptr i64 %"tmp#15##0" to ptr + store i64 3, ptr %"tmp#30##0" + %"tmp#31##0" = add i64 %"tmp#15##0", 8 + %"tmp#32##0" = inttoptr i64 %"tmp#31##0" to ptr + store i64 %"tmp#11##0", ptr %"tmp#32##0" + %"tmp#33##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#19##0" = ptrtoint ptr %"tmp#33##0" to i64 + %"tmp#34##0" = inttoptr i64 %"tmp#19##0" to ptr + store i64 2, ptr %"tmp#34##0" + %"tmp#35##0" = add i64 %"tmp#19##0", 8 + %"tmp#36##0" = inttoptr i64 %"tmp#35##0" to ptr + store i64 %"tmp#15##0", ptr %"tmp#36##0" + %"tmp#37##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#23##0" = ptrtoint ptr %"tmp#37##0" to i64 + %"tmp#38##0" = inttoptr i64 %"tmp#23##0" to ptr + store i64 1, ptr %"tmp#38##0" + %"tmp#39##0" = add i64 %"tmp#23##0", 8 + %"tmp#40##0" = inttoptr i64 %"tmp#39##0" to ptr + store i64 %"tmp#19##0", ptr %"tmp#40##0" + tail call fastcc void @"stmt_for.using_next#cont#1<0>"(i64 %"tmp#23##0") + ret void } - -define external fastcc void @"stmt_for.using_next#cont#1<0>"(i64 %"tmp#5##0") { -entry: - %0 = icmp ne i64 %"tmp#5##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"tmp#5##0" to i64* - %2 = load i64, i64* %1 - %3 = add i64 %"tmp#5##0", 8 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = icmp eq i64 %2, 3 - br i1 %6, label %if.then1, label %if.else1 -if.else: - ret void -if.then1: - musttail call fastcc void @"stmt_for.using_next#cont#1<0>"(i64 %5) - ret void -if.else1: - tail call ccc void @print_int(i64 %2) - tail call ccc void @putchar(i8 10) - musttail call fastcc void @"stmt_for.using_next#cont#1<0>"(i64 %5) - ret void +define external fastcc void @"stmt_for.using_next#cont#1<0>"(i64 %"tmp#5##0") { + %"tmp#10##0" = icmp ne i64 %"tmp#5##0", 0 + br i1 %"tmp#10##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#17##0" = inttoptr i64 %"tmp#5##0" to ptr + %"i##0" = load i64, ptr %"tmp#17##0" + %"tmp#18##0" = add i64 %"tmp#5##0", 8 + %"tmp#19##0" = inttoptr i64 %"tmp#18##0" to ptr + %"tmp#5##1" = load i64, ptr %"tmp#19##0" + %"tmp#7##0" = icmp eq i64 %"i##0", 3 + br i1 %"tmp#7##0", label %if.then.1, label %if.else.1 +if.then.1: + tail call fastcc void @"stmt_for.using_next#cont#1<0>"(i64 %"tmp#5##1") + ret void +if.else.1: + call ccc void @print_int(i64 %"i##0") + call ccc void @putchar(i8 10) + tail call fastcc void @"stmt_for.using_next#cont#1<0>"(i64 %"tmp#5##1") + ret void +if.else.0: + ret void } - -define external fastcc void @"stmt_for.using_unless<0>"() { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 4, i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 0, i64* %5 - %6 = trunc i64 16 to i32 - %7 = tail call ccc i8* @wybe_malloc(i32 %6) - %8 = ptrtoint i8* %7 to i64 - %9 = inttoptr i64 %8 to i64* - store i64 3, i64* %9 - %10 = add i64 %8, 8 - %11 = inttoptr i64 %10 to i64* - store i64 %2, i64* %11 - %12 = trunc i64 16 to i32 - %13 = tail call ccc i8* @wybe_malloc(i32 %12) - %14 = ptrtoint i8* %13 to i64 - %15 = inttoptr i64 %14 to i64* - store i64 2, i64* %15 - %16 = add i64 %14, 8 - %17 = inttoptr i64 %16 to i64* - store i64 %8, i64* %17 - %18 = trunc i64 16 to i32 - %19 = tail call ccc i8* @wybe_malloc(i32 %18) - %20 = ptrtoint i8* %19 to i64 - %21 = inttoptr i64 %20 to i64* - store i64 1, i64* %21 - %22 = add i64 %20, 8 - %23 = inttoptr i64 %22 to i64* - store i64 %14, i64* %23 - tail call fastcc void @"stmt_for.using_unless#cont#1<0>"(i64 %20) - ret void +define external fastcc void @"stmt_for.using_unless<0>"() { + %"tmp#25##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#11##0" = ptrtoint ptr %"tmp#25##0" to i64 + %"tmp#26##0" = inttoptr i64 %"tmp#11##0" to ptr + store i64 4, ptr %"tmp#26##0" + %"tmp#27##0" = add i64 %"tmp#11##0", 8 + %"tmp#28##0" = inttoptr i64 %"tmp#27##0" to ptr + store i64 0, ptr %"tmp#28##0" + %"tmp#29##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#15##0" = ptrtoint ptr %"tmp#29##0" to i64 + %"tmp#30##0" = inttoptr i64 %"tmp#15##0" to ptr + store i64 3, ptr %"tmp#30##0" + %"tmp#31##0" = add i64 %"tmp#15##0", 8 + %"tmp#32##0" = inttoptr i64 %"tmp#31##0" to ptr + store i64 %"tmp#11##0", ptr %"tmp#32##0" + %"tmp#33##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#19##0" = ptrtoint ptr %"tmp#33##0" to i64 + %"tmp#34##0" = inttoptr i64 %"tmp#19##0" to ptr + store i64 2, ptr %"tmp#34##0" + %"tmp#35##0" = add i64 %"tmp#19##0", 8 + %"tmp#36##0" = inttoptr i64 %"tmp#35##0" to ptr + store i64 %"tmp#15##0", ptr %"tmp#36##0" + %"tmp#37##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#23##0" = ptrtoint ptr %"tmp#37##0" to i64 + %"tmp#38##0" = inttoptr i64 %"tmp#23##0" to ptr + store i64 1, ptr %"tmp#38##0" + %"tmp#39##0" = add i64 %"tmp#23##0", 8 + %"tmp#40##0" = inttoptr i64 %"tmp#39##0" to ptr + store i64 %"tmp#19##0", ptr %"tmp#40##0" + tail call fastcc void @"stmt_for.using_unless#cont#1<0>"(i64 %"tmp#23##0") + ret void } - -define external fastcc void @"stmt_for.using_unless#cont#1<0>"(i64 %"tmp#5##0") { -entry: - %0 = icmp ne i64 %"tmp#5##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"tmp#5##0" to i64* - %2 = load i64, i64* %1 - %3 = add i64 %"tmp#5##0", 8 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = icmp slt i64 %2, 3 - br i1 %6, label %if.then1, label %if.else1 -if.else: - ret void -if.then1: - musttail call fastcc void @"stmt_for.using_unless#cont#1<0>"(i64 %5) - ret void -if.else1: - tail call ccc void @print_int(i64 %2) - tail call ccc void @putchar(i8 10) - musttail call fastcc void @"stmt_for.using_unless#cont#1<0>"(i64 %5) - ret void +define external fastcc void @"stmt_for.using_unless#cont#1<0>"(i64 %"tmp#5##0") { + %"tmp#10##0" = icmp ne i64 %"tmp#5##0", 0 + br i1 %"tmp#10##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#17##0" = inttoptr i64 %"tmp#5##0" to ptr + %"i##0" = load i64, ptr %"tmp#17##0" + %"tmp#18##0" = add i64 %"tmp#5##0", 8 + %"tmp#19##0" = inttoptr i64 %"tmp#18##0" to ptr + %"tmp#5##1" = load i64, ptr %"tmp#19##0" + %"tmp#7##0" = icmp slt i64 %"i##0", 3 + br i1 %"tmp#7##0", label %if.then.1, label %if.else.1 +if.then.1: + tail call fastcc void @"stmt_for.using_unless#cont#1<0>"(i64 %"tmp#5##1") + ret void +if.else.1: + call ccc void @print_int(i64 %"i##0") + call ccc void @putchar(i8 10) + tail call fastcc void @"stmt_for.using_unless#cont#1<0>"(i64 %"tmp#5##1") + ret void +if.else.0: + ret void } - -define external fastcc void @"stmt_for.using_until<0>"() { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 4, i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 0, i64* %5 - %6 = trunc i64 16 to i32 - %7 = tail call ccc i8* @wybe_malloc(i32 %6) - %8 = ptrtoint i8* %7 to i64 - %9 = inttoptr i64 %8 to i64* - store i64 3, i64* %9 - %10 = add i64 %8, 8 - %11 = inttoptr i64 %10 to i64* - store i64 %2, i64* %11 - %12 = trunc i64 16 to i32 - %13 = tail call ccc i8* @wybe_malloc(i32 %12) - %14 = ptrtoint i8* %13 to i64 - %15 = inttoptr i64 %14 to i64* - store i64 2, i64* %15 - %16 = add i64 %14, 8 - %17 = inttoptr i64 %16 to i64* - store i64 %8, i64* %17 - %18 = trunc i64 16 to i32 - %19 = tail call ccc i8* @wybe_malloc(i32 %18) - %20 = ptrtoint i8* %19 to i64 - %21 = inttoptr i64 %20 to i64* - store i64 1, i64* %21 - %22 = add i64 %20, 8 - %23 = inttoptr i64 %22 to i64* - store i64 %14, i64* %23 - tail call fastcc void @"stmt_for.using_until#cont#1<0>"(i64 %20) - ret void +define external fastcc void @"stmt_for.using_until<0>"() { + %"tmp#25##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#11##0" = ptrtoint ptr %"tmp#25##0" to i64 + %"tmp#26##0" = inttoptr i64 %"tmp#11##0" to ptr + store i64 4, ptr %"tmp#26##0" + %"tmp#27##0" = add i64 %"tmp#11##0", 8 + %"tmp#28##0" = inttoptr i64 %"tmp#27##0" to ptr + store i64 0, ptr %"tmp#28##0" + %"tmp#29##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#15##0" = ptrtoint ptr %"tmp#29##0" to i64 + %"tmp#30##0" = inttoptr i64 %"tmp#15##0" to ptr + store i64 3, ptr %"tmp#30##0" + %"tmp#31##0" = add i64 %"tmp#15##0", 8 + %"tmp#32##0" = inttoptr i64 %"tmp#31##0" to ptr + store i64 %"tmp#11##0", ptr %"tmp#32##0" + %"tmp#33##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#19##0" = ptrtoint ptr %"tmp#33##0" to i64 + %"tmp#34##0" = inttoptr i64 %"tmp#19##0" to ptr + store i64 2, ptr %"tmp#34##0" + %"tmp#35##0" = add i64 %"tmp#19##0", 8 + %"tmp#36##0" = inttoptr i64 %"tmp#35##0" to ptr + store i64 %"tmp#15##0", ptr %"tmp#36##0" + %"tmp#37##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#23##0" = ptrtoint ptr %"tmp#37##0" to i64 + %"tmp#38##0" = inttoptr i64 %"tmp#23##0" to ptr + store i64 1, ptr %"tmp#38##0" + %"tmp#39##0" = add i64 %"tmp#23##0", 8 + %"tmp#40##0" = inttoptr i64 %"tmp#39##0" to ptr + store i64 %"tmp#19##0", ptr %"tmp#40##0" + tail call fastcc void @"stmt_for.using_until#cont#1<0>"(i64 %"tmp#23##0") + ret void } - -define external fastcc void @"stmt_for.using_until#cont#1<0>"(i64 %"tmp#5##0") { -entry: - %0 = icmp ne i64 %"tmp#5##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"tmp#5##0" to i64* - %2 = load i64, i64* %1 - %3 = add i64 %"tmp#5##0", 8 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = icmp eq i64 %2, 3 - br i1 %6, label %if.then1, label %if.else1 -if.else: - ret void -if.then1: - ret void -if.else1: - tail call ccc void @print_int(i64 %2) - tail call ccc void @putchar(i8 10) - musttail call fastcc void @"stmt_for.using_until#cont#1<0>"(i64 %5) - ret void +define external fastcc void @"stmt_for.using_until#cont#1<0>"(i64 %"tmp#5##0") { + %"tmp#10##0" = icmp ne i64 %"tmp#5##0", 0 + br i1 %"tmp#10##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#17##0" = inttoptr i64 %"tmp#5##0" to ptr + %"i##0" = load i64, ptr %"tmp#17##0" + %"tmp#18##0" = add i64 %"tmp#5##0", 8 + %"tmp#19##0" = inttoptr i64 %"tmp#18##0" to ptr + %"tmp#5##1" = load i64, ptr %"tmp#19##0" + %"tmp#7##0" = icmp eq i64 %"i##0", 3 + br i1 %"tmp#7##0", label %if.then.1, label %if.else.1 +if.then.1: + ret void +if.else.1: + call ccc void @print_int(i64 %"i##0") + call ccc void @putchar(i8 10) + tail call fastcc void @"stmt_for.using_until#cont#1<0>"(i64 %"tmp#5##1") + ret void +if.else.0: + ret void } - -define external fastcc void @"stmt_for.using_when<0>"() { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 4, i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 0, i64* %5 - %6 = trunc i64 16 to i32 - %7 = tail call ccc i8* @wybe_malloc(i32 %6) - %8 = ptrtoint i8* %7 to i64 - %9 = inttoptr i64 %8 to i64* - store i64 3, i64* %9 - %10 = add i64 %8, 8 - %11 = inttoptr i64 %10 to i64* - store i64 %2, i64* %11 - %12 = trunc i64 16 to i32 - %13 = tail call ccc i8* @wybe_malloc(i32 %12) - %14 = ptrtoint i8* %13 to i64 - %15 = inttoptr i64 %14 to i64* - store i64 2, i64* %15 - %16 = add i64 %14, 8 - %17 = inttoptr i64 %16 to i64* - store i64 %8, i64* %17 - %18 = trunc i64 16 to i32 - %19 = tail call ccc i8* @wybe_malloc(i32 %18) - %20 = ptrtoint i8* %19 to i64 - %21 = inttoptr i64 %20 to i64* - store i64 1, i64* %21 - %22 = add i64 %20, 8 - %23 = inttoptr i64 %22 to i64* - store i64 %14, i64* %23 - tail call fastcc void @"stmt_for.using_when#cont#1<0>"(i64 %20) - ret void +define external fastcc void @"stmt_for.using_when<0>"() { + %"tmp#25##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#11##0" = ptrtoint ptr %"tmp#25##0" to i64 + %"tmp#26##0" = inttoptr i64 %"tmp#11##0" to ptr + store i64 4, ptr %"tmp#26##0" + %"tmp#27##0" = add i64 %"tmp#11##0", 8 + %"tmp#28##0" = inttoptr i64 %"tmp#27##0" to ptr + store i64 0, ptr %"tmp#28##0" + %"tmp#29##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#15##0" = ptrtoint ptr %"tmp#29##0" to i64 + %"tmp#30##0" = inttoptr i64 %"tmp#15##0" to ptr + store i64 3, ptr %"tmp#30##0" + %"tmp#31##0" = add i64 %"tmp#15##0", 8 + %"tmp#32##0" = inttoptr i64 %"tmp#31##0" to ptr + store i64 %"tmp#11##0", ptr %"tmp#32##0" + %"tmp#33##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#19##0" = ptrtoint ptr %"tmp#33##0" to i64 + %"tmp#34##0" = inttoptr i64 %"tmp#19##0" to ptr + store i64 2, ptr %"tmp#34##0" + %"tmp#35##0" = add i64 %"tmp#19##0", 8 + %"tmp#36##0" = inttoptr i64 %"tmp#35##0" to ptr + store i64 %"tmp#15##0", ptr %"tmp#36##0" + %"tmp#37##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#23##0" = ptrtoint ptr %"tmp#37##0" to i64 + %"tmp#38##0" = inttoptr i64 %"tmp#23##0" to ptr + store i64 1, ptr %"tmp#38##0" + %"tmp#39##0" = add i64 %"tmp#23##0", 8 + %"tmp#40##0" = inttoptr i64 %"tmp#39##0" to ptr + store i64 %"tmp#19##0", ptr %"tmp#40##0" + tail call fastcc void @"stmt_for.using_when#cont#1<0>"(i64 %"tmp#23##0") + ret void } - -define external fastcc void @"stmt_for.using_when#cont#1<0>"(i64 %"tmp#5##0") { -entry: - %0 = icmp ne i64 %"tmp#5##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"tmp#5##0" to i64* - %2 = load i64, i64* %1 - %3 = add i64 %"tmp#5##0", 8 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = icmp slt i64 %2, 3 - br i1 %6, label %if.then1, label %if.else1 -if.else: - ret void -if.then1: - tail call ccc void @print_int(i64 %2) - tail call ccc void @putchar(i8 10) - musttail call fastcc void @"stmt_for.using_when#cont#1<0>"(i64 %5) - ret void -if.else1: - musttail call fastcc void @"stmt_for.using_when#cont#1<0>"(i64 %5) - ret void +define external fastcc void @"stmt_for.using_when#cont#1<0>"(i64 %"tmp#5##0") { + %"tmp#10##0" = icmp ne i64 %"tmp#5##0", 0 + br i1 %"tmp#10##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#17##0" = inttoptr i64 %"tmp#5##0" to ptr + %"i##0" = load i64, ptr %"tmp#17##0" + %"tmp#18##0" = add i64 %"tmp#5##0", 8 + %"tmp#19##0" = inttoptr i64 %"tmp#18##0" to ptr + %"tmp#5##1" = load i64, ptr %"tmp#19##0" + %"tmp#7##0" = icmp slt i64 %"i##0", 3 + br i1 %"tmp#7##0", label %if.then.1, label %if.else.1 +if.then.1: + call ccc void @print_int(i64 %"i##0") + call ccc void @putchar(i8 10) + tail call fastcc void @"stmt_for.using_when#cont#1<0>"(i64 %"tmp#5##1") + ret void +if.else.1: + tail call fastcc void @"stmt_for.using_when#cont#1<0>"(i64 %"tmp#5##1") + ret void +if.else.0: + ret void } - -define external fastcc void @"stmt_for.using_while<0>"() { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 4, i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 0, i64* %5 - %6 = trunc i64 16 to i32 - %7 = tail call ccc i8* @wybe_malloc(i32 %6) - %8 = ptrtoint i8* %7 to i64 - %9 = inttoptr i64 %8 to i64* - store i64 3, i64* %9 - %10 = add i64 %8, 8 - %11 = inttoptr i64 %10 to i64* - store i64 %2, i64* %11 - %12 = trunc i64 16 to i32 - %13 = tail call ccc i8* @wybe_malloc(i32 %12) - %14 = ptrtoint i8* %13 to i64 - %15 = inttoptr i64 %14 to i64* - store i64 2, i64* %15 - %16 = add i64 %14, 8 - %17 = inttoptr i64 %16 to i64* - store i64 %8, i64* %17 - %18 = trunc i64 16 to i32 - %19 = tail call ccc i8* @wybe_malloc(i32 %18) - %20 = ptrtoint i8* %19 to i64 - %21 = inttoptr i64 %20 to i64* - store i64 1, i64* %21 - %22 = add i64 %20, 8 - %23 = inttoptr i64 %22 to i64* - store i64 %14, i64* %23 - tail call fastcc void @"stmt_for.using_while#cont#1<0>"(i64 %20) - ret void +define external fastcc void @"stmt_for.using_while<0>"() { + %"tmp#25##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#11##0" = ptrtoint ptr %"tmp#25##0" to i64 + %"tmp#26##0" = inttoptr i64 %"tmp#11##0" to ptr + store i64 4, ptr %"tmp#26##0" + %"tmp#27##0" = add i64 %"tmp#11##0", 8 + %"tmp#28##0" = inttoptr i64 %"tmp#27##0" to ptr + store i64 0, ptr %"tmp#28##0" + %"tmp#29##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#15##0" = ptrtoint ptr %"tmp#29##0" to i64 + %"tmp#30##0" = inttoptr i64 %"tmp#15##0" to ptr + store i64 3, ptr %"tmp#30##0" + %"tmp#31##0" = add i64 %"tmp#15##0", 8 + %"tmp#32##0" = inttoptr i64 %"tmp#31##0" to ptr + store i64 %"tmp#11##0", ptr %"tmp#32##0" + %"tmp#33##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#19##0" = ptrtoint ptr %"tmp#33##0" to i64 + %"tmp#34##0" = inttoptr i64 %"tmp#19##0" to ptr + store i64 2, ptr %"tmp#34##0" + %"tmp#35##0" = add i64 %"tmp#19##0", 8 + %"tmp#36##0" = inttoptr i64 %"tmp#35##0" to ptr + store i64 %"tmp#15##0", ptr %"tmp#36##0" + %"tmp#37##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#23##0" = ptrtoint ptr %"tmp#37##0" to i64 + %"tmp#38##0" = inttoptr i64 %"tmp#23##0" to ptr + store i64 1, ptr %"tmp#38##0" + %"tmp#39##0" = add i64 %"tmp#23##0", 8 + %"tmp#40##0" = inttoptr i64 %"tmp#39##0" to ptr + store i64 %"tmp#19##0", ptr %"tmp#40##0" + tail call fastcc void @"stmt_for.using_while#cont#1<0>"(i64 %"tmp#23##0") + ret void } - -define external fastcc void @"stmt_for.using_while#cont#1<0>"(i64 %"tmp#5##0") { -entry: - %0 = icmp ne i64 %"tmp#5##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"tmp#5##0" to i64* - %2 = load i64, i64* %1 - %3 = add i64 %"tmp#5##0", 8 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = icmp slt i64 %2, 3 - br i1 %6, label %if.then1, label %if.else1 -if.else: - ret void -if.then1: - tail call ccc void @print_int(i64 %2) - tail call ccc void @putchar(i8 10) - musttail call fastcc void @"stmt_for.using_while#cont#1<0>"(i64 %5) - ret void -if.else1: - ret void +define external fastcc void @"stmt_for.using_while#cont#1<0>"(i64 %"tmp#5##0") { + %"tmp#10##0" = icmp ne i64 %"tmp#5##0", 0 + br i1 %"tmp#10##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#17##0" = inttoptr i64 %"tmp#5##0" to ptr + %"i##0" = load i64, ptr %"tmp#17##0" + %"tmp#18##0" = add i64 %"tmp#5##0", 8 + %"tmp#19##0" = inttoptr i64 %"tmp#18##0" to ptr + %"tmp#5##1" = load i64, ptr %"tmp#19##0" + %"tmp#7##0" = icmp slt i64 %"i##0", 3 + br i1 %"tmp#7##0", label %if.then.1, label %if.else.1 +if.then.1: + call ccc void @print_int(i64 %"i##0") + call ccc void @putchar(i8 10) + tail call fastcc void @"stmt_for.using_while#cont#1<0>"(i64 %"tmp#5##1") + ret void +if.else.1: + ret void +if.else.0: + ret void } - -define external fastcc void @"stmt_for.using_xrange<0>"() alwaysinline { -entry: - %0 = tail call fastcc i64 @"stmt_for.xrange<0>"(i64 1, i64 1, i64 10) - tail call fastcc void @"stmt_for.using_xrange#cont#1<0>"(i64 %0) - ret void +define external fastcc void @"stmt_for.using_xrange<0>"() { + %"tmp#1##0" = tail call fastcc i64 @"stmt_for.xrange<0>"(i64 1, i64 1, i64 10) + tail call fastcc void @"stmt_for.using_xrange#cont#1<0>"(i64 %"tmp#1##0") + ret void } - -define external fastcc void @"stmt_for.using_xrange#cont#1<0>"(i64 %"tmp#0##0") { -entry: - %0 = tail call fastcc {i64, i64, i1} @"stmt_for.int_sequence.[|]<0>"(i64 %"tmp#0##0") - %1 = extractvalue {i64, i64, i1} %0, 0 - %2 = extractvalue {i64, i64, i1} %0, 1 - %3 = extractvalue {i64, i64, i1} %0, 2 - br i1 %3, label %if.then, label %if.else -if.then: - tail call ccc void @print_int(i64 %1) - tail call ccc void @putchar(i8 10) - musttail call fastcc void @"stmt_for.using_xrange#cont#1<0>"(i64 %2) - ret void -if.else: - ret void +define external fastcc void @"stmt_for.using_xrange#cont#1<0>"(i64 %"tmp#0##0") { + %"tmp#8##0" = tail call fastcc {i64, i64, i1} @"stmt_for.int_sequence.[|]<0>"(i64 %"tmp#0##0") + %"i##0" = extractvalue {i64, i64, i1}%"tmp#8##0", 0 + %"tmp#0##1" = extractvalue {i64, i64, i1}%"tmp#8##0", 1 + %"tmp#3##0" = extractvalue {i64, i64, i1}%"tmp#8##0", 2 + br i1 %"tmp#3##0", label %if.then.0, label %if.else.0 +if.then.0: + call ccc void @print_int(i64 %"i##0") + call ccc void @putchar(i8 10) + tail call fastcc void @"stmt_for.using_xrange#cont#1<0>"(i64 %"tmp#0##1") + ret void +if.else.0: + ret void } - -define external fastcc void @"stmt_for.using_xrange_reverse<0>"() alwaysinline { -entry: - %0 = tail call fastcc i64 @"stmt_for.xrange<0>"(i64 10, i64 -1, i64 1) - tail call fastcc void @"stmt_for.using_xrange_reverse#cont#1<0>"(i64 %0) - ret void +define external fastcc void @"stmt_for.using_xrange_reverse<0>"() { + %"tmp#1##0" = tail call fastcc i64 @"stmt_for.xrange<0>"(i64 10, i64 -1, i64 1) + tail call fastcc void @"stmt_for.using_xrange_reverse#cont#1<0>"(i64 %"tmp#1##0") + ret void } - -define external fastcc void @"stmt_for.using_xrange_reverse#cont#1<0>"(i64 %"tmp#0##0") { -entry: - %0 = tail call fastcc {i64, i64, i1} @"stmt_for.int_sequence.[|]<0>"(i64 %"tmp#0##0") - %1 = extractvalue {i64, i64, i1} %0, 0 - %2 = extractvalue {i64, i64, i1} %0, 1 - %3 = extractvalue {i64, i64, i1} %0, 2 - br i1 %3, label %if.then, label %if.else -if.then: - tail call ccc void @print_int(i64 %1) - tail call ccc void @putchar(i8 10) - musttail call fastcc void @"stmt_for.using_xrange_reverse#cont#1<0>"(i64 %2) - ret void -if.else: - ret void +define external fastcc void @"stmt_for.using_xrange_reverse#cont#1<0>"(i64 %"tmp#0##0") { + %"tmp#8##0" = tail call fastcc {i64, i64, i1} @"stmt_for.int_sequence.[|]<0>"(i64 %"tmp#0##0") + %"i##0" = extractvalue {i64, i64, i1}%"tmp#8##0", 0 + %"tmp#0##1" = extractvalue {i64, i64, i1}%"tmp#8##0", 1 + %"tmp#3##0" = extractvalue {i64, i64, i1}%"tmp#8##0", 2 + br i1 %"tmp#3##0", label %if.then.0, label %if.else.0 +if.then.0: + call ccc void @print_int(i64 %"i##0") + call ccc void @putchar(i8 10) + tail call fastcc void @"stmt_for.using_xrange_reverse#cont#1<0>"(i64 %"tmp#0##1") + ret void +if.else.0: + ret void } - -define external fastcc i64 @"stmt_for.xrange<0>"(i64 %"start##0", i64 %"stride##0", i64 %"end##0") { -entry: - %0 = trunc i64 24 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"start##0", i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"stride##0", i64* %5 - %6 = add i64 %2, 16 - %7 = inttoptr i64 %6 to i64* - store i64 %"end##0", i64* %7 - ret i64 %2 +define external fastcc i64 @"stmt_for.xrange<0>"(i64 %"start##0", i64 %"stride##0", i64 %"end##0") { + %"tmp#8##0" = call ccc ptr @wybe_malloc(i32 24) + %"tmp#4##0" = ptrtoint ptr %"tmp#8##0" to i64 + %"tmp#9##0" = inttoptr i64 %"tmp#4##0" to ptr + store i64 %"start##0", ptr %"tmp#9##0" + %"tmp#10##0" = add i64 %"tmp#4##0", 8 + %"tmp#11##0" = inttoptr i64 %"tmp#10##0" to ptr + store i64 %"stride##0", ptr %"tmp#11##0" + %"tmp#12##0" = add i64 %"tmp#4##0", 16 + %"tmp#13##0" = inttoptr i64 %"tmp#12##0" to ptr + store i64 %"end##0", ptr %"tmp#13##0" + ret i64 %"tmp#4##0" } + -------------------------------------------------- Module stmt_for.int_sequence - representation : address + representation : pointer public submods : public resources: public procs : stmt_for.int_sequence.=<0> @@ -1837,259 +1678,223 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'stmt_for.int_sequence' - - - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i1 @"stmt_for.int_sequence.=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = add i64 %"#left##0", 16 - %6 = inttoptr i64 %5 to i64* - %7 = load i64, i64* %6 - %8 = inttoptr i64 %"#right##0" to i64* - %9 = load i64, i64* %8 - %10 = add i64 %"#right##0", 8 - %11 = inttoptr i64 %10 to i64* - %12 = load i64, i64* %11 - %13 = add i64 %"#right##0", 16 - %14 = inttoptr i64 %13 to i64* - %15 = load i64, i64* %14 - %16 = icmp eq i64 %1, %9 - br i1 %16, label %if.then, label %if.else -if.then: - %17 = icmp eq i64 %4, %12 - br i1 %17, label %if.then1, label %if.else1 -if.else: - ret i1 0 -if.then1: - %18 = icmp eq i64 %7, %15 - ret i1 %18 -if.else1: - ret i1 0 +source_filename = "!ROOT!/final-dump/stmt_for.wybe" +target triple ???? + + +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc i1 @"stmt_for.int_sequence.=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#12##0" = inttoptr i64 %"#left##0" to ptr + %"#left#start##0" = load i64, ptr %"tmp#12##0" + %"tmp#13##0" = add i64 %"#left##0", 8 + %"tmp#14##0" = inttoptr i64 %"tmp#13##0" to ptr + %"#left#stride##0" = load i64, ptr %"tmp#14##0" + %"tmp#15##0" = add i64 %"#left##0", 16 + %"tmp#16##0" = inttoptr i64 %"tmp#15##0" to ptr + %"#left#end##0" = load i64, ptr %"tmp#16##0" + %"tmp#17##0" = inttoptr i64 %"#right##0" to ptr + %"#right#start##0" = load i64, ptr %"tmp#17##0" + %"tmp#18##0" = add i64 %"#right##0", 8 + %"tmp#19##0" = inttoptr i64 %"tmp#18##0" to ptr + %"#right#stride##0" = load i64, ptr %"tmp#19##0" + %"tmp#20##0" = add i64 %"#right##0", 16 + %"tmp#21##0" = inttoptr i64 %"tmp#20##0" to ptr + %"#right#end##0" = load i64, ptr %"tmp#21##0" + %"tmp#1##0" = icmp eq i64 %"#left#start##0", %"#right#start##0" + br i1 %"tmp#1##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = icmp eq i64 %"#left#stride##0", %"#right#stride##0" + br i1 %"tmp#2##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#22##0" = icmp eq i64 %"#left#end##0", %"#right#end##0" + ret i1 %"tmp#22##0" +if.else.1: + ret i1 0 +if.else.0: + ret i1 0 } - -define external fastcc {i64, i64, i1} @"stmt_for.int_sequence.[|]<0>"(i64 %"current##0") { -entry: - %0 = inttoptr i64 %"current##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"current##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = add i64 %"current##0", 16 - %6 = inttoptr i64 %5 to i64* - %7 = load i64, i64* %6 - %8 = icmp slt i64 %4, 0 - br i1 %8, label %if.then, label %if.else -if.then: - %9 = icmp slt i64 %7, %1 - br i1 %9, label %if.then1, label %if.else1 -if.else: - %20 = icmp sgt i64 %7, %1 - br i1 %20, label %if.then2, label %if.else2 -if.then1: - %10 = tail call fastcc {i64, i64, i1} @"stmt_for.int_sequence.[|]#cont#1<0>"(i64 %7, i64 %1, i64 %4) - %11 = extractvalue {i64, i64, i1} %10, 0 - %12 = extractvalue {i64, i64, i1} %10, 1 - %13 = extractvalue {i64, i64, i1} %10, 2 - %14 = insertvalue {i64, i64, i1} undef, i64 %11, 0 - %15 = insertvalue {i64, i64, i1} %14, i64 %12, 1 - %16 = insertvalue {i64, i64, i1} %15, i1 %13, 2 - ret {i64, i64, i1} %16 -if.else1: - %17 = insertvalue {i64, i64, i1} undef, i64 undef, 0 - %18 = insertvalue {i64, i64, i1} %17, i64 undef, 1 - %19 = insertvalue {i64, i64, i1} %18, i1 0, 2 - ret {i64, i64, i1} %19 -if.then2: - %21 = tail call fastcc {i64, i64, i1} @"stmt_for.int_sequence.[|]#cont#1<0>"(i64 %7, i64 %1, i64 %4) - %22 = extractvalue {i64, i64, i1} %21, 0 - %23 = extractvalue {i64, i64, i1} %21, 1 - %24 = extractvalue {i64, i64, i1} %21, 2 - %25 = insertvalue {i64, i64, i1} undef, i64 %22, 0 - %26 = insertvalue {i64, i64, i1} %25, i64 %23, 1 - %27 = insertvalue {i64, i64, i1} %26, i1 %24, 2 - ret {i64, i64, i1} %27 -if.else2: - %28 = insertvalue {i64, i64, i1} undef, i64 undef, 0 - %29 = insertvalue {i64, i64, i1} %28, i64 undef, 1 - %30 = insertvalue {i64, i64, i1} %29, i1 0, 2 - ret {i64, i64, i1} %30 +define external fastcc {i64, i64, i1} @"stmt_for.int_sequence.[|]<0>"(i64 %"current##0") { + %"tmp#12##0" = inttoptr i64 %"current##0" to ptr + %"s##0" = load i64, ptr %"tmp#12##0" + %"tmp#13##0" = add i64 %"current##0", 8 + %"tmp#14##0" = inttoptr i64 %"tmp#13##0" to ptr + %"st##0" = load i64, ptr %"tmp#14##0" + %"tmp#15##0" = add i64 %"current##0", 16 + %"tmp#16##0" = inttoptr i64 %"tmp#15##0" to ptr + %"en##0" = load i64, ptr %"tmp#16##0" + %"tmp#4##0" = icmp slt i64 %"st##0", 0 + br i1 %"tmp#4##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = icmp slt i64 %"en##0", %"s##0" + br i1 %"tmp#2##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#17##0" = tail call fastcc {i64, i64, i1} @"stmt_for.int_sequence.[|]#cont#1<0>"(i64 %"en##0", i64 %"s##0", i64 %"st##0") + %"tmp#18##0" = extractvalue {i64, i64, i1}%"tmp#17##0", 0 + %"tmp#19##0" = extractvalue {i64, i64, i1}%"tmp#17##0", 1 + %"tmp#20##0" = extractvalue {i64, i64, i1}%"tmp#17##0", 2 + %"tmp#21##0" = insertvalue {i64, i64, i1} undef, i64 %"tmp#18##0", 0 + %"tmp#22##0" = insertvalue {i64, i64, i1} %"tmp#21##0", i64 %"tmp#19##0", 1 + %"tmp#23##0" = insertvalue {i64, i64, i1} %"tmp#22##0", i1 %"tmp#20##0", 2 + ret {i64, i64, i1} %"tmp#23##0" +if.else.1: + %"tmp#24##0" = insertvalue {i64, i64, i1} undef, i64 undef, 0 + %"tmp#25##0" = insertvalue {i64, i64, i1} %"tmp#24##0", i64 undef, 1 + %"tmp#26##0" = insertvalue {i64, i64, i1} %"tmp#25##0", i1 0, 2 + ret {i64, i64, i1} %"tmp#26##0" +if.else.0: + %"tmp#3##0" = icmp sgt i64 %"en##0", %"s##0" + br i1 %"tmp#3##0", label %if.then.2, label %if.else.2 +if.then.2: + %"tmp#27##0" = tail call fastcc {i64, i64, i1} @"stmt_for.int_sequence.[|]#cont#1<0>"(i64 %"en##0", i64 %"s##0", i64 %"st##0") + %"tmp#28##0" = extractvalue {i64, i64, i1}%"tmp#27##0", 0 + %"tmp#29##0" = extractvalue {i64, i64, i1}%"tmp#27##0", 1 + %"tmp#30##0" = extractvalue {i64, i64, i1}%"tmp#27##0", 2 + %"tmp#31##0" = insertvalue {i64, i64, i1} undef, i64 %"tmp#28##0", 0 + %"tmp#32##0" = insertvalue {i64, i64, i1} %"tmp#31##0", i64 %"tmp#29##0", 1 + %"tmp#33##0" = insertvalue {i64, i64, i1} %"tmp#32##0", i1 %"tmp#30##0", 2 + ret {i64, i64, i1} %"tmp#33##0" +if.else.2: + %"tmp#34##0" = insertvalue {i64, i64, i1} undef, i64 undef, 0 + %"tmp#35##0" = insertvalue {i64, i64, i1} %"tmp#34##0", i64 undef, 1 + %"tmp#36##0" = insertvalue {i64, i64, i1} %"tmp#35##0", i1 0, 2 + ret {i64, i64, i1} %"tmp#36##0" } - -define external fastcc {i64, i64, i1} @"stmt_for.int_sequence.[|]#cont#1<0>"(i64 %"en##0", i64 %"s##0", i64 %"st##0") { -entry: - %0 = add i64 %"s##0", %"st##0" - %1 = trunc i64 24 to i32 - %2 = tail call ccc i8* @wybe_malloc(i32 %1) - %3 = ptrtoint i8* %2 to i64 - %4 = inttoptr i64 %3 to i64* - store i64 %0, i64* %4 - %5 = add i64 %3, 8 - %6 = inttoptr i64 %5 to i64* - store i64 %"st##0", i64* %6 - %7 = add i64 %3, 16 - %8 = inttoptr i64 %7 to i64* - store i64 %"en##0", i64* %8 - %9 = insertvalue {i64, i64, i1} undef, i64 %"s##0", 0 - %10 = insertvalue {i64, i64, i1} %9, i64 %3, 1 - %11 = insertvalue {i64, i64, i1} %10, i1 1, 2 - ret {i64, i64, i1} %11 +define external fastcc {i64, i64, i1} @"stmt_for.int_sequence.[|]#cont#1<0>"(i64 %"en##0", i64 %"s##0", i64 %"st##0") { + %"tmp#1##0" = add i64 %"s##0", %"st##0" + %"tmp#10##0" = call ccc ptr @wybe_malloc(i32 24) + %"tmp#7##0" = ptrtoint ptr %"tmp#10##0" to i64 + %"tmp#11##0" = inttoptr i64 %"tmp#7##0" to ptr + store i64 %"tmp#1##0", ptr %"tmp#11##0" + %"tmp#12##0" = add i64 %"tmp#7##0", 8 + %"tmp#13##0" = inttoptr i64 %"tmp#12##0" to ptr + store i64 %"st##0", ptr %"tmp#13##0" + %"tmp#14##0" = add i64 %"tmp#7##0", 16 + %"tmp#15##0" = inttoptr i64 %"tmp#14##0" to ptr + store i64 %"en##0", ptr %"tmp#15##0" + %"tmp#16##0" = insertvalue {i64, i64, i1} undef, i64 %"s##0", 0 + %"tmp#17##0" = insertvalue {i64, i64, i1} %"tmp#16##0", i64 %"tmp#7##0", 1 + %"tmp#18##0" = insertvalue {i64, i64, i1} %"tmp#17##0", i1 1, 2 + ret {i64, i64, i1} %"tmp#18##0" } - -define external fastcc i64 @"stmt_for.int_sequence.end<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = add i64 %"#rec##0", 16 - %1 = inttoptr i64 %0 to i64* - %2 = load i64, i64* %1 - ret i64 %2 +define external fastcc i64 @"stmt_for.int_sequence.end<0>"(i64 %"#rec##0") { + %"tmp#0##0" = add i64 %"#rec##0", 16 + %"tmp#1##0" = inttoptr i64 %"tmp#0##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"stmt_for.int_sequence.end<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 24 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 24 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = add i64 %2, 16 - %7 = inttoptr i64 %6 to i64* - store i64 %"#field##0", i64* %7 - ret i64 %2 +define external fastcc i64 @"stmt_for.int_sequence.end<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 24) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 24, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = add i64 %"tmp#2##0", 16 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 %"#field##0", ptr %"tmp#4##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"stmt_for.int_sequence.int_sequence<0>"(i64 %"start##0", i64 %"stride##0", i64 %"end##0") alwaysinline { -entry: - %0 = trunc i64 24 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"start##0", i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"stride##0", i64* %5 - %6 = add i64 %2, 16 - %7 = inttoptr i64 %6 to i64* - store i64 %"end##0", i64* %7 - ret i64 %2 +define external fastcc i64 @"stmt_for.int_sequence.int_sequence<0>"(i64 %"start##0", i64 %"stride##0", i64 %"end##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 24) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"start##0", ptr %"tmp#1##0" + %"tmp#2##0" = add i64 %"#rec##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"stride##0", ptr %"tmp#3##0" + %"tmp#4##0" = add i64 %"#rec##0", 16 + %"tmp#5##0" = inttoptr i64 %"tmp#4##0" to ptr + store i64 %"end##0", ptr %"tmp#5##0" + ret i64 %"#rec##0" } - -define external fastcc {i64, i64, i64} @"stmt_for.int_sequence.int_sequence<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#result##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#result##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = add i64 %"#result##0", 16 - %6 = inttoptr i64 %5 to i64* - %7 = load i64, i64* %6 - %8 = insertvalue {i64, i64, i64} undef, i64 %1, 0 - %9 = insertvalue {i64, i64, i64} %8, i64 %4, 1 - %10 = insertvalue {i64, i64, i64} %9, i64 %7, 2 - ret {i64, i64, i64} %10 +define external fastcc {i64, i64, i64} @"stmt_for.int_sequence.int_sequence<1>"(i64 %"#result##0") { + %"tmp#0##0" = inttoptr i64 %"#result##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + %"tmp#2##0" = add i64 %"#result##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#3##0" + %"tmp#5##0" = add i64 %"#result##0", 16 + %"tmp#6##0" = inttoptr i64 %"tmp#5##0" to ptr + %"tmp#7##0" = load i64, ptr %"tmp#6##0" + %"tmp#8##0" = insertvalue {i64, i64, i64} undef, i64 %"tmp#1##0", 0 + %"tmp#9##0" = insertvalue {i64, i64, i64} %"tmp#8##0", i64 %"tmp#4##0", 1 + %"tmp#10##0" = insertvalue {i64, i64, i64} %"tmp#9##0", i64 %"tmp#7##0", 2 + ret {i64, i64, i64} %"tmp#10##0" } - -define external fastcc i64 @"stmt_for.int_sequence.start<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#rec##0" to i64* - %1 = load i64, i64* %0 - ret i64 %1 +define external fastcc i64 @"stmt_for.int_sequence.start<0>"(i64 %"#rec##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + ret i64 %"tmp#1##0" } - -define external fastcc i64 @"stmt_for.int_sequence.start<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 24 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 24 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = inttoptr i64 %2 to i64* - store i64 %"#field##0", i64* %6 - ret i64 %2 +define external fastcc i64 @"stmt_for.int_sequence.start<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 24) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 24, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"#field##0", ptr %"tmp#3##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"stmt_for.int_sequence.stride<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = add i64 %"#rec##0", 8 - %1 = inttoptr i64 %0 to i64* - %2 = load i64, i64* %1 - ret i64 %2 +define external fastcc i64 @"stmt_for.int_sequence.stride<0>"(i64 %"#rec##0") { + %"tmp#0##0" = add i64 %"#rec##0", 8 + %"tmp#1##0" = inttoptr i64 %"tmp#0##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"stmt_for.int_sequence.stride<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 24 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 24 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = add i64 %2, 8 - %7 = inttoptr i64 %6 to i64* - store i64 %"#field##0", i64* %7 - ret i64 %2 +define external fastcc i64 @"stmt_for.int_sequence.stride<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 24) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 24, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = add i64 %"tmp#2##0", 8 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 %"#field##0", ptr %"tmp#4##0" + ret i64 %"tmp#2##0" } - -define external fastcc i1 @"stmt_for.int_sequence.~=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = add i64 %"#left##0", 16 - %6 = inttoptr i64 %5 to i64* - %7 = load i64, i64* %6 - %8 = inttoptr i64 %"#right##0" to i64* - %9 = load i64, i64* %8 - %10 = add i64 %"#right##0", 8 - %11 = inttoptr i64 %10 to i64* - %12 = load i64, i64* %11 - %13 = add i64 %"#right##0", 16 - %14 = inttoptr i64 %13 to i64* - %15 = load i64, i64* %14 - %16 = icmp eq i64 %1, %9 - br i1 %16, label %if.then, label %if.else -if.then: - %17 = icmp eq i64 %4, %12 - br i1 %17, label %if.then1, label %if.else1 -if.else: - %21 = xor i1 0, 1 - ret i1 %21 -if.then1: - %18 = icmp eq i64 %7, %15 - %19 = xor i1 %18, 1 - ret i1 %19 -if.else1: - %20 = xor i1 0, 1 - ret i1 %20 +define external fastcc i1 @"stmt_for.int_sequence.~=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#11##0" = inttoptr i64 %"#left##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#11##0" + %"tmp#12##0" = add i64 %"#left##0", 8 + %"tmp#13##0" = inttoptr i64 %"tmp#12##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#13##0" + %"tmp#14##0" = add i64 %"#left##0", 16 + %"tmp#15##0" = inttoptr i64 %"tmp#14##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#15##0" + %"tmp#16##0" = inttoptr i64 %"#right##0" to ptr + %"tmp#6##0" = load i64, ptr %"tmp#16##0" + %"tmp#17##0" = add i64 %"#right##0", 8 + %"tmp#18##0" = inttoptr i64 %"tmp#17##0" to ptr + %"tmp#7##0" = load i64, ptr %"tmp#18##0" + %"tmp#19##0" = add i64 %"#right##0", 16 + %"tmp#20##0" = inttoptr i64 %"tmp#19##0" to ptr + %"tmp#8##0" = load i64, ptr %"tmp#20##0" + %"tmp#9##0" = icmp eq i64 %"tmp#3##0", %"tmp#6##0" + br i1 %"tmp#9##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#10##0" = icmp eq i64 %"tmp#4##0", %"tmp#7##0" + br i1 %"tmp#10##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#0##0" = icmp eq i64 %"tmp#5##0", %"tmp#8##0" + %"tmp#21##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#21##0" +if.else.1: + %"tmp#22##0" = xor i1 0, 1 + ret i1 %"tmp#22##0" +if.else.0: + %"tmp#23##0" = xor i1 0, 1 + ret i1 %"tmp#23##0" } diff --git a/test-cases/final-dump/stmt_if.exp b/test-cases/final-dump/stmt_if.exp index 865cd4a81..470573360 100644 --- a/test-cases/final-dump/stmt_if.exp +++ b/test-cases/final-dump/stmt_if.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module stmt_if representation : (not a type) public submods : tree -> stmt_if.tree @@ -103,123 +106,96 @@ lookup(key##0:wybe.int, tree##0:stmt_if.tree, ?result##0:wybe.bool)<{}; {}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'stmt_if' - - - - -@stmt_if.5 = constant {i64, i64} { i64 27, i64 ptrtoint ([?? x i8]* @stmt_if.4 to i64) } - - -@stmt_if.1 = constant {i64, i64} { i64 30, i64 ptrtoint ([?? x i8]* @stmt_if.0 to i64) } - - -@stmt_if.3 = constant {i64, i64} { i64 35, i64 ptrtoint ([?? x i8]* @stmt_if.2 to i64) } - - -@stmt_if.7 = constant {i64, i64} { i64 35, i64 ptrtoint ([?? x i8]* @stmt_if.6 to i64) } - - -@stmt_if.4 = constant [?? x i8] c"lookup fails when it should\00" - - -@stmt_if.2 = constant [?? x i8] c"lookup fails when it should succeed\00" - - -@stmt_if.0 = constant [?? x i8] c"lookup succeeds when it should\00" - - -@stmt_if.6 = constant [?? x i8] c"lookup succeeds when it should fail\00" - - -declare external ccc void @putchar(i8) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"stmt_if.foobar<0>"() { -entry: - %0 = trunc i64 24 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 0, i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 1, i64* %5 - %6 = add i64 %2, 16 - %7 = inttoptr i64 %6 to i64* - store i64 0, i64* %7 - %8 = tail call fastcc i1 @"stmt_if.lookup<0>"(i64 1, i64 %2) - br i1 %8, label %if.then, label %if.else -if.then: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @stmt_if.1, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"stmt_if.foobar#cont#1<0>"(i64 %2) - ret void -if.else: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @stmt_if.3, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"stmt_if.foobar#cont#1<0>"(i64 %2) - ret void +source_filename = "!ROOT!/final-dump/stmt_if.wybe" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c"lookup fails when it should\00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c"lookup fails when it should succeed\00", align 8 +@"cstring#2" = private unnamed_addr constant [ ?? x i8 ] c"lookup succeeds when it should\00", align 8 +@"cstring#3" = private unnamed_addr constant [ ?? x i8 ] c"lookup succeeds when it should fail\00", align 8 +@"string#4" = private unnamed_addr constant {i64, i64} { i64 27, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +@"string#5" = private unnamed_addr constant {i64, i64} { i64 35, i64 ptrtoint( ptr @"cstring#1" to i64 ) }, align 8 +@"string#6" = private unnamed_addr constant {i64, i64} { i64 30, i64 ptrtoint( ptr @"cstring#2" to i64 ) }, align 8 +@"string#7" = private unnamed_addr constant {i64, i64} { i64 35, i64 ptrtoint( ptr @"cstring#3" to i64 ) }, align 8 + +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @putchar(i8) +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"stmt_if.foobar<0>"() { + %"tmp#18##0" = call ccc ptr @wybe_malloc(i32 24) + %"tmp#8##0" = ptrtoint ptr %"tmp#18##0" to i64 + %"tmp#19##0" = inttoptr i64 %"tmp#8##0" to ptr + store i64 0, ptr %"tmp#19##0" + %"tmp#20##0" = add i64 %"tmp#8##0", 8 + %"tmp#21##0" = inttoptr i64 %"tmp#20##0" to ptr + store i64 1, ptr %"tmp#21##0" + %"tmp#22##0" = add i64 %"tmp#8##0", 16 + %"tmp#23##0" = inttoptr i64 %"tmp#22##0" to ptr + store i64 0, ptr %"tmp#23##0" + %"tmp#4##0" = tail call fastcc i1 @"stmt_if.lookup<0>"(i64 1, i64 %"tmp#8##0") + br i1 %"tmp#4##0", label %if.then.0, label %if.else.0 +if.then.0: + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#6" to i64 )) + call ccc void @putchar(i8 10) + tail call fastcc void @"stmt_if.foobar#cont#1<0>"(i64 %"tmp#8##0") + ret void +if.else.0: + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#5" to i64 )) + call ccc void @putchar(i8 10) + tail call fastcc void @"stmt_if.foobar#cont#1<0>"(i64 %"tmp#8##0") + ret void } - -define external fastcc void @"stmt_if.foobar#cont#1<0>"(i64 %"tr##0") { -entry: - %0 = tail call fastcc i1 @"stmt_if.lookup<0>"(i64 3, i64 %"tr##0") - br i1 %0, label %if.then, label %if.else -if.then: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @stmt_if.5, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - ret void -if.else: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @stmt_if.7, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"stmt_if.foobar#cont#1<0>"(i64 %"tr##0") { + %"tmp#3##0" = tail call fastcc i1 @"stmt_if.lookup<0>"(i64 3, i64 %"tr##0") + br i1 %"tmp#3##0", label %if.then.0, label %if.else.0 +if.then.0: + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#4" to i64 )) + call ccc void @putchar(i8 10) + ret void +if.else.0: + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#7" to i64 )) + call ccc void @putchar(i8 10) + ret void } - -define external fastcc i1 @"stmt_if.lookup<0>"(i64 %"key##0", i64 %"tree##0") { -entry: - %0 = icmp ne i64 %"tree##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"tree##0" to i64* - %2 = load i64, i64* %1 - %3 = add i64 %"tree##0", 8 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = add i64 %"tree##0", 16 - %7 = inttoptr i64 %6 to i64* - %8 = load i64, i64* %7 - %9 = icmp eq i64 %"key##0", %5 - br i1 %9, label %if.then1, label %if.else1 -if.else: - ret i1 0 -if.then1: - ret i1 1 -if.else1: - %10 = icmp slt i64 %"key##0", %5 - br i1 %10, label %if.then2, label %if.else2 -if.then2: - %11 = musttail call fastcc i1 @"stmt_if.lookup<0>"(i64 %"key##0", i64 %2) - ret i1 %11 -if.else2: - %12 = musttail call fastcc i1 @"stmt_if.lookup<0>"(i64 %"key##0", i64 %8) - ret i1 %12 +define external fastcc i1 @"stmt_if.lookup<0>"(i64 %"key##0", i64 %"tree##0") { + %"tmp#6##0" = icmp ne i64 %"tree##0", 0 + br i1 %"tmp#6##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#11##0" = inttoptr i64 %"tree##0" to ptr + %"left##0" = load i64, ptr %"tmp#11##0" + %"tmp#12##0" = add i64 %"tree##0", 8 + %"tmp#13##0" = inttoptr i64 %"tmp#12##0" to ptr + %"nodekey##0" = load i64, ptr %"tmp#13##0" + %"tmp#14##0" = add i64 %"tree##0", 16 + %"tmp#15##0" = inttoptr i64 %"tmp#14##0" to ptr + %"right##0" = load i64, ptr %"tmp#15##0" + %"tmp#3##0" = icmp eq i64 %"key##0", %"nodekey##0" + br i1 %"tmp#3##0", label %if.then.1, label %if.else.1 +if.then.1: + ret i1 1 +if.else.1: + %"tmp#2##0" = icmp slt i64 %"key##0", %"nodekey##0" + br i1 %"tmp#2##0", label %if.then.2, label %if.else.2 +if.then.2: + %"tmp#16##0" = tail call fastcc i1 @"stmt_if.lookup<0>"(i64 %"key##0", i64 %"left##0") + ret i1 %"tmp#16##0" +if.else.2: + %"tmp#17##0" = tail call fastcc i1 @"stmt_if.lookup<0>"(i64 %"key##0", i64 %"right##0") + ret i1 %"tmp#17##0" +if.else.0: + ret i1 0 } + -------------------------------------------------- Module stmt_if.tree - representation : address + representation : pointer public submods : public resources: public procs : stmt_if.tree.=<0> @@ -424,242 +400,209 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'stmt_if.tree' - - - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i1 @"stmt_if.tree.=<0>"(i64 %"#left##0", i64 %"#right##0") { -entry: - %0 = icmp ne i64 %"#left##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"#left##0" to i64* - %2 = load i64, i64* %1 - %3 = add i64 %"#left##0", 8 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = add i64 %"#left##0", 16 - %7 = inttoptr i64 %6 to i64* - %8 = load i64, i64* %7 - %9 = icmp ne i64 %"#right##0", 0 - br i1 %9, label %if.then1, label %if.else1 -if.else: - %21 = icmp eq i64 %"#right##0", 0 - ret i1 %21 -if.then1: - %10 = inttoptr i64 %"#right##0" to i64* - %11 = load i64, i64* %10 - %12 = add i64 %"#right##0", 8 - %13 = inttoptr i64 %12 to i64* - %14 = load i64, i64* %13 - %15 = add i64 %"#right##0", 16 - %16 = inttoptr i64 %15 to i64* - %17 = load i64, i64* %16 - %18 = tail call fastcc i1 @"stmt_if.tree.=<0>"(i64 %2, i64 %11) - br i1 %18, label %if.then2, label %if.else2 -if.else1: - ret i1 0 -if.then2: - %19 = icmp eq i64 %5, %14 - br i1 %19, label %if.then3, label %if.else3 -if.else2: - ret i1 0 -if.then3: - %20 = musttail call fastcc i1 @"stmt_if.tree.=<0>"(i64 %8, i64 %17) - ret i1 %20 -if.else3: - ret i1 0 +source_filename = "!ROOT!/final-dump/stmt_if.wybe" +target triple ???? + + +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc i1 @"stmt_if.tree.=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#0##0" = icmp ne i64 %"#left##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#13##0" = inttoptr i64 %"#left##0" to ptr + %"#left#left##0" = load i64, ptr %"tmp#13##0" + %"tmp#14##0" = add i64 %"#left##0", 8 + %"tmp#15##0" = inttoptr i64 %"tmp#14##0" to ptr + %"#left#key##0" = load i64, ptr %"tmp#15##0" + %"tmp#16##0" = add i64 %"#left##0", 16 + %"tmp#17##0" = inttoptr i64 %"tmp#16##0" to ptr + %"#left#right##0" = load i64, ptr %"tmp#17##0" + %"tmp#10##0" = icmp ne i64 %"#right##0", 0 + br i1 %"tmp#10##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#18##0" = inttoptr i64 %"#right##0" to ptr + %"#right#left##0" = load i64, ptr %"tmp#18##0" + %"tmp#19##0" = add i64 %"#right##0", 8 + %"tmp#20##0" = inttoptr i64 %"tmp#19##0" to ptr + %"#right#key##0" = load i64, ptr %"tmp#20##0" + %"tmp#21##0" = add i64 %"#right##0", 16 + %"tmp#22##0" = inttoptr i64 %"tmp#21##0" to ptr + %"#right#right##0" = load i64, ptr %"tmp#22##0" + %"tmp#4##0" = tail call fastcc i1 @"stmt_if.tree.=<0>"(i64 %"#left#left##0", i64 %"#right#left##0") + br i1 %"tmp#4##0", label %if.then.2, label %if.else.2 +if.then.2: + %"tmp#5##0" = icmp eq i64 %"#left#key##0", %"#right#key##0" + br i1 %"tmp#5##0", label %if.then.3, label %if.else.3 +if.then.3: + %"tmp#23##0" = tail call fastcc i1 @"stmt_if.tree.=<0>"(i64 %"#left#right##0", i64 %"#right#right##0") + ret i1 %"tmp#23##0" +if.else.3: + ret i1 0 +if.else.2: + ret i1 0 +if.else.1: + ret i1 0 +if.else.0: + %"tmp#24##0" = icmp eq i64 %"#right##0", 0 + ret i1 %"tmp#24##0" } - -define external fastcc i64 @"stmt_if.tree.empty<0>"() alwaysinline { -entry: - ret i64 0 +define external fastcc i64 @"stmt_if.tree.empty<0>"() { + ret i64 0 } - -define external fastcc {i64, i1} @"stmt_if.tree.key<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = add i64 %"#rec##0", 8 - %2 = inttoptr i64 %1 to i64* - %3 = load i64, i64* %2 - %4 = insertvalue {i64, i1} undef, i64 %3, 0 - %5 = insertvalue {i64, i1} %4, i1 1, 1 - ret {i64, i1} %5 -if.else: - %6 = insertvalue {i64, i1} undef, i64 undef, 0 - %7 = insertvalue {i64, i1} %6, i1 0, 1 - ret {i64, i1} %7 +define external fastcc {i64, i1} @"stmt_if.tree.key<0>"(i64 %"#rec##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = add i64 %"#rec##0", 8 + %"tmp#2##0" = inttoptr i64 %"tmp#1##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#2##0" + %"tmp#4##0" = insertvalue {i64, i1} undef, i64 %"tmp#3##0", 0 + %"tmp#5##0" = insertvalue {i64, i1} %"tmp#4##0", i1 1, 1 + ret {i64, i1} %"tmp#5##0" +if.else.0: + %"tmp#6##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#7##0" = insertvalue {i64, i1} %"tmp#6##0", i1 0, 1 + ret {i64, i1} %"tmp#7##0" } - -define external fastcc {i64, i1} @"stmt_if.tree.key<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = trunc i64 24 to i32 - %2 = tail call ccc i8* @wybe_malloc(i32 %1) - %3 = ptrtoint i8* %2 to i64 - %4 = inttoptr i64 %3 to i8* - %5 = inttoptr i64 %"#rec##0" to i8* - %6 = trunc i64 24 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %4, i8* %5, i32 %6, i1 0) - %7 = add i64 %3, 8 - %8 = inttoptr i64 %7 to i64* - store i64 %"#field##0", i64* %8 - %9 = insertvalue {i64, i1} undef, i64 %3, 0 - %10 = insertvalue {i64, i1} %9, i1 1, 1 - ret {i64, i1} %10 -if.else: - %11 = insertvalue {i64, i1} undef, i64 0, 0 - %12 = insertvalue {i64, i1} %11, i1 0, 1 - ret {i64, i1} %12 +define external fastcc {i64, i1} @"stmt_if.tree.key<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#2##0" = call ccc ptr @wybe_malloc(i32 24) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#2##0", ptr %"tmp#1##0", i64 24, i1 0) + %"tmp#3##0" = ptrtoint ptr %"tmp#2##0" to i64 + %"tmp#4##0" = add i64 %"tmp#3##0", 8 + %"tmp#5##0" = inttoptr i64 %"tmp#4##0" to ptr + store i64 %"#field##0", ptr %"tmp#5##0" + %"tmp#6##0" = insertvalue {i64, i1} undef, i64 %"tmp#3##0", 0 + %"tmp#7##0" = insertvalue {i64, i1} %"tmp#6##0", i1 1, 1 + ret {i64, i1} %"tmp#7##0" +if.else.0: + %"tmp#8##0" = insertvalue {i64, i1} undef, i64 0, 0 + %"tmp#9##0" = insertvalue {i64, i1} %"tmp#8##0", i1 0, 1 + ret {i64, i1} %"tmp#9##0" } - -define external fastcc {i64, i1} @"stmt_if.tree.left<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"#rec##0" to i64* - %2 = load i64, i64* %1 - %3 = insertvalue {i64, i1} undef, i64 %2, 0 - %4 = insertvalue {i64, i1} %3, i1 1, 1 - ret {i64, i1} %4 -if.else: - %5 = insertvalue {i64, i1} undef, i64 undef, 0 - %6 = insertvalue {i64, i1} %5, i1 0, 1 - ret {i64, i1} %6 +define external fastcc {i64, i1} @"stmt_if.tree.left<0>"(i64 %"#rec##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + %"tmp#3##0" = insertvalue {i64, i1} undef, i64 %"tmp#2##0", 0 + %"tmp#4##0" = insertvalue {i64, i1} %"tmp#3##0", i1 1, 1 + ret {i64, i1} %"tmp#4##0" +if.else.0: + %"tmp#5##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#6##0" = insertvalue {i64, i1} %"tmp#5##0", i1 0, 1 + ret {i64, i1} %"tmp#6##0" } - -define external fastcc {i64, i1} @"stmt_if.tree.left<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = trunc i64 24 to i32 - %2 = tail call ccc i8* @wybe_malloc(i32 %1) - %3 = ptrtoint i8* %2 to i64 - %4 = inttoptr i64 %3 to i8* - %5 = inttoptr i64 %"#rec##0" to i8* - %6 = trunc i64 24 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %4, i8* %5, i32 %6, i1 0) - %7 = inttoptr i64 %3 to i64* - store i64 %"#field##0", i64* %7 - %8 = insertvalue {i64, i1} undef, i64 %3, 0 - %9 = insertvalue {i64, i1} %8, i1 1, 1 - ret {i64, i1} %9 -if.else: - %10 = insertvalue {i64, i1} undef, i64 0, 0 - %11 = insertvalue {i64, i1} %10, i1 0, 1 - ret {i64, i1} %11 +define external fastcc {i64, i1} @"stmt_if.tree.left<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#2##0" = call ccc ptr @wybe_malloc(i32 24) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#2##0", ptr %"tmp#1##0", i64 24, i1 0) + %"tmp#3##0" = ptrtoint ptr %"tmp#2##0" to i64 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 %"#field##0", ptr %"tmp#4##0" + %"tmp#5##0" = insertvalue {i64, i1} undef, i64 %"tmp#3##0", 0 + %"tmp#6##0" = insertvalue {i64, i1} %"tmp#5##0", i1 1, 1 + ret {i64, i1} %"tmp#6##0" +if.else.0: + %"tmp#7##0" = insertvalue {i64, i1} undef, i64 0, 0 + %"tmp#8##0" = insertvalue {i64, i1} %"tmp#7##0", i1 0, 1 + ret {i64, i1} %"tmp#8##0" } - -define external fastcc i64 @"stmt_if.tree.node<0>"(i64 %"left##0", i64 %"key##0", i64 %"right##0") alwaysinline { -entry: - %0 = trunc i64 24 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"left##0", i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"key##0", i64* %5 - %6 = add i64 %2, 16 - %7 = inttoptr i64 %6 to i64* - store i64 %"right##0", i64* %7 - ret i64 %2 +define external fastcc i64 @"stmt_if.tree.node<0>"(i64 %"left##0", i64 %"key##0", i64 %"right##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 24) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"left##0", ptr %"tmp#1##0" + %"tmp#2##0" = add i64 %"#rec##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"key##0", ptr %"tmp#3##0" + %"tmp#4##0" = add i64 %"#rec##0", 16 + %"tmp#5##0" = inttoptr i64 %"tmp#4##0" to ptr + store i64 %"right##0", ptr %"tmp#5##0" + ret i64 %"#rec##0" } - -define external fastcc {i64, i64, i64, i1} @"stmt_if.tree.node<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#result##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"#result##0" to i64* - %2 = load i64, i64* %1 - %3 = add i64 %"#result##0", 8 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = add i64 %"#result##0", 16 - %7 = inttoptr i64 %6 to i64* - %8 = load i64, i64* %7 - %9 = insertvalue {i64, i64, i64, i1} undef, i64 %2, 0 - %10 = insertvalue {i64, i64, i64, i1} %9, i64 %5, 1 - %11 = insertvalue {i64, i64, i64, i1} %10, i64 %8, 2 - %12 = insertvalue {i64, i64, i64, i1} %11, i1 1, 3 - ret {i64, i64, i64, i1} %12 -if.else: - %13 = insertvalue {i64, i64, i64, i1} undef, i64 undef, 0 - %14 = insertvalue {i64, i64, i64, i1} %13, i64 undef, 1 - %15 = insertvalue {i64, i64, i64, i1} %14, i64 undef, 2 - %16 = insertvalue {i64, i64, i64, i1} %15, i1 0, 3 - ret {i64, i64, i64, i1} %16 +define external fastcc {i64, i64, i64, i1} @"stmt_if.tree.node<1>"(i64 %"#result##0") { + %"tmp#0##0" = icmp ne i64 %"#result##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = inttoptr i64 %"#result##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + %"tmp#3##0" = add i64 %"#result##0", 8 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#4##0" + %"tmp#6##0" = add i64 %"#result##0", 16 + %"tmp#7##0" = inttoptr i64 %"tmp#6##0" to ptr + %"tmp#8##0" = load i64, ptr %"tmp#7##0" + %"tmp#9##0" = insertvalue {i64, i64, i64, i1} undef, i64 %"tmp#2##0", 0 + %"tmp#10##0" = insertvalue {i64, i64, i64, i1} %"tmp#9##0", i64 %"tmp#5##0", 1 + %"tmp#11##0" = insertvalue {i64, i64, i64, i1} %"tmp#10##0", i64 %"tmp#8##0", 2 + %"tmp#12##0" = insertvalue {i64, i64, i64, i1} %"tmp#11##0", i1 1, 3 + ret {i64, i64, i64, i1} %"tmp#12##0" +if.else.0: + %"tmp#13##0" = insertvalue {i64, i64, i64, i1} undef, i64 undef, 0 + %"tmp#14##0" = insertvalue {i64, i64, i64, i1} %"tmp#13##0", i64 undef, 1 + %"tmp#15##0" = insertvalue {i64, i64, i64, i1} %"tmp#14##0", i64 undef, 2 + %"tmp#16##0" = insertvalue {i64, i64, i64, i1} %"tmp#15##0", i1 0, 3 + ret {i64, i64, i64, i1} %"tmp#16##0" } - -define external fastcc {i64, i1} @"stmt_if.tree.right<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = add i64 %"#rec##0", 16 - %2 = inttoptr i64 %1 to i64* - %3 = load i64, i64* %2 - %4 = insertvalue {i64, i1} undef, i64 %3, 0 - %5 = insertvalue {i64, i1} %4, i1 1, 1 - ret {i64, i1} %5 -if.else: - %6 = insertvalue {i64, i1} undef, i64 undef, 0 - %7 = insertvalue {i64, i1} %6, i1 0, 1 - ret {i64, i1} %7 +define external fastcc {i64, i1} @"stmt_if.tree.right<0>"(i64 %"#rec##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = add i64 %"#rec##0", 16 + %"tmp#2##0" = inttoptr i64 %"tmp#1##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#2##0" + %"tmp#4##0" = insertvalue {i64, i1} undef, i64 %"tmp#3##0", 0 + %"tmp#5##0" = insertvalue {i64, i1} %"tmp#4##0", i1 1, 1 + ret {i64, i1} %"tmp#5##0" +if.else.0: + %"tmp#6##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#7##0" = insertvalue {i64, i1} %"tmp#6##0", i1 0, 1 + ret {i64, i1} %"tmp#7##0" } - -define external fastcc {i64, i1} @"stmt_if.tree.right<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = trunc i64 24 to i32 - %2 = tail call ccc i8* @wybe_malloc(i32 %1) - %3 = ptrtoint i8* %2 to i64 - %4 = inttoptr i64 %3 to i8* - %5 = inttoptr i64 %"#rec##0" to i8* - %6 = trunc i64 24 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %4, i8* %5, i32 %6, i1 0) - %7 = add i64 %3, 16 - %8 = inttoptr i64 %7 to i64* - store i64 %"#field##0", i64* %8 - %9 = insertvalue {i64, i1} undef, i64 %3, 0 - %10 = insertvalue {i64, i1} %9, i1 1, 1 - ret {i64, i1} %10 -if.else: - %11 = insertvalue {i64, i1} undef, i64 0, 0 - %12 = insertvalue {i64, i1} %11, i1 0, 1 - ret {i64, i1} %12 +define external fastcc {i64, i1} @"stmt_if.tree.right<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#2##0" = call ccc ptr @wybe_malloc(i32 24) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#2##0", ptr %"tmp#1##0", i64 24, i1 0) + %"tmp#3##0" = ptrtoint ptr %"tmp#2##0" to i64 + %"tmp#4##0" = add i64 %"tmp#3##0", 16 + %"tmp#5##0" = inttoptr i64 %"tmp#4##0" to ptr + store i64 %"#field##0", ptr %"tmp#5##0" + %"tmp#6##0" = insertvalue {i64, i1} undef, i64 %"tmp#3##0", 0 + %"tmp#7##0" = insertvalue {i64, i1} %"tmp#6##0", i1 1, 1 + ret {i64, i1} %"tmp#7##0" +if.else.0: + %"tmp#8##0" = insertvalue {i64, i1} undef, i64 0, 0 + %"tmp#9##0" = insertvalue {i64, i1} %"tmp#8##0", i1 0, 1 + ret {i64, i1} %"tmp#9##0" } - -define external fastcc i1 @"stmt_if.tree.~=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = tail call fastcc i1 @"stmt_if.tree.=<0>"(i64 %"#left##0", i64 %"#right##0") - %1 = xor i1 %0, 1 - ret i1 %1 +define external fastcc i1 @"stmt_if.tree.~=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#0##0" = tail call fastcc i1 @"stmt_if.tree.=<0>"(i64 %"#left##0", i64 %"#right##0") + %"tmp#1##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#1##0" } diff --git a/test-cases/final-dump/stmt_if2.exp b/test-cases/final-dump/stmt_if2.exp index f434f310e..dfe3589c8 100644 --- a/test-cases/final-dump/stmt_if2.exp +++ b/test-cases/final-dump/stmt_if2.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module stmt_if2 representation : (not a type) public submods : tree -> stmt_if2.tree @@ -89,93 +92,80 @@ lookup#cont#1(tmp#4##0:wybe.bool, ?#result##0:wybe.bool)<{}; {}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'stmt_if2' - - - - -@stmt_if2.1 = constant {i64, i64} { i64 5, i64 ptrtoint ([?? x i8]* @stmt_if2.0 to i64) } - - -@stmt_if2.0 = constant [?? x i8] c"found\00" - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"stmt_if2.<0>"() { -entry: - %0 = trunc i64 24 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 0, i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 1, i64* %5 - %6 = add i64 %2, 16 - %7 = inttoptr i64 %6 to i64* - store i64 0, i64* %7 - %8 = tail call fastcc i1 @"stmt_if2.lookup<0>"(i64 1, i64 %2) - br i1 %8, label %if.then, label %if.else -if.then: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @stmt_if2.1, i32 0, i32 0) to i64)) - ret void -if.else: - ret void +source_filename = "!ROOT!/final-dump/stmt_if2.wybe" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c"found\00", align 8 +@"string#1" = private unnamed_addr constant {i64, i64} { i64 5, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 + +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"stmt_if2.<0>"() { + %"tmp#11##0" = call ccc ptr @wybe_malloc(i32 24) + %"tmp#7##0" = ptrtoint ptr %"tmp#11##0" to i64 + %"tmp#12##0" = inttoptr i64 %"tmp#7##0" to ptr + store i64 0, ptr %"tmp#12##0" + %"tmp#13##0" = add i64 %"tmp#7##0", 8 + %"tmp#14##0" = inttoptr i64 %"tmp#13##0" to ptr + store i64 1, ptr %"tmp#14##0" + %"tmp#15##0" = add i64 %"tmp#7##0", 16 + %"tmp#16##0" = inttoptr i64 %"tmp#15##0" to ptr + store i64 0, ptr %"tmp#16##0" + %"tmp#3##0" = tail call fastcc i1 @"stmt_if2.lookup<0>"(i64 1, i64 %"tmp#7##0") + br i1 %"tmp#3##0", label %if.then.0, label %if.else.0 +if.then.0: + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#1" to i64 )) + ret void +if.else.0: + ret void } - -define external fastcc i1 @"stmt_if2.lookup<0>"(i64 %"key##0", i64 %"tree##0") { -entry: - %0 = tail call fastcc i1 @"stmt_if2.tree.=<0>"(i64 %"tree##0", i64 0) - br i1 %0, label %if.then, label %if.else -if.then: - ret i1 0 -if.else: - %1 = icmp ne i64 %"tree##0", 0 - br i1 %1, label %if.then1, label %if.else1 -if.then1: - %2 = inttoptr i64 %"tree##0" to i64* - %3 = load i64, i64* %2 - %4 = add i64 %"tree##0", 8 - %5 = inttoptr i64 %4 to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"tree##0", 16 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = icmp eq i64 %6, %"key##0" - br i1 %10, label %if.then2, label %if.else2 -if.else1: - ret i1 0 -if.then2: - ret i1 1 -if.else2: - %11 = icmp sgt i64 %6, %"key##0" - br i1 %11, label %if.then3, label %if.else3 -if.then3: - %12 = musttail call fastcc i1 @"stmt_if2.lookup<0>"(i64 %"key##0", i64 %3) - ret i1 %12 -if.else3: - %13 = musttail call fastcc i1 @"stmt_if2.lookup<0>"(i64 %"key##0", i64 %9) - ret i1 %13 +define external fastcc i1 @"stmt_if2.lookup<0>"(i64 %"key##0", i64 %"tree##0") { + %"tmp#13##0" = tail call fastcc i1 @"stmt_if2.tree.=<0>"(i64 %"tree##0", i64 0) + br i1 %"tmp#13##0", label %if.then.0, label %if.else.0 +if.then.0: + ret i1 0 +if.else.0: + %"tmp#15##0" = icmp ne i64 %"tree##0", 0 + br i1 %"tmp#15##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#23##0" = inttoptr i64 %"tree##0" to ptr + %"l##0" = load i64, ptr %"tmp#23##0" + %"tmp#24##0" = add i64 %"tree##0", 8 + %"tmp#25##0" = inttoptr i64 %"tmp#24##0" to ptr + %"k##0" = load i64, ptr %"tmp#25##0" + %"tmp#26##0" = add i64 %"tree##0", 16 + %"tmp#27##0" = inttoptr i64 %"tmp#26##0" to ptr + %"r##0" = load i64, ptr %"tmp#27##0" + %"tmp#11##0" = icmp eq i64 %"k##0", %"key##0" + br i1 %"tmp#11##0", label %if.then.2, label %if.else.2 +if.then.2: + ret i1 1 +if.else.2: + %"tmp#10##0" = icmp sgt i64 %"k##0", %"key##0" + br i1 %"tmp#10##0", label %if.then.3, label %if.else.3 +if.then.3: + %"tmp#28##0" = tail call fastcc i1 @"stmt_if2.lookup<0>"(i64 %"key##0", i64 %"l##0") + ret i1 %"tmp#28##0" +if.else.3: + %"tmp#29##0" = tail call fastcc i1 @"stmt_if2.lookup<0>"(i64 %"key##0", i64 %"r##0") + ret i1 %"tmp#29##0" +if.else.1: + ret i1 0 } - -define external fastcc i1 @"stmt_if2.lookup#cont#1<0>"(i1 %"tmp#4##0") alwaysinline { -entry: - ret i1 %"tmp#4##0" +define external fastcc i1 @"stmt_if2.lookup#cont#1<0>"(i1 %"tmp#4##0") { + ret i1 %"tmp#4##0" } + -------------------------------------------------- Module stmt_if2.tree - representation : address + representation : pointer public submods : public resources: public procs : stmt_if2.tree.=<0> @@ -380,242 +370,209 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'stmt_if2.tree' - - - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i1 @"stmt_if2.tree.=<0>"(i64 %"#left##0", i64 %"#right##0") { -entry: - %0 = icmp ne i64 %"#left##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"#left##0" to i64* - %2 = load i64, i64* %1 - %3 = add i64 %"#left##0", 8 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = add i64 %"#left##0", 16 - %7 = inttoptr i64 %6 to i64* - %8 = load i64, i64* %7 - %9 = icmp ne i64 %"#right##0", 0 - br i1 %9, label %if.then1, label %if.else1 -if.else: - %21 = icmp eq i64 %"#right##0", 0 - ret i1 %21 -if.then1: - %10 = inttoptr i64 %"#right##0" to i64* - %11 = load i64, i64* %10 - %12 = add i64 %"#right##0", 8 - %13 = inttoptr i64 %12 to i64* - %14 = load i64, i64* %13 - %15 = add i64 %"#right##0", 16 - %16 = inttoptr i64 %15 to i64* - %17 = load i64, i64* %16 - %18 = tail call fastcc i1 @"stmt_if2.tree.=<0>"(i64 %2, i64 %11) - br i1 %18, label %if.then2, label %if.else2 -if.else1: - ret i1 0 -if.then2: - %19 = icmp eq i64 %5, %14 - br i1 %19, label %if.then3, label %if.else3 -if.else2: - ret i1 0 -if.then3: - %20 = musttail call fastcc i1 @"stmt_if2.tree.=<0>"(i64 %8, i64 %17) - ret i1 %20 -if.else3: - ret i1 0 +source_filename = "!ROOT!/final-dump/stmt_if2.wybe" +target triple ???? + + +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc i1 @"stmt_if2.tree.=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#0##0" = icmp ne i64 %"#left##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#13##0" = inttoptr i64 %"#left##0" to ptr + %"#left#left##0" = load i64, ptr %"tmp#13##0" + %"tmp#14##0" = add i64 %"#left##0", 8 + %"tmp#15##0" = inttoptr i64 %"tmp#14##0" to ptr + %"#left#key##0" = load i64, ptr %"tmp#15##0" + %"tmp#16##0" = add i64 %"#left##0", 16 + %"tmp#17##0" = inttoptr i64 %"tmp#16##0" to ptr + %"#left#right##0" = load i64, ptr %"tmp#17##0" + %"tmp#10##0" = icmp ne i64 %"#right##0", 0 + br i1 %"tmp#10##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#18##0" = inttoptr i64 %"#right##0" to ptr + %"#right#left##0" = load i64, ptr %"tmp#18##0" + %"tmp#19##0" = add i64 %"#right##0", 8 + %"tmp#20##0" = inttoptr i64 %"tmp#19##0" to ptr + %"#right#key##0" = load i64, ptr %"tmp#20##0" + %"tmp#21##0" = add i64 %"#right##0", 16 + %"tmp#22##0" = inttoptr i64 %"tmp#21##0" to ptr + %"#right#right##0" = load i64, ptr %"tmp#22##0" + %"tmp#4##0" = tail call fastcc i1 @"stmt_if2.tree.=<0>"(i64 %"#left#left##0", i64 %"#right#left##0") + br i1 %"tmp#4##0", label %if.then.2, label %if.else.2 +if.then.2: + %"tmp#5##0" = icmp eq i64 %"#left#key##0", %"#right#key##0" + br i1 %"tmp#5##0", label %if.then.3, label %if.else.3 +if.then.3: + %"tmp#23##0" = tail call fastcc i1 @"stmt_if2.tree.=<0>"(i64 %"#left#right##0", i64 %"#right#right##0") + ret i1 %"tmp#23##0" +if.else.3: + ret i1 0 +if.else.2: + ret i1 0 +if.else.1: + ret i1 0 +if.else.0: + %"tmp#24##0" = icmp eq i64 %"#right##0", 0 + ret i1 %"tmp#24##0" } - -define external fastcc i64 @"stmt_if2.tree.empty<0>"() alwaysinline { -entry: - ret i64 0 +define external fastcc i64 @"stmt_if2.tree.empty<0>"() { + ret i64 0 } - -define external fastcc {i64, i1} @"stmt_if2.tree.key<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = add i64 %"#rec##0", 8 - %2 = inttoptr i64 %1 to i64* - %3 = load i64, i64* %2 - %4 = insertvalue {i64, i1} undef, i64 %3, 0 - %5 = insertvalue {i64, i1} %4, i1 1, 1 - ret {i64, i1} %5 -if.else: - %6 = insertvalue {i64, i1} undef, i64 undef, 0 - %7 = insertvalue {i64, i1} %6, i1 0, 1 - ret {i64, i1} %7 +define external fastcc {i64, i1} @"stmt_if2.tree.key<0>"(i64 %"#rec##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = add i64 %"#rec##0", 8 + %"tmp#2##0" = inttoptr i64 %"tmp#1##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#2##0" + %"tmp#4##0" = insertvalue {i64, i1} undef, i64 %"tmp#3##0", 0 + %"tmp#5##0" = insertvalue {i64, i1} %"tmp#4##0", i1 1, 1 + ret {i64, i1} %"tmp#5##0" +if.else.0: + %"tmp#6##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#7##0" = insertvalue {i64, i1} %"tmp#6##0", i1 0, 1 + ret {i64, i1} %"tmp#7##0" } - -define external fastcc {i64, i1} @"stmt_if2.tree.key<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = trunc i64 24 to i32 - %2 = tail call ccc i8* @wybe_malloc(i32 %1) - %3 = ptrtoint i8* %2 to i64 - %4 = inttoptr i64 %3 to i8* - %5 = inttoptr i64 %"#rec##0" to i8* - %6 = trunc i64 24 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %4, i8* %5, i32 %6, i1 0) - %7 = add i64 %3, 8 - %8 = inttoptr i64 %7 to i64* - store i64 %"#field##0", i64* %8 - %9 = insertvalue {i64, i1} undef, i64 %3, 0 - %10 = insertvalue {i64, i1} %9, i1 1, 1 - ret {i64, i1} %10 -if.else: - %11 = insertvalue {i64, i1} undef, i64 0, 0 - %12 = insertvalue {i64, i1} %11, i1 0, 1 - ret {i64, i1} %12 +define external fastcc {i64, i1} @"stmt_if2.tree.key<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#2##0" = call ccc ptr @wybe_malloc(i32 24) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#2##0", ptr %"tmp#1##0", i64 24, i1 0) + %"tmp#3##0" = ptrtoint ptr %"tmp#2##0" to i64 + %"tmp#4##0" = add i64 %"tmp#3##0", 8 + %"tmp#5##0" = inttoptr i64 %"tmp#4##0" to ptr + store i64 %"#field##0", ptr %"tmp#5##0" + %"tmp#6##0" = insertvalue {i64, i1} undef, i64 %"tmp#3##0", 0 + %"tmp#7##0" = insertvalue {i64, i1} %"tmp#6##0", i1 1, 1 + ret {i64, i1} %"tmp#7##0" +if.else.0: + %"tmp#8##0" = insertvalue {i64, i1} undef, i64 0, 0 + %"tmp#9##0" = insertvalue {i64, i1} %"tmp#8##0", i1 0, 1 + ret {i64, i1} %"tmp#9##0" } - -define external fastcc {i64, i1} @"stmt_if2.tree.left<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"#rec##0" to i64* - %2 = load i64, i64* %1 - %3 = insertvalue {i64, i1} undef, i64 %2, 0 - %4 = insertvalue {i64, i1} %3, i1 1, 1 - ret {i64, i1} %4 -if.else: - %5 = insertvalue {i64, i1} undef, i64 undef, 0 - %6 = insertvalue {i64, i1} %5, i1 0, 1 - ret {i64, i1} %6 +define external fastcc {i64, i1} @"stmt_if2.tree.left<0>"(i64 %"#rec##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + %"tmp#3##0" = insertvalue {i64, i1} undef, i64 %"tmp#2##0", 0 + %"tmp#4##0" = insertvalue {i64, i1} %"tmp#3##0", i1 1, 1 + ret {i64, i1} %"tmp#4##0" +if.else.0: + %"tmp#5##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#6##0" = insertvalue {i64, i1} %"tmp#5##0", i1 0, 1 + ret {i64, i1} %"tmp#6##0" } - -define external fastcc {i64, i1} @"stmt_if2.tree.left<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = trunc i64 24 to i32 - %2 = tail call ccc i8* @wybe_malloc(i32 %1) - %3 = ptrtoint i8* %2 to i64 - %4 = inttoptr i64 %3 to i8* - %5 = inttoptr i64 %"#rec##0" to i8* - %6 = trunc i64 24 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %4, i8* %5, i32 %6, i1 0) - %7 = inttoptr i64 %3 to i64* - store i64 %"#field##0", i64* %7 - %8 = insertvalue {i64, i1} undef, i64 %3, 0 - %9 = insertvalue {i64, i1} %8, i1 1, 1 - ret {i64, i1} %9 -if.else: - %10 = insertvalue {i64, i1} undef, i64 0, 0 - %11 = insertvalue {i64, i1} %10, i1 0, 1 - ret {i64, i1} %11 +define external fastcc {i64, i1} @"stmt_if2.tree.left<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#2##0" = call ccc ptr @wybe_malloc(i32 24) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#2##0", ptr %"tmp#1##0", i64 24, i1 0) + %"tmp#3##0" = ptrtoint ptr %"tmp#2##0" to i64 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 %"#field##0", ptr %"tmp#4##0" + %"tmp#5##0" = insertvalue {i64, i1} undef, i64 %"tmp#3##0", 0 + %"tmp#6##0" = insertvalue {i64, i1} %"tmp#5##0", i1 1, 1 + ret {i64, i1} %"tmp#6##0" +if.else.0: + %"tmp#7##0" = insertvalue {i64, i1} undef, i64 0, 0 + %"tmp#8##0" = insertvalue {i64, i1} %"tmp#7##0", i1 0, 1 + ret {i64, i1} %"tmp#8##0" } - -define external fastcc i64 @"stmt_if2.tree.node<0>"(i64 %"left##0", i64 %"key##0", i64 %"right##0") alwaysinline { -entry: - %0 = trunc i64 24 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"left##0", i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"key##0", i64* %5 - %6 = add i64 %2, 16 - %7 = inttoptr i64 %6 to i64* - store i64 %"right##0", i64* %7 - ret i64 %2 +define external fastcc i64 @"stmt_if2.tree.node<0>"(i64 %"left##0", i64 %"key##0", i64 %"right##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 24) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"left##0", ptr %"tmp#1##0" + %"tmp#2##0" = add i64 %"#rec##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"key##0", ptr %"tmp#3##0" + %"tmp#4##0" = add i64 %"#rec##0", 16 + %"tmp#5##0" = inttoptr i64 %"tmp#4##0" to ptr + store i64 %"right##0", ptr %"tmp#5##0" + ret i64 %"#rec##0" } - -define external fastcc {i64, i64, i64, i1} @"stmt_if2.tree.node<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#result##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"#result##0" to i64* - %2 = load i64, i64* %1 - %3 = add i64 %"#result##0", 8 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = add i64 %"#result##0", 16 - %7 = inttoptr i64 %6 to i64* - %8 = load i64, i64* %7 - %9 = insertvalue {i64, i64, i64, i1} undef, i64 %2, 0 - %10 = insertvalue {i64, i64, i64, i1} %9, i64 %5, 1 - %11 = insertvalue {i64, i64, i64, i1} %10, i64 %8, 2 - %12 = insertvalue {i64, i64, i64, i1} %11, i1 1, 3 - ret {i64, i64, i64, i1} %12 -if.else: - %13 = insertvalue {i64, i64, i64, i1} undef, i64 undef, 0 - %14 = insertvalue {i64, i64, i64, i1} %13, i64 undef, 1 - %15 = insertvalue {i64, i64, i64, i1} %14, i64 undef, 2 - %16 = insertvalue {i64, i64, i64, i1} %15, i1 0, 3 - ret {i64, i64, i64, i1} %16 +define external fastcc {i64, i64, i64, i1} @"stmt_if2.tree.node<1>"(i64 %"#result##0") { + %"tmp#0##0" = icmp ne i64 %"#result##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = inttoptr i64 %"#result##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + %"tmp#3##0" = add i64 %"#result##0", 8 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#4##0" + %"tmp#6##0" = add i64 %"#result##0", 16 + %"tmp#7##0" = inttoptr i64 %"tmp#6##0" to ptr + %"tmp#8##0" = load i64, ptr %"tmp#7##0" + %"tmp#9##0" = insertvalue {i64, i64, i64, i1} undef, i64 %"tmp#2##0", 0 + %"tmp#10##0" = insertvalue {i64, i64, i64, i1} %"tmp#9##0", i64 %"tmp#5##0", 1 + %"tmp#11##0" = insertvalue {i64, i64, i64, i1} %"tmp#10##0", i64 %"tmp#8##0", 2 + %"tmp#12##0" = insertvalue {i64, i64, i64, i1} %"tmp#11##0", i1 1, 3 + ret {i64, i64, i64, i1} %"tmp#12##0" +if.else.0: + %"tmp#13##0" = insertvalue {i64, i64, i64, i1} undef, i64 undef, 0 + %"tmp#14##0" = insertvalue {i64, i64, i64, i1} %"tmp#13##0", i64 undef, 1 + %"tmp#15##0" = insertvalue {i64, i64, i64, i1} %"tmp#14##0", i64 undef, 2 + %"tmp#16##0" = insertvalue {i64, i64, i64, i1} %"tmp#15##0", i1 0, 3 + ret {i64, i64, i64, i1} %"tmp#16##0" } - -define external fastcc {i64, i1} @"stmt_if2.tree.right<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = add i64 %"#rec##0", 16 - %2 = inttoptr i64 %1 to i64* - %3 = load i64, i64* %2 - %4 = insertvalue {i64, i1} undef, i64 %3, 0 - %5 = insertvalue {i64, i1} %4, i1 1, 1 - ret {i64, i1} %5 -if.else: - %6 = insertvalue {i64, i1} undef, i64 undef, 0 - %7 = insertvalue {i64, i1} %6, i1 0, 1 - ret {i64, i1} %7 +define external fastcc {i64, i1} @"stmt_if2.tree.right<0>"(i64 %"#rec##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = add i64 %"#rec##0", 16 + %"tmp#2##0" = inttoptr i64 %"tmp#1##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#2##0" + %"tmp#4##0" = insertvalue {i64, i1} undef, i64 %"tmp#3##0", 0 + %"tmp#5##0" = insertvalue {i64, i1} %"tmp#4##0", i1 1, 1 + ret {i64, i1} %"tmp#5##0" +if.else.0: + %"tmp#6##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#7##0" = insertvalue {i64, i1} %"tmp#6##0", i1 0, 1 + ret {i64, i1} %"tmp#7##0" } - -define external fastcc {i64, i1} @"stmt_if2.tree.right<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = trunc i64 24 to i32 - %2 = tail call ccc i8* @wybe_malloc(i32 %1) - %3 = ptrtoint i8* %2 to i64 - %4 = inttoptr i64 %3 to i8* - %5 = inttoptr i64 %"#rec##0" to i8* - %6 = trunc i64 24 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %4, i8* %5, i32 %6, i1 0) - %7 = add i64 %3, 16 - %8 = inttoptr i64 %7 to i64* - store i64 %"#field##0", i64* %8 - %9 = insertvalue {i64, i1} undef, i64 %3, 0 - %10 = insertvalue {i64, i1} %9, i1 1, 1 - ret {i64, i1} %10 -if.else: - %11 = insertvalue {i64, i1} undef, i64 0, 0 - %12 = insertvalue {i64, i1} %11, i1 0, 1 - ret {i64, i1} %12 +define external fastcc {i64, i1} @"stmt_if2.tree.right<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#2##0" = call ccc ptr @wybe_malloc(i32 24) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#2##0", ptr %"tmp#1##0", i64 24, i1 0) + %"tmp#3##0" = ptrtoint ptr %"tmp#2##0" to i64 + %"tmp#4##0" = add i64 %"tmp#3##0", 16 + %"tmp#5##0" = inttoptr i64 %"tmp#4##0" to ptr + store i64 %"#field##0", ptr %"tmp#5##0" + %"tmp#6##0" = insertvalue {i64, i1} undef, i64 %"tmp#3##0", 0 + %"tmp#7##0" = insertvalue {i64, i1} %"tmp#6##0", i1 1, 1 + ret {i64, i1} %"tmp#7##0" +if.else.0: + %"tmp#8##0" = insertvalue {i64, i1} undef, i64 0, 0 + %"tmp#9##0" = insertvalue {i64, i1} %"tmp#8##0", i1 0, 1 + ret {i64, i1} %"tmp#9##0" } - -define external fastcc i1 @"stmt_if2.tree.~=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = tail call fastcc i1 @"stmt_if2.tree.=<0>"(i64 %"#left##0", i64 %"#right##0") - %1 = xor i1 %0, 1 - ret i1 %1 +define external fastcc i1 @"stmt_if2.tree.~=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#0##0" = tail call fastcc i1 @"stmt_if2.tree.=<0>"(i64 %"#left##0", i64 %"#right##0") + %"tmp#1##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#1##0" } diff --git a/test-cases/final-dump/stmt_nop.exp b/test-cases/final-dump/stmt_nop.exp index 386962298..ad366cabc 100644 --- a/test-cases/final-dump/stmt_nop.exp +++ b/test-cases/final-dump/stmt_nop.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module stmt_nop representation : (not a type) public submods : @@ -17,19 +20,15 @@ module top-level code > public {inline,semipure} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'stmt_nop' +source_filename = "!ROOT!/final-dump/stmt_nop.wybe" +target triple ???? - - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -define external fastcc void @"stmt_nop.<0>"() alwaysinline { -entry: - ret void +define external fastcc void @"stmt_nop.<0>"() { + ret void } diff --git a/test-cases/final-dump/stmt_unless.exp b/test-cases/final-dump/stmt_unless.exp index 6e6f2e2db..cb4580e98 100644 --- a/test-cases/final-dump/stmt_unless.exp +++ b/test-cases/final-dump/stmt_unless.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module stmt_unless representation : (not a type) public submods : @@ -62,62 +65,48 @@ mod(x##0:wybe.int, y##0:wybe.int, ?#result##0:wybe.int)<{}; {}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'stmt_unless' - - - - -declare external ccc void @putchar(i8) - - -declare external ccc void @print_int(i64) +source_filename = "!ROOT!/final-dump/stmt_unless.wybe" +target triple ???? -declare external ccc i8* @wybe_malloc(i32) +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"stmt_unless.<0>"() alwaysinline { -entry: - tail call fastcc void @"stmt_unless.#cont#1<0>"(i64 10) - ret void +define external fastcc void @"stmt_unless.<0>"() { + tail call fastcc void @"stmt_unless.#cont#1<0>"(i64 10) + ret void } - -define external fastcc void @"stmt_unless.#cont#1<0>"(i64 %"n##0") { -entry: - %0 = icmp sgt i64 %"n##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - musttail call fastcc void @"stmt_unless.#cont#2<0>"(i64 %"n##0") - ret void -if.else: - ret void +define external fastcc void @"stmt_unless.#cont#1<0>"(i64 %"n##0") { + %"tmp#3##0" = icmp sgt i64 %"n##0", 0 + br i1 %"tmp#3##0", label %if.then.0, label %if.else.0 +if.then.0: + tail call fastcc void @"stmt_unless.#cont#2<0>"(i64 %"n##0") + ret void +if.else.0: + ret void } - -define external fastcc void @"stmt_unless.#cont#2<0>"(i64 %"n##0") { -entry: - %0 = sub i64 %"n##0", 1 - %1 = urem i64 %0, 2 - %2 = icmp eq i64 %1, 0 - br i1 %2, label %if.then, label %if.else -if.then: - musttail call fastcc void @"stmt_unless.#cont#1<0>"(i64 %0) - ret void -if.else: - tail call ccc void @print_int(i64 %0) - tail call ccc void @putchar(i8 10) - musttail call fastcc void @"stmt_unless.#cont#1<0>"(i64 %0) - ret void +define external fastcc void @"stmt_unless.#cont#2<0>"(i64 %"n##0") { + %"tmp#0##0" = sub i64 %"n##0", 1 + %"tmp#1##0" = urem i64 %"tmp#0##0", 2 + %"tmp#2##0" = icmp eq i64 %"tmp#1##0", 0 + br i1 %"tmp#2##0", label %if.then.0, label %if.else.0 +if.then.0: + tail call fastcc void @"stmt_unless.#cont#1<0>"(i64 %"tmp#0##0") + ret void +if.else.0: + call ccc void @print_int(i64 %"tmp#0##0") + call ccc void @putchar(i8 10) + tail call fastcc void @"stmt_unless.#cont#1<0>"(i64 %"tmp#0##0") + ret void } - -define external fastcc i64 @"stmt_unless.mod<0>"(i64 %"x##0", i64 %"y##0") alwaysinline { -entry: - %0 = urem i64 %"x##0", %"y##0" - ret i64 %0 +define external fastcc i64 @"stmt_unless.mod<0>"(i64 %"x##0", i64 %"y##0") { + %"tmp#1##0" = urem i64 %"x##0", %"y##0" + ret i64 %"tmp#1##0" } diff --git a/test-cases/final-dump/stmt_until.exp b/test-cases/final-dump/stmt_until.exp index 5be83e279..1fa82f3e0 100644 --- a/test-cases/final-dump/stmt_until.exp +++ b/test-cases/final-dump/stmt_until.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module stmt_until representation : (not a type) public submods : @@ -50,51 +53,39 @@ proc #cont#2 > {inline,semipure} (1 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'stmt_until' +source_filename = "!ROOT!/final-dump/stmt_until.wybe" +target triple ???? - - - -declare external ccc void @putchar(i8) - - -declare external ccc void @print_int(i64) +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"stmt_until.<0>"() alwaysinline { -entry: - tail call fastcc void @"stmt_until.#cont#1<0>"(i64 10) - ret void +define external fastcc void @"stmt_until.<0>"() { + tail call fastcc void @"stmt_until.#cont#1<0>"(i64 10) + ret void } - -define external fastcc void @"stmt_until.#cont#1<0>"(i64 %"n##0") { -entry: - %0 = icmp slt i64 %"n##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - ret void -if.else: - %1 = sub i64 %"n##0", 1 - tail call ccc void @print_int(i64 %1) - tail call ccc void @putchar(i8 10) - musttail call fastcc void @"stmt_until.#cont#1<0>"(i64 %1) - ret void +define external fastcc void @"stmt_until.#cont#1<0>"(i64 %"n##0") { + %"tmp#1##0" = icmp slt i64 %"n##0", 0 + br i1 %"tmp#1##0", label %if.then.0, label %if.else.0 +if.then.0: + ret void +if.else.0: + %"tmp#5##0" = sub i64 %"n##0", 1 + call ccc void @print_int(i64 %"tmp#5##0") + call ccc void @putchar(i8 10) + tail call fastcc void @"stmt_until.#cont#1<0>"(i64 %"tmp#5##0") + ret void } - -define external fastcc void @"stmt_until.#cont#2<0>"(i64 %"n##0") alwaysinline { -entry: - %0 = sub i64 %"n##0", 1 - tail call ccc void @print_int(i64 %0) - tail call ccc void @putchar(i8 10) - musttail call fastcc void @"stmt_until.#cont#1<0>"(i64 %0) - ret void +define external fastcc void @"stmt_until.#cont#2<0>"(i64 %"n##0") { + %"tmp#0##0" = sub i64 %"n##0", 1 + call ccc void @print_int(i64 %"tmp#0##0") + call ccc void @putchar(i8 10) + tail call fastcc void @"stmt_until.#cont#1<0>"(i64 %"tmp#0##0") + ret void } diff --git a/test-cases/final-dump/stmt_when.exp b/test-cases/final-dump/stmt_when.exp index a8f5a2dbf..8faec3f30 100644 --- a/test-cases/final-dump/stmt_when.exp +++ b/test-cases/final-dump/stmt_when.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module stmt_when representation : (not a type) public submods : @@ -62,62 +65,48 @@ mod(x##0:wybe.int, y##0:wybe.int, ?#result##0:wybe.int)<{}; {}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'stmt_when' - - - - -declare external ccc void @putchar(i8) - - -declare external ccc void @print_int(i64) +source_filename = "!ROOT!/final-dump/stmt_when.wybe" +target triple ???? -declare external ccc i8* @wybe_malloc(i32) +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"stmt_when.<0>"() alwaysinline { -entry: - tail call fastcc void @"stmt_when.#cont#1<0>"(i64 10) - ret void +define external fastcc void @"stmt_when.<0>"() { + tail call fastcc void @"stmt_when.#cont#1<0>"(i64 10) + ret void } - -define external fastcc void @"stmt_when.#cont#1<0>"(i64 %"n##0") { -entry: - %0 = icmp sgt i64 %"n##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - musttail call fastcc void @"stmt_when.#cont#2<0>"(i64 %"n##0") - ret void -if.else: - ret void +define external fastcc void @"stmt_when.#cont#1<0>"(i64 %"n##0") { + %"tmp#3##0" = icmp sgt i64 %"n##0", 0 + br i1 %"tmp#3##0", label %if.then.0, label %if.else.0 +if.then.0: + tail call fastcc void @"stmt_when.#cont#2<0>"(i64 %"n##0") + ret void +if.else.0: + ret void } - -define external fastcc void @"stmt_when.#cont#2<0>"(i64 %"n##0") { -entry: - %0 = sub i64 %"n##0", 1 - %1 = urem i64 %0, 2 - %2 = icmp eq i64 %1, 0 - br i1 %2, label %if.then, label %if.else -if.then: - tail call ccc void @print_int(i64 %0) - tail call ccc void @putchar(i8 10) - musttail call fastcc void @"stmt_when.#cont#1<0>"(i64 %0) - ret void -if.else: - musttail call fastcc void @"stmt_when.#cont#1<0>"(i64 %0) - ret void +define external fastcc void @"stmt_when.#cont#2<0>"(i64 %"n##0") { + %"tmp#0##0" = sub i64 %"n##0", 1 + %"tmp#1##0" = urem i64 %"tmp#0##0", 2 + %"tmp#2##0" = icmp eq i64 %"tmp#1##0", 0 + br i1 %"tmp#2##0", label %if.then.0, label %if.else.0 +if.then.0: + call ccc void @print_int(i64 %"tmp#0##0") + call ccc void @putchar(i8 10) + tail call fastcc void @"stmt_when.#cont#1<0>"(i64 %"tmp#0##0") + ret void +if.else.0: + tail call fastcc void @"stmt_when.#cont#1<0>"(i64 %"tmp#0##0") + ret void } - -define external fastcc i64 @"stmt_when.mod<0>"(i64 %"x##0", i64 %"y##0") alwaysinline { -entry: - %0 = urem i64 %"x##0", %"y##0" - ret i64 %0 +define external fastcc i64 @"stmt_when.mod<0>"(i64 %"x##0", i64 %"y##0") { + %"tmp#1##0" = urem i64 %"x##0", %"y##0" + ret i64 %"tmp#1##0" } diff --git a/test-cases/final-dump/stmt_while.exp b/test-cases/final-dump/stmt_while.exp index 32a7a923b..7ddadca5b 100644 --- a/test-cases/final-dump/stmt_while.exp +++ b/test-cases/final-dump/stmt_while.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module stmt_while representation : (not a type) public submods : @@ -50,51 +53,39 @@ proc #cont#2 > {inline,semipure} (1 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'stmt_while' +source_filename = "!ROOT!/final-dump/stmt_while.wybe" +target triple ???? - - - -declare external ccc void @putchar(i8) - - -declare external ccc void @print_int(i64) +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"stmt_while.<0>"() alwaysinline { -entry: - tail call fastcc void @"stmt_while.#cont#1<0>"(i64 10) - ret void +define external fastcc void @"stmt_while.<0>"() { + tail call fastcc void @"stmt_while.#cont#1<0>"(i64 10) + ret void } - -define external fastcc void @"stmt_while.#cont#1<0>"(i64 %"n##0") { -entry: - %0 = icmp sgt i64 %"n##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = sub i64 %"n##0", 1 - tail call ccc void @print_int(i64 %1) - tail call ccc void @putchar(i8 10) - musttail call fastcc void @"stmt_while.#cont#1<0>"(i64 %1) - ret void -if.else: - ret void +define external fastcc void @"stmt_while.#cont#1<0>"(i64 %"n##0") { + %"tmp#1##0" = icmp sgt i64 %"n##0", 0 + br i1 %"tmp#1##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#5##0" = sub i64 %"n##0", 1 + call ccc void @print_int(i64 %"tmp#5##0") + call ccc void @putchar(i8 10) + tail call fastcc void @"stmt_while.#cont#1<0>"(i64 %"tmp#5##0") + ret void +if.else.0: + ret void } - -define external fastcc void @"stmt_while.#cont#2<0>"(i64 %"n##0") alwaysinline { -entry: - %0 = sub i64 %"n##0", 1 - tail call ccc void @print_int(i64 %0) - tail call ccc void @putchar(i8 10) - musttail call fastcc void @"stmt_while.#cont#1<0>"(i64 %0) - ret void +define external fastcc void @"stmt_while.#cont#2<0>"(i64 %"n##0") { + %"tmp#0##0" = sub i64 %"n##0", 1 + call ccc void @print_int(i64 %"tmp#0##0") + call ccc void @putchar(i8 10) + tail call fastcc void @"stmt_while.#cont#1<0>"(i64 %"tmp#0##0") + ret void } diff --git a/test-cases/final-dump/string.exp b/test-cases/final-dump/string.exp index 0da2dd70c..2f4591d81 100644 --- a/test-cases/final-dump/string.exp +++ b/test-cases/final-dump/string.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module string representation : (not a type) public submods : @@ -36,52 +39,54 @@ module top-level code > public {semipure} (0 calls) foreign lpvm load(<>:wybe.phantom, ?%tmp#46##0:wybe.phantom) @string:nn:nn foreign c putchar('\n':wybe.char, ~tmp#46##0:wybe.phantom, ?tmp#47##0:wybe.phantom) @string:nn:nn foreign lpvm store(~%tmp#47##0:wybe.phantom, <>:wybe.phantom) @string:nn:nn - foreign llvm shl('a':wybe.string, 2:wybe.string, ?tmp#106##0:wybe.string) @string:nn:nn - foreign llvm or(~tmp#106##0:wybe.string, 1024:wybe.string, ?tmp#107##0:wybe.string) @string:nn:nn - foreign llvm or(~tmp#107##0:wybe.string, 3:wybe.string, ?tmp#1##0:wybe.string) @string:nn:nn + foreign lpvm cast('a':wybe.char, ?tmp#111##0:wybe.string) @string:nn:nn + foreign llvm shl(~tmp#111##0:wybe.string, 2:wybe.string, ?tmp#112##0:wybe.string) @string:nn:nn + foreign llvm or(~tmp#112##0:wybe.string, 1024:wybe.string, ?tmp#113##0:wybe.string) @string:nn:nn + foreign llvm or(~tmp#113##0:wybe.string, 3:wybe.string, ?tmp#1##0:wybe.string) @string:nn:nn wybe.string.print<0>(tmp#1##0:wybe.string)<{<>}; {<>}; {}> #66 @string:nn:nn - foreign lpvm load(<>:wybe.phantom, ?%tmp#52##0:wybe.phantom) @string:nn:nn - foreign c putchar('\n':wybe.char, ~tmp#52##0:wybe.phantom, ?tmp#53##0:wybe.phantom) @string:nn:nn - foreign lpvm store(~%tmp#53##0:wybe.phantom, <>:wybe.phantom) @string:nn:nn + foreign lpvm load(<>:wybe.phantom, ?%tmp#53##0:wybe.phantom) @string:nn:nn + foreign c putchar('\n':wybe.char, ~tmp#53##0:wybe.phantom, ?tmp#54##0:wybe.phantom) @string:nn:nn + foreign lpvm store(~%tmp#54##0:wybe.phantom, <>:wybe.phantom) @string:nn:nn wybe.range.construct<0>(1:wybe.int, 3:wybe.int, 100:wybe.int, ?tmp#3##0:wybe.range) #67 @string:nn:nn wybe.string.[]<1>("abcdefghi":wybe.string, tmp#3##0:wybe.range, ?tmp#2##0:wybe.string) #9 @string:nn:nn wybe.string.print<0>[410bae77d3](~tmp#2##0:wybe.string)<{<>}; {<>}; {}> #68 @string:nn:nn - foreign lpvm load(<>:wybe.phantom, ?%tmp#58##0:wybe.phantom) @string:nn:nn - foreign c putchar('\n':wybe.char, ~tmp#58##0:wybe.phantom, ?tmp#59##0:wybe.phantom) @string:nn:nn - foreign lpvm store(~%tmp#59##0:wybe.phantom, <>:wybe.phantom) @string:nn:nn + foreign lpvm load(<>:wybe.phantom, ?%tmp#59##0:wybe.phantom) @string:nn:nn + foreign c putchar('\n':wybe.char, ~tmp#59##0:wybe.phantom, ?tmp#60##0:wybe.phantom) @string:nn:nn + foreign lpvm store(~%tmp#60##0:wybe.phantom, <>:wybe.phantom) @string:nn:nn wybe.string.[]<1>("abcdefghi":wybe.string, ~tmp#3##0:wybe.range, ?tmp#5##0:wybe.string) #12 @string:nn:nn wybe.range...<0>(1:wybe.int, 3:wybe.int, ?tmp#7##0:wybe.range) #13 @string:nn:nn wybe.string.[]<1>(~tmp#5##0:wybe.string, ~tmp#7##0:wybe.range, ?tmp#4##0:wybe.string) #14 @string:nn:nn wybe.string.print<0>[410bae77d3](~tmp#4##0:wybe.string)<{<>}; {<>}; {}> #70 @string:nn:nn - foreign lpvm load(<>:wybe.phantom, ?%tmp#64##0:wybe.phantom) @string:nn:nn - foreign c putchar('\n':wybe.char, ~tmp#64##0:wybe.phantom, ?tmp#65##0:wybe.phantom) @string:nn:nn - foreign c print_string(c"\nTESTING CONVERSION TO c_string":wybe.c_string, ~tmp#65##0:wybe.phantom, ?tmp#68##0:wybe.phantom) @string:nn:nn - foreign c putchar('\n':wybe.char, ~tmp#68##0:wybe.phantom, ?tmp#69##0:wybe.phantom) @string:nn:nn - foreign lpvm store(~%tmp#69##0:wybe.phantom, <>:wybe.phantom) @string:nn:nn - foreign llvm shl('d':wybe.string, 2:wybe.string, ?tmp#71##0:wybe.string) @string:nn:nn - foreign llvm or(~tmp#71##0:wybe.string, 1024:wybe.string, ?tmp#72##0:wybe.string) @string:nn:nn - foreign llvm or(~tmp#72##0:wybe.string, 3:wybe.string, ?tmp#10##0:wybe.string) @string:nn:nn + foreign lpvm load(<>:wybe.phantom, ?%tmp#65##0:wybe.phantom) @string:nn:nn + foreign c putchar('\n':wybe.char, ~tmp#65##0:wybe.phantom, ?tmp#66##0:wybe.phantom) @string:nn:nn + foreign c print_string(c"\nTESTING CONVERSION TO c_string":wybe.c_string, ~tmp#66##0:wybe.phantom, ?tmp#69##0:wybe.phantom) @string:nn:nn + foreign c putchar('\n':wybe.char, ~tmp#69##0:wybe.phantom, ?tmp#70##0:wybe.phantom) @string:nn:nn + foreign lpvm store(~%tmp#70##0:wybe.phantom, <>:wybe.phantom) @string:nn:nn + foreign lpvm cast('d':wybe.char, ?tmp#72##0:wybe.string) @string:nn:nn + foreign llvm shl(~tmp#72##0:wybe.string, 2:wybe.string, ?tmp#73##0:wybe.string) @string:nn:nn + foreign llvm or(~tmp#73##0:wybe.string, 1024:wybe.string, ?tmp#74##0:wybe.string) @string:nn:nn + foreign llvm or(~tmp#74##0:wybe.string, 3:wybe.string, ?tmp#10##0:wybe.string) @string:nn:nn wybe.range...<0>(1:wybe.int, 2:wybe.int, ?tmp#12##0:wybe.range) #18 @string:nn:nn wybe.string.[]<1>("efg":wybe.string, ~tmp#12##0:wybe.range, ?tmp#11##0:wybe.string) #19 @string:nn:nn wybe.string.,,<0>(~tmp#10##0:wybe.string, ~tmp#11##0:wybe.string, ?tmp#9##0:wybe.string) #20 @string:nn:nn wybe.string.,,<0>("abc":wybe.string, ~tmp#9##0:wybe.string, ?tmp#8##0:wybe.string) #21 @string:nn:nn wybe.string.c_string<0>(tmp#8##0:wybe.string, ?r##0:wybe.c_string) #22 @string:nn:nn wybe.string.print<0>(~tmp#8##0:wybe.string)<{<>}; {<>}; {}> #23 @string:nn:nn - foreign lpvm load(<>:wybe.phantom, ?%tmp#74##0:wybe.phantom) @string:nn:nn - foreign c putchar(' ':wybe.char, ~tmp#74##0:wybe.phantom, ?tmp#75##0:wybe.phantom) @string:nn:nn - foreign c print_string(~r##0:wybe.c_string, ~tmp#75##0:wybe.phantom, ?tmp#78##0:wybe.phantom) @string:nn:nn - foreign c putchar('\n':wybe.char, ~tmp#78##0:wybe.phantom, ?tmp#79##0:wybe.phantom) @string:nn:nn - foreign c print_string(c"\nTESTING LOOPS":wybe.c_string, ~tmp#79##0:wybe.phantom, ?tmp#82##0:wybe.phantom) @string:nn:nn - foreign c putchar('\n':wybe.char, ~tmp#82##0:wybe.phantom, ?tmp#83##0:wybe.phantom) @string:nn:nn - foreign lpvm store(~%tmp#83##0:wybe.phantom, <>:wybe.phantom) @string:nn:nn + foreign lpvm load(<>:wybe.phantom, ?%tmp#76##0:wybe.phantom) @string:nn:nn + foreign c putchar(' ':wybe.char, ~tmp#76##0:wybe.phantom, ?tmp#77##0:wybe.phantom) @string:nn:nn + foreign c print_string(~r##0:wybe.c_string, ~tmp#77##0:wybe.phantom, ?tmp#80##0:wybe.phantom) @string:nn:nn + foreign c putchar('\n':wybe.char, ~tmp#80##0:wybe.phantom, ?tmp#81##0:wybe.phantom) @string:nn:nn + foreign c print_string(c"\nTESTING LOOPS":wybe.c_string, ~tmp#81##0:wybe.phantom, ?tmp#84##0:wybe.phantom) @string:nn:nn + foreign c putchar('\n':wybe.char, ~tmp#84##0:wybe.phantom, ?tmp#85##0:wybe.phantom) @string:nn:nn + foreign lpvm store(~%tmp#85##0:wybe.phantom, <>:wybe.phantom) @string:nn:nn string.print_loop#cont#1<0>("abc":wybe.string)<{<>}; {<>}; {}> #71 @string:nn:nn wybe.range.irange<0>(10:wybe.int, -1:wybe.int, 1:wybe.int, ?tmp#14##0:wybe.range) #28 @string:nn:nn wybe.string.[]<1>("abcdefghijkl":wybe.string, ~tmp#14##0:wybe.range, ?tmp#13##0:wybe.string) #29 @string:nn:nn string.print_loop#cont#1<0>[410bae77d3](~tmp#13##0:wybe.string)<{<>}; {<>}; {}> #72 @string:nn:nn - foreign lpvm load(<>:wybe.phantom, ?%tmp#87##0:wybe.phantom) @string:nn:nn - foreign c print_string(c"\nTESTING INDEXING":wybe.c_string, ~tmp#87##0:wybe.phantom, ?tmp#88##0:wybe.phantom) @string:nn:nn - foreign c putchar('\n':wybe.char, ~tmp#88##0:wybe.phantom, ?tmp#89##0:wybe.phantom) @string:nn:nn - foreign lpvm store(~%tmp#89##0:wybe.phantom, <>:wybe.phantom) @string:nn:nn + foreign lpvm load(<>:wybe.phantom, ?%tmp#89##0:wybe.phantom) @string:nn:nn + foreign c print_string(c"\nTESTING INDEXING":wybe.c_string, ~tmp#89##0:wybe.phantom, ?tmp#90##0:wybe.phantom) @string:nn:nn + foreign c putchar('\n':wybe.char, ~tmp#90##0:wybe.phantom, ?tmp#91##0:wybe.phantom) @string:nn:nn + foreign lpvm store(~%tmp#91##0:wybe.phantom, <>:wybe.phantom) @string:nn:nn string.test_index<0>("abc":wybe.string, 0:wybe.int)<{<>}; {<>}; {}> #32 @string:nn:nn string.test_index<0>("abc":wybe.string, 1:wybe.int)<{<>}; {<>}; {}> #33 @string:nn:nn string.test_index<0>("abcdefghijklmnopqrstuvwxyz":wybe.string, 25:wybe.int)<{<>}; {<>}; {}> #34 @string:nn:nn @@ -100,12 +105,14 @@ module top-level code > public {semipure} (0 calls) string.test_index<0>(~tmp#21##0:wybe.string, 2:wybe.int)<{<>}; {<>}; {}> #50 @string:nn:nn wybe.string.,,<0>("abc":wybe.string, tmp#1##0:wybe.string, ?tmp#23##0:wybe.string) #52 @string:nn:nn string.test_index<0>(~tmp#23##0:wybe.string, 2:wybe.int)<{<>}; {<>}; {}> #53 @string:nn:nn - foreign llvm shl('b':wybe.string, 2:wybe.string, ?tmp#109##0:wybe.string) @string:nn:nn - foreign llvm or(~tmp#109##0:wybe.string, 1024:wybe.string, ?tmp#110##0:wybe.string) @string:nn:nn - foreign llvm or(~tmp#110##0:wybe.string, 3:wybe.string, ?tmp#29##0:wybe.string) @string:nn:nn - foreign llvm shl('c':wybe.string, 2:wybe.string, ?tmp#112##0:wybe.string) @string:nn:nn - foreign llvm or(~tmp#112##0:wybe.string, 1024:wybe.string, ?tmp#113##0:wybe.string) @string:nn:nn - foreign llvm or(~tmp#113##0:wybe.string, 3:wybe.string, ?tmp#30##0:wybe.string) @string:nn:nn + foreign lpvm cast('b':wybe.char, ?tmp#115##0:wybe.string) @string:nn:nn + foreign llvm shl(~tmp#115##0:wybe.string, 2:wybe.string, ?tmp#116##0:wybe.string) @string:nn:nn + foreign llvm or(~tmp#116##0:wybe.string, 1024:wybe.string, ?tmp#117##0:wybe.string) @string:nn:nn + foreign llvm or(~tmp#117##0:wybe.string, 3:wybe.string, ?tmp#29##0:wybe.string) @string:nn:nn + foreign lpvm cast('c':wybe.char, ?tmp#119##0:wybe.string) @string:nn:nn + foreign llvm shl(~tmp#119##0:wybe.string, 2:wybe.string, ?tmp#120##0:wybe.string) @string:nn:nn + foreign llvm or(~tmp#120##0:wybe.string, 1024:wybe.string, ?tmp#121##0:wybe.string) @string:nn:nn + foreign llvm or(~tmp#121##0:wybe.string, 3:wybe.string, ?tmp#30##0:wybe.string) @string:nn:nn wybe.string.,,<0>(~tmp#29##0:wybe.string, ~tmp#30##0:wybe.string, ?tmp#28##0:wybe.string) #57 @string:nn:nn wybe.string.,,<0>(~tmp#1##0:wybe.string, ~tmp#28##0:wybe.string, ?tmp#26##0:wybe.string) #58 @string:nn:nn wybe.range...<0>(0:wybe.int, 2:wybe.int, ?tmp#31##0:wybe.range) #59 @string:nn:nn @@ -122,7 +129,7 @@ print_loop(s##0:wybe.string)<{<>}; {<>}; {}>: proc print_loop#cont#1 > (2 calls) -0: string.print_loop#cont#1<0>[410bae77d3] +0: string.print_loop#cont#1<0> print_loop#cont#1(tmp#0##0:wybe.string)<{<>}; {<>}; {}>: AliasPairs: [] InterestingCallProperties: [InterestingUnaliased 0] @@ -178,267 +185,183 @@ test_index(s##0:wybe.string, i##0:wybe.int)<{<>}; {<>}; LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'string' - - - - -@string.2 = constant {i64, i64} { i64 0, i64 ptrtoint ([?? x i8]* @string.1 to i64) } - - -@string.4 = constant {i64, i64} { i64 1, i64 ptrtoint ([?? x i8]* @string.3 to i64) } - - -@string.19 = constant {i64, i64} { i64 2, i64 ptrtoint ([?? x i8]* @string.18 to i64) } - - -@string.21 = constant {i64, i64} { i64 2, i64 ptrtoint ([?? x i8]* @string.20 to i64) } - - -@string.11 = constant {i64, i64} { i64 3, i64 ptrtoint ([?? x i8]* @string.10 to i64) } - - -@string.6 = constant {i64, i64} { i64 3, i64 ptrtoint ([?? x i8]* @string.5 to i64) } - - -@string.23 = constant {i64, i64} { i64 8, i64 ptrtoint ([?? x i8]* @string.22 to i64) } - - -@string.8 = constant {i64, i64} { i64 9, i64 ptrtoint ([?? x i8]* @string.7 to i64) } - - -@string.14 = constant {i64, i64} { i64 12, i64 ptrtoint ([?? x i8]* @string.13 to i64) } - - -@string.17 = constant {i64, i64} { i64 26, i64 ptrtoint ([?? x i8]* @string.16 to i64) } - - -@string.1 = constant [?? x i8] c"\00" - - -@string.9 = constant [?? x i8] c"\0aTESTING CONVERSION TO c_string\00" - - -@string.15 = constant [?? x i8] c"\0aTESTING INDEXING\00" - - -@string.12 = constant [?? x i8] c"\0aTESTING LOOPS\00" - - -@string.24 = constant [?? x i8] c"OUT OF RANGE\00" - - -@string.0 = constant [?? x i8] c"TESTING CONSTRUCTION\00" - - -@string.3 = constant [?? x i8] c"a\00" - - -@string.18 = constant [?? x i8] c"ab\00" - - -@string.5 = constant [?? x i8] c"abc\00" - - -@string.22 = constant [?? x i8] c"abcdefgh\00" - - -@string.7 = constant [?? x i8] c"abcdefghi\00" - - -@string.13 = constant [?? x i8] c"abcdefghijkl\00" - - -@string.16 = constant [?? x i8] c"abcdefghijklmnopqrstuvwxyz\00" - - -@string.20 = constant [?? x i8] c"cd\00" - - -@string.10 = constant [?? x i8] c"efg\00" - - -declare external ccc void @putchar(i8) - - -declare external ccc void @print_string(i64) - - -declare external fastcc {i8, i1} @"wybe.string.[]<0>"(i64, i64) - - -declare external fastcc {i8, i64, i1} @"wybe.string.[|]<0>[785a827a1b]"(i64) - - -declare external fastcc {i8, i64, i1} @"wybe.string.[|]<0>"(i64) - - -declare external fastcc i64 @"wybe.string.[]<1>"(i64, i64) - - -declare external fastcc i64 @"wybe.range...<0>"(i64, i64) - - -declare external fastcc i64 @"wybe.string.,,<0>"(i64, i64) - - -declare external fastcc i64 @"wybe.range.construct<0>"(i64, i64, i64) - - -declare external fastcc i64 @"wybe.range.irange<0>"(i64, i64, i64) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external fastcc i64 @"wybe.string.c_string<0>"(i64) - - -declare external fastcc void @"wybe.string.print<0>[410bae77d3]"(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"string.<0>"() { -entry: - tail call ccc void @print_string(i64 ptrtoint (i8* getelementptr inbounds ([?? x i8], [?? x i8]* @string.0, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @string.2, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @string.4, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @string.6, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - %0 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @string.6, i32 0, i32 0) to i64), i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @string.6, i32 0, i32 0) to i64)) - tail call fastcc void @"wybe.string.print<0>[410bae77d3]"(i64 %0) - tail call ccc void @putchar(i8 10) - %1 = shl i64 97, 2 - %2 = or i64 %1, 1024 - %3 = or i64 %2, 3 - tail call fastcc void @"wybe.string.print<0>"(i64 %3) - tail call ccc void @putchar(i8 10) - %4 = tail call fastcc i64 @"wybe.range.construct<0>"(i64 1, i64 3, i64 100) - %5 = tail call fastcc i64 @"wybe.string.[]<1>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @string.8, i32 0, i32 0) to i64), i64 %4) - tail call fastcc void @"wybe.string.print<0>[410bae77d3]"(i64 %5) - tail call ccc void @putchar(i8 10) - %6 = tail call fastcc i64 @"wybe.string.[]<1>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @string.8, i32 0, i32 0) to i64), i64 %4) - %7 = tail call fastcc i64 @"wybe.range...<0>"(i64 1, i64 3) - %8 = tail call fastcc i64 @"wybe.string.[]<1>"(i64 %6, i64 %7) - tail call fastcc void @"wybe.string.print<0>[410bae77d3]"(i64 %8) - tail call ccc void @putchar(i8 10) - tail call ccc void @print_string(i64 ptrtoint (i8* getelementptr inbounds ([?? x i8], [?? x i8]* @string.9, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - %9 = shl i64 100, 2 - %10 = or i64 %9, 1024 - %11 = or i64 %10, 3 - %12 = tail call fastcc i64 @"wybe.range...<0>"(i64 1, i64 2) - %13 = tail call fastcc i64 @"wybe.string.[]<1>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @string.11, i32 0, i32 0) to i64), i64 %12) - %14 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 %11, i64 %13) - %15 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @string.6, i32 0, i32 0) to i64), i64 %14) - %16 = tail call fastcc i64 @"wybe.string.c_string<0>"(i64 %15) - tail call fastcc void @"wybe.string.print<0>"(i64 %15) - tail call ccc void @putchar(i8 32) - tail call ccc void @print_string(i64 %16) - tail call ccc void @putchar(i8 10) - tail call ccc void @print_string(i64 ptrtoint (i8* getelementptr inbounds ([?? x i8], [?? x i8]* @string.12, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"string.print_loop#cont#1<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @string.6, i32 0, i32 0) to i64)) - %17 = tail call fastcc i64 @"wybe.range.irange<0>"(i64 10, i64 -1, i64 1) - %18 = tail call fastcc i64 @"wybe.string.[]<1>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @string.14, i32 0, i32 0) to i64), i64 %17) - tail call fastcc void @"string.print_loop#cont#1<0>[410bae77d3]"(i64 %18) - tail call ccc void @print_string(i64 ptrtoint (i8* getelementptr inbounds ([?? x i8], [?? x i8]* @string.15, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"string.test_index<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @string.6, i32 0, i32 0) to i64), i64 0) - tail call fastcc void @"string.test_index<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @string.6, i32 0, i32 0) to i64), i64 1) - tail call fastcc void @"string.test_index<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @string.17, i32 0, i32 0) to i64), i64 25) - %19 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @string.19, i32 0, i32 0) to i64), i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @string.21, i32 0, i32 0) to i64)) - tail call fastcc void @"string.test_index<0>"(i64 %19, i64 1) - %20 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @string.19, i32 0, i32 0) to i64), i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @string.21, i32 0, i32 0) to i64)) - tail call fastcc void @"string.test_index<0>"(i64 %20, i64 2) - tail call fastcc void @"string.test_index<0>"(i64 %3, i64 0) - %21 = tail call fastcc i64 @"wybe.range.construct<0>"(i64 0, i64 2, i64 10) - %22 = tail call fastcc i64 @"wybe.string.[]<1>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @string.23, i32 0, i32 0) to i64), i64 %21) - tail call fastcc void @"string.test_index<0>"(i64 %22, i64 0) - tail call fastcc void @"string.test_index<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @string.6, i32 0, i32 0) to i64), i64 3) - tail call fastcc void @"string.test_index<0>"(i64 %3, i64 3) - tail call fastcc void @"string.test_index<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @string.6, i32 0, i32 0) to i64), i64 -3) - %23 = tail call fastcc i64 @"wybe.string.[]<1>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @string.6, i32 0, i32 0) to i64), i64 %21) - tail call fastcc void @"string.test_index<0>"(i64 %23, i64 2) - %24 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @string.6, i32 0, i32 0) to i64), i64 %3) - tail call fastcc void @"string.test_index<0>"(i64 %24, i64 2) - %25 = shl i64 98, 2 - %26 = or i64 %25, 1024 - %27 = or i64 %26, 3 - %28 = shl i64 99, 2 - %29 = or i64 %28, 1024 - %30 = or i64 %29, 3 - %31 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 %27, i64 %30) - %32 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 %3, i64 %31) - %33 = tail call fastcc i64 @"wybe.range...<0>"(i64 0, i64 2) - %34 = tail call fastcc i64 @"wybe.string.[]<1>"(i64 %32, i64 %33) - tail call fastcc void @"string.test_index<0>"(i64 %34, i64 1) - ret void +source_filename = "!ROOT!/final-dump/string.wybe" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c"\00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c"\0ATESTING CONVERSION TO c_string\00", align 8 +@"cstring#2" = private unnamed_addr constant [ ?? x i8 ] c"\0ATESTING INDEXING\00", align 8 +@"cstring#3" = private unnamed_addr constant [ ?? x i8 ] c"\0ATESTING LOOPS\00", align 8 +@"cstring#4" = private unnamed_addr constant [ ?? x i8 ] c"OUT OF RANGE\00", align 8 +@"cstring#5" = private unnamed_addr constant [ ?? x i8 ] c"TESTING CONSTRUCTION\00", align 8 +@"cstring#6" = private unnamed_addr constant [ ?? x i8 ] c"a\00", align 8 +@"cstring#7" = private unnamed_addr constant [ ?? x i8 ] c"ab\00", align 8 +@"cstring#8" = private unnamed_addr constant [ ?? x i8 ] c"abc\00", align 8 +@"cstring#9" = private unnamed_addr constant [ ?? x i8 ] c"abcdefgh\00", align 8 +@"cstring#10" = private unnamed_addr constant [ ?? x i8 ] c"abcdefghi\00", align 8 +@"cstring#11" = private unnamed_addr constant [ ?? x i8 ] c"abcdefghijkl\00", align 8 +@"cstring#12" = private unnamed_addr constant [ ?? x i8 ] c"abcdefghijklmnopqrstuvwxyz\00", align 8 +@"cstring#13" = private unnamed_addr constant [ ?? x i8 ] c"cd\00", align 8 +@"cstring#14" = private unnamed_addr constant [ ?? x i8 ] c"efg\00", align 8 +@"string#15" = private unnamed_addr constant {i64, i64} { i64 0, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +@"string#16" = private unnamed_addr constant {i64, i64} { i64 1, i64 ptrtoint( ptr @"cstring#6" to i64 ) }, align 8 +@"string#17" = private unnamed_addr constant {i64, i64} { i64 2, i64 ptrtoint( ptr @"cstring#7" to i64 ) }, align 8 +@"string#18" = private unnamed_addr constant {i64, i64} { i64 3, i64 ptrtoint( ptr @"cstring#8" to i64 ) }, align 8 +@"string#19" = private unnamed_addr constant {i64, i64} { i64 8, i64 ptrtoint( ptr @"cstring#9" to i64 ) }, align 8 +@"string#20" = private unnamed_addr constant {i64, i64} { i64 9, i64 ptrtoint( ptr @"cstring#10" to i64 ) }, align 8 +@"string#21" = private unnamed_addr constant {i64, i64} { i64 12, i64 ptrtoint( ptr @"cstring#11" to i64 ) }, align 8 +@"string#22" = private unnamed_addr constant {i64, i64} { i64 26, i64 ptrtoint( ptr @"cstring#12" to i64 ) }, align 8 +@"string#23" = private unnamed_addr constant {i64, i64} { i64 2, i64 ptrtoint( ptr @"cstring#13" to i64 ) }, align 8 +@"string#24" = private unnamed_addr constant {i64, i64} { i64 3, i64 ptrtoint( ptr @"cstring#14" to i64 ) }, align 8 + +declare external fastcc i64 @"wybe.range...<0>"(i64, i64) +declare external fastcc i64 @"wybe.range.construct<0>"(i64, i64, i64) +declare external fastcc i64 @"wybe.range.irange<0>"(i64, i64, i64) +declare external fastcc i64 @"wybe.string.,,<0>"(i64, i64) +declare external fastcc {i8, i1} @"wybe.string.[]<0>"(i64, i64) +declare external fastcc i64 @"wybe.string.[]<1>"(i64, i64) +declare external fastcc {i8, i64, i1} @"wybe.string.[|]<0>"(i64) +declare external fastcc {i8, i64, i1} @"wybe.string.[|]<0>[785a827a1b]"(i64) +declare external fastcc i64 @"wybe.string.c_string<0>"(i64) +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external fastcc void @"wybe.string.print<0>[410bae77d3]"(i64) +declare external ccc void @print_string(i64) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"string.<0>"() { + call ccc void @print_string(i64 ptrtoint( ptr @"cstring#5" to i64 )) + call ccc void @putchar(i8 10) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#15" to i64 )) + call ccc void @putchar(i8 10) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#16" to i64 )) + call ccc void @putchar(i8 10) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#18" to i64 )) + call ccc void @putchar(i8 10) + %"tmp#0##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint( ptr @"string#18" to i64 ), i64 ptrtoint( ptr @"string#18" to i64 )) + tail call fastcc void @"wybe.string.print<0>[410bae77d3]"(i64 %"tmp#0##0") + call ccc void @putchar(i8 10) + %"tmp#111##0" = zext i8 97 to i64 + %"tmp#112##0" = shl i64 %"tmp#111##0", 2 + %"tmp#113##0" = or i64 %"tmp#112##0", 1024 + %"tmp#1##0" = or i64 %"tmp#113##0", 3 + tail call fastcc void @"wybe.string.print<0>"(i64 %"tmp#1##0") + call ccc void @putchar(i8 10) + %"tmp#3##0" = tail call fastcc i64 @"wybe.range.construct<0>"(i64 1, i64 3, i64 100) + %"tmp#2##0" = tail call fastcc i64 @"wybe.string.[]<1>"(i64 ptrtoint( ptr @"string#20" to i64 ), i64 %"tmp#3##0") + tail call fastcc void @"wybe.string.print<0>[410bae77d3]"(i64 %"tmp#2##0") + call ccc void @putchar(i8 10) + %"tmp#5##0" = tail call fastcc i64 @"wybe.string.[]<1>"(i64 ptrtoint( ptr @"string#20" to i64 ), i64 %"tmp#3##0") + %"tmp#7##0" = tail call fastcc i64 @"wybe.range...<0>"(i64 1, i64 3) + %"tmp#4##0" = tail call fastcc i64 @"wybe.string.[]<1>"(i64 %"tmp#5##0", i64 %"tmp#7##0") + tail call fastcc void @"wybe.string.print<0>[410bae77d3]"(i64 %"tmp#4##0") + call ccc void @putchar(i8 10) + call ccc void @print_string(i64 ptrtoint( ptr @"cstring#1" to i64 )) + call ccc void @putchar(i8 10) + %"tmp#72##0" = zext i8 100 to i64 + %"tmp#73##0" = shl i64 %"tmp#72##0", 2 + %"tmp#74##0" = or i64 %"tmp#73##0", 1024 + %"tmp#10##0" = or i64 %"tmp#74##0", 3 + %"tmp#12##0" = tail call fastcc i64 @"wybe.range...<0>"(i64 1, i64 2) + %"tmp#11##0" = tail call fastcc i64 @"wybe.string.[]<1>"(i64 ptrtoint( ptr @"string#24" to i64 ), i64 %"tmp#12##0") + %"tmp#9##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 %"tmp#10##0", i64 %"tmp#11##0") + %"tmp#8##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint( ptr @"string#18" to i64 ), i64 %"tmp#9##0") + %"r##0" = tail call fastcc i64 @"wybe.string.c_string<0>"(i64 %"tmp#8##0") + tail call fastcc void @"wybe.string.print<0>"(i64 %"tmp#8##0") + call ccc void @putchar(i8 32) + call ccc void @print_string(i64 %"r##0") + call ccc void @putchar(i8 10) + call ccc void @print_string(i64 ptrtoint( ptr @"cstring#3" to i64 )) + call ccc void @putchar(i8 10) + tail call fastcc void @"string.print_loop#cont#1<0>"(i64 ptrtoint( ptr @"string#18" to i64 )) + %"tmp#14##0" = tail call fastcc i64 @"wybe.range.irange<0>"(i64 10, i64 -1, i64 1) + %"tmp#13##0" = tail call fastcc i64 @"wybe.string.[]<1>"(i64 ptrtoint( ptr @"string#21" to i64 ), i64 %"tmp#14##0") + tail call fastcc void @"string.print_loop#cont#1<0>[410bae77d3]"(i64 %"tmp#13##0") + call ccc void @print_string(i64 ptrtoint( ptr @"cstring#2" to i64 )) + call ccc void @putchar(i8 10) + tail call fastcc void @"string.test_index<0>"(i64 ptrtoint( ptr @"string#18" to i64 ), i64 0) + tail call fastcc void @"string.test_index<0>"(i64 ptrtoint( ptr @"string#18" to i64 ), i64 1) + tail call fastcc void @"string.test_index<0>"(i64 ptrtoint( ptr @"string#22" to i64 ), i64 25) + %"tmp#15##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint( ptr @"string#17" to i64 ), i64 ptrtoint( ptr @"string#23" to i64 )) + tail call fastcc void @"string.test_index<0>"(i64 %"tmp#15##0", i64 1) + %"tmp#16##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint( ptr @"string#17" to i64 ), i64 ptrtoint( ptr @"string#23" to i64 )) + tail call fastcc void @"string.test_index<0>"(i64 %"tmp#16##0", i64 2) + tail call fastcc void @"string.test_index<0>"(i64 %"tmp#1##0", i64 0) + %"tmp#19##0" = tail call fastcc i64 @"wybe.range.construct<0>"(i64 0, i64 2, i64 10) + %"tmp#18##0" = tail call fastcc i64 @"wybe.string.[]<1>"(i64 ptrtoint( ptr @"string#19" to i64 ), i64 %"tmp#19##0") + tail call fastcc void @"string.test_index<0>"(i64 %"tmp#18##0", i64 0) + tail call fastcc void @"string.test_index<0>"(i64 ptrtoint( ptr @"string#18" to i64 ), i64 3) + tail call fastcc void @"string.test_index<0>"(i64 %"tmp#1##0", i64 3) + tail call fastcc void @"string.test_index<0>"(i64 ptrtoint( ptr @"string#18" to i64 ), i64 -3) + %"tmp#21##0" = tail call fastcc i64 @"wybe.string.[]<1>"(i64 ptrtoint( ptr @"string#18" to i64 ), i64 %"tmp#19##0") + tail call fastcc void @"string.test_index<0>"(i64 %"tmp#21##0", i64 2) + %"tmp#23##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint( ptr @"string#18" to i64 ), i64 %"tmp#1##0") + tail call fastcc void @"string.test_index<0>"(i64 %"tmp#23##0", i64 2) + %"tmp#115##0" = zext i8 98 to i64 + %"tmp#116##0" = shl i64 %"tmp#115##0", 2 + %"tmp#117##0" = or i64 %"tmp#116##0", 1024 + %"tmp#29##0" = or i64 %"tmp#117##0", 3 + %"tmp#119##0" = zext i8 99 to i64 + %"tmp#120##0" = shl i64 %"tmp#119##0", 2 + %"tmp#121##0" = or i64 %"tmp#120##0", 1024 + %"tmp#30##0" = or i64 %"tmp#121##0", 3 + %"tmp#28##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 %"tmp#29##0", i64 %"tmp#30##0") + %"tmp#26##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 %"tmp#1##0", i64 %"tmp#28##0") + %"tmp#31##0" = tail call fastcc i64 @"wybe.range...<0>"(i64 0, i64 2) + %"tmp#25##0" = tail call fastcc i64 @"wybe.string.[]<1>"(i64 %"tmp#26##0", i64 %"tmp#31##0") + tail call fastcc void @"string.test_index<0>"(i64 %"tmp#25##0", i64 1) + ret void } - -define external fastcc void @"string.print_loop<0>"(i64 %"s##0") alwaysinline { -entry: - musttail call fastcc void @"string.print_loop#cont#1<0>"(i64 %"s##0") - ret void +define external fastcc void @"string.print_loop<0>"(i64 %"s##0") { + tail call fastcc void @"string.print_loop#cont#1<0>"(i64 %"s##0") + ret void } - -define external fastcc void @"string.print_loop#cont#1<0>"(i64 %"tmp#0##0") { -entry: - %0 = tail call fastcc {i8, i64, i1} @"wybe.string.[|]<0>"(i64 %"tmp#0##0") - %1 = extractvalue {i8, i64, i1} %0, 0 - %2 = extractvalue {i8, i64, i1} %0, 1 - %3 = extractvalue {i8, i64, i1} %0, 2 - br i1 %3, label %if.then, label %if.else -if.then: - tail call ccc void @putchar(i8 %1) - musttail call fastcc void @"string.print_loop#cont#1<0>[410bae77d3]"(i64 %2) - ret void -if.else: - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"string.print_loop#cont#1<0>"(i64 %"tmp#0##0") { + %"tmp#8##0" = tail call fastcc {i8, i64, i1} @"wybe.string.[|]<0>"(i64 %"tmp#0##0") + %"c##0" = extractvalue {i8, i64, i1}%"tmp#8##0", 0 + %"tmp#0##1" = extractvalue {i8, i64, i1}%"tmp#8##0", 1 + %"tmp#2##0" = extractvalue {i8, i64, i1}%"tmp#8##0", 2 + br i1 %"tmp#2##0", label %if.then.0, label %if.else.0 +if.then.0: + call ccc void @putchar(i8 %"c##0") + tail call fastcc void @"string.print_loop#cont#1<0>[410bae77d3]"(i64 %"tmp#0##1") + ret void +if.else.0: + call ccc void @putchar(i8 10) + ret void } - -define external fastcc void @"string.print_loop#cont#1<0>[410bae77d3]"(i64 %"tmp#0##0") { -entry: - %0 = tail call fastcc {i8, i64, i1} @"wybe.string.[|]<0>[785a827a1b]"(i64 %"tmp#0##0") - %1 = extractvalue {i8, i64, i1} %0, 0 - %2 = extractvalue {i8, i64, i1} %0, 1 - %3 = extractvalue {i8, i64, i1} %0, 2 - br i1 %3, label %if.then, label %if.else -if.then: - tail call ccc void @putchar(i8 %1) - musttail call fastcc void @"string.print_loop#cont#1<0>[410bae77d3]"(i64 %2) - ret void -if.else: - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"string.print_loop#cont#1<0>[410bae77d3]"(i64 %"tmp#0##0") { + %"tmp#8##0" = tail call fastcc {i8, i64, i1} @"wybe.string.[|]<0>[785a827a1b]"(i64 %"tmp#0##0") + %"c##0" = extractvalue {i8, i64, i1}%"tmp#8##0", 0 + %"tmp#0##1" = extractvalue {i8, i64, i1}%"tmp#8##0", 1 + %"tmp#2##0" = extractvalue {i8, i64, i1}%"tmp#8##0", 2 + br i1 %"tmp#2##0", label %if.then.0, label %if.else.0 +if.then.0: + call ccc void @putchar(i8 %"c##0") + tail call fastcc void @"string.print_loop#cont#1<0>[410bae77d3]"(i64 %"tmp#0##1") + ret void +if.else.0: + call ccc void @putchar(i8 10) + ret void } - -define external fastcc void @"string.test_index<0>"(i64 %"s##0", i64 %"i##0") { -entry: - %0 = tail call fastcc {i8, i1} @"wybe.string.[]<0>"(i64 %"s##0", i64 %"i##0") - %1 = extractvalue {i8, i1} %0, 0 - %2 = extractvalue {i8, i1} %0, 1 - br i1 %2, label %if.then, label %if.else -if.then: - tail call ccc void @putchar(i8 %1) - tail call ccc void @putchar(i8 10) - ret void -if.else: - tail call ccc void @print_string(i64 ptrtoint (i8* getelementptr inbounds ([?? x i8], [?? x i8]* @string.24, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"string.test_index<0>"(i64 %"s##0", i64 %"i##0") { + %"tmp#10##0" = tail call fastcc {i8, i1} @"wybe.string.[]<0>"(i64 %"s##0", i64 %"i##0") + %"tmp#0##0" = extractvalue {i8, i1}%"tmp#10##0", 0 + %"tmp#1##0" = extractvalue {i8, i1}%"tmp#10##0", 1 + br i1 %"tmp#1##0", label %if.then.0, label %if.else.0 +if.then.0: + call ccc void @putchar(i8 %"tmp#0##0") + call ccc void @putchar(i8 10) + ret void +if.else.0: + call ccc void @print_string(i64 ptrtoint( ptr @"cstring#4" to i64 )) + call ccc void @putchar(i8 10) + ret void } diff --git a/test-cases/final-dump/string_interpolation.exp b/test-cases/final-dump/string_interpolation.exp index d8d9f737b..01e05305b 100644 --- a/test-cases/final-dump/string_interpolation.exp +++ b/test-cases/final-dump/string_interpolation.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module string_interpolation representation : (not a type) public submods : @@ -41,87 +44,49 @@ module top-level code > public {semipure} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'string_interpolation' - - - - -@string_interpolation.3 = constant {i64, i64} { i64 1, i64 ptrtoint ([?? x i8]* @string_interpolation.2 to i64) } - - -@string_interpolation.1 = constant {i64, i64} { i64 4, i64 ptrtoint ([?? x i8]* @string_interpolation.0 to i64) } - - -@string_interpolation.5 = constant {i64, i64} { i64 7, i64 ptrtoint ([?? x i8]* @string_interpolation.4 to i64) } - - -@string_interpolation.11 = constant {i64, i64} { i64 10, i64 ptrtoint ([?? x i8]* @string_interpolation.10 to i64) } - - -@string_interpolation.7 = constant {i64, i64} { i64 14, i64 ptrtoint ([?? x i8]* @string_interpolation.6 to i64) } - - -@string_interpolation.9 = constant {i64, i64} { i64 15, i64 ptrtoint ([?? x i8]* @string_interpolation.8 to i64) } - - -@string_interpolation.8 = constant [?? x i8] c" and minint is \00" - - -@string_interpolation.6 = constant [?? x i8] c" is the answer\00" - - -@string_interpolation.2 = constant [?? x i8] c"!\00" - - -@string_interpolation.4 = constant [?? x i8] c"Hello, \00" - - -@string_interpolation.0 = constant [?? x i8] c"Wybe\00" - - -@string_interpolation.10 = constant [?? x i8] c"maxint is \00" - - -declare external ccc void @putchar(i8) - - -declare external fastcc void @"wybe.string.print<0>[410bae77d3]"(i64) - - -declare external fastcc i64 @"wybe.string.,,<0>"(i64, i64) - - -declare external fastcc i64 @"wybe.int.fmt<2>"(i64, i64, i8) - - -declare external ccc i64 @ipow(i64, i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"string_interpolation.<0>"() { -entry: - %0 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @string_interpolation.1, i32 0, i32 0) to i64), i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @string_interpolation.3, i32 0, i32 0) to i64)) - %1 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @string_interpolation.5, i32 0, i32 0) to i64), i64 %0) - tail call fastcc void @"wybe.string.print<0>[410bae77d3]"(i64 %1) - tail call ccc void @putchar(i8 10) - %2 = tail call fastcc i64 @"wybe.int.fmt<2>"(i64 42, i64 0, i8 32) - %3 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 %2, i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @string_interpolation.7, i32 0, i32 0) to i64)) - tail call fastcc void @"wybe.string.print<0>[410bae77d3]"(i64 %3) - tail call ccc void @putchar(i8 10) - %4 = tail call ccc i64 @ipow(i64 2, i64 63) - %5 = sub i64 %4, 1 - %6 = tail call fastcc i64 @"wybe.int.fmt<2>"(i64 %5, i64 0, i8 32) - %7 = tail call fastcc i64 @"wybe.int.fmt<2>"(i64 %4, i64 0, i8 32) - %8 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @string_interpolation.9, i32 0, i32 0) to i64), i64 %7) - %9 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 %6, i64 %8) - %10 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @string_interpolation.11, i32 0, i32 0) to i64), i64 %9) - tail call fastcc void @"wybe.string.print<0>[410bae77d3]"(i64 %10) - tail call ccc void @putchar(i8 10) - ret void +source_filename = "!ROOT!/final-dump/string_interpolation.wybe" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c" and minint is \00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c" is the answer\00", align 8 +@"cstring#2" = private unnamed_addr constant [ ?? x i8 ] c"!\00", align 8 +@"cstring#3" = private unnamed_addr constant [ ?? x i8 ] c"Hello, \00", align 8 +@"cstring#4" = private unnamed_addr constant [ ?? x i8 ] c"Wybe\00", align 8 +@"cstring#5" = private unnamed_addr constant [ ?? x i8 ] c"maxint is \00", align 8 +@"string#6" = private unnamed_addr constant {i64, i64} { i64 15, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +@"string#7" = private unnamed_addr constant {i64, i64} { i64 14, i64 ptrtoint( ptr @"cstring#1" to i64 ) }, align 8 +@"string#8" = private unnamed_addr constant {i64, i64} { i64 1, i64 ptrtoint( ptr @"cstring#2" to i64 ) }, align 8 +@"string#9" = private unnamed_addr constant {i64, i64} { i64 7, i64 ptrtoint( ptr @"cstring#3" to i64 ) }, align 8 +@"string#10" = private unnamed_addr constant {i64, i64} { i64 4, i64 ptrtoint( ptr @"cstring#4" to i64 ) }, align 8 +@"string#11" = private unnamed_addr constant {i64, i64} { i64 10, i64 ptrtoint( ptr @"cstring#5" to i64 ) }, align 8 + +declare external fastcc i64 @"wybe.int.fmt<2>"(i64, i64, i8) +declare external fastcc i64 @"wybe.string.,,<0>"(i64, i64) +declare external fastcc void @"wybe.string.print<0>[410bae77d3]"(i64) +declare external ccc i64 @ipow(i64, i64) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"string_interpolation.<0>"() { + %"tmp#1##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint( ptr @"string#10" to i64 ), i64 ptrtoint( ptr @"string#8" to i64 )) + %"tmp#0##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint( ptr @"string#9" to i64 ), i64 %"tmp#1##0") + tail call fastcc void @"wybe.string.print<0>[410bae77d3]"(i64 %"tmp#0##0") + call ccc void @putchar(i8 10) + %"tmp#5##0" = tail call fastcc i64 @"wybe.int.fmt<2>"(i64 42, i64 0, i8 32) + %"tmp#4##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 %"tmp#5##0", i64 ptrtoint( ptr @"string#7" to i64 )) + tail call fastcc void @"wybe.string.print<0>[410bae77d3]"(i64 %"tmp#4##0") + call ccc void @putchar(i8 10) + %"tmp#10##0" = call ccc i64 @ipow(i64 2, i64 63) + %"tmp#9##0" = sub i64 %"tmp#10##0", 1 + %"tmp#8##0" = tail call fastcc i64 @"wybe.int.fmt<2>"(i64 %"tmp#9##0", i64 0, i8 32) + %"tmp#12##0" = tail call fastcc i64 @"wybe.int.fmt<2>"(i64 %"tmp#10##0", i64 0, i8 32) + %"tmp#11##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint( ptr @"string#6" to i64 ), i64 %"tmp#12##0") + %"tmp#7##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 %"tmp#8##0", i64 %"tmp#11##0") + %"tmp#6##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint( ptr @"string#11" to i64 ), i64 %"tmp#7##0") + tail call fastcc void @"wybe.string.print<0>[410bae77d3]"(i64 %"tmp#6##0") + call ccc void @putchar(i8 10) + ret void } diff --git a/test-cases/final-dump/student.exp b/test-cases/final-dump/student.exp index c53bee519..cbf646302 100644 --- a/test-cases/final-dump/student.exp +++ b/test-cases/final-dump/student.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module student representation : (not a type) public submods : course -> student.course @@ -46,7 +49,7 @@ module top-level code > public {semipure} (0 calls) proc printStudent > public (1 calls) -0: student.printStudent<0>[410bae77d3] +0: student.printStudent<0> printStudent(stu##0:student.student)<{<>}; {<>}; {}>: AliasPairs: [] InterestingCallProperties: [InterestingUnaliased 0] @@ -93,128 +96,96 @@ printStudent(stu##0:student.student)<{<>}; {<>}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'student' - - - - -@student.3 = constant {i64, i64} { i64 12, i64 ptrtoint ([?? x i8]* @student.2 to i64) } - - -@student.5 = constant {i64, i64} { i64 13, i64 ptrtoint ([?? x i8]* @student.4 to i64) } - - -@student.7 = constant {i64, i64} { i64 13, i64 ptrtoint ([?? x i8]* @student.6 to i64) } - - -@student.1 = constant {i64, i64} { i64 23, i64 ptrtoint ([?? x i8]* @student.0 to i64) } - - -@student.0 = constant [?? x i8] c"Declarative Programming\00" - - -@student.4 = constant [?? x i8] c"course code: \00" - - -@student.6 = constant [?? x i8] c"course name: \00" - - -@student.2 = constant [?? x i8] c"student id: \00" - - -declare external ccc void @putchar(i8) - - -declare external fastcc void @"wybe.string.print<0>[410bae77d3]"(i64) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc void @print_int(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"student.<0>"() { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 90048, i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @student.1, i32 0, i32 0) to i64), i64* %5 - %6 = trunc i64 16 to i32 - %7 = tail call ccc i8* @wybe_malloc(i32 %6) - %8 = ptrtoint i8* %7 to i64 - %9 = inttoptr i64 %8 to i64* - store i64 12345, i64* %9 - %10 = add i64 %8, 8 - %11 = inttoptr i64 %10 to i64* - store i64 %2, i64* %11 - tail call fastcc void @"student.printStudent<0>[410bae77d3]"(i64 %8) - ret void +source_filename = "!ROOT!/final-dump/student.wybe" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c"Declarative Programming\00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c"course code: \00", align 8 +@"cstring#2" = private unnamed_addr constant [ ?? x i8 ] c"course name: \00", align 8 +@"cstring#3" = private unnamed_addr constant [ ?? x i8 ] c"student id: \00", align 8 +@"string#4" = private unnamed_addr constant {i64, i64} { i64 23, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +@"string#5" = private unnamed_addr constant {i64, i64} { i64 13, i64 ptrtoint( ptr @"cstring#1" to i64 ) }, align 8 +@"string#6" = private unnamed_addr constant {i64, i64} { i64 13, i64 ptrtoint( ptr @"cstring#2" to i64 ) }, align 8 +@"string#7" = private unnamed_addr constant {i64, i64} { i64 12, i64 ptrtoint( ptr @"cstring#3" to i64 ) }, align 8 + +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external fastcc void @"wybe.string.print<0>[410bae77d3]"(i64) +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"student.<0>"() { + %"tmp#12##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#4##0" = ptrtoint ptr %"tmp#12##0" to i64 + %"tmp#13##0" = inttoptr i64 %"tmp#4##0" to ptr + store i64 90048, ptr %"tmp#13##0" + %"tmp#14##0" = add i64 %"tmp#4##0", 8 + %"tmp#15##0" = inttoptr i64 %"tmp#14##0" to ptr + store i64 ptrtoint( ptr @"string#4" to i64 ), ptr %"tmp#15##0" + %"tmp#16##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#9##0" = ptrtoint ptr %"tmp#16##0" to i64 + %"tmp#17##0" = inttoptr i64 %"tmp#9##0" to ptr + store i64 12345, ptr %"tmp#17##0" + %"tmp#18##0" = add i64 %"tmp#9##0", 8 + %"tmp#19##0" = inttoptr i64 %"tmp#18##0" to ptr + store i64 %"tmp#4##0", ptr %"tmp#19##0" + tail call fastcc void @"student.printStudent<0>[410bae77d3]"(i64 %"tmp#9##0") + ret void } - -define external fastcc void @"student.printStudent<0>"(i64 %"stu##0") { -entry: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @student.3, i32 0, i32 0) to i64)) - %0 = inttoptr i64 %"stu##0" to i64* - %1 = load i64, i64* %0 - tail call ccc void @print_int(i64 %1) - tail call ccc void @putchar(i8 10) - %2 = add i64 %"stu##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @student.5, i32 0, i32 0) to i64)) - %5 = inttoptr i64 %4 to i64* - %6 = load i64, i64* %5 - tail call ccc void @print_int(i64 %6) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @student.7, i32 0, i32 0) to i64)) - %7 = add i64 %4, 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - tail call fastcc void @"wybe.string.print<0>"(i64 %9) - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"student.printStudent<0>"(i64 %"stu##0") { + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#7" to i64 )) + %"tmp#19##0" = inttoptr i64 %"stu##0" to ptr + %"tmp#0##0" = load i64, ptr %"tmp#19##0" + call ccc void @print_int(i64 %"tmp#0##0") + call ccc void @putchar(i8 10) + %"tmp#20##0" = add i64 %"stu##0", 8 + %"tmp#21##0" = inttoptr i64 %"tmp#20##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#21##0" + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#5" to i64 )) + %"tmp#22##0" = inttoptr i64 %"tmp#1##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#22##0" + call ccc void @print_int(i64 %"tmp#2##0") + call ccc void @putchar(i8 10) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#6" to i64 )) + %"tmp#23##0" = add i64 %"tmp#1##0", 8 + %"tmp#24##0" = inttoptr i64 %"tmp#23##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#24##0" + tail call fastcc void @"wybe.string.print<0>"(i64 %"tmp#3##0") + call ccc void @putchar(i8 10) + ret void } - -define external fastcc void @"student.printStudent<0>[410bae77d3]"(i64 %"stu##0") { -entry: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @student.3, i32 0, i32 0) to i64)) - %0 = inttoptr i64 %"stu##0" to i64* - %1 = load i64, i64* %0 - tail call ccc void @print_int(i64 %1) - tail call ccc void @putchar(i8 10) - %2 = add i64 %"stu##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @student.5, i32 0, i32 0) to i64)) - %5 = inttoptr i64 %4 to i64* - %6 = load i64, i64* %5 - tail call ccc void @print_int(i64 %6) - tail call ccc void @putchar(i8 10) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @student.7, i32 0, i32 0) to i64)) - %7 = add i64 %4, 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - tail call fastcc void @"wybe.string.print<0>[410bae77d3]"(i64 %9) - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"student.printStudent<0>[410bae77d3]"(i64 %"stu##0") { + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#7" to i64 )) + %"tmp#19##0" = inttoptr i64 %"stu##0" to ptr + %"tmp#0##0" = load i64, ptr %"tmp#19##0" + call ccc void @print_int(i64 %"tmp#0##0") + call ccc void @putchar(i8 10) + %"tmp#20##0" = add i64 %"stu##0", 8 + %"tmp#21##0" = inttoptr i64 %"tmp#20##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#21##0" + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#5" to i64 )) + %"tmp#22##0" = inttoptr i64 %"tmp#1##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#22##0" + call ccc void @print_int(i64 %"tmp#2##0") + call ccc void @putchar(i8 10) + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#6" to i64 )) + %"tmp#23##0" = add i64 %"tmp#1##0", 8 + %"tmp#24##0" = inttoptr i64 %"tmp#23##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#24##0" + tail call fastcc void @"wybe.string.print<0>[410bae77d3]"(i64 %"tmp#3##0") + call ccc void @putchar(i8 10) + ret void } + -------------------------------------------------- Module student.course - representation : address + representation : pointer public submods : public resources: public procs : student.course.=<0> @@ -318,145 +289,120 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'student.course' - - - - -declare external fastcc i2 @"wybe.string.<=>#cont#2<0>"(i2, i64, i64, i64, i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i1 @"student.course.=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %"#right##0" to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = icmp eq i64 %1, %6 - br i1 %10, label %if.then, label %if.else -if.then: - %11 = tail call fastcc i2 @"wybe.string.<=>#cont#2<0>"(i2 1, i64 %4, i64 %9, i64 %4, i64 %9) - %12 = icmp eq i2 %11, 1 - ret i1 %12 -if.else: - ret i1 0 +source_filename = "!ROOT!/final-dump/student.wybe" +target triple ???? + + +declare external fastcc i2 @"wybe.string.<=>#cont#2<0>"(i2, i64, i64, i64, i64) +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc i1 @"student.course.=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#10##0" = inttoptr i64 %"#left##0" to ptr + %"#left#code##0" = load i64, ptr %"tmp#10##0" + %"tmp#11##0" = add i64 %"#left##0", 8 + %"tmp#12##0" = inttoptr i64 %"tmp#11##0" to ptr + %"#left#name##0" = load i64, ptr %"tmp#12##0" + %"tmp#13##0" = inttoptr i64 %"#right##0" to ptr + %"#right#code##0" = load i64, ptr %"tmp#13##0" + %"tmp#14##0" = add i64 %"#right##0", 8 + %"tmp#15##0" = inttoptr i64 %"tmp#14##0" to ptr + %"#right#name##0" = load i64, ptr %"tmp#15##0" + %"tmp#1##0" = icmp eq i64 %"#left#code##0", %"#right#code##0" + br i1 %"tmp#1##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#9##0" = tail call fastcc i2 @"wybe.string.<=>#cont#2<0>"(i2 1, i64 %"#left#name##0", i64 %"#right#name##0", i64 %"#left#name##0", i64 %"#right#name##0") + %"tmp#16##0" = icmp eq i2 %"tmp#9##0", 1 + ret i1 %"tmp#16##0" +if.else.0: + ret i1 0 } - -define external fastcc i64 @"student.course.code<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#rec##0" to i64* - %1 = load i64, i64* %0 - ret i64 %1 +define external fastcc i64 @"student.course.code<0>"(i64 %"#rec##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + ret i64 %"tmp#1##0" } - -define external fastcc i64 @"student.course.code<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = inttoptr i64 %2 to i64* - store i64 %"#field##0", i64* %6 - ret i64 %2 +define external fastcc i64 @"student.course.code<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"#field##0", ptr %"tmp#3##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"student.course.course<0>"(i64 %"code##0", i64 %"name##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"code##0", i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"name##0", i64* %5 - ret i64 %2 +define external fastcc i64 @"student.course.course<0>"(i64 %"code##0", i64 %"name##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 16) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"code##0", ptr %"tmp#1##0" + %"tmp#2##0" = add i64 %"#rec##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"name##0", ptr %"tmp#3##0" + ret i64 %"#rec##0" } - -define external fastcc {i64, i64} @"student.course.course<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#result##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#result##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = insertvalue {i64, i64} undef, i64 %1, 0 - %6 = insertvalue {i64, i64} %5, i64 %4, 1 - ret {i64, i64} %6 +define external fastcc {i64, i64} @"student.course.course<1>"(i64 %"#result##0") { + %"tmp#0##0" = inttoptr i64 %"#result##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + %"tmp#2##0" = add i64 %"#result##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#3##0" + %"tmp#5##0" = insertvalue {i64, i64} undef, i64 %"tmp#1##0", 0 + %"tmp#6##0" = insertvalue {i64, i64} %"tmp#5##0", i64 %"tmp#4##0", 1 + ret {i64, i64} %"tmp#6##0" } - -define external fastcc i64 @"student.course.name<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = add i64 %"#rec##0", 8 - %1 = inttoptr i64 %0 to i64* - %2 = load i64, i64* %1 - ret i64 %2 +define external fastcc i64 @"student.course.name<0>"(i64 %"#rec##0") { + %"tmp#0##0" = add i64 %"#rec##0", 8 + %"tmp#1##0" = inttoptr i64 %"tmp#0##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"student.course.name<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = add i64 %2, 8 - %7 = inttoptr i64 %6 to i64* - store i64 %"#field##0", i64* %7 - ret i64 %2 +define external fastcc i64 @"student.course.name<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = add i64 %"tmp#2##0", 8 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 %"#field##0", ptr %"tmp#4##0" + ret i64 %"tmp#2##0" } - -define external fastcc i1 @"student.course.~=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %"#right##0" to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = icmp eq i64 %1, %6 - br i1 %10, label %if.then, label %if.else -if.then: - %11 = tail call fastcc i2 @"wybe.string.<=>#cont#2<0>"(i2 1, i64 %4, i64 %9, i64 %4, i64 %9) - %12 = icmp eq i2 %11, 1 - %13 = xor i1 %12, 1 - ret i1 %13 -if.else: - %14 = xor i1 0, 1 - ret i1 %14 +define external fastcc i1 @"student.course.~=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#9##0" = inttoptr i64 %"#left##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#9##0" + %"tmp#10##0" = add i64 %"#left##0", 8 + %"tmp#11##0" = inttoptr i64 %"tmp#10##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#11##0" + %"tmp#12##0" = inttoptr i64 %"#right##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#12##0" + %"tmp#13##0" = add i64 %"#right##0", 8 + %"tmp#14##0" = inttoptr i64 %"tmp#13##0" to ptr + %"tmp#6##0" = load i64, ptr %"tmp#14##0" + %"tmp#7##0" = icmp eq i64 %"tmp#3##0", %"tmp#5##0" + br i1 %"tmp#7##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#8##0" = tail call fastcc i2 @"wybe.string.<=>#cont#2<0>"(i2 1, i64 %"tmp#4##0", i64 %"tmp#6##0", i64 %"tmp#4##0", i64 %"tmp#6##0") + %"tmp#0##0" = icmp eq i2 %"tmp#8##0", 1 + %"tmp#15##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#15##0" +if.else.0: + %"tmp#16##0" = xor i1 0, 1 + ret i1 %"tmp#16##0" } + -------------------------------------------------- Module student.student - representation : address + representation : pointer public submods : public resources: public procs : student.student.=<0> @@ -583,170 +529,144 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'student.student' - - - - -declare external fastcc i2 @"wybe.string.<=>#cont#2<0>"(i2, i64, i64, i64, i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i1 @"student.student.=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %"#right##0" to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = icmp eq i64 %1, %6 - br i1 %10, label %if.then, label %if.else -if.then: - %11 = inttoptr i64 %4 to i64* - %12 = load i64, i64* %11 - %13 = add i64 %4, 8 - %14 = inttoptr i64 %13 to i64* - %15 = load i64, i64* %14 - %16 = inttoptr i64 %9 to i64* - %17 = load i64, i64* %16 - %18 = add i64 %9, 8 - %19 = inttoptr i64 %18 to i64* - %20 = load i64, i64* %19 - %21 = icmp eq i64 %17, %12 - br i1 %21, label %if.then1, label %if.else1 -if.else: - ret i1 0 -if.then1: - %22 = tail call fastcc i2 @"wybe.string.<=>#cont#2<0>"(i2 1, i64 %15, i64 %20, i64 %15, i64 %20) - %23 = icmp eq i2 %22, 1 - ret i1 %23 -if.else1: - ret i1 0 +source_filename = "!ROOT!/final-dump/student.wybe" +target triple ???? + + +declare external fastcc i2 @"wybe.string.<=>#cont#2<0>"(i2, i64, i64, i64, i64) +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc i1 @"student.student.=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#15##0" = inttoptr i64 %"#left##0" to ptr + %"#left#id##0" = load i64, ptr %"tmp#15##0" + %"tmp#16##0" = add i64 %"#left##0", 8 + %"tmp#17##0" = inttoptr i64 %"tmp#16##0" to ptr + %"#left#major##0" = load i64, ptr %"tmp#17##0" + %"tmp#18##0" = inttoptr i64 %"#right##0" to ptr + %"#right#id##0" = load i64, ptr %"tmp#18##0" + %"tmp#19##0" = add i64 %"#right##0", 8 + %"tmp#20##0" = inttoptr i64 %"tmp#19##0" to ptr + %"#right#major##0" = load i64, ptr %"tmp#20##0" + %"tmp#1##0" = icmp eq i64 %"#left#id##0", %"#right#id##0" + br i1 %"tmp#1##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#21##0" = inttoptr i64 %"#left#major##0" to ptr + %"tmp#9##0" = load i64, ptr %"tmp#21##0" + %"tmp#22##0" = add i64 %"#left#major##0", 8 + %"tmp#23##0" = inttoptr i64 %"tmp#22##0" to ptr + %"tmp#10##0" = load i64, ptr %"tmp#23##0" + %"tmp#24##0" = inttoptr i64 %"#right#major##0" to ptr + %"tmp#11##0" = load i64, ptr %"tmp#24##0" + %"tmp#25##0" = add i64 %"#right#major##0", 8 + %"tmp#26##0" = inttoptr i64 %"tmp#25##0" to ptr + %"tmp#12##0" = load i64, ptr %"tmp#26##0" + %"tmp#13##0" = icmp eq i64 %"tmp#11##0", %"tmp#9##0" + br i1 %"tmp#13##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#14##0" = tail call fastcc i2 @"wybe.string.<=>#cont#2<0>"(i2 1, i64 %"tmp#10##0", i64 %"tmp#12##0", i64 %"tmp#10##0", i64 %"tmp#12##0") + %"tmp#27##0" = icmp eq i2 %"tmp#14##0", 1 + ret i1 %"tmp#27##0" +if.else.1: + ret i1 0 +if.else.0: + ret i1 0 } - -define external fastcc i64 @"student.student.id<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#rec##0" to i64* - %1 = load i64, i64* %0 - ret i64 %1 +define external fastcc i64 @"student.student.id<0>"(i64 %"#rec##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + ret i64 %"tmp#1##0" } - -define external fastcc i64 @"student.student.id<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = inttoptr i64 %2 to i64* - store i64 %"#field##0", i64* %6 - ret i64 %2 +define external fastcc i64 @"student.student.id<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"#field##0", ptr %"tmp#3##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"student.student.major<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = add i64 %"#rec##0", 8 - %1 = inttoptr i64 %0 to i64* - %2 = load i64, i64* %1 - ret i64 %2 +define external fastcc i64 @"student.student.major<0>"(i64 %"#rec##0") { + %"tmp#0##0" = add i64 %"#rec##0", 8 + %"tmp#1##0" = inttoptr i64 %"tmp#0##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"student.student.major<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = add i64 %2, 8 - %7 = inttoptr i64 %6 to i64* - store i64 %"#field##0", i64* %7 - ret i64 %2 +define external fastcc i64 @"student.student.major<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = add i64 %"tmp#2##0", 8 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 %"#field##0", ptr %"tmp#4##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"student.student.student<0>"(i64 %"id##0", i64 %"major##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"id##0", i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"major##0", i64* %5 - ret i64 %2 +define external fastcc i64 @"student.student.student<0>"(i64 %"id##0", i64 %"major##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 16) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"id##0", ptr %"tmp#1##0" + %"tmp#2##0" = add i64 %"#rec##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"major##0", ptr %"tmp#3##0" + ret i64 %"#rec##0" } - -define external fastcc {i64, i64} @"student.student.student<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#result##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#result##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = insertvalue {i64, i64} undef, i64 %1, 0 - %6 = insertvalue {i64, i64} %5, i64 %4, 1 - ret {i64, i64} %6 +define external fastcc {i64, i64} @"student.student.student<1>"(i64 %"#result##0") { + %"tmp#0##0" = inttoptr i64 %"#result##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + %"tmp#2##0" = add i64 %"#result##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#3##0" + %"tmp#5##0" = insertvalue {i64, i64} undef, i64 %"tmp#1##0", 0 + %"tmp#6##0" = insertvalue {i64, i64} %"tmp#5##0", i64 %"tmp#4##0", 1 + ret {i64, i64} %"tmp#6##0" } - -define external fastcc i1 @"student.student.~=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = inttoptr i64 %"#right##0" to i64* - %6 = load i64, i64* %5 - %7 = add i64 %"#right##0", 8 - %8 = inttoptr i64 %7 to i64* - %9 = load i64, i64* %8 - %10 = icmp eq i64 %1, %6 - br i1 %10, label %if.then, label %if.else -if.then: - %11 = inttoptr i64 %4 to i64* - %12 = load i64, i64* %11 - %13 = add i64 %4, 8 - %14 = inttoptr i64 %13 to i64* - %15 = load i64, i64* %14 - %16 = inttoptr i64 %9 to i64* - %17 = load i64, i64* %16 - %18 = add i64 %9, 8 - %19 = inttoptr i64 %18 to i64* - %20 = load i64, i64* %19 - %21 = icmp eq i64 %17, %12 - br i1 %21, label %if.then1, label %if.else1 -if.else: - %26 = xor i1 0, 1 - ret i1 %26 -if.then1: - %22 = tail call fastcc i2 @"wybe.string.<=>#cont#2<0>"(i2 1, i64 %15, i64 %20, i64 %15, i64 %20) - %23 = icmp eq i2 %22, 1 - %24 = xor i1 %23, 1 - ret i1 %24 -if.else1: - %25 = xor i1 0, 1 - ret i1 %25 +define external fastcc i1 @"student.student.~=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#14##0" = inttoptr i64 %"#left##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#14##0" + %"tmp#15##0" = add i64 %"#left##0", 8 + %"tmp#16##0" = inttoptr i64 %"tmp#15##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#16##0" + %"tmp#17##0" = inttoptr i64 %"#right##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#17##0" + %"tmp#18##0" = add i64 %"#right##0", 8 + %"tmp#19##0" = inttoptr i64 %"tmp#18##0" to ptr + %"tmp#6##0" = load i64, ptr %"tmp#19##0" + %"tmp#7##0" = icmp eq i64 %"tmp#3##0", %"tmp#5##0" + br i1 %"tmp#7##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#20##0" = inttoptr i64 %"tmp#4##0" to ptr + %"tmp#8##0" = load i64, ptr %"tmp#20##0" + %"tmp#21##0" = add i64 %"tmp#4##0", 8 + %"tmp#22##0" = inttoptr i64 %"tmp#21##0" to ptr + %"tmp#9##0" = load i64, ptr %"tmp#22##0" + %"tmp#23##0" = inttoptr i64 %"tmp#6##0" to ptr + %"tmp#10##0" = load i64, ptr %"tmp#23##0" + %"tmp#24##0" = add i64 %"tmp#6##0", 8 + %"tmp#25##0" = inttoptr i64 %"tmp#24##0" to ptr + %"tmp#11##0" = load i64, ptr %"tmp#25##0" + %"tmp#12##0" = icmp eq i64 %"tmp#10##0", %"tmp#8##0" + br i1 %"tmp#12##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#13##0" = tail call fastcc i2 @"wybe.string.<=>#cont#2<0>"(i2 1, i64 %"tmp#9##0", i64 %"tmp#11##0", i64 %"tmp#9##0", i64 %"tmp#11##0") + %"tmp#0##0" = icmp eq i2 %"tmp#13##0", 1 + %"tmp#26##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#26##0" +if.else.1: + %"tmp#27##0" = xor i1 0, 1 + ret i1 %"tmp#27##0" +if.else.0: + %"tmp#28##0" = xor i1 0, 1 + ret i1 %"tmp#28##0" } diff --git a/test-cases/final-dump/submodule.exp b/test-cases/final-dump/submodule.exp index 5c445fe51..7aa0d4ba7 100644 --- a/test-cases/final-dump/submodule.exp +++ b/test-cases/final-dump/submodule.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module submodule representation : (not a type) public submods : publictest -> submodule.publictest @@ -15,16 +18,15 @@ AFTER EVERYTHING: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'submodule' +source_filename = "!ROOT!/final-dump/submodule.wybe" +target triple ???? - - - -declare external ccc i8* @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) -------------------------------------------------- Module submodule.privatetest representation : (not a type) @@ -53,45 +55,30 @@ semi_hidden()<{<>}; {<>}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'submodule.privatetest' +source_filename = "!ROOT!/final-dump/submodule.wybe" +target triple ???? - - - -@submodule.privatetest.3 = constant {i64, i64} { i64 31, i64 ptrtoint ([?? x i8]* @submodule.privatetest.2 to i64) } - - -@submodule.privatetest.1 = constant {i64, i64} { i64 32, i64 ptrtoint ([?? x i8]* @submodule.privatetest.0 to i64) } - - -@submodule.privatetest.0 = constant [?? x i8] c"private proc in a private module\00" - - -@submodule.privatetest.2 = constant [?? x i8] c"public proc in a private module\00" - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc i8* @wybe_malloc(i32) - +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c"private proc in a private module\00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c"public proc in a private module\00", align 8 +@"string#2" = private unnamed_addr constant {i64, i64} { i64 32, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +@"string#3" = private unnamed_addr constant {i64, i64} { i64 31, i64 ptrtoint( ptr @"cstring#1" to i64 ) }, align 8 -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) - -define external fastcc void @"submodule.privatetest.hidden<0>"() alwaysinline { -entry: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @submodule.privatetest.1, i32 0, i32 0) to i64)) - ret void +define external fastcc void @"submodule.privatetest.hidden<0>"() { + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#2" to i64 )) + ret void } - -define external fastcc void @"submodule.privatetest.semi_hidden<0>"() alwaysinline { -entry: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @submodule.privatetest.3, i32 0, i32 0) to i64)) - ret void +define external fastcc void @"submodule.privatetest.semi_hidden<0>"() { + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#3" to i64 )) + ret void } + -------------------------------------------------- Module submodule.publictest representation : (not a type) @@ -120,42 +107,26 @@ visible()<{<>}; {<>}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'submodule.publictest' +source_filename = "!ROOT!/final-dump/submodule.wybe" +target triple ???? - - - -@submodule.publictest.3 = constant {i64, i64} { i64 30, i64 ptrtoint ([?? x i8]* @submodule.publictest.2 to i64) } - - -@submodule.publictest.1 = constant {i64, i64} { i64 31, i64 ptrtoint ([?? x i8]* @submodule.publictest.0 to i64) } - - -@submodule.publictest.0 = constant [?? x i8] c"private proc in a public module\00" +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c"private proc in a public module\00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c"public proc in a public module\00", align 8 +@"string#2" = private unnamed_addr constant {i64, i64} { i64 31, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +@"string#3" = private unnamed_addr constant {i64, i64} { i64 30, i64 ptrtoint( ptr @"cstring#1" to i64 ) }, align 8 +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -@submodule.publictest.2 = constant [?? x i8] c"public proc in a public module\00" - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"submodule.publictest.semi_visible<0>"() alwaysinline { -entry: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @submodule.publictest.1, i32 0, i32 0) to i64)) - ret void +define external fastcc void @"submodule.publictest.semi_visible<0>"() { + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#2" to i64 )) + ret void } - -define external fastcc void @"submodule.publictest.visible<0>"() alwaysinline { -entry: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @submodule.publictest.3, i32 0, i32 0) to i64)) - ret void +define external fastcc void @"submodule.publictest.visible<0>"() { + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#3" to i64 )) + ret void } diff --git a/test-cases/final-dump/subresource.exp b/test-cases/final-dump/subresource.exp index 7fbe7f3b3..2eec9ee35 100644 --- a/test-cases/final-dump/subresource.exp +++ b/test-cases/final-dump/subresource.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module subresource representation : (not a type) public submods : @@ -27,48 +30,30 @@ module top-level code > public {semipure} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'subresource' - - - - -@"resource#subresource.a.res" = global i64 undef - - -@subresource.1 = constant {i64, i64} { i64 6, i64 ptrtoint ([?? x i8]* @subresource.0 to i64) } - - -@subresource.0 = constant [?? x i8] c"res = \00" - - -declare external ccc void @putchar(i8) - - -declare external fastcc void @"wybe.string.print<0>[410bae77d3]"(i64) - - -declare external fastcc i64 @"wybe.string.,,<0>"(i64, i64) - - -declare external fastcc i64 @"wybe.int.fmt<2>"(i64, i64, i8) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"subresource.<0>"() { -entry: - %0 = load i64, i64* @"resource#subresource.a.res" - %1 = tail call fastcc i64 @"wybe.int.fmt<2>"(i64 %0, i64 0, i8 32) - %2 = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @subresource.1, i32 0, i32 0) to i64), i64 %1) - tail call fastcc void @"wybe.string.print<0>[410bae77d3]"(i64 %2) - tail call ccc void @putchar(i8 10) - ret void +source_filename = "!ROOT!/final-dump/subresource.wybe" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c"res = \00", align 8 +@"string#1" = private unnamed_addr constant {i64, i64} { i64 6, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 + +declare external fastcc i64 @"wybe.int.fmt<2>"(i64, i64, i8) +declare external fastcc i64 @"wybe.string.,,<0>"(i64, i64) +declare external fastcc void @"wybe.string.print<0>[410bae77d3]"(i64) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"subresource.<0>"() { + %"res##0" = load i64, ptr @"resource#subresource.a.res" + %"tmp#1##0" = tail call fastcc i64 @"wybe.int.fmt<2>"(i64 %"res##0", i64 0, i8 32) + %"tmp#0##0" = tail call fastcc i64 @"wybe.string.,,<0>"(i64 ptrtoint( ptr @"string#1" to i64 ), i64 %"tmp#1##0") + tail call fastcc void @"wybe.string.print<0>[410bae77d3]"(i64 %"tmp#0##0") + call ccc void @putchar(i8 10) + ret void } + -------------------------------------------------- Module subresource.a representation : (not a type) @@ -83,16 +68,12 @@ entry: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'subresource.a' - - - - -@"resource#subresource.a.res" = global i64 undef - - -declare external ccc i8* @wybe_malloc(i32) +source_filename = "!ROOT!/final-dump/subresource.wybe" +target triple ???? -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) +@"resource#subresource.a.res" = global i64 undef diff --git a/test-cases/final-dump/terminal_ok.exp b/test-cases/final-dump/terminal_ok.exp index 54b1ee15e..75bc80580 100644 --- a/test-cases/final-dump/terminal_ok.exp +++ b/test-cases/final-dump/terminal_ok.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module terminal_ok representation : (not a type) public submods : @@ -32,35 +35,27 @@ exit_bool(b##0:wybe.bool)<{}; {}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'terminal_ok' - - - - -declare external ccc void @exit(i64) +source_filename = "!ROOT!/final-dump/terminal_ok.wybe" +target triple ???? -declare external ccc i8* @wybe_malloc(i32) +declare external ccc void @exit(i64) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"terminal_ok.<0>"() alwaysinline { -entry: - tail call fastcc void @"terminal_ok.exit_bool<0>"(i1 0) - ret void +define external fastcc void @"terminal_ok.<0>"() { + tail call fastcc void @"terminal_ok.exit_bool<0>"(i1 0) + ret void } - -define external fastcc void @"terminal_ok.exit_bool<0>"(i1 %"b##0") { -entry: - br i1 %"b##0", label %if.then, label %if.else -if.then: - tail call ccc void @exit(i64 1) - ret void -if.else: - tail call ccc void @exit(i64 0) - ret void +define external fastcc void @"terminal_ok.exit_bool<0>"(i1 %"b##0") { + br i1 %"b##0", label %if.then.0, label %if.else.0 +if.then.0: + call ccc void @exit(i64 1) + ret void +if.else.0: + call ccc void @exit(i64 0) + ret void } diff --git a/test-cases/final-dump/test_loop.exp b/test-cases/final-dump/test_loop.exp index 5f1f1a56f..870a511f1 100644 --- a/test-cases/final-dump/test_loop.exp +++ b/test-cases/final-dump/test_loop.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module test_loop representation : (not a type) public submods : int_seq -> test_loop.int_seq @@ -40,7 +43,7 @@ find_modulo(seq##0:test_loop.int_seq, modulus##0:wybe.int, ?i##0:wybe.int, ?#suc proc find_modulo#cont#1 > (2 calls) -0: test_loop.find_modulo#cont#1<0>[6dacb8fd25] +0: test_loop.find_modulo#cont#1<0> find_modulo#cont#1(modulus##0:wybe.int, seq##0:test_loop.int_seq, ?i##1:wybe.int, ?#success##0:wybe.bool)<{}; {}; {}>: AliasPairs: [] InterestingCallProperties: [InterestingUnaliased 1] @@ -117,155 +120,126 @@ find_test(modulus##0:wybe.int)<{<>}; {<>}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'test_loop' - - - - -@test_loop.3 = constant {i64, i64} { i64 4, i64 ptrtoint ([?? x i8]* @test_loop.2 to i64) } - - -@test_loop.1 = constant {i64, i64} { i64 31, i64 ptrtoint ([?? x i8]* @test_loop.0 to i64) } - - -@test_loop.5 = constant {i64, i64} { i64 39, i64 ptrtoint ([?? x i8]* @test_loop.4 to i64) } - - -@test_loop.2 = constant [?? x i8] c" is \00" - - -@test_loop.4 = constant [?? x i8] c"Couldn't find even number divisible by \00" - - -@test_loop.0 = constant [?? x i8] c"First even number divisible by \00" - - -declare external ccc void @putchar(i8) - - -declare external ccc void @print_int(i64) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"test_loop.<0>"() alwaysinline { -entry: - tail call fastcc void @"test_loop.find_test<0>"(i64 3) - tail call fastcc void @"test_loop.find_test<0>"(i64 7) - ret void +source_filename = "!ROOT!/final-dump/test_loop.wybe" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c" is \00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c"Couldn't find even number divisible by \00", align 8 +@"cstring#2" = private unnamed_addr constant [ ?? x i8 ] c"First even number divisible by \00", align 8 +@"string#3" = private unnamed_addr constant {i64, i64} { i64 4, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +@"string#4" = private unnamed_addr constant {i64, i64} { i64 39, i64 ptrtoint( ptr @"cstring#1" to i64 ) }, align 8 +@"string#5" = private unnamed_addr constant {i64, i64} { i64 31, i64 ptrtoint( ptr @"cstring#2" to i64 ) }, align 8 + +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"test_loop.<0>"() { + tail call fastcc void @"test_loop.find_test<0>"(i64 3) + tail call fastcc void @"test_loop.find_test<0>"(i64 7) + ret void } - -define external fastcc {i64, i1} @"test_loop.find_modulo<0>"(i64 %"seq##0", i64 %"modulus##0") alwaysinline { -entry: - %0 = tail call fastcc {i64, i1} @"test_loop.find_modulo#cont#1<0>"(i64 %"modulus##0", i64 %"seq##0") - %1 = extractvalue {i64, i1} %0, 0 - %2 = extractvalue {i64, i1} %0, 1 - %3 = insertvalue {i64, i1} undef, i64 %1, 0 - %4 = insertvalue {i64, i1} %3, i1 %2, 1 - ret {i64, i1} %4 +define external fastcc {i64, i1} @"test_loop.find_modulo<0>"(i64 %"seq##0", i64 %"modulus##0") { + %"tmp#3##0" = tail call fastcc {i64, i1} @"test_loop.find_modulo#cont#1<0>"(i64 %"modulus##0", i64 %"seq##0") + %"tmp#4##0" = extractvalue {i64, i1}%"tmp#3##0", 0 + %"tmp#5##0" = extractvalue {i64, i1}%"tmp#3##0", 1 + %"tmp#6##0" = insertvalue {i64, i1} undef, i64 %"tmp#4##0", 0 + %"tmp#7##0" = insertvalue {i64, i1} %"tmp#6##0", i1 %"tmp#5##0", 1 + ret {i64, i1} %"tmp#7##0" } - -define external fastcc {i64, i1} @"test_loop.find_modulo#cont#1<0>"(i64 %"modulus##0", i64 %"seq##0") { -entry: - %0 = tail call fastcc {i64, i64, i1} @"test_loop.int_seq.seq_next<0>"(i64 %"seq##0") - %1 = extractvalue {i64, i64, i1} %0, 0 - %2 = extractvalue {i64, i64, i1} %0, 1 - %3 = extractvalue {i64, i64, i1} %0, 2 - br i1 %3, label %if.then, label %if.else -if.then: - %4 = srem i64 %2, %"modulus##0" - %5 = icmp eq i64 %4, 0 - br i1 %5, label %if.then1, label %if.else1 -if.else: - %13 = insertvalue {i64, i1} undef, i64 %2, 0 - %14 = insertvalue {i64, i1} %13, i1 0, 1 - ret {i64, i1} %14 -if.then1: - %6 = insertvalue {i64, i1} undef, i64 %2, 0 - %7 = insertvalue {i64, i1} %6, i1 1, 1 - ret {i64, i1} %7 -if.else1: - %8 = tail call fastcc {i64, i1} @"test_loop.find_modulo#cont#1<0>"(i64 %"modulus##0", i64 %1) - %9 = extractvalue {i64, i1} %8, 0 - %10 = extractvalue {i64, i1} %8, 1 - %11 = insertvalue {i64, i1} undef, i64 %9, 0 - %12 = insertvalue {i64, i1} %11, i1 %10, 1 - ret {i64, i1} %12 +define external fastcc {i64, i1} @"test_loop.find_modulo#cont#1<0>"(i64 %"modulus##0", i64 %"seq##0") { + %"tmp#7##0" = tail call fastcc {i64, i64, i1} @"test_loop.int_seq.seq_next<0>"(i64 %"seq##0") + %"seq##1" = extractvalue {i64, i64, i1}%"tmp#7##0", 0 + %"i##0" = extractvalue {i64, i64, i1}%"tmp#7##0", 1 + %"tmp#1##0" = extractvalue {i64, i64, i1}%"tmp#7##0", 2 + br i1 %"tmp#1##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#0##0" = srem i64 %"i##0", %"modulus##0" + %"tmp#2##0" = icmp eq i64 %"tmp#0##0", 0 + br i1 %"tmp#2##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#8##0" = insertvalue {i64, i1} undef, i64 %"i##0", 0 + %"tmp#9##0" = insertvalue {i64, i1} %"tmp#8##0", i1 1, 1 + ret {i64, i1} %"tmp#9##0" +if.else.1: + %"tmp#10##0" = tail call fastcc {i64, i1} @"test_loop.find_modulo#cont#1<0>"(i64 %"modulus##0", i64 %"seq##1") + %"tmp#11##0" = extractvalue {i64, i1}%"tmp#10##0", 0 + %"tmp#12##0" = extractvalue {i64, i1}%"tmp#10##0", 1 + %"tmp#13##0" = insertvalue {i64, i1} undef, i64 %"tmp#11##0", 0 + %"tmp#14##0" = insertvalue {i64, i1} %"tmp#13##0", i1 %"tmp#12##0", 1 + ret {i64, i1} %"tmp#14##0" +if.else.0: + %"tmp#15##0" = insertvalue {i64, i1} undef, i64 %"i##0", 0 + %"tmp#16##0" = insertvalue {i64, i1} %"tmp#15##0", i1 0, 1 + ret {i64, i1} %"tmp#16##0" } - -define external fastcc {i64, i1} @"test_loop.find_modulo#cont#1<0>[6dacb8fd25]"(i64 %"modulus##0", i64 %"seq##0") { -entry: - %0 = tail call fastcc {i64, i64, i1} @"test_loop.int_seq.seq_next<0>[410bae77d3]"(i64 %"seq##0") - %1 = extractvalue {i64, i64, i1} %0, 0 - %2 = extractvalue {i64, i64, i1} %0, 1 - %3 = extractvalue {i64, i64, i1} %0, 2 - br i1 %3, label %if.then, label %if.else -if.then: - %4 = srem i64 %2, %"modulus##0" - %5 = icmp eq i64 %4, 0 - br i1 %5, label %if.then1, label %if.else1 -if.else: - %13 = insertvalue {i64, i1} undef, i64 %2, 0 - %14 = insertvalue {i64, i1} %13, i1 0, 1 - ret {i64, i1} %14 -if.then1: - %6 = insertvalue {i64, i1} undef, i64 %2, 0 - %7 = insertvalue {i64, i1} %6, i1 1, 1 - ret {i64, i1} %7 -if.else1: - %8 = tail call fastcc {i64, i1} @"test_loop.find_modulo#cont#1<0>[6dacb8fd25]"(i64 %"modulus##0", i64 %1) - %9 = extractvalue {i64, i1} %8, 0 - %10 = extractvalue {i64, i1} %8, 1 - %11 = insertvalue {i64, i1} undef, i64 %9, 0 - %12 = insertvalue {i64, i1} %11, i1 %10, 1 - ret {i64, i1} %12 +define external fastcc {i64, i1} @"test_loop.find_modulo#cont#1<0>[6dacb8fd25]"(i64 %"modulus##0", i64 %"seq##0") { + %"tmp#7##0" = tail call fastcc {i64, i64, i1} @"test_loop.int_seq.seq_next<0>[410bae77d3]"(i64 %"seq##0") + %"seq##1" = extractvalue {i64, i64, i1}%"tmp#7##0", 0 + %"i##0" = extractvalue {i64, i64, i1}%"tmp#7##0", 1 + %"tmp#1##0" = extractvalue {i64, i64, i1}%"tmp#7##0", 2 + br i1 %"tmp#1##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#0##0" = srem i64 %"i##0", %"modulus##0" + %"tmp#2##0" = icmp eq i64 %"tmp#0##0", 0 + br i1 %"tmp#2##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#8##0" = insertvalue {i64, i1} undef, i64 %"i##0", 0 + %"tmp#9##0" = insertvalue {i64, i1} %"tmp#8##0", i1 1, 1 + ret {i64, i1} %"tmp#9##0" +if.else.1: + %"tmp#10##0" = tail call fastcc {i64, i1} @"test_loop.find_modulo#cont#1<0>[6dacb8fd25]"(i64 %"modulus##0", i64 %"seq##1") + %"tmp#11##0" = extractvalue {i64, i1}%"tmp#10##0", 0 + %"tmp#12##0" = extractvalue {i64, i1}%"tmp#10##0", 1 + %"tmp#13##0" = insertvalue {i64, i1} undef, i64 %"tmp#11##0", 0 + %"tmp#14##0" = insertvalue {i64, i1} %"tmp#13##0", i1 %"tmp#12##0", 1 + ret {i64, i1} %"tmp#14##0" +if.else.0: + %"tmp#15##0" = insertvalue {i64, i1} undef, i64 %"i##0", 0 + %"tmp#16##0" = insertvalue {i64, i1} %"tmp#15##0", i1 0, 1 + ret {i64, i1} %"tmp#16##0" } - -define external fastcc void @"test_loop.find_test<0>"(i64 %"modulus##0") { -entry: - %0 = trunc i64 24 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 2, i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 2, i64* %5 - %6 = add i64 %2, 16 - %7 = inttoptr i64 %6 to i64* - store i64 10, i64* %7 - %8 = tail call fastcc {i64, i1} @"test_loop.find_modulo#cont#1<0>[6dacb8fd25]"(i64 %"modulus##0", i64 %2) - %9 = extractvalue {i64, i1} %8, 0 - %10 = extractvalue {i64, i1} %8, 1 - br i1 %10, label %if.then, label %if.else -if.then: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @test_loop.1, i32 0, i32 0) to i64)) - tail call ccc void @print_int(i64 %"modulus##0") - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @test_loop.3, i32 0, i32 0) to i64)) - tail call ccc void @print_int(i64 %9) - tail call ccc void @putchar(i8 10) - ret void -if.else: - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @test_loop.5, i32 0, i32 0) to i64)) - tail call ccc void @print_int(i64 %"modulus##0") - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"test_loop.find_test<0>"(i64 %"modulus##0") { + %"tmp#22##0" = call ccc ptr @wybe_malloc(i32 24) + %"tmp#5##0" = ptrtoint ptr %"tmp#22##0" to i64 + %"tmp#23##0" = inttoptr i64 %"tmp#5##0" to ptr + store i64 2, ptr %"tmp#23##0" + %"tmp#24##0" = add i64 %"tmp#5##0", 8 + %"tmp#25##0" = inttoptr i64 %"tmp#24##0" to ptr + store i64 2, ptr %"tmp#25##0" + %"tmp#26##0" = add i64 %"tmp#5##0", 16 + %"tmp#27##0" = inttoptr i64 %"tmp#26##0" to ptr + store i64 10, ptr %"tmp#27##0" + %"tmp#28##0" = tail call fastcc {i64, i1} @"test_loop.find_modulo#cont#1<0>[6dacb8fd25]"(i64 %"modulus##0", i64 %"tmp#5##0") + %"i##0" = extractvalue {i64, i1}%"tmp#28##0", 0 + %"tmp#1##0" = extractvalue {i64, i1}%"tmp#28##0", 1 + br i1 %"tmp#1##0", label %if.then.0, label %if.else.0 +if.then.0: + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#5" to i64 )) + call ccc void @print_int(i64 %"modulus##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#3" to i64 )) + call ccc void @print_int(i64 %"i##0") + call ccc void @putchar(i8 10) + ret void +if.else.0: + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#4" to i64 )) + call ccc void @print_int(i64 %"modulus##0") + call ccc void @putchar(i8 10) + ret void } + -------------------------------------------------- Module test_loop.int_seq - representation : address + representation : pointer public submods : public resources: public procs : test_loop.int_seq.=<0> @@ -441,252 +415,214 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'test_loop.int_seq' - - - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i1 @"test_loop.int_seq.=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = add i64 %"#left##0", 16 - %6 = inttoptr i64 %5 to i64* - %7 = load i64, i64* %6 - %8 = inttoptr i64 %"#right##0" to i64* - %9 = load i64, i64* %8 - %10 = add i64 %"#right##0", 8 - %11 = inttoptr i64 %10 to i64* - %12 = load i64, i64* %11 - %13 = add i64 %"#right##0", 16 - %14 = inttoptr i64 %13 to i64* - %15 = load i64, i64* %14 - %16 = icmp eq i64 %1, %9 - br i1 %16, label %if.then, label %if.else -if.then: - %17 = icmp eq i64 %4, %12 - br i1 %17, label %if.then1, label %if.else1 -if.else: - ret i1 0 -if.then1: - %18 = icmp eq i64 %7, %15 - ret i1 %18 -if.else1: - ret i1 0 +source_filename = "!ROOT!/final-dump/test_loop.wybe" +target triple ???? + + +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc i1 @"test_loop.int_seq.=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#12##0" = inttoptr i64 %"#left##0" to ptr + %"#left#low##0" = load i64, ptr %"tmp#12##0" + %"tmp#13##0" = add i64 %"#left##0", 8 + %"tmp#14##0" = inttoptr i64 %"tmp#13##0" to ptr + %"#left#step##0" = load i64, ptr %"tmp#14##0" + %"tmp#15##0" = add i64 %"#left##0", 16 + %"tmp#16##0" = inttoptr i64 %"tmp#15##0" to ptr + %"#left#high##0" = load i64, ptr %"tmp#16##0" + %"tmp#17##0" = inttoptr i64 %"#right##0" to ptr + %"#right#low##0" = load i64, ptr %"tmp#17##0" + %"tmp#18##0" = add i64 %"#right##0", 8 + %"tmp#19##0" = inttoptr i64 %"tmp#18##0" to ptr + %"#right#step##0" = load i64, ptr %"tmp#19##0" + %"tmp#20##0" = add i64 %"#right##0", 16 + %"tmp#21##0" = inttoptr i64 %"tmp#20##0" to ptr + %"#right#high##0" = load i64, ptr %"tmp#21##0" + %"tmp#1##0" = icmp eq i64 %"#left#low##0", %"#right#low##0" + br i1 %"tmp#1##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#2##0" = icmp eq i64 %"#left#step##0", %"#right#step##0" + br i1 %"tmp#2##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#22##0" = icmp eq i64 %"#left#high##0", %"#right#high##0" + ret i1 %"tmp#22##0" +if.else.1: + ret i1 0 +if.else.0: + ret i1 0 } - -define external fastcc i64 @"test_loop.int_seq.high<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = add i64 %"#rec##0", 16 - %1 = inttoptr i64 %0 to i64* - %2 = load i64, i64* %1 - ret i64 %2 +define external fastcc i64 @"test_loop.int_seq.high<0>"(i64 %"#rec##0") { + %"tmp#0##0" = add i64 %"#rec##0", 16 + %"tmp#1##0" = inttoptr i64 %"tmp#0##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"test_loop.int_seq.high<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 24 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 24 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = add i64 %2, 16 - %7 = inttoptr i64 %6 to i64* - store i64 %"#field##0", i64* %7 - ret i64 %2 +define external fastcc i64 @"test_loop.int_seq.high<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 24) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 24, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = add i64 %"tmp#2##0", 16 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 %"#field##0", ptr %"tmp#4##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"test_loop.int_seq.int_seq<0>"(i64 %"low##0", i64 %"step##0", i64 %"high##0") alwaysinline { -entry: - %0 = trunc i64 24 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"low##0", i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"step##0", i64* %5 - %6 = add i64 %2, 16 - %7 = inttoptr i64 %6 to i64* - store i64 %"high##0", i64* %7 - ret i64 %2 +define external fastcc i64 @"test_loop.int_seq.int_seq<0>"(i64 %"low##0", i64 %"step##0", i64 %"high##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 24) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"low##0", ptr %"tmp#1##0" + %"tmp#2##0" = add i64 %"#rec##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"step##0", ptr %"tmp#3##0" + %"tmp#4##0" = add i64 %"#rec##0", 16 + %"tmp#5##0" = inttoptr i64 %"tmp#4##0" to ptr + store i64 %"high##0", ptr %"tmp#5##0" + ret i64 %"#rec##0" } - -define external fastcc {i64, i64, i64} @"test_loop.int_seq.int_seq<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#result##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#result##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = add i64 %"#result##0", 16 - %6 = inttoptr i64 %5 to i64* - %7 = load i64, i64* %6 - %8 = insertvalue {i64, i64, i64} undef, i64 %1, 0 - %9 = insertvalue {i64, i64, i64} %8, i64 %4, 1 - %10 = insertvalue {i64, i64, i64} %9, i64 %7, 2 - ret {i64, i64, i64} %10 +define external fastcc {i64, i64, i64} @"test_loop.int_seq.int_seq<1>"(i64 %"#result##0") { + %"tmp#0##0" = inttoptr i64 %"#result##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + %"tmp#2##0" = add i64 %"#result##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#3##0" + %"tmp#5##0" = add i64 %"#result##0", 16 + %"tmp#6##0" = inttoptr i64 %"tmp#5##0" to ptr + %"tmp#7##0" = load i64, ptr %"tmp#6##0" + %"tmp#8##0" = insertvalue {i64, i64, i64} undef, i64 %"tmp#1##0", 0 + %"tmp#9##0" = insertvalue {i64, i64, i64} %"tmp#8##0", i64 %"tmp#4##0", 1 + %"tmp#10##0" = insertvalue {i64, i64, i64} %"tmp#9##0", i64 %"tmp#7##0", 2 + ret {i64, i64, i64} %"tmp#10##0" } - -define external fastcc i64 @"test_loop.int_seq.low<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#rec##0" to i64* - %1 = load i64, i64* %0 - ret i64 %1 +define external fastcc i64 @"test_loop.int_seq.low<0>"(i64 %"#rec##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + ret i64 %"tmp#1##0" } - -define external fastcc i64 @"test_loop.int_seq.low<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 24 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 24 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = inttoptr i64 %2 to i64* - store i64 %"#field##0", i64* %6 - ret i64 %2 +define external fastcc i64 @"test_loop.int_seq.low<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 24) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 24, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"#field##0", ptr %"tmp#3##0" + ret i64 %"tmp#2##0" } - -define external fastcc {i64, i64, i1} @"test_loop.int_seq.seq_next<0>"(i64 %"seq##0") { -entry: - %0 = inttoptr i64 %"seq##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"seq##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = add i64 %"seq##0", 16 - %6 = inttoptr i64 %5 to i64* - %7 = load i64, i64* %6 - %8 = icmp sle i64 %1, %7 - br i1 %8, label %if.then, label %if.else -if.then: - %9 = add i64 %1, %4 - %10 = trunc i64 24 to i32 - %11 = tail call ccc i8* @wybe_malloc(i32 %10) - %12 = ptrtoint i8* %11 to i64 - %13 = inttoptr i64 %12 to i8* - %14 = inttoptr i64 %"seq##0" to i8* - %15 = trunc i64 24 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %13, i8* %14, i32 %15, i1 0) - %16 = inttoptr i64 %12 to i64* - store i64 %9, i64* %16 - %17 = insertvalue {i64, i64, i1} undef, i64 %12, 0 - %18 = insertvalue {i64, i64, i1} %17, i64 %1, 1 - %19 = insertvalue {i64, i64, i1} %18, i1 1, 2 - ret {i64, i64, i1} %19 -if.else: - %20 = insertvalue {i64, i64, i1} undef, i64 %"seq##0", 0 - %21 = insertvalue {i64, i64, i1} %20, i64 %1, 1 - %22 = insertvalue {i64, i64, i1} %21, i1 0, 2 - ret {i64, i64, i1} %22 +define external fastcc {i64, i64, i1} @"test_loop.int_seq.seq_next<0>"(i64 %"seq##0") { + %"tmp#9##0" = inttoptr i64 %"seq##0" to ptr + %"tmp#10##0" = load i64, ptr %"tmp#9##0" + %"tmp#11##0" = add i64 %"seq##0", 8 + %"tmp#12##0" = inttoptr i64 %"tmp#11##0" to ptr + %"step##0" = load i64, ptr %"tmp#12##0" + %"tmp#13##0" = add i64 %"seq##0", 16 + %"tmp#14##0" = inttoptr i64 %"tmp#13##0" to ptr + %"limit##0" = load i64, ptr %"tmp#14##0" + %"tmp#1##0" = icmp sle i64 %"tmp#10##0", %"limit##0" + br i1 %"tmp#1##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#0##0" = add i64 %"tmp#10##0", %"step##0" + %"tmp#15##0" = inttoptr i64 %"seq##0" to ptr + %"tmp#16##0" = call ccc ptr @wybe_malloc(i32 24) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#16##0", ptr %"tmp#15##0", i64 24, i1 0) + %"tmp#17##0" = ptrtoint ptr %"tmp#16##0" to i64 + %"tmp#18##0" = inttoptr i64 %"tmp#17##0" to ptr + store i64 %"tmp#0##0", ptr %"tmp#18##0" + %"tmp#19##0" = insertvalue {i64, i64, i1} undef, i64 %"tmp#17##0", 0 + %"tmp#20##0" = insertvalue {i64, i64, i1} %"tmp#19##0", i64 %"tmp#10##0", 1 + %"tmp#21##0" = insertvalue {i64, i64, i1} %"tmp#20##0", i1 1, 2 + ret {i64, i64, i1} %"tmp#21##0" +if.else.0: + %"tmp#22##0" = insertvalue {i64, i64, i1} undef, i64 %"seq##0", 0 + %"tmp#23##0" = insertvalue {i64, i64, i1} %"tmp#22##0", i64 %"tmp#10##0", 1 + %"tmp#24##0" = insertvalue {i64, i64, i1} %"tmp#23##0", i1 0, 2 + ret {i64, i64, i1} %"tmp#24##0" } - -define external fastcc {i64, i64, i1} @"test_loop.int_seq.seq_next<0>[410bae77d3]"(i64 %"seq##0") { -entry: - %0 = inttoptr i64 %"seq##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"seq##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = add i64 %"seq##0", 16 - %6 = inttoptr i64 %5 to i64* - %7 = load i64, i64* %6 - %8 = icmp sle i64 %1, %7 - br i1 %8, label %if.then, label %if.else -if.then: - %9 = add i64 %1, %4 - %10 = inttoptr i64 %"seq##0" to i64* - store i64 %9, i64* %10 - %11 = insertvalue {i64, i64, i1} undef, i64 %"seq##0", 0 - %12 = insertvalue {i64, i64, i1} %11, i64 %1, 1 - %13 = insertvalue {i64, i64, i1} %12, i1 1, 2 - ret {i64, i64, i1} %13 -if.else: - %14 = insertvalue {i64, i64, i1} undef, i64 %"seq##0", 0 - %15 = insertvalue {i64, i64, i1} %14, i64 %1, 1 - %16 = insertvalue {i64, i64, i1} %15, i1 0, 2 - ret {i64, i64, i1} %16 +define external fastcc {i64, i64, i1} @"test_loop.int_seq.seq_next<0>[410bae77d3]"(i64 %"seq##0") { + %"tmp#9##0" = inttoptr i64 %"seq##0" to ptr + %"tmp#10##0" = load i64, ptr %"tmp#9##0" + %"tmp#11##0" = add i64 %"seq##0", 8 + %"tmp#12##0" = inttoptr i64 %"tmp#11##0" to ptr + %"step##0" = load i64, ptr %"tmp#12##0" + %"tmp#13##0" = add i64 %"seq##0", 16 + %"tmp#14##0" = inttoptr i64 %"tmp#13##0" to ptr + %"limit##0" = load i64, ptr %"tmp#14##0" + %"tmp#1##0" = icmp sle i64 %"tmp#10##0", %"limit##0" + br i1 %"tmp#1##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#0##0" = add i64 %"tmp#10##0", %"step##0" + %"tmp#15##0" = inttoptr i64 %"seq##0" to ptr + store i64 %"tmp#0##0", ptr %"tmp#15##0" + %"tmp#16##0" = insertvalue {i64, i64, i1} undef, i64 %"seq##0", 0 + %"tmp#17##0" = insertvalue {i64, i64, i1} %"tmp#16##0", i64 %"tmp#10##0", 1 + %"tmp#18##0" = insertvalue {i64, i64, i1} %"tmp#17##0", i1 1, 2 + ret {i64, i64, i1} %"tmp#18##0" +if.else.0: + %"tmp#19##0" = insertvalue {i64, i64, i1} undef, i64 %"seq##0", 0 + %"tmp#20##0" = insertvalue {i64, i64, i1} %"tmp#19##0", i64 %"tmp#10##0", 1 + %"tmp#21##0" = insertvalue {i64, i64, i1} %"tmp#20##0", i1 0, 2 + ret {i64, i64, i1} %"tmp#21##0" } - -define external fastcc i64 @"test_loop.int_seq.step<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = add i64 %"#rec##0", 8 - %1 = inttoptr i64 %0 to i64* - %2 = load i64, i64* %1 - ret i64 %2 +define external fastcc i64 @"test_loop.int_seq.step<0>"(i64 %"#rec##0") { + %"tmp#0##0" = add i64 %"#rec##0", 8 + %"tmp#1##0" = inttoptr i64 %"tmp#0##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"test_loop.int_seq.step<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 24 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 24 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = add i64 %2, 8 - %7 = inttoptr i64 %6 to i64* - store i64 %"#field##0", i64* %7 - ret i64 %2 +define external fastcc i64 @"test_loop.int_seq.step<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 24) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 24, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = add i64 %"tmp#2##0", 8 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 %"#field##0", ptr %"tmp#4##0" + ret i64 %"tmp#2##0" } - -define external fastcc i1 @"test_loop.int_seq.~=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#left##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#left##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = add i64 %"#left##0", 16 - %6 = inttoptr i64 %5 to i64* - %7 = load i64, i64* %6 - %8 = inttoptr i64 %"#right##0" to i64* - %9 = load i64, i64* %8 - %10 = add i64 %"#right##0", 8 - %11 = inttoptr i64 %10 to i64* - %12 = load i64, i64* %11 - %13 = add i64 %"#right##0", 16 - %14 = inttoptr i64 %13 to i64* - %15 = load i64, i64* %14 - %16 = icmp eq i64 %1, %9 - br i1 %16, label %if.then, label %if.else -if.then: - %17 = icmp eq i64 %4, %12 - br i1 %17, label %if.then1, label %if.else1 -if.else: - %21 = xor i1 0, 1 - ret i1 %21 -if.then1: - %18 = icmp eq i64 %7, %15 - %19 = xor i1 %18, 1 - ret i1 %19 -if.else1: - %20 = xor i1 0, 1 - ret i1 %20 +define external fastcc i1 @"test_loop.int_seq.~=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#11##0" = inttoptr i64 %"#left##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#11##0" + %"tmp#12##0" = add i64 %"#left##0", 8 + %"tmp#13##0" = inttoptr i64 %"tmp#12##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#13##0" + %"tmp#14##0" = add i64 %"#left##0", 16 + %"tmp#15##0" = inttoptr i64 %"tmp#14##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#15##0" + %"tmp#16##0" = inttoptr i64 %"#right##0" to ptr + %"tmp#6##0" = load i64, ptr %"tmp#16##0" + %"tmp#17##0" = add i64 %"#right##0", 8 + %"tmp#18##0" = inttoptr i64 %"tmp#17##0" to ptr + %"tmp#7##0" = load i64, ptr %"tmp#18##0" + %"tmp#19##0" = add i64 %"#right##0", 16 + %"tmp#20##0" = inttoptr i64 %"tmp#19##0" to ptr + %"tmp#8##0" = load i64, ptr %"tmp#20##0" + %"tmp#9##0" = icmp eq i64 %"tmp#3##0", %"tmp#6##0" + br i1 %"tmp#9##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#10##0" = icmp eq i64 %"tmp#4##0", %"tmp#7##0" + br i1 %"tmp#10##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#0##0" = icmp eq i64 %"tmp#5##0", %"tmp#8##0" + %"tmp#21##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#21##0" +if.else.1: + %"tmp#22##0" = xor i1 0, 1 + ret i1 %"tmp#22##0" +if.else.0: + %"tmp#23##0" = xor i1 0, 1 + ret i1 %"tmp#23##0" } diff --git a/test-cases/final-dump/tests.exp b/test-cases/final-dump/tests.exp index c191aef61..7bca1687e 100644 --- a/test-cases/final-dump/tests.exp +++ b/test-cases/final-dump/tests.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module tests representation : (not a type) public submods : map -> tests.map @@ -93,90 +96,81 @@ lt3(x##0:wybe.int, y##0:wybe.int, ?#success##0:wybe.bool)<{}; {}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'tests' - - - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc {i64, i1} @"tests.lookup<0>"(i64 %"key##0", i64 %"map##0") { -entry: - %0 = icmp ne i64 %"map##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = add i64 %"map##0", 8 - %2 = inttoptr i64 %1 to i64* - %3 = load i64, i64* %2 - %4 = icmp eq i64 %"key##0", %3 - br i1 %4, label %if.then1, label %if.else1 -if.else: - %26 = insertvalue {i64, i1} undef, i64 undef, 0 - %27 = insertvalue {i64, i1} %26, i1 0, 1 - ret {i64, i1} %27 -if.then1: - %5 = add i64 %"map##0", 16 - %6 = inttoptr i64 %5 to i64* - %7 = load i64, i64* %6 - %8 = insertvalue {i64, i1} undef, i64 %7, 0 - %9 = insertvalue {i64, i1} %8, i1 1, 1 - ret {i64, i1} %9 -if.else1: - %10 = icmp slt i64 %"key##0", %3 - br i1 %10, label %if.then2, label %if.else2 -if.then2: - %11 = inttoptr i64 %"map##0" to i64* - %12 = load i64, i64* %11 - %13 = tail call fastcc {i64, i1} @"tests.lookup<0>"(i64 %"key##0", i64 %12) - %14 = extractvalue {i64, i1} %13, 0 - %15 = extractvalue {i64, i1} %13, 1 - %16 = insertvalue {i64, i1} undef, i64 %14, 0 - %17 = insertvalue {i64, i1} %16, i1 %15, 1 - ret {i64, i1} %17 -if.else2: - %18 = add i64 %"map##0", 24 - %19 = inttoptr i64 %18 to i64* - %20 = load i64, i64* %19 - %21 = tail call fastcc {i64, i1} @"tests.lookup<0>"(i64 %"key##0", i64 %20) - %22 = extractvalue {i64, i1} %21, 0 - %23 = extractvalue {i64, i1} %21, 1 - %24 = insertvalue {i64, i1} undef, i64 %22, 0 - %25 = insertvalue {i64, i1} %24, i1 %23, 1 - ret {i64, i1} %25 +source_filename = "!ROOT!/final-dump/tests.wybe" +target triple ???? + + +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc {i64, i1} @"tests.lookup<0>"(i64 %"key##0", i64 %"map##0") { + %"tmp#15##0" = icmp ne i64 %"map##0", 0 + br i1 %"tmp#15##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#40##0" = add i64 %"map##0", 8 + %"tmp#41##0" = inttoptr i64 %"tmp#40##0" to ptr + %"tmp#0##0" = load i64, ptr %"tmp#41##0" + %"tmp#13##0" = icmp eq i64 %"key##0", %"tmp#0##0" + br i1 %"tmp#13##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#42##0" = add i64 %"map##0", 16 + %"tmp#43##0" = inttoptr i64 %"tmp#42##0" to ptr + %"tmp#44##0" = load i64, ptr %"tmp#43##0" + %"tmp#45##0" = insertvalue {i64, i1} undef, i64 %"tmp#44##0", 0 + %"tmp#46##0" = insertvalue {i64, i1} %"tmp#45##0", i1 1, 1 + ret {i64, i1} %"tmp#46##0" +if.else.1: + %"tmp#11##0" = icmp slt i64 %"key##0", %"tmp#0##0" + br i1 %"tmp#11##0", label %if.then.2, label %if.else.2 +if.then.2: + %"tmp#47##0" = inttoptr i64 %"map##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#47##0" + %"tmp#48##0" = tail call fastcc {i64, i1} @"tests.lookup<0>"(i64 %"key##0", i64 %"tmp#3##0") + %"tmp#49##0" = extractvalue {i64, i1}%"tmp#48##0", 0 + %"tmp#50##0" = extractvalue {i64, i1}%"tmp#48##0", 1 + %"tmp#51##0" = insertvalue {i64, i1} undef, i64 %"tmp#49##0", 0 + %"tmp#52##0" = insertvalue {i64, i1} %"tmp#51##0", i1 %"tmp#50##0", 1 + ret {i64, i1} %"tmp#52##0" +if.else.2: + %"tmp#53##0" = add i64 %"map##0", 24 + %"tmp#54##0" = inttoptr i64 %"tmp#53##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#54##0" + %"tmp#55##0" = tail call fastcc {i64, i1} @"tests.lookup<0>"(i64 %"key##0", i64 %"tmp#4##0") + %"tmp#56##0" = extractvalue {i64, i1}%"tmp#55##0", 0 + %"tmp#57##0" = extractvalue {i64, i1}%"tmp#55##0", 1 + %"tmp#58##0" = insertvalue {i64, i1} undef, i64 %"tmp#56##0", 0 + %"tmp#59##0" = insertvalue {i64, i1} %"tmp#58##0", i1 %"tmp#57##0", 1 + ret {i64, i1} %"tmp#59##0" +if.else.0: + %"tmp#60##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#61##0" = insertvalue {i64, i1} %"tmp#60##0", i1 0, 1 + ret {i64, i1} %"tmp#61##0" } - -define external fastcc i1 @"tests.lt<0>"(i64 %"x##0", i64 %"y##0") { -entry: - %0 = icmp slt i64 %"x##0", %"y##0" - br i1 %0, label %if.then, label %if.else -if.then: - ret i1 1 -if.else: - ret i1 0 +define external fastcc i1 @"tests.lt<0>"(i64 %"x##0", i64 %"y##0") { + %"tmp#3##0" = icmp slt i64 %"x##0", %"y##0" + br i1 %"tmp#3##0", label %if.then.0, label %if.else.0 +if.then.0: + ret i1 1 +if.else.0: + ret i1 0 } - -define external fastcc i1 @"tests.lt2<0>"(i64 %"x##0", i64 %"y##0") alwaysinline { -entry: - %0 = musttail call fastcc i1 @"tests.lt<0>"(i64 %"x##0", i64 %"y##0") - ret i1 %0 +define external fastcc i1 @"tests.lt2<0>"(i64 %"x##0", i64 %"y##0") { + %"tmp#1##0" = tail call fastcc i1 @"tests.lt<0>"(i64 %"x##0", i64 %"y##0") + ret i1 %"tmp#1##0" } - -define external fastcc i1 @"tests.lt3<0>"(i64 %"x##0", i64 %"y##0") alwaysinline { -entry: - %0 = musttail call fastcc i1 @"tests.lt<0>"(i64 %"y##0", i64 %"x##0") - ret i1 %0 +define external fastcc i1 @"tests.lt3<0>"(i64 %"x##0", i64 %"y##0") { + %"tmp#3##0" = tail call fastcc i1 @"tests.lt<0>"(i64 %"y##0", i64 %"x##0") + ret i1 %"tmp#3##0" } + -------------------------------------------------- Module tests.map - representation : address + representation : pointer public submods : public resources: public procs : tests.map.=<0> @@ -427,304 +421,264 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'tests.map' - - - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i1 @"tests.map.=<0>"(i64 %"#left##0", i64 %"#right##0") { -entry: - %0 = icmp ne i64 %"#left##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"#left##0" to i64* - %2 = load i64, i64* %1 - %3 = add i64 %"#left##0", 8 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = add i64 %"#left##0", 16 - %7 = inttoptr i64 %6 to i64* - %8 = load i64, i64* %7 - %9 = add i64 %"#left##0", 24 - %10 = inttoptr i64 %9 to i64* - %11 = load i64, i64* %10 - %12 = icmp ne i64 %"#right##0", 0 - br i1 %12, label %if.then1, label %if.else1 -if.else: - %28 = icmp eq i64 %"#right##0", 0 - ret i1 %28 -if.then1: - %13 = inttoptr i64 %"#right##0" to i64* - %14 = load i64, i64* %13 - %15 = add i64 %"#right##0", 8 - %16 = inttoptr i64 %15 to i64* - %17 = load i64, i64* %16 - %18 = add i64 %"#right##0", 16 - %19 = inttoptr i64 %18 to i64* - %20 = load i64, i64* %19 - %21 = add i64 %"#right##0", 24 - %22 = inttoptr i64 %21 to i64* - %23 = load i64, i64* %22 - %24 = tail call fastcc i1 @"tests.map.=<0>"(i64 %2, i64 %14) - br i1 %24, label %if.then2, label %if.else2 -if.else1: - ret i1 0 -if.then2: - %25 = icmp eq i64 %5, %17 - br i1 %25, label %if.then3, label %if.else3 -if.else2: - ret i1 0 -if.then3: - %26 = icmp eq i64 %8, %20 - br i1 %26, label %if.then4, label %if.else4 -if.else3: - ret i1 0 -if.then4: - %27 = musttail call fastcc i1 @"tests.map.=<0>"(i64 %11, i64 %23) - ret i1 %27 -if.else4: - ret i1 0 +source_filename = "!ROOT!/final-dump/tests.wybe" +target triple ???? + + +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc i1 @"tests.map.=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#0##0" = icmp ne i64 %"#left##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#16##0" = inttoptr i64 %"#left##0" to ptr + %"#left#left##0" = load i64, ptr %"tmp#16##0" + %"tmp#17##0" = add i64 %"#left##0", 8 + %"tmp#18##0" = inttoptr i64 %"tmp#17##0" to ptr + %"#left#key##0" = load i64, ptr %"tmp#18##0" + %"tmp#19##0" = add i64 %"#left##0", 16 + %"tmp#20##0" = inttoptr i64 %"tmp#19##0" to ptr + %"#left#value##0" = load i64, ptr %"tmp#20##0" + %"tmp#21##0" = add i64 %"#left##0", 24 + %"tmp#22##0" = inttoptr i64 %"tmp#21##0" to ptr + %"#left#right##0" = load i64, ptr %"tmp#22##0" + %"tmp#11##0" = icmp ne i64 %"#right##0", 0 + br i1 %"tmp#11##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#23##0" = inttoptr i64 %"#right##0" to ptr + %"#right#left##0" = load i64, ptr %"tmp#23##0" + %"tmp#24##0" = add i64 %"#right##0", 8 + %"tmp#25##0" = inttoptr i64 %"tmp#24##0" to ptr + %"#right#key##0" = load i64, ptr %"tmp#25##0" + %"tmp#26##0" = add i64 %"#right##0", 16 + %"tmp#27##0" = inttoptr i64 %"tmp#26##0" to ptr + %"#right#value##0" = load i64, ptr %"tmp#27##0" + %"tmp#28##0" = add i64 %"#right##0", 24 + %"tmp#29##0" = inttoptr i64 %"tmp#28##0" to ptr + %"#right#right##0" = load i64, ptr %"tmp#29##0" + %"tmp#4##0" = tail call fastcc i1 @"tests.map.=<0>"(i64 %"#left#left##0", i64 %"#right#left##0") + br i1 %"tmp#4##0", label %if.then.2, label %if.else.2 +if.then.2: + %"tmp#5##0" = icmp eq i64 %"#left#key##0", %"#right#key##0" + br i1 %"tmp#5##0", label %if.then.3, label %if.else.3 +if.then.3: + %"tmp#6##0" = icmp eq i64 %"#left#value##0", %"#right#value##0" + br i1 %"tmp#6##0", label %if.then.4, label %if.else.4 +if.then.4: + %"tmp#30##0" = tail call fastcc i1 @"tests.map.=<0>"(i64 %"#left#right##0", i64 %"#right#right##0") + ret i1 %"tmp#30##0" +if.else.4: + ret i1 0 +if.else.3: + ret i1 0 +if.else.2: + ret i1 0 +if.else.1: + ret i1 0 +if.else.0: + %"tmp#31##0" = icmp eq i64 %"#right##0", 0 + ret i1 %"tmp#31##0" } - -define external fastcc i64 @"tests.map.empty<0>"() alwaysinline { -entry: - ret i64 0 +define external fastcc i64 @"tests.map.empty<0>"() { + ret i64 0 } - -define external fastcc {i64, i1} @"tests.map.key<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = add i64 %"#rec##0", 8 - %2 = inttoptr i64 %1 to i64* - %3 = load i64, i64* %2 - %4 = insertvalue {i64, i1} undef, i64 %3, 0 - %5 = insertvalue {i64, i1} %4, i1 1, 1 - ret {i64, i1} %5 -if.else: - %6 = insertvalue {i64, i1} undef, i64 undef, 0 - %7 = insertvalue {i64, i1} %6, i1 0, 1 - ret {i64, i1} %7 +define external fastcc {i64, i1} @"tests.map.key<0>"(i64 %"#rec##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = add i64 %"#rec##0", 8 + %"tmp#2##0" = inttoptr i64 %"tmp#1##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#2##0" + %"tmp#4##0" = insertvalue {i64, i1} undef, i64 %"tmp#3##0", 0 + %"tmp#5##0" = insertvalue {i64, i1} %"tmp#4##0", i1 1, 1 + ret {i64, i1} %"tmp#5##0" +if.else.0: + %"tmp#6##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#7##0" = insertvalue {i64, i1} %"tmp#6##0", i1 0, 1 + ret {i64, i1} %"tmp#7##0" } - -define external fastcc {i64, i1} @"tests.map.key<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = trunc i64 32 to i32 - %2 = tail call ccc i8* @wybe_malloc(i32 %1) - %3 = ptrtoint i8* %2 to i64 - %4 = inttoptr i64 %3 to i8* - %5 = inttoptr i64 %"#rec##0" to i8* - %6 = trunc i64 32 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %4, i8* %5, i32 %6, i1 0) - %7 = add i64 %3, 8 - %8 = inttoptr i64 %7 to i64* - store i64 %"#field##0", i64* %8 - %9 = insertvalue {i64, i1} undef, i64 %3, 0 - %10 = insertvalue {i64, i1} %9, i1 1, 1 - ret {i64, i1} %10 -if.else: - %11 = insertvalue {i64, i1} undef, i64 0, 0 - %12 = insertvalue {i64, i1} %11, i1 0, 1 - ret {i64, i1} %12 +define external fastcc {i64, i1} @"tests.map.key<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#2##0" = call ccc ptr @wybe_malloc(i32 32) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#2##0", ptr %"tmp#1##0", i64 32, i1 0) + %"tmp#3##0" = ptrtoint ptr %"tmp#2##0" to i64 + %"tmp#4##0" = add i64 %"tmp#3##0", 8 + %"tmp#5##0" = inttoptr i64 %"tmp#4##0" to ptr + store i64 %"#field##0", ptr %"tmp#5##0" + %"tmp#6##0" = insertvalue {i64, i1} undef, i64 %"tmp#3##0", 0 + %"tmp#7##0" = insertvalue {i64, i1} %"tmp#6##0", i1 1, 1 + ret {i64, i1} %"tmp#7##0" +if.else.0: + %"tmp#8##0" = insertvalue {i64, i1} undef, i64 0, 0 + %"tmp#9##0" = insertvalue {i64, i1} %"tmp#8##0", i1 0, 1 + ret {i64, i1} %"tmp#9##0" } - -define external fastcc {i64, i1} @"tests.map.left<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"#rec##0" to i64* - %2 = load i64, i64* %1 - %3 = insertvalue {i64, i1} undef, i64 %2, 0 - %4 = insertvalue {i64, i1} %3, i1 1, 1 - ret {i64, i1} %4 -if.else: - %5 = insertvalue {i64, i1} undef, i64 undef, 0 - %6 = insertvalue {i64, i1} %5, i1 0, 1 - ret {i64, i1} %6 +define external fastcc {i64, i1} @"tests.map.left<0>"(i64 %"#rec##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + %"tmp#3##0" = insertvalue {i64, i1} undef, i64 %"tmp#2##0", 0 + %"tmp#4##0" = insertvalue {i64, i1} %"tmp#3##0", i1 1, 1 + ret {i64, i1} %"tmp#4##0" +if.else.0: + %"tmp#5##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#6##0" = insertvalue {i64, i1} %"tmp#5##0", i1 0, 1 + ret {i64, i1} %"tmp#6##0" } - -define external fastcc {i64, i1} @"tests.map.left<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = trunc i64 32 to i32 - %2 = tail call ccc i8* @wybe_malloc(i32 %1) - %3 = ptrtoint i8* %2 to i64 - %4 = inttoptr i64 %3 to i8* - %5 = inttoptr i64 %"#rec##0" to i8* - %6 = trunc i64 32 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %4, i8* %5, i32 %6, i1 0) - %7 = inttoptr i64 %3 to i64* - store i64 %"#field##0", i64* %7 - %8 = insertvalue {i64, i1} undef, i64 %3, 0 - %9 = insertvalue {i64, i1} %8, i1 1, 1 - ret {i64, i1} %9 -if.else: - %10 = insertvalue {i64, i1} undef, i64 0, 0 - %11 = insertvalue {i64, i1} %10, i1 0, 1 - ret {i64, i1} %11 +define external fastcc {i64, i1} @"tests.map.left<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#2##0" = call ccc ptr @wybe_malloc(i32 32) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#2##0", ptr %"tmp#1##0", i64 32, i1 0) + %"tmp#3##0" = ptrtoint ptr %"tmp#2##0" to i64 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 %"#field##0", ptr %"tmp#4##0" + %"tmp#5##0" = insertvalue {i64, i1} undef, i64 %"tmp#3##0", 0 + %"tmp#6##0" = insertvalue {i64, i1} %"tmp#5##0", i1 1, 1 + ret {i64, i1} %"tmp#6##0" +if.else.0: + %"tmp#7##0" = insertvalue {i64, i1} undef, i64 0, 0 + %"tmp#8##0" = insertvalue {i64, i1} %"tmp#7##0", i1 0, 1 + ret {i64, i1} %"tmp#8##0" } - -define external fastcc i64 @"tests.map.node<0>"(i64 %"left##0", i64 %"key##0", i64 %"value##0", i64 %"right##0") alwaysinline { -entry: - %0 = trunc i64 32 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"left##0", i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"key##0", i64* %5 - %6 = add i64 %2, 16 - %7 = inttoptr i64 %6 to i64* - store i64 %"value##0", i64* %7 - %8 = add i64 %2, 24 - %9 = inttoptr i64 %8 to i64* - store i64 %"right##0", i64* %9 - ret i64 %2 +define external fastcc i64 @"tests.map.node<0>"(i64 %"left##0", i64 %"key##0", i64 %"value##0", i64 %"right##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 32) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"left##0", ptr %"tmp#1##0" + %"tmp#2##0" = add i64 %"#rec##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"key##0", ptr %"tmp#3##0" + %"tmp#4##0" = add i64 %"#rec##0", 16 + %"tmp#5##0" = inttoptr i64 %"tmp#4##0" to ptr + store i64 %"value##0", ptr %"tmp#5##0" + %"tmp#6##0" = add i64 %"#rec##0", 24 + %"tmp#7##0" = inttoptr i64 %"tmp#6##0" to ptr + store i64 %"right##0", ptr %"tmp#7##0" + ret i64 %"#rec##0" } - -define external fastcc {i64, i64, i64, i64, i1} @"tests.map.node<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#result##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"#result##0" to i64* - %2 = load i64, i64* %1 - %3 = add i64 %"#result##0", 8 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = add i64 %"#result##0", 16 - %7 = inttoptr i64 %6 to i64* - %8 = load i64, i64* %7 - %9 = add i64 %"#result##0", 24 - %10 = inttoptr i64 %9 to i64* - %11 = load i64, i64* %10 - %12 = insertvalue {i64, i64, i64, i64, i1} undef, i64 %2, 0 - %13 = insertvalue {i64, i64, i64, i64, i1} %12, i64 %5, 1 - %14 = insertvalue {i64, i64, i64, i64, i1} %13, i64 %8, 2 - %15 = insertvalue {i64, i64, i64, i64, i1} %14, i64 %11, 3 - %16 = insertvalue {i64, i64, i64, i64, i1} %15, i1 1, 4 - ret {i64, i64, i64, i64, i1} %16 -if.else: - %17 = insertvalue {i64, i64, i64, i64, i1} undef, i64 undef, 0 - %18 = insertvalue {i64, i64, i64, i64, i1} %17, i64 undef, 1 - %19 = insertvalue {i64, i64, i64, i64, i1} %18, i64 undef, 2 - %20 = insertvalue {i64, i64, i64, i64, i1} %19, i64 undef, 3 - %21 = insertvalue {i64, i64, i64, i64, i1} %20, i1 0, 4 - ret {i64, i64, i64, i64, i1} %21 +define external fastcc {i64, i64, i64, i64, i1} @"tests.map.node<1>"(i64 %"#result##0") { + %"tmp#0##0" = icmp ne i64 %"#result##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = inttoptr i64 %"#result##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + %"tmp#3##0" = add i64 %"#result##0", 8 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#4##0" + %"tmp#6##0" = add i64 %"#result##0", 16 + %"tmp#7##0" = inttoptr i64 %"tmp#6##0" to ptr + %"tmp#8##0" = load i64, ptr %"tmp#7##0" + %"tmp#9##0" = add i64 %"#result##0", 24 + %"tmp#10##0" = inttoptr i64 %"tmp#9##0" to ptr + %"tmp#11##0" = load i64, ptr %"tmp#10##0" + %"tmp#12##0" = insertvalue {i64, i64, i64, i64, i1} undef, i64 %"tmp#2##0", 0 + %"tmp#13##0" = insertvalue {i64, i64, i64, i64, i1} %"tmp#12##0", i64 %"tmp#5##0", 1 + %"tmp#14##0" = insertvalue {i64, i64, i64, i64, i1} %"tmp#13##0", i64 %"tmp#8##0", 2 + %"tmp#15##0" = insertvalue {i64, i64, i64, i64, i1} %"tmp#14##0", i64 %"tmp#11##0", 3 + %"tmp#16##0" = insertvalue {i64, i64, i64, i64, i1} %"tmp#15##0", i1 1, 4 + ret {i64, i64, i64, i64, i1} %"tmp#16##0" +if.else.0: + %"tmp#17##0" = insertvalue {i64, i64, i64, i64, i1} undef, i64 undef, 0 + %"tmp#18##0" = insertvalue {i64, i64, i64, i64, i1} %"tmp#17##0", i64 undef, 1 + %"tmp#19##0" = insertvalue {i64, i64, i64, i64, i1} %"tmp#18##0", i64 undef, 2 + %"tmp#20##0" = insertvalue {i64, i64, i64, i64, i1} %"tmp#19##0", i64 undef, 3 + %"tmp#21##0" = insertvalue {i64, i64, i64, i64, i1} %"tmp#20##0", i1 0, 4 + ret {i64, i64, i64, i64, i1} %"tmp#21##0" } - -define external fastcc {i64, i1} @"tests.map.right<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = add i64 %"#rec##0", 24 - %2 = inttoptr i64 %1 to i64* - %3 = load i64, i64* %2 - %4 = insertvalue {i64, i1} undef, i64 %3, 0 - %5 = insertvalue {i64, i1} %4, i1 1, 1 - ret {i64, i1} %5 -if.else: - %6 = insertvalue {i64, i1} undef, i64 undef, 0 - %7 = insertvalue {i64, i1} %6, i1 0, 1 - ret {i64, i1} %7 +define external fastcc {i64, i1} @"tests.map.right<0>"(i64 %"#rec##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = add i64 %"#rec##0", 24 + %"tmp#2##0" = inttoptr i64 %"tmp#1##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#2##0" + %"tmp#4##0" = insertvalue {i64, i1} undef, i64 %"tmp#3##0", 0 + %"tmp#5##0" = insertvalue {i64, i1} %"tmp#4##0", i1 1, 1 + ret {i64, i1} %"tmp#5##0" +if.else.0: + %"tmp#6##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#7##0" = insertvalue {i64, i1} %"tmp#6##0", i1 0, 1 + ret {i64, i1} %"tmp#7##0" } - -define external fastcc {i64, i1} @"tests.map.right<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = trunc i64 32 to i32 - %2 = tail call ccc i8* @wybe_malloc(i32 %1) - %3 = ptrtoint i8* %2 to i64 - %4 = inttoptr i64 %3 to i8* - %5 = inttoptr i64 %"#rec##0" to i8* - %6 = trunc i64 32 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %4, i8* %5, i32 %6, i1 0) - %7 = add i64 %3, 24 - %8 = inttoptr i64 %7 to i64* - store i64 %"#field##0", i64* %8 - %9 = insertvalue {i64, i1} undef, i64 %3, 0 - %10 = insertvalue {i64, i1} %9, i1 1, 1 - ret {i64, i1} %10 -if.else: - %11 = insertvalue {i64, i1} undef, i64 0, 0 - %12 = insertvalue {i64, i1} %11, i1 0, 1 - ret {i64, i1} %12 +define external fastcc {i64, i1} @"tests.map.right<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#2##0" = call ccc ptr @wybe_malloc(i32 32) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#2##0", ptr %"tmp#1##0", i64 32, i1 0) + %"tmp#3##0" = ptrtoint ptr %"tmp#2##0" to i64 + %"tmp#4##0" = add i64 %"tmp#3##0", 24 + %"tmp#5##0" = inttoptr i64 %"tmp#4##0" to ptr + store i64 %"#field##0", ptr %"tmp#5##0" + %"tmp#6##0" = insertvalue {i64, i1} undef, i64 %"tmp#3##0", 0 + %"tmp#7##0" = insertvalue {i64, i1} %"tmp#6##0", i1 1, 1 + ret {i64, i1} %"tmp#7##0" +if.else.0: + %"tmp#8##0" = insertvalue {i64, i1} undef, i64 0, 0 + %"tmp#9##0" = insertvalue {i64, i1} %"tmp#8##0", i1 0, 1 + ret {i64, i1} %"tmp#9##0" } - -define external fastcc {i64, i1} @"tests.map.value<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = add i64 %"#rec##0", 16 - %2 = inttoptr i64 %1 to i64* - %3 = load i64, i64* %2 - %4 = insertvalue {i64, i1} undef, i64 %3, 0 - %5 = insertvalue {i64, i1} %4, i1 1, 1 - ret {i64, i1} %5 -if.else: - %6 = insertvalue {i64, i1} undef, i64 undef, 0 - %7 = insertvalue {i64, i1} %6, i1 0, 1 - ret {i64, i1} %7 +define external fastcc {i64, i1} @"tests.map.value<0>"(i64 %"#rec##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = add i64 %"#rec##0", 16 + %"tmp#2##0" = inttoptr i64 %"tmp#1##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#2##0" + %"tmp#4##0" = insertvalue {i64, i1} undef, i64 %"tmp#3##0", 0 + %"tmp#5##0" = insertvalue {i64, i1} %"tmp#4##0", i1 1, 1 + ret {i64, i1} %"tmp#5##0" +if.else.0: + %"tmp#6##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#7##0" = insertvalue {i64, i1} %"tmp#6##0", i1 0, 1 + ret {i64, i1} %"tmp#7##0" } - -define external fastcc {i64, i1} @"tests.map.value<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = trunc i64 32 to i32 - %2 = tail call ccc i8* @wybe_malloc(i32 %1) - %3 = ptrtoint i8* %2 to i64 - %4 = inttoptr i64 %3 to i8* - %5 = inttoptr i64 %"#rec##0" to i8* - %6 = trunc i64 32 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %4, i8* %5, i32 %6, i1 0) - %7 = add i64 %3, 16 - %8 = inttoptr i64 %7 to i64* - store i64 %"#field##0", i64* %8 - %9 = insertvalue {i64, i1} undef, i64 %3, 0 - %10 = insertvalue {i64, i1} %9, i1 1, 1 - ret {i64, i1} %10 -if.else: - %11 = insertvalue {i64, i1} undef, i64 0, 0 - %12 = insertvalue {i64, i1} %11, i1 0, 1 - ret {i64, i1} %12 +define external fastcc {i64, i1} @"tests.map.value<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#2##0" = call ccc ptr @wybe_malloc(i32 32) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#2##0", ptr %"tmp#1##0", i64 32, i1 0) + %"tmp#3##0" = ptrtoint ptr %"tmp#2##0" to i64 + %"tmp#4##0" = add i64 %"tmp#3##0", 16 + %"tmp#5##0" = inttoptr i64 %"tmp#4##0" to ptr + store i64 %"#field##0", ptr %"tmp#5##0" + %"tmp#6##0" = insertvalue {i64, i1} undef, i64 %"tmp#3##0", 0 + %"tmp#7##0" = insertvalue {i64, i1} %"tmp#6##0", i1 1, 1 + ret {i64, i1} %"tmp#7##0" +if.else.0: + %"tmp#8##0" = insertvalue {i64, i1} undef, i64 0, 0 + %"tmp#9##0" = insertvalue {i64, i1} %"tmp#8##0", i1 0, 1 + ret {i64, i1} %"tmp#9##0" } - -define external fastcc i1 @"tests.map.~=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = tail call fastcc i1 @"tests.map.=<0>"(i64 %"#left##0", i64 %"#right##0") - %1 = xor i1 %0, 1 - ret i1 %1 +define external fastcc i1 @"tests.map.~=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#0##0" = tail call fastcc i1 @"tests.map.=<0>"(i64 %"#left##0", i64 %"#right##0") + %"tmp#1##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#1##0" } diff --git a/test-cases/final-dump/thistype.exp b/test-cases/final-dump/thistype.exp index 17aafc62c..7e1738f77 100644 --- a/test-cases/final-dump/thistype.exp +++ b/test-cases/final-dump/thistype.exp @@ -1,7 +1,10 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module thistype - representation : address + representation : pointer public submods : public resources: public procs : thistype.<0> @@ -83,7 +86,7 @@ proc = > public (2 calls) proc concat > public (2 calls) -0: thistype.concat<0>[410bae77d3] +0: thistype.concat<0> concat(x##0:thistype, y##0:thistype, outByReference #result##0:thistype)<{}; {}; {}>: AliasPairs: [(#result##0,y##0)] InterestingCallProperties: [InterestingUnaliased 0] @@ -240,299 +243,255 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'thistype' - - - - -declare external ccc void @putchar(i8) - - -declare external ccc void @print_int(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"thistype.<0>"() { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 3, i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 0, i64* %5 - %6 = trunc i64 16 to i32 - %7 = tail call ccc i8* @wybe_malloc(i32 %6) - %8 = ptrtoint i8* %7 to i64 - %9 = inttoptr i64 %8 to i64* - store i64 2, i64* %9 - %10 = add i64 %8, 8 - %11 = inttoptr i64 %10 to i64* - store i64 %2, i64* %11 - %12 = trunc i64 16 to i32 - %13 = tail call ccc i8* @wybe_malloc(i32 %12) - %14 = ptrtoint i8* %13 to i64 - %15 = inttoptr i64 %14 to i64* - store i64 1, i64* %15 - %16 = add i64 %14, 8 - %17 = inttoptr i64 %16 to i64* - store i64 %8, i64* %17 - %18 = trunc i64 16 to i32 - %19 = tail call ccc i8* @wybe_malloc(i32 %18) - %20 = ptrtoint i8* %19 to i64 - %21 = inttoptr i64 %20 to i64* - store i64 200, i64* %21 - %22 = add i64 %20, 8 - %23 = inttoptr i64 %22 to i64* - store i64 0, i64* %23 - %24 = trunc i64 16 to i32 - %25 = tail call ccc i8* @wybe_malloc(i32 %24) - %26 = ptrtoint i8* %25 to i64 - %27 = inttoptr i64 %26 to i64* - store i64 100, i64* %27 - %28 = add i64 %26, 8 - %29 = inttoptr i64 %28 to i64* - store i64 %20, i64* %29 - %30 = alloca i64 - call fastcc void @"thistype.concat<0>[410bae77d3]"(i64 %14, i64 %26, i64* %30) - %31 = load i64, i64* %30 - %32 = tail call fastcc i64 @"thistype.length<0>"(i64 %31) - tail call ccc void @print_int(i64 %32) - tail call ccc void @putchar(i8 10) - ret void +source_filename = "!ROOT!/final-dump/thistype.wybe" +target triple ???? + + +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"thistype.<0>"() { + %"tmp#33##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#11##0" = ptrtoint ptr %"tmp#33##0" to i64 + %"tmp#34##0" = inttoptr i64 %"tmp#11##0" to ptr + store i64 3, ptr %"tmp#34##0" + %"tmp#35##0" = add i64 %"tmp#11##0", 8 + %"tmp#36##0" = inttoptr i64 %"tmp#35##0" to ptr + store i64 0, ptr %"tmp#36##0" + %"tmp#37##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#15##0" = ptrtoint ptr %"tmp#37##0" to i64 + %"tmp#38##0" = inttoptr i64 %"tmp#15##0" to ptr + store i64 2, ptr %"tmp#38##0" + %"tmp#39##0" = add i64 %"tmp#15##0", 8 + %"tmp#40##0" = inttoptr i64 %"tmp#39##0" to ptr + store i64 %"tmp#11##0", ptr %"tmp#40##0" + %"tmp#41##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#19##0" = ptrtoint ptr %"tmp#41##0" to i64 + %"tmp#42##0" = inttoptr i64 %"tmp#19##0" to ptr + store i64 1, ptr %"tmp#42##0" + %"tmp#43##0" = add i64 %"tmp#19##0", 8 + %"tmp#44##0" = inttoptr i64 %"tmp#43##0" to ptr + store i64 %"tmp#15##0", ptr %"tmp#44##0" + %"tmp#45##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#23##0" = ptrtoint ptr %"tmp#45##0" to i64 + %"tmp#46##0" = inttoptr i64 %"tmp#23##0" to ptr + store i64 200, ptr %"tmp#46##0" + %"tmp#47##0" = add i64 %"tmp#23##0", 8 + %"tmp#48##0" = inttoptr i64 %"tmp#47##0" to ptr + store i64 0, ptr %"tmp#48##0" + %"tmp#49##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#27##0" = ptrtoint ptr %"tmp#49##0" to i64 + %"tmp#50##0" = inttoptr i64 %"tmp#27##0" to ptr + store i64 100, ptr %"tmp#50##0" + %"tmp#51##0" = add i64 %"tmp#27##0", 8 + %"tmp#52##0" = inttoptr i64 %"tmp#51##0" to ptr + store i64 %"tmp#23##0", ptr %"tmp#52##0" + %"tmp#53##0" = alloca i8, i64 8, align 8 + call fastcc void @"thistype.concat<0>[410bae77d3]"(i64 %"tmp#19##0", i64 %"tmp#27##0", ptr %"tmp#53##0") + %"tmp#8##0" = load i64, ptr %"tmp#53##0" + %"tmp#7##0" = call fastcc i64 @"thistype.length<0>"(i64 %"tmp#8##0") + call ccc void @print_int(i64 %"tmp#7##0") + call ccc void @putchar(i8 10) + ret void } - -define external fastcc i1 @"thistype.=<0>"(i64 %"#left##0", i64 %"#right##0") { -entry: - %0 = icmp ne i64 %"#left##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"#left##0" to i64* - %2 = load i64, i64* %1 - %3 = add i64 %"#left##0", 8 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = icmp ne i64 %"#right##0", 0 - br i1 %6, label %if.then1, label %if.else1 -if.else: - %14 = icmp eq i64 %"#right##0", 0 - ret i1 %14 -if.then1: - %7 = inttoptr i64 %"#right##0" to i64* - %8 = load i64, i64* %7 - %9 = add i64 %"#right##0", 8 - %10 = inttoptr i64 %9 to i64* - %11 = load i64, i64* %10 - %12 = icmp eq i64 %2, %8 - br i1 %12, label %if.then2, label %if.else2 -if.else1: - ret i1 0 -if.then2: - %13 = musttail call fastcc i1 @"thistype.=<0>"(i64 %5, i64 %11) - ret i1 %13 -if.else2: - ret i1 0 +define external fastcc i1 @"thistype.=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#0##0" = icmp ne i64 %"#left##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#12##0" = inttoptr i64 %"#left##0" to ptr + %"#left#head##0" = load i64, ptr %"tmp#12##0" + %"tmp#13##0" = add i64 %"#left##0", 8 + %"tmp#14##0" = inttoptr i64 %"tmp#13##0" to ptr + %"#left#tail##0" = load i64, ptr %"tmp#14##0" + %"tmp#9##0" = icmp ne i64 %"#right##0", 0 + br i1 %"tmp#9##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#15##0" = inttoptr i64 %"#right##0" to ptr + %"#right#head##0" = load i64, ptr %"tmp#15##0" + %"tmp#16##0" = add i64 %"#right##0", 8 + %"tmp#17##0" = inttoptr i64 %"tmp#16##0" to ptr + %"#right#tail##0" = load i64, ptr %"tmp#17##0" + %"tmp#4##0" = icmp eq i64 %"#left#head##0", %"#right#head##0" + br i1 %"tmp#4##0", label %if.then.2, label %if.else.2 +if.then.2: + %"tmp#18##0" = tail call fastcc i1 @"thistype.=<0>"(i64 %"#left#tail##0", i64 %"#right#tail##0") + ret i1 %"tmp#18##0" +if.else.2: + ret i1 0 +if.else.1: + ret i1 0 +if.else.0: + %"tmp#19##0" = icmp eq i64 %"#right##0", 0 + ret i1 %"tmp#19##0" } - -define external fastcc void @"thistype.concat<0>"(i64 %"x##0", i64 %"y##0", i64* %"#result##0") { -entry: - %0 = icmp ne i64 %"x##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"x##0" to i64* - %2 = load i64, i64* %1 - %3 = add i64 %"x##0", 8 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = trunc i64 16 to i32 - %7 = tail call ccc i8* @wybe_malloc(i32 %6) - %8 = ptrtoint i8* %7 to i64 - %9 = inttoptr i64 %8 to i64* - store i64 %2, i64* %9 - %10 = add i64 %8, 8 - %11 = inttoptr i64 %10 to i64* - store i64 %8, i64* %"#result##0" - musttail call fastcc void @"thistype.concat<0>"(i64 %5, i64 %"y##0", i64* %11) - ret void -if.else: - store i64 %"y##0", i64* %"#result##0" - ret void +define external fastcc void @"thistype.concat<0>"(i64 %"x##0", i64 %"y##0", ptr %"tmp#10##0") { + %"tmp#5##0" = icmp ne i64 %"x##0", 0 + br i1 %"tmp#5##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#11##0" = inttoptr i64 %"x##0" to ptr + %"h##0" = load i64, ptr %"tmp#11##0" + %"tmp#12##0" = add i64 %"x##0", 8 + %"tmp#13##0" = inttoptr i64 %"tmp#12##0" to ptr + %"t##0" = load i64, ptr %"tmp#13##0" + %"tmp#14##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#8##0" = ptrtoint ptr %"tmp#14##0" to i64 + %"tmp#15##0" = inttoptr i64 %"tmp#8##0" to ptr + store i64 %"h##0", ptr %"tmp#15##0" + store i64 %"tmp#8##0", ptr %"tmp#10##0" + %"tmp#16##0" = add i64 %"tmp#8##0", 8 + %"tmp#17##0" = inttoptr i64 %"tmp#16##0" to ptr + musttail call fastcc void @"thistype.concat<0>"(i64 %"t##0", i64 %"y##0", ptr %"tmp#17##0") + ret void +if.else.0: + store i64 %"y##0", ptr %"tmp#10##0" + ret void } - -define external fastcc void @"thistype.concat<0>[410bae77d3]"(i64 %"x##0", i64 %"y##0", i64* %"#result##0") { -entry: - %0 = icmp ne i64 %"x##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = add i64 %"x##0", 8 - %2 = inttoptr i64 %1 to i64* - %3 = load i64, i64* %2 - %4 = add i64 %"x##0", 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"x##0", i64* %"#result##0" - musttail call fastcc void @"thistype.concat<0>[410bae77d3]"(i64 %3, i64 %"y##0", i64* %5) - ret void -if.else: - store i64 %"y##0", i64* %"#result##0" - ret void +define external fastcc void @"thistype.concat<0>[410bae77d3]"(i64 %"x##0", i64 %"y##0", ptr %"tmp#10##0") { + %"tmp#5##0" = icmp ne i64 %"x##0", 0 + br i1 %"tmp#5##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#11##0" = add i64 %"x##0", 8 + %"tmp#12##0" = inttoptr i64 %"tmp#11##0" to ptr + %"t##0" = load i64, ptr %"tmp#12##0" + store i64 %"x##0", ptr %"tmp#10##0" + %"tmp#13##0" = add i64 %"x##0", 8 + %"tmp#14##0" = inttoptr i64 %"tmp#13##0" to ptr + musttail call fastcc void @"thistype.concat<0>[410bae77d3]"(i64 %"t##0", i64 %"y##0", ptr %"tmp#14##0") + ret void +if.else.0: + store i64 %"y##0", ptr %"tmp#10##0" + ret void } - -define external fastcc i64 @"thistype.cons<0>"(i64 %"head##0", i64 %"tail##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"head##0", i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"tail##0", i64* %5 - ret i64 %2 +define external fastcc i64 @"thistype.cons<0>"(i64 %"head##0", i64 %"tail##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 16) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"head##0", ptr %"tmp#1##0" + %"tmp#2##0" = add i64 %"#rec##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"tail##0", ptr %"tmp#3##0" + ret i64 %"#rec##0" } - -define external fastcc {i64, i64, i1} @"thistype.cons<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#result##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"#result##0" to i64* - %2 = load i64, i64* %1 - %3 = add i64 %"#result##0", 8 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = insertvalue {i64, i64, i1} undef, i64 %2, 0 - %7 = insertvalue {i64, i64, i1} %6, i64 %5, 1 - %8 = insertvalue {i64, i64, i1} %7, i1 1, 2 - ret {i64, i64, i1} %8 -if.else: - %9 = insertvalue {i64, i64, i1} undef, i64 undef, 0 - %10 = insertvalue {i64, i64, i1} %9, i64 undef, 1 - %11 = insertvalue {i64, i64, i1} %10, i1 0, 2 - ret {i64, i64, i1} %11 +define external fastcc {i64, i64, i1} @"thistype.cons<1>"(i64 %"#result##0") { + %"tmp#0##0" = icmp ne i64 %"#result##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = inttoptr i64 %"#result##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + %"tmp#3##0" = add i64 %"#result##0", 8 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#4##0" + %"tmp#6##0" = insertvalue {i64, i64, i1} undef, i64 %"tmp#2##0", 0 + %"tmp#7##0" = insertvalue {i64, i64, i1} %"tmp#6##0", i64 %"tmp#5##0", 1 + %"tmp#8##0" = insertvalue {i64, i64, i1} %"tmp#7##0", i1 1, 2 + ret {i64, i64, i1} %"tmp#8##0" +if.else.0: + %"tmp#9##0" = insertvalue {i64, i64, i1} undef, i64 undef, 0 + %"tmp#10##0" = insertvalue {i64, i64, i1} %"tmp#9##0", i64 undef, 1 + %"tmp#11##0" = insertvalue {i64, i64, i1} %"tmp#10##0", i1 0, 2 + ret {i64, i64, i1} %"tmp#11##0" } - -define external fastcc {i64, i1} @"thistype.head<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"#rec##0" to i64* - %2 = load i64, i64* %1 - %3 = insertvalue {i64, i1} undef, i64 %2, 0 - %4 = insertvalue {i64, i1} %3, i1 1, 1 - ret {i64, i1} %4 -if.else: - %5 = insertvalue {i64, i1} undef, i64 undef, 0 - %6 = insertvalue {i64, i1} %5, i1 0, 1 - ret {i64, i1} %6 +define external fastcc {i64, i1} @"thistype.head<0>"(i64 %"#rec##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + %"tmp#3##0" = insertvalue {i64, i1} undef, i64 %"tmp#2##0", 0 + %"tmp#4##0" = insertvalue {i64, i1} %"tmp#3##0", i1 1, 1 + ret {i64, i1} %"tmp#4##0" +if.else.0: + %"tmp#5##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#6##0" = insertvalue {i64, i1} %"tmp#5##0", i1 0, 1 + ret {i64, i1} %"tmp#6##0" } - -define external fastcc {i64, i1} @"thistype.head<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = trunc i64 16 to i32 - %2 = tail call ccc i8* @wybe_malloc(i32 %1) - %3 = ptrtoint i8* %2 to i64 - %4 = inttoptr i64 %3 to i8* - %5 = inttoptr i64 %"#rec##0" to i8* - %6 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %4, i8* %5, i32 %6, i1 0) - %7 = inttoptr i64 %3 to i64* - store i64 %"#field##0", i64* %7 - %8 = insertvalue {i64, i1} undef, i64 %3, 0 - %9 = insertvalue {i64, i1} %8, i1 1, 1 - ret {i64, i1} %9 -if.else: - %10 = insertvalue {i64, i1} undef, i64 0, 0 - %11 = insertvalue {i64, i1} %10, i1 0, 1 - ret {i64, i1} %11 +define external fastcc {i64, i1} @"thistype.head<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#2##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#2##0", ptr %"tmp#1##0", i64 16, i1 0) + %"tmp#3##0" = ptrtoint ptr %"tmp#2##0" to i64 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 %"#field##0", ptr %"tmp#4##0" + %"tmp#5##0" = insertvalue {i64, i1} undef, i64 %"tmp#3##0", 0 + %"tmp#6##0" = insertvalue {i64, i1} %"tmp#5##0", i1 1, 1 + ret {i64, i1} %"tmp#6##0" +if.else.0: + %"tmp#7##0" = insertvalue {i64, i1} undef, i64 0, 0 + %"tmp#8##0" = insertvalue {i64, i1} %"tmp#7##0", i1 0, 1 + ret {i64, i1} %"tmp#8##0" } - -define external fastcc i64 @"thistype.length<0>"(i64 %"x##0") { -entry: - %0 = icmp ne i64 %"x##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = add i64 %"x##0", 8 - %2 = inttoptr i64 %1 to i64* - %3 = load i64, i64* %2 - %4 = tail call fastcc i64 @"thistype.length<0>"(i64 %3) - %5 = add i64 %4, 1 - ret i64 %5 -if.else: - ret i64 0 +define external fastcc i64 @"thistype.length<0>"(i64 %"x##0") { + %"tmp#5##0" = icmp ne i64 %"x##0", 0 + br i1 %"tmp#5##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#8##0" = add i64 %"x##0", 8 + %"tmp#9##0" = inttoptr i64 %"tmp#8##0" to ptr + %"t##0" = load i64, ptr %"tmp#9##0" + %"tmp#2##0" = tail call fastcc i64 @"thistype.length<0>"(i64 %"t##0") + %"tmp#10##0" = add i64 %"tmp#2##0", 1 + ret i64 %"tmp#10##0" +if.else.0: + ret i64 0 } - -define external fastcc i64 @"thistype.nil<0>"() alwaysinline { -entry: - ret i64 0 +define external fastcc i64 @"thistype.nil<0>"() { + ret i64 0 } - -define external fastcc {i64, i1} @"thistype.tail<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = add i64 %"#rec##0", 8 - %2 = inttoptr i64 %1 to i64* - %3 = load i64, i64* %2 - %4 = insertvalue {i64, i1} undef, i64 %3, 0 - %5 = insertvalue {i64, i1} %4, i1 1, 1 - ret {i64, i1} %5 -if.else: - %6 = insertvalue {i64, i1} undef, i64 undef, 0 - %7 = insertvalue {i64, i1} %6, i1 0, 1 - ret {i64, i1} %7 +define external fastcc {i64, i1} @"thistype.tail<0>"(i64 %"#rec##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = add i64 %"#rec##0", 8 + %"tmp#2##0" = inttoptr i64 %"tmp#1##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#2##0" + %"tmp#4##0" = insertvalue {i64, i1} undef, i64 %"tmp#3##0", 0 + %"tmp#5##0" = insertvalue {i64, i1} %"tmp#4##0", i1 1, 1 + ret {i64, i1} %"tmp#5##0" +if.else.0: + %"tmp#6##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#7##0" = insertvalue {i64, i1} %"tmp#6##0", i1 0, 1 + ret {i64, i1} %"tmp#7##0" } - -define external fastcc {i64, i1} @"thistype.tail<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = trunc i64 16 to i32 - %2 = tail call ccc i8* @wybe_malloc(i32 %1) - %3 = ptrtoint i8* %2 to i64 - %4 = inttoptr i64 %3 to i8* - %5 = inttoptr i64 %"#rec##0" to i8* - %6 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %4, i8* %5, i32 %6, i1 0) - %7 = add i64 %3, 8 - %8 = inttoptr i64 %7 to i64* - store i64 %"#field##0", i64* %8 - %9 = insertvalue {i64, i1} undef, i64 %3, 0 - %10 = insertvalue {i64, i1} %9, i1 1, 1 - ret {i64, i1} %10 -if.else: - %11 = insertvalue {i64, i1} undef, i64 0, 0 - %12 = insertvalue {i64, i1} %11, i1 0, 1 - ret {i64, i1} %12 +define external fastcc {i64, i1} @"thistype.tail<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#2##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#2##0", ptr %"tmp#1##0", i64 16, i1 0) + %"tmp#3##0" = ptrtoint ptr %"tmp#2##0" to i64 + %"tmp#4##0" = add i64 %"tmp#3##0", 8 + %"tmp#5##0" = inttoptr i64 %"tmp#4##0" to ptr + store i64 %"#field##0", ptr %"tmp#5##0" + %"tmp#6##0" = insertvalue {i64, i1} undef, i64 %"tmp#3##0", 0 + %"tmp#7##0" = insertvalue {i64, i1} %"tmp#6##0", i1 1, 1 + ret {i64, i1} %"tmp#7##0" +if.else.0: + %"tmp#8##0" = insertvalue {i64, i1} undef, i64 0, 0 + %"tmp#9##0" = insertvalue {i64, i1} %"tmp#8##0", i1 0, 1 + ret {i64, i1} %"tmp#9##0" } - -define external fastcc i1 @"thistype.~=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = tail call fastcc i1 @"thistype.=<0>"(i64 %"#left##0", i64 %"#right##0") - %1 = xor i1 %0, 1 - ret i1 %1 +define external fastcc i1 @"thistype.~=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#0##0" = tail call fastcc i1 @"thistype.=<0>"(i64 %"#left##0", i64 %"#right##0") + %"tmp#1##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#1##0" } diff --git a/test-cases/final-dump/top_level_use.exp b/test-cases/final-dump/top_level_use.exp index cfa1a405a..f4edc8b40 100644 --- a/test-cases/final-dump/top_level_use.exp +++ b/test-cases/final-dump/top_level_use.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module top_level_use representation : (not a type) public submods : @@ -21,30 +24,20 @@ module top-level code > public {semipure} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'top_level_use' +source_filename = "!ROOT!/final-dump/top_level_use.wybe" +target triple ???? - - - -@"resource#top_level_use.res" = global i64 undef - - -declare external ccc void @putchar(i8) - - -declare external ccc void @print_int(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) +@"resource#top_level_use.res" = global i64 undef -define external fastcc void @"top_level_use.<0>"() { -entry: - tail call ccc void @print_int(i64 0) - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"top_level_use.<0>"() { + call ccc void @print_int(i64 0) + call ccc void @putchar(i8 10) + ret void } diff --git a/test-cases/final-dump/type_enum.exp b/test-cases/final-dump/type_enum.exp index cfc4c3a39..3b8a263ef 100644 --- a/test-cases/final-dump/type_enum.exp +++ b/test-cases/final-dump/type_enum.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module type_enum representation : (not a type) public submods : season -> type_enum.season @@ -19,16 +22,15 @@ AFTER EVERYTHING: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'type_enum' - - +source_filename = "!ROOT!/final-dump/type_enum.wybe" +target triple ???? -declare external ccc i8* @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) -------------------------------------------------- Module type_enum.season representation : 2 bit unsigned @@ -95,52 +97,38 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'type_enum.season' +source_filename = "!ROOT!/final-dump/type_enum.wybe" +target triple ???? - - - -declare external ccc i8* @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i1 @"type_enum.season.=<0>"(i2 %"#left##0", i2 %"#right##0") alwaysinline { -entry: - %0 = icmp eq i2 %"#left##0", %"#right##0" - ret i1 %0 +define external fastcc i1 @"type_enum.season.=<0>"(i2 %"#left##0", i2 %"#right##0") { + %"tmp#1##0" = icmp eq i2 %"#left##0", %"#right##0" + ret i1 %"tmp#1##0" } - -define external fastcc i2 @"type_enum.season.autumn<0>"() alwaysinline { -entry: - ret i2 3 +define external fastcc i2 @"type_enum.season.autumn<0>"() { + ret i2 3 } - -define external fastcc i2 @"type_enum.season.spring<0>"() alwaysinline { -entry: - ret i2 1 +define external fastcc i2 @"type_enum.season.spring<0>"() { + ret i2 1 } - -define external fastcc i2 @"type_enum.season.summer<0>"() alwaysinline { -entry: - ret i2 2 +define external fastcc i2 @"type_enum.season.summer<0>"() { + ret i2 2 } - -define external fastcc i2 @"type_enum.season.winter<0>"() alwaysinline { -entry: - ret i2 0 +define external fastcc i2 @"type_enum.season.winter<0>"() { + ret i2 0 } - -define external fastcc i1 @"type_enum.season.~=<0>"(i2 %"#left##0", i2 %"#right##0") alwaysinline { -entry: - %0 = icmp eq i2 %"#left##0", %"#right##0" - %1 = xor i1 %0, 1 - ret i1 %1 +define external fastcc i1 @"type_enum.season.~=<0>"(i2 %"#left##0", i2 %"#right##0") { + %"tmp#0##0" = icmp eq i2 %"#left##0", %"#right##0" + %"tmp#3##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#3##0" } diff --git a/test-cases/final-dump/type_generics.exp b/test-cases/final-dump/type_generics.exp index 8cb7cc38a..3449907e2 100644 --- a/test-cases/final-dump/type_generics.exp +++ b/test-cases/final-dump/type_generics.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module type_generics representation : (not a type) public submods : @@ -161,178 +164,149 @@ foo2(x##0:T0 <{}; {}; {0}>, ?y##0:T0 <{}; {}; {0}>, ?#success##0:wybe.bool)<{}; LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'type_generics' - - - - -declare external ccc void @putchar(i8) - - -declare external ccc void @print_int(i64) - - -declare external fastcc i64 @"wybe.list.length1<0>"(i64, i64) - - -declare external fastcc void @"wybe.bool.print<0>"(i1) - - -declare external ccc void @print_float(double) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"type_generics.<0>"() { -entry: - tail call fastcc void @"type_generics.foo<0>"(i64 1) - tail call fastcc void @"type_generics.foo<0>"(i64 1) - tail call fastcc void @"type_generics.foo<0>"(i64 bitcast (double 1.000000e0 to i64)) - tail call fastcc void @"type_generics.foo<0>"(i64 bitcast (double 1.000000e0 to i64)) - %0 = tail call fastcc {i64, i1} @"type_generics.foo2<0>"(i64 1) - %1 = extractvalue {i64, i1} %0, 0 - %2 = extractvalue {i64, i1} %0, 1 - br i1 %2, label %if.then, label %if.else -if.then: - tail call ccc void @print_int(i64 %1) - tail call ccc void @putchar(i8 10) - musttail call fastcc void @"type_generics.#cont#1<0>"() - ret void -if.else: - musttail call fastcc void @"type_generics.#cont#1<0>"() - ret void +source_filename = "!ROOT!/final-dump/type_generics.wybe" +target triple ???? + + +declare external fastcc void @"wybe.bool.print<0>"(i1) +declare external fastcc i64 @"wybe.list.length1<0>"(i64, i64) +declare external ccc void @print_float(double) +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"type_generics.<0>"() { + tail call fastcc void @"type_generics.foo<0>"(i64 1) + tail call fastcc void @"type_generics.foo<0>"(i64 1) + tail call fastcc void @"type_generics.foo<0>"(i64 bitcast( double 1.0 to i64 )) + tail call fastcc void @"type_generics.foo<0>"(i64 bitcast( double 1.0 to i64 )) + %"tmp#13##0" = tail call fastcc {i64, i1} @"type_generics.foo2<0>"(i64 1) + %"y##0" = extractvalue {i64, i1}%"tmp#13##0", 0 + %"tmp#8##0" = extractvalue {i64, i1}%"tmp#13##0", 1 + br i1 %"tmp#8##0", label %if.then.0, label %if.else.0 +if.then.0: + call ccc void @print_int(i64 %"y##0") + call ccc void @putchar(i8 10) + tail call fastcc void @"type_generics.#cont#1<0>"() + ret void +if.else.0: + tail call fastcc void @"type_generics.#cont#1<0>"() + ret void } - -define external fastcc void @"type_generics.#cont#1<0>"() { -entry: - %0 = tail call fastcc {i64, i1} @"type_generics.foo2<0>"(i64 1) - %1 = extractvalue {i64, i1} %0, 0 - %2 = extractvalue {i64, i1} %0, 1 - br i1 %2, label %if.then, label %if.else -if.then: - tail call ccc void @print_int(i64 %1) - tail call ccc void @putchar(i8 10) - musttail call fastcc void @"type_generics.#cont#2<0>"() - ret void -if.else: - musttail call fastcc void @"type_generics.#cont#2<0>"() - ret void +define external fastcc void @"type_generics.#cont#1<0>"() { + %"tmp#12##0" = tail call fastcc {i64, i1} @"type_generics.foo2<0>"(i64 1) + %"y##0" = extractvalue {i64, i1}%"tmp#12##0", 0 + %"tmp#7##0" = extractvalue {i64, i1}%"tmp#12##0", 1 + br i1 %"tmp#7##0", label %if.then.0, label %if.else.0 +if.then.0: + call ccc void @print_int(i64 %"y##0") + call ccc void @putchar(i8 10) + tail call fastcc void @"type_generics.#cont#2<0>"() + ret void +if.else.0: + tail call fastcc void @"type_generics.#cont#2<0>"() + ret void } - -define external fastcc void @"type_generics.#cont#2<0>"() { -entry: - %0 = tail call fastcc {i64, i1} @"type_generics.foo2<0>"(i64 bitcast (double 1.000000e0 to i64)) - %1 = extractvalue {i64, i1} %0, 0 - %2 = extractvalue {i64, i1} %0, 1 - br i1 %2, label %if.then, label %if.else -if.then: - %3 = bitcast i64 %1 to double - tail call ccc void @print_float(double %3) - tail call ccc void @putchar(i8 10) - musttail call fastcc void @"type_generics.#cont#3<0>"() - ret void -if.else: - musttail call fastcc void @"type_generics.#cont#3<0>"() - ret void +define external fastcc void @"type_generics.#cont#2<0>"() { + %"tmp#11##0" = tail call fastcc {i64, i1} @"type_generics.foo2<0>"(i64 bitcast( double 1.0 to i64 )) + %"tmp#12##0" = extractvalue {i64, i1}%"tmp#11##0", 0 + %"fx##0" = bitcast i64 %"tmp#12##0" to double + %"tmp#6##0" = extractvalue {i64, i1}%"tmp#11##0", 1 + br i1 %"tmp#6##0", label %if.then.0, label %if.else.0 +if.then.0: + call ccc void @print_float(double %"fx##0") + call ccc void @putchar(i8 10) + tail call fastcc void @"type_generics.#cont#3<0>"() + ret void +if.else.0: + tail call fastcc void @"type_generics.#cont#3<0>"() + ret void } - -define external fastcc void @"type_generics.#cont#3<0>"() { -entry: - %0 = tail call fastcc {i64, i1} @"type_generics.foo2<0>"(i64 bitcast (double 1.000000e0 to i64)) - %1 = extractvalue {i64, i1} %0, 0 - %2 = extractvalue {i64, i1} %0, 1 - br i1 %2, label %if.then, label %if.else -if.then: - %3 = bitcast i64 %1 to double - tail call ccc void @print_float(double %3) - tail call ccc void @putchar(i8 10) - musttail call fastcc void @"type_generics.#cont#4<0>"() - ret void -if.else: - musttail call fastcc void @"type_generics.#cont#4<0>"() - ret void +define external fastcc void @"type_generics.#cont#3<0>"() { + %"tmp#10##0" = tail call fastcc {i64, i1} @"type_generics.foo2<0>"(i64 bitcast( double 1.0 to i64 )) + %"tmp#11##0" = extractvalue {i64, i1}%"tmp#10##0", 0 + %"x##1" = bitcast i64 %"tmp#11##0" to double + %"tmp#5##0" = extractvalue {i64, i1}%"tmp#10##0", 1 + br i1 %"tmp#5##0", label %if.then.0, label %if.else.0 +if.then.0: + call ccc void @print_float(double %"x##1") + call ccc void @putchar(i8 10) + tail call fastcc void @"type_generics.#cont#4<0>"() + ret void +if.else.0: + tail call fastcc void @"type_generics.#cont#4<0>"() + ret void } - -define external fastcc void @"type_generics.#cont#4<0>"() { -entry: - %0 = tail call fastcc {i64, i1} @"type_generics.foo2<0>"(i64 97) - %1 = extractvalue {i64, i1} %0, 0 - %2 = extractvalue {i64, i1} %0, 1 - br i1 %2, label %if.then, label %if.else -if.then: - %3 = trunc i64 %1 to i8 - tail call ccc void @putchar(i8 %3) - tail call ccc void @putchar(i8 10) - musttail call fastcc void @"type_generics.#cont#5<0>"() - ret void -if.else: - musttail call fastcc void @"type_generics.#cont#5<0>"() - ret void +define external fastcc void @"type_generics.#cont#4<0>"() { + %"tmp#9##0" = tail call fastcc {i64, i1} @"type_generics.foo2<0>"(i64 97) + %"tmp#10##0" = extractvalue {i64, i1}%"tmp#9##0", 0 + %"z##0" = trunc i64 %"tmp#10##0" to i8 + %"tmp#4##0" = extractvalue {i64, i1}%"tmp#9##0", 1 + br i1 %"tmp#4##0", label %if.then.0, label %if.else.0 +if.then.0: + call ccc void @putchar(i8 %"z##0") + call ccc void @putchar(i8 10) + tail call fastcc void @"type_generics.#cont#5<0>"() + ret void +if.else.0: + tail call fastcc void @"type_generics.#cont#5<0>"() + ret void } - -define external fastcc void @"type_generics.#cont#5<0>"() { -entry: - %0 = tail call fastcc {i64, i1} @"type_generics.foo2<0>"(i64 0) - %1 = extractvalue {i64, i1} %0, 0 - %2 = extractvalue {i64, i1} %0, 1 - br i1 %2, label %if.then, label %if.else -if.then: - %3 = trunc i64 %1 to i1 - tail call fastcc void @"wybe.bool.print<0>"(i1 %3) - tail call ccc void @putchar(i8 10) - ret void -if.else: - ret void +define external fastcc void @"type_generics.#cont#5<0>"() { + %"tmp#7##0" = tail call fastcc {i64, i1} @"type_generics.foo2<0>"(i64 0) + %"tmp#8##0" = extractvalue {i64, i1}%"tmp#7##0", 0 + %"b##0" = trunc i64 %"tmp#8##0" to i1 + %"tmp#3##0" = extractvalue {i64, i1}%"tmp#7##0", 1 + br i1 %"tmp#3##0", label %if.then.0, label %if.else.0 +if.then.0: + tail call fastcc void @"wybe.bool.print<0>"(i1 %"b##0") + call ccc void @putchar(i8 10) + ret void +if.else.0: + ret void } - -define external fastcc void @"type_generics.foo<0>"(i64 %"x##0") { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"x##0", i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 0, i64* %5 - %6 = tail call fastcc i64 @"wybe.list.length1<0>"(i64 %2, i64 0) - tail call ccc void @print_int(i64 %6) - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"type_generics.foo<0>"(i64 %"x##0") { + %"tmp#12##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#5##0" = ptrtoint ptr %"tmp#12##0" to i64 + %"tmp#13##0" = inttoptr i64 %"tmp#5##0" to ptr + store i64 %"x##0", ptr %"tmp#13##0" + %"tmp#14##0" = add i64 %"tmp#5##0", 8 + %"tmp#15##0" = inttoptr i64 %"tmp#14##0" to ptr + store i64 0, ptr %"tmp#15##0" + %"tmp#2##0" = tail call fastcc i64 @"wybe.list.length1<0>"(i64 %"tmp#5##0", i64 0) + call ccc void @print_int(i64 %"tmp#2##0") + call ccc void @putchar(i8 10) + ret void } - -define external fastcc {i64, i1} @"type_generics.foo2<0>"(i64 %"x##0") { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"x##0", i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 0, i64* %5 - %6 = icmp ne i64 %2, 0 - br i1 %6, label %if.then, label %if.else -if.then: - %7 = inttoptr i64 %2 to i64* - %8 = load i64, i64* %7 - %9 = insertvalue {i64, i1} undef, i64 %8, 0 - %10 = insertvalue {i64, i1} %9, i1 1, 1 - ret {i64, i1} %10 -if.else: - %11 = insertvalue {i64, i1} undef, i64 undef, 0 - %12 = insertvalue {i64, i1} %11, i1 0, 1 - ret {i64, i1} %12 +define external fastcc {i64, i1} @"type_generics.foo2<0>"(i64 %"x##0") { + %"tmp#10##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#6##0" = ptrtoint ptr %"tmp#10##0" to i64 + %"tmp#11##0" = inttoptr i64 %"tmp#6##0" to ptr + store i64 %"x##0", ptr %"tmp#11##0" + %"tmp#12##0" = add i64 %"tmp#6##0", 8 + %"tmp#13##0" = inttoptr i64 %"tmp#12##0" to ptr + store i64 0, ptr %"tmp#13##0" + %"tmp#9##0" = icmp ne i64 %"tmp#6##0", 0 + br i1 %"tmp#9##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#14##0" = inttoptr i64 %"tmp#6##0" to ptr + %"tmp#15##0" = load i64, ptr %"tmp#14##0" + %"tmp#16##0" = insertvalue {i64, i1} undef, i64 %"tmp#15##0", 0 + %"tmp#17##0" = insertvalue {i64, i1} %"tmp#16##0", i1 1, 1 + ret {i64, i1} %"tmp#17##0" +if.else.0: + %"tmp#18##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#19##0" = insertvalue {i64, i1} %"tmp#18##0", i1 0, 1 + ret {i64, i1} %"tmp#19##0" } diff --git a/test-cases/final-dump/type_int.exp b/test-cases/final-dump/type_int.exp index dd62f5192..561c89766 100644 --- a/test-cases/final-dump/type_int.exp +++ b/test-cases/final-dump/type_int.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module type_int representation : (not a type) public submods : myint -> type_int.myint @@ -27,16 +30,15 @@ AFTER EVERYTHING: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'type_int' +source_filename = "!ROOT!/final-dump/type_int.wybe" +target triple ???? - +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) -------------------------------------------------- Module type_int.myint representation : 64 bit signed @@ -166,111 +168,81 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'type_int.myint' - - +source_filename = "!ROOT!/final-dump/type_int.wybe" +target triple ???? -declare external ccc i8* @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i64 @"type_int.myint.*<0>"(i64 %"x##0", i64 %"y##0") alwaysinline { -entry: - %0 = mul i64 %"x##0", %"y##0" - ret i64 %0 +define external fastcc i64 @"type_int.myint.*<0>"(i64 %"x##0", i64 %"y##0") { + %"tmp#1##0" = mul i64 %"x##0", %"y##0" + ret i64 %"tmp#1##0" } - -define external fastcc i64 @"type_int.myint.+<0>"(i64 %"x##0", i64 %"y##0") alwaysinline { -entry: - %0 = add i64 %"x##0", %"y##0" - ret i64 %0 +define external fastcc i64 @"type_int.myint.+<0>"(i64 %"x##0", i64 %"y##0") { + %"tmp#1##0" = add i64 %"x##0", %"y##0" + ret i64 %"tmp#1##0" } - -define external fastcc i64 @"type_int.myint.+<1>"(i64 %"y##0", i64 %"z##0") alwaysinline { -entry: - %0 = sub i64 %"z##0", %"y##0" - ret i64 %0 +define external fastcc i64 @"type_int.myint.+<1>"(i64 %"y##0", i64 %"z##0") { + %"tmp#1##0" = sub i64 %"z##0", %"y##0" + ret i64 %"tmp#1##0" } - -define external fastcc i64 @"type_int.myint.+<2>"(i64 %"x##0", i64 %"z##0") alwaysinline { -entry: - %0 = sub i64 %"z##0", %"x##0" - ret i64 %0 +define external fastcc i64 @"type_int.myint.+<2>"(i64 %"x##0", i64 %"z##0") { + %"tmp#1##0" = sub i64 %"z##0", %"x##0" + ret i64 %"tmp#1##0" } - -define external fastcc i64 @"type_int.myint.-<0>"(i64 %"x##0", i64 %"y##0") alwaysinline { -entry: - %0 = sub i64 %"x##0", %"y##0" - ret i64 %0 +define external fastcc i64 @"type_int.myint.-<0>"(i64 %"x##0", i64 %"y##0") { + %"tmp#1##0" = sub i64 %"x##0", %"y##0" + ret i64 %"tmp#1##0" } - -define external fastcc i64 @"type_int.myint.-<1>"(i64 %"y##0", i64 %"z##0") alwaysinline { -entry: - %0 = add i64 %"y##0", %"z##0" - ret i64 %0 +define external fastcc i64 @"type_int.myint.-<1>"(i64 %"y##0", i64 %"z##0") { + %"tmp#1##0" = add i64 %"y##0", %"z##0" + ret i64 %"tmp#1##0" } - -define external fastcc i64 @"type_int.myint.-<2>"(i64 %"x##0", i64 %"z##0") alwaysinline { -entry: - %0 = sub i64 %"z##0", %"x##0" - ret i64 %0 +define external fastcc i64 @"type_int.myint.-<2>"(i64 %"x##0", i64 %"z##0") { + %"tmp#1##0" = sub i64 %"z##0", %"x##0" + ret i64 %"tmp#1##0" } - -define external fastcc i64 @"type_int.myint./<0>"(i64 %"x##0", i64 %"y##0") alwaysinline { -entry: - %0 = sdiv exact i64 %"x##0", %"y##0" - ret i64 %0 +define external fastcc i64 @"type_int.myint./<0>"(i64 %"x##0", i64 %"y##0") { + %"tmp#1##0" = sdiv i64 %"x##0", %"y##0" + ret i64 %"tmp#1##0" } - -define external fastcc i1 @"type_int.myint.<<0>"(i64 %"x##0", i64 %"y##0") alwaysinline { -entry: - %0 = icmp slt i64 %"x##0", %"y##0" - ret i1 %0 +define external fastcc i1 @"type_int.myint.<<0>"(i64 %"x##0", i64 %"y##0") { + %"tmp#1##0" = icmp slt i64 %"x##0", %"y##0" + ret i1 %"tmp#1##0" } - -define external fastcc i1 @"type_int.myint.<=<0>"(i64 %"x##0", i64 %"y##0") alwaysinline { -entry: - %0 = icmp sle i64 %"x##0", %"y##0" - ret i1 %0 +define external fastcc i1 @"type_int.myint.<=<0>"(i64 %"x##0", i64 %"y##0") { + %"tmp#1##0" = icmp sle i64 %"x##0", %"y##0" + ret i1 %"tmp#1##0" } - -define external fastcc i1 @"type_int.myint.=<0>"(i64 %"x##0", i64 %"y##0") alwaysinline { -entry: - %0 = icmp eq i64 %"x##0", %"y##0" - ret i1 %0 +define external fastcc i1 @"type_int.myint.=<0>"(i64 %"x##0", i64 %"y##0") { + %"tmp#1##0" = icmp eq i64 %"x##0", %"y##0" + ret i1 %"tmp#1##0" } - -define external fastcc i1 @"type_int.myint.><0>"(i64 %"x##0", i64 %"y##0") alwaysinline { -entry: - %0 = icmp sgt i64 %"x##0", %"y##0" - ret i1 %0 +define external fastcc i1 @"type_int.myint.><0>"(i64 %"x##0", i64 %"y##0") { + %"tmp#1##0" = icmp sgt i64 %"x##0", %"y##0" + ret i1 %"tmp#1##0" } - -define external fastcc i1 @"type_int.myint.>=<0>"(i64 %"x##0", i64 %"y##0") alwaysinline { -entry: - %0 = icmp sge i64 %"x##0", %"y##0" - ret i1 %0 +define external fastcc i1 @"type_int.myint.>=<0>"(i64 %"x##0", i64 %"y##0") { + %"tmp#1##0" = icmp sge i64 %"x##0", %"y##0" + ret i1 %"tmp#1##0" } - -define external fastcc i1 @"type_int.myint.~=<0>"(i64 %"x##0", i64 %"y##0") alwaysinline { -entry: - %0 = icmp ne i64 %"x##0", %"y##0" - ret i1 %0 +define external fastcc i1 @"type_int.myint.~=<0>"(i64 %"x##0", i64 %"y##0") { + %"tmp#1##0" = icmp ne i64 %"x##0", %"y##0" + ret i1 %"tmp#1##0" } diff --git a/test-cases/final-dump/type_list.exp b/test-cases/final-dump/type_list.exp index 6b02014c8..adce2c22f 100644 --- a/test-cases/final-dump/type_list.exp +++ b/test-cases/final-dump/type_list.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module type_list representation : (not a type) public submods : intlist -> type_list.intlist @@ -51,7 +54,7 @@ module top-level code > public {semipure} (0 calls) proc ,, > public (2 calls) -0: type_list.,,<0>[410bae77d3] +0: type_list.,,<0> ,,(x##0:type_list.intlist, y##0:type_list.intlist, outByReference #result##0:type_list.intlist)<{}; {}; {}>: AliasPairs: [(#result##0,y##0)] InterestingCallProperties: [InterestingUnaliased 0] @@ -100,134 +103,118 @@ length(x##0:type_list.intlist, ?#result##0:wybe.int)<{}; {}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'type_list' - - - - -declare external ccc void @print_int(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"type_list.<0>"() { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 3, i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 0, i64* %5 - %6 = trunc i64 16 to i32 - %7 = tail call ccc i8* @wybe_malloc(i32 %6) - %8 = ptrtoint i8* %7 to i64 - %9 = inttoptr i64 %8 to i64* - store i64 2, i64* %9 - %10 = add i64 %8, 8 - %11 = inttoptr i64 %10 to i64* - store i64 %2, i64* %11 - %12 = trunc i64 16 to i32 - %13 = tail call ccc i8* @wybe_malloc(i32 %12) - %14 = ptrtoint i8* %13 to i64 - %15 = inttoptr i64 %14 to i64* - store i64 1, i64* %15 - %16 = add i64 %14, 8 - %17 = inttoptr i64 %16 to i64* - store i64 %8, i64* %17 - %18 = trunc i64 16 to i32 - %19 = tail call ccc i8* @wybe_malloc(i32 %18) - %20 = ptrtoint i8* %19 to i64 - %21 = inttoptr i64 %20 to i64* - store i64 200, i64* %21 - %22 = add i64 %20, 8 - %23 = inttoptr i64 %22 to i64* - store i64 0, i64* %23 - %24 = trunc i64 16 to i32 - %25 = tail call ccc i8* @wybe_malloc(i32 %24) - %26 = ptrtoint i8* %25 to i64 - %27 = inttoptr i64 %26 to i64* - store i64 100, i64* %27 - %28 = add i64 %26, 8 - %29 = inttoptr i64 %28 to i64* - store i64 %20, i64* %29 - %30 = alloca i64 - call fastcc void @"type_list.,,<0>[410bae77d3]"(i64 %14, i64 %26, i64* %30) - %31 = load i64, i64* %30 - %32 = tail call fastcc i64 @"type_list.length<0>"(i64 %31) - tail call ccc void @print_int(i64 %32) - ret void +source_filename = "!ROOT!/final-dump/type_list.wybe" +target triple ???? + + +declare external ccc void @print_int(i64) +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"type_list.<0>"() { + %"tmp#37##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#11##0" = ptrtoint ptr %"tmp#37##0" to i64 + %"tmp#38##0" = inttoptr i64 %"tmp#11##0" to ptr + store i64 3, ptr %"tmp#38##0" + %"tmp#39##0" = add i64 %"tmp#11##0", 8 + %"tmp#40##0" = inttoptr i64 %"tmp#39##0" to ptr + store i64 0, ptr %"tmp#40##0" + %"tmp#41##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#16##0" = ptrtoint ptr %"tmp#41##0" to i64 + %"tmp#42##0" = inttoptr i64 %"tmp#16##0" to ptr + store i64 2, ptr %"tmp#42##0" + %"tmp#43##0" = add i64 %"tmp#16##0", 8 + %"tmp#44##0" = inttoptr i64 %"tmp#43##0" to ptr + store i64 %"tmp#11##0", ptr %"tmp#44##0" + %"tmp#45##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#21##0" = ptrtoint ptr %"tmp#45##0" to i64 + %"tmp#46##0" = inttoptr i64 %"tmp#21##0" to ptr + store i64 1, ptr %"tmp#46##0" + %"tmp#47##0" = add i64 %"tmp#21##0", 8 + %"tmp#48##0" = inttoptr i64 %"tmp#47##0" to ptr + store i64 %"tmp#16##0", ptr %"tmp#48##0" + %"tmp#49##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#26##0" = ptrtoint ptr %"tmp#49##0" to i64 + %"tmp#50##0" = inttoptr i64 %"tmp#26##0" to ptr + store i64 200, ptr %"tmp#50##0" + %"tmp#51##0" = add i64 %"tmp#26##0", 8 + %"tmp#52##0" = inttoptr i64 %"tmp#51##0" to ptr + store i64 0, ptr %"tmp#52##0" + %"tmp#53##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#31##0" = ptrtoint ptr %"tmp#53##0" to i64 + %"tmp#54##0" = inttoptr i64 %"tmp#31##0" to ptr + store i64 100, ptr %"tmp#54##0" + %"tmp#55##0" = add i64 %"tmp#31##0", 8 + %"tmp#56##0" = inttoptr i64 %"tmp#55##0" to ptr + store i64 %"tmp#26##0", ptr %"tmp#56##0" + %"tmp#57##0" = alloca i8, i64 8, align 8 + call fastcc void @"type_list.,,<0>[410bae77d3]"(i64 %"tmp#21##0", i64 %"tmp#31##0", ptr %"tmp#57##0") + %"tmp#8##0" = load i64, ptr %"tmp#57##0" + %"tmp#7##0" = call fastcc i64 @"type_list.length<0>"(i64 %"tmp#8##0") + call ccc void @print_int(i64 %"tmp#7##0") + ret void } - -define external fastcc void @"type_list.,,<0>"(i64 %"x##0", i64 %"y##0", i64* %"#result##0") { -entry: - %0 = icmp ne i64 %"x##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"x##0" to i64* - %2 = load i64, i64* %1 - %3 = add i64 %"x##0", 8 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = trunc i64 16 to i32 - %7 = tail call ccc i8* @wybe_malloc(i32 %6) - %8 = ptrtoint i8* %7 to i64 - %9 = inttoptr i64 %8 to i64* - store i64 %2, i64* %9 - %10 = add i64 %8, 8 - %11 = inttoptr i64 %10 to i64* - store i64 %8, i64* %"#result##0" - musttail call fastcc void @"type_list.,,<0>"(i64 %5, i64 %"y##0", i64* %11) - ret void -if.else: - store i64 %"y##0", i64* %"#result##0" - ret void +define external fastcc void @"type_list.,,<0>"(i64 %"x##0", i64 %"y##0", ptr %"tmp#11##0") { + %"tmp#5##0" = icmp ne i64 %"x##0", 0 + br i1 %"tmp#5##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#12##0" = inttoptr i64 %"x##0" to ptr + %"h##0" = load i64, ptr %"tmp#12##0" + %"tmp#13##0" = add i64 %"x##0", 8 + %"tmp#14##0" = inttoptr i64 %"tmp#13##0" to ptr + %"t##0" = load i64, ptr %"tmp#14##0" + %"tmp#15##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#8##0" = ptrtoint ptr %"tmp#15##0" to i64 + %"tmp#16##0" = inttoptr i64 %"tmp#8##0" to ptr + store i64 %"h##0", ptr %"tmp#16##0" + store i64 %"tmp#8##0", ptr %"tmp#11##0" + %"tmp#17##0" = add i64 %"tmp#8##0", 8 + %"tmp#18##0" = inttoptr i64 %"tmp#17##0" to ptr + musttail call fastcc void @"type_list.,,<0>"(i64 %"t##0", i64 %"y##0", ptr %"tmp#18##0") + ret void +if.else.0: + store i64 %"y##0", ptr %"tmp#11##0" + ret void } - -define external fastcc void @"type_list.,,<0>[410bae77d3]"(i64 %"x##0", i64 %"y##0", i64* %"#result##0") { -entry: - %0 = icmp ne i64 %"x##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = add i64 %"x##0", 8 - %2 = inttoptr i64 %1 to i64* - %3 = load i64, i64* %2 - %4 = add i64 %"x##0", 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"x##0", i64* %"#result##0" - musttail call fastcc void @"type_list.,,<0>[410bae77d3]"(i64 %3, i64 %"y##0", i64* %5) - ret void -if.else: - store i64 %"y##0", i64* %"#result##0" - ret void +define external fastcc void @"type_list.,,<0>[410bae77d3]"(i64 %"x##0", i64 %"y##0", ptr %"tmp#11##0") { + %"tmp#5##0" = icmp ne i64 %"x##0", 0 + br i1 %"tmp#5##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#12##0" = add i64 %"x##0", 8 + %"tmp#13##0" = inttoptr i64 %"tmp#12##0" to ptr + %"t##0" = load i64, ptr %"tmp#13##0" + store i64 %"x##0", ptr %"tmp#11##0" + %"tmp#14##0" = add i64 %"x##0", 8 + %"tmp#15##0" = inttoptr i64 %"tmp#14##0" to ptr + musttail call fastcc void @"type_list.,,<0>[410bae77d3]"(i64 %"t##0", i64 %"y##0", ptr %"tmp#15##0") + ret void +if.else.0: + store i64 %"y##0", ptr %"tmp#11##0" + ret void } - -define external fastcc i64 @"type_list.length<0>"(i64 %"x##0") { -entry: - %0 = icmp ne i64 %"x##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = add i64 %"x##0", 8 - %2 = inttoptr i64 %1 to i64* - %3 = load i64, i64* %2 - %4 = tail call fastcc i64 @"type_list.length<0>"(i64 %3) - %5 = add i64 %4, 1 - ret i64 %5 -if.else: - ret i64 0 +define external fastcc i64 @"type_list.length<0>"(i64 %"x##0") { + %"tmp#5##0" = icmp ne i64 %"x##0", 0 + br i1 %"tmp#5##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#8##0" = add i64 %"x##0", 8 + %"tmp#9##0" = inttoptr i64 %"tmp#8##0" to ptr + %"t##0" = load i64, ptr %"tmp#9##0" + %"tmp#2##0" = tail call fastcc i64 @"type_list.length<0>"(i64 %"t##0") + %"tmp#10##0" = add i64 %"tmp#2##0", 1 + ret i64 %"tmp#10##0" +if.else.0: + ret i64 0 } + -------------------------------------------------- Module type_list.intlist - representation : address + representation : pointer public submods : public resources: public procs : type_list.intlist.=<0> @@ -386,180 +373,154 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'type_list.intlist' - - - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i1 @"type_list.intlist.=<0>"(i64 %"#left##0", i64 %"#right##0") { -entry: - %0 = icmp ne i64 %"#left##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"#left##0" to i64* - %2 = load i64, i64* %1 - %3 = add i64 %"#left##0", 8 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = icmp ne i64 %"#right##0", 0 - br i1 %6, label %if.then1, label %if.else1 -if.else: - %14 = icmp eq i64 %"#right##0", 0 - ret i1 %14 -if.then1: - %7 = inttoptr i64 %"#right##0" to i64* - %8 = load i64, i64* %7 - %9 = add i64 %"#right##0", 8 - %10 = inttoptr i64 %9 to i64* - %11 = load i64, i64* %10 - %12 = icmp eq i64 %2, %8 - br i1 %12, label %if.then2, label %if.else2 -if.else1: - ret i1 0 -if.then2: - %13 = musttail call fastcc i1 @"type_list.intlist.=<0>"(i64 %5, i64 %11) - ret i1 %13 -if.else2: - ret i1 0 +source_filename = "!ROOT!/final-dump/type_list.wybe" +target triple ???? + + +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc i1 @"type_list.intlist.=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#0##0" = icmp ne i64 %"#left##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#12##0" = inttoptr i64 %"#left##0" to ptr + %"#left#head##0" = load i64, ptr %"tmp#12##0" + %"tmp#13##0" = add i64 %"#left##0", 8 + %"tmp#14##0" = inttoptr i64 %"tmp#13##0" to ptr + %"#left#tail##0" = load i64, ptr %"tmp#14##0" + %"tmp#9##0" = icmp ne i64 %"#right##0", 0 + br i1 %"tmp#9##0", label %if.then.1, label %if.else.1 +if.then.1: + %"tmp#15##0" = inttoptr i64 %"#right##0" to ptr + %"#right#head##0" = load i64, ptr %"tmp#15##0" + %"tmp#16##0" = add i64 %"#right##0", 8 + %"tmp#17##0" = inttoptr i64 %"tmp#16##0" to ptr + %"#right#tail##0" = load i64, ptr %"tmp#17##0" + %"tmp#4##0" = icmp eq i64 %"#left#head##0", %"#right#head##0" + br i1 %"tmp#4##0", label %if.then.2, label %if.else.2 +if.then.2: + %"tmp#18##0" = tail call fastcc i1 @"type_list.intlist.=<0>"(i64 %"#left#tail##0", i64 %"#right#tail##0") + ret i1 %"tmp#18##0" +if.else.2: + ret i1 0 +if.else.1: + ret i1 0 +if.else.0: + %"tmp#19##0" = icmp eq i64 %"#right##0", 0 + ret i1 %"tmp#19##0" } - -define external fastcc i64 @"type_list.intlist.cons<0>"(i64 %"head##0", i64 %"tail##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"head##0", i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"tail##0", i64* %5 - ret i64 %2 +define external fastcc i64 @"type_list.intlist.cons<0>"(i64 %"head##0", i64 %"tail##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 16) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"head##0", ptr %"tmp#1##0" + %"tmp#2##0" = add i64 %"#rec##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"tail##0", ptr %"tmp#3##0" + ret i64 %"#rec##0" } - -define external fastcc {i64, i64, i1} @"type_list.intlist.cons<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#result##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"#result##0" to i64* - %2 = load i64, i64* %1 - %3 = add i64 %"#result##0", 8 - %4 = inttoptr i64 %3 to i64* - %5 = load i64, i64* %4 - %6 = insertvalue {i64, i64, i1} undef, i64 %2, 0 - %7 = insertvalue {i64, i64, i1} %6, i64 %5, 1 - %8 = insertvalue {i64, i64, i1} %7, i1 1, 2 - ret {i64, i64, i1} %8 -if.else: - %9 = insertvalue {i64, i64, i1} undef, i64 undef, 0 - %10 = insertvalue {i64, i64, i1} %9, i64 undef, 1 - %11 = insertvalue {i64, i64, i1} %10, i1 0, 2 - ret {i64, i64, i1} %11 +define external fastcc {i64, i64, i1} @"type_list.intlist.cons<1>"(i64 %"#result##0") { + %"tmp#0##0" = icmp ne i64 %"#result##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = inttoptr i64 %"#result##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + %"tmp#3##0" = add i64 %"#result##0", 8 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + %"tmp#5##0" = load i64, ptr %"tmp#4##0" + %"tmp#6##0" = insertvalue {i64, i64, i1} undef, i64 %"tmp#2##0", 0 + %"tmp#7##0" = insertvalue {i64, i64, i1} %"tmp#6##0", i64 %"tmp#5##0", 1 + %"tmp#8##0" = insertvalue {i64, i64, i1} %"tmp#7##0", i1 1, 2 + ret {i64, i64, i1} %"tmp#8##0" +if.else.0: + %"tmp#9##0" = insertvalue {i64, i64, i1} undef, i64 undef, 0 + %"tmp#10##0" = insertvalue {i64, i64, i1} %"tmp#9##0", i64 undef, 1 + %"tmp#11##0" = insertvalue {i64, i64, i1} %"tmp#10##0", i1 0, 2 + ret {i64, i64, i1} %"tmp#11##0" } - -define external fastcc {i64, i1} @"type_list.intlist.head<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = inttoptr i64 %"#rec##0" to i64* - %2 = load i64, i64* %1 - %3 = insertvalue {i64, i1} undef, i64 %2, 0 - %4 = insertvalue {i64, i1} %3, i1 1, 1 - ret {i64, i1} %4 -if.else: - %5 = insertvalue {i64, i1} undef, i64 undef, 0 - %6 = insertvalue {i64, i1} %5, i1 0, 1 - ret {i64, i1} %6 +define external fastcc {i64, i1} @"type_list.intlist.head<0>"(i64 %"#rec##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + %"tmp#3##0" = insertvalue {i64, i1} undef, i64 %"tmp#2##0", 0 + %"tmp#4##0" = insertvalue {i64, i1} %"tmp#3##0", i1 1, 1 + ret {i64, i1} %"tmp#4##0" +if.else.0: + %"tmp#5##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#6##0" = insertvalue {i64, i1} %"tmp#5##0", i1 0, 1 + ret {i64, i1} %"tmp#6##0" } - -define external fastcc {i64, i1} @"type_list.intlist.head<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = trunc i64 16 to i32 - %2 = tail call ccc i8* @wybe_malloc(i32 %1) - %3 = ptrtoint i8* %2 to i64 - %4 = inttoptr i64 %3 to i8* - %5 = inttoptr i64 %"#rec##0" to i8* - %6 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %4, i8* %5, i32 %6, i1 0) - %7 = inttoptr i64 %3 to i64* - store i64 %"#field##0", i64* %7 - %8 = insertvalue {i64, i1} undef, i64 %3, 0 - %9 = insertvalue {i64, i1} %8, i1 1, 1 - ret {i64, i1} %9 -if.else: - %10 = insertvalue {i64, i1} undef, i64 0, 0 - %11 = insertvalue {i64, i1} %10, i1 0, 1 - ret {i64, i1} %11 +define external fastcc {i64, i1} @"type_list.intlist.head<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#2##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#2##0", ptr %"tmp#1##0", i64 16, i1 0) + %"tmp#3##0" = ptrtoint ptr %"tmp#2##0" to i64 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 %"#field##0", ptr %"tmp#4##0" + %"tmp#5##0" = insertvalue {i64, i1} undef, i64 %"tmp#3##0", 0 + %"tmp#6##0" = insertvalue {i64, i1} %"tmp#5##0", i1 1, 1 + ret {i64, i1} %"tmp#6##0" +if.else.0: + %"tmp#7##0" = insertvalue {i64, i1} undef, i64 0, 0 + %"tmp#8##0" = insertvalue {i64, i1} %"tmp#7##0", i1 0, 1 + ret {i64, i1} %"tmp#8##0" } - -define external fastcc i64 @"type_list.intlist.nil<0>"() alwaysinline { -entry: - ret i64 0 +define external fastcc i64 @"type_list.intlist.nil<0>"() { + ret i64 0 } - -define external fastcc {i64, i1} @"type_list.intlist.tail<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = add i64 %"#rec##0", 8 - %2 = inttoptr i64 %1 to i64* - %3 = load i64, i64* %2 - %4 = insertvalue {i64, i1} undef, i64 %3, 0 - %5 = insertvalue {i64, i1} %4, i1 1, 1 - ret {i64, i1} %5 -if.else: - %6 = insertvalue {i64, i1} undef, i64 undef, 0 - %7 = insertvalue {i64, i1} %6, i1 0, 1 - ret {i64, i1} %7 +define external fastcc {i64, i1} @"type_list.intlist.tail<0>"(i64 %"#rec##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = add i64 %"#rec##0", 8 + %"tmp#2##0" = inttoptr i64 %"tmp#1##0" to ptr + %"tmp#3##0" = load i64, ptr %"tmp#2##0" + %"tmp#4##0" = insertvalue {i64, i1} undef, i64 %"tmp#3##0", 0 + %"tmp#5##0" = insertvalue {i64, i1} %"tmp#4##0", i1 1, 1 + ret {i64, i1} %"tmp#5##0" +if.else.0: + %"tmp#6##0" = insertvalue {i64, i1} undef, i64 undef, 0 + %"tmp#7##0" = insertvalue {i64, i1} %"tmp#6##0", i1 0, 1 + ret {i64, i1} %"tmp#7##0" } - -define external fastcc {i64, i1} @"type_list.intlist.tail<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = icmp ne i64 %"#rec##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = trunc i64 16 to i32 - %2 = tail call ccc i8* @wybe_malloc(i32 %1) - %3 = ptrtoint i8* %2 to i64 - %4 = inttoptr i64 %3 to i8* - %5 = inttoptr i64 %"#rec##0" to i8* - %6 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %4, i8* %5, i32 %6, i1 0) - %7 = add i64 %3, 8 - %8 = inttoptr i64 %7 to i64* - store i64 %"#field##0", i64* %8 - %9 = insertvalue {i64, i1} undef, i64 %3, 0 - %10 = insertvalue {i64, i1} %9, i1 1, 1 - ret {i64, i1} %10 -if.else: - %11 = insertvalue {i64, i1} undef, i64 0, 0 - %12 = insertvalue {i64, i1} %11, i1 0, 1 - ret {i64, i1} %12 +define external fastcc {i64, i1} @"type_list.intlist.tail<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = icmp ne i64 %"#rec##0", 0 + br i1 %"tmp#0##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#2##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#2##0", ptr %"tmp#1##0", i64 16, i1 0) + %"tmp#3##0" = ptrtoint ptr %"tmp#2##0" to i64 + %"tmp#4##0" = add i64 %"tmp#3##0", 8 + %"tmp#5##0" = inttoptr i64 %"tmp#4##0" to ptr + store i64 %"#field##0", ptr %"tmp#5##0" + %"tmp#6##0" = insertvalue {i64, i1} undef, i64 %"tmp#3##0", 0 + %"tmp#7##0" = insertvalue {i64, i1} %"tmp#6##0", i1 1, 1 + ret {i64, i1} %"tmp#7##0" +if.else.0: + %"tmp#8##0" = insertvalue {i64, i1} undef, i64 0, 0 + %"tmp#9##0" = insertvalue {i64, i1} %"tmp#8##0", i1 0, 1 + ret {i64, i1} %"tmp#9##0" } - -define external fastcc i1 @"type_list.intlist.~=<0>"(i64 %"#left##0", i64 %"#right##0") alwaysinline { -entry: - %0 = tail call fastcc i1 @"type_list.intlist.=<0>"(i64 %"#left##0", i64 %"#right##0") - %1 = xor i1 %0, 1 - ret i1 %1 +define external fastcc i1 @"type_list.intlist.~=<0>"(i64 %"#left##0", i64 %"#right##0") { + %"tmp#0##0" = tail call fastcc i1 @"type_list.intlist.=<0>"(i64 %"#left##0", i64 %"#right##0") + %"tmp#1##0" = xor i1 %"tmp#0##0", 1 + ret i1 %"tmp#1##0" } diff --git a/test-cases/final-dump/unbranch_bug.exp b/test-cases/final-dump/unbranch_bug.exp index ccc3ec7f5..03b2a0560 100644 --- a/test-cases/final-dump/unbranch_bug.exp +++ b/test-cases/final-dump/unbranch_bug.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module unbranch_bug representation : (not a type) public submods : @@ -47,47 +50,37 @@ proc #cont#3 > {semipure} (2 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'unbranch_bug' - - - - -declare external ccc i8* @wybe_malloc(i32) +source_filename = "!ROOT!/final-dump/unbranch_bug.wybe" +target triple ???? -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) - -define external fastcc void @"unbranch_bug.<0>"() alwaysinline { -entry: - tail call fastcc void @"unbranch_bug.#cont#3<0>"(i64 0) - ret void +define external fastcc void @"unbranch_bug.<0>"() { + tail call fastcc void @"unbranch_bug.#cont#3<0>"(i64 0) + ret void } - -define external fastcc void @"unbranch_bug.#cont#1<0>"() alwaysinline { -entry: - ret void +define external fastcc void @"unbranch_bug.#cont#1<0>"() { + ret void } - -define external fastcc void @"unbranch_bug.#cont#2<0>"() alwaysinline { -entry: - ret void +define external fastcc void @"unbranch_bug.#cont#2<0>"() { + ret void } - -define external fastcc void @"unbranch_bug.#cont#3<0>"(i64 %"tmp#0##0") { -entry: - %0 = icmp ne i64 %"tmp#0##0", 0 - br i1 %0, label %if.then, label %if.else -if.then: - %1 = add i64 %"tmp#0##0", 8 - %2 = inttoptr i64 %1 to i64* - %3 = load i64, i64* %2 - musttail call fastcc void @"unbranch_bug.#cont#3<0>"(i64 %3) - ret void -if.else: - ret void +define external fastcc void @"unbranch_bug.#cont#3<0>"(i64 %"tmp#0##0") { + %"tmp#7##0" = icmp ne i64 %"tmp#0##0", 0 + br i1 %"tmp#7##0", label %if.then.0, label %if.else.0 +if.then.0: + %"tmp#8##0" = add i64 %"tmp#0##0", 8 + %"tmp#9##0" = inttoptr i64 %"tmp#8##0" to ptr + %"tmp#0##1" = load i64, ptr %"tmp#9##0" + tail call fastcc void @"unbranch_bug.#cont#3<0>"(i64 %"tmp#0##1") + ret void +if.else.0: + ret void } diff --git a/test-cases/final-dump/unbranch_inout.exp b/test-cases/final-dump/unbranch_inout.exp index 782bd14dd..9592a5129 100644 --- a/test-cases/final-dump/unbranch_inout.exp +++ b/test-cases/final-dump/unbranch_inout.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module unbranch_inout representation : (not a type) public submods : @@ -35,35 +38,25 @@ bug#cont#1(i##0:wybe.int, [?i##0:wybe.int])<{}; {}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'unbranch_inout' - - - - -declare external ccc void @print_int(i64) +source_filename = "!ROOT!/final-dump/unbranch_inout.wybe" +target triple ???? -declare external ccc i8* @wybe_malloc(i32) +declare external ccc void @print_int(i64) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"unbranch_inout.<0>"() alwaysinline { -entry: - tail call ccc void @print_int(i64 1) - ret void +define external fastcc void @"unbranch_inout.<0>"() { + call ccc void @print_int(i64 1) + ret void } - -define external fastcc i64 @"unbranch_inout.bug<0>"(i64 %"i##0") alwaysinline { -entry: - ret i64 %"i##0" +define external fastcc i64 @"unbranch_inout.bug<0>"(i64 %"i##0") { + ret i64 %"i##0" } - -define external fastcc void @"unbranch_inout.bug#cont#1<0>"(i64 %"i##0") alwaysinline { -entry: - ret void +define external fastcc void @"unbranch_inout.bug#cont#1<0>"(i64 %"i##0") { + ret void } diff --git a/test-cases/final-dump/unbranch_issue.exp b/test-cases/final-dump/unbranch_issue.exp index e38656379..cbc11418f 100644 --- a/test-cases/final-dump/unbranch_issue.exp +++ b/test-cases/final-dump/unbranch_issue.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module unbranch_issue representation : (not a type) public submods : @@ -35,36 +38,28 @@ test#cont#1(b##0:wybe.bool, tmp#2##0:wybe.int, tmp#3##0:wybe.int, ?#success##0:w LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'unbranch_issue' - - - - -@"resource#unbranch_issue.n" = global i64 undef +source_filename = "!ROOT!/final-dump/unbranch_issue.wybe" +target triple ???? -declare external ccc i8* @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) +@"resource#unbranch_issue.n" = global i64 undef - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i1 @"unbranch_issue.test<0>"() alwaysinline { -entry: - %0 = load i64, i64* @"resource#unbranch_issue.n" - %1 = tail call fastcc i1 @"unbranch_issue.test#cont#1<0>"(i1 0, i64 %0, i64 %0) - ret i1 %1 +define external fastcc i1 @"unbranch_issue.test<0>"() { + %"tmp#2##0" = load i64, ptr @"resource#unbranch_issue.n" + %"tmp#5##0" = tail call fastcc i1 @"unbranch_issue.test#cont#1<0>"(i1 0, i64 %"tmp#2##0", i64 %"tmp#2##0") + ret i1 %"tmp#5##0" } - -define external fastcc i1 @"unbranch_issue.test#cont#1<0>"(i1 %"b##0", i64 %"tmp#2##0", i64 %"tmp#3##0") { -entry: - br i1 %"b##0", label %if.then, label %if.else -if.then: - store i64 %"tmp#3##0", i64* @"resource#unbranch_issue.n" - ret i1 1 -if.else: - store i64 %"tmp#2##0", i64* @"resource#unbranch_issue.n" - ret i1 0 +define external fastcc i1 @"unbranch_issue.test#cont#1<0>"(i1 %"b##0", i64 %"tmp#2##0", i64 %"tmp#3##0") { + br i1 %"b##0", label %if.then.0, label %if.else.0 +if.then.0: + store i64 %"tmp#3##0", ptr @"resource#unbranch_issue.n" + ret i1 1 +if.else.0: + store i64 %"tmp#2##0", ptr @"resource#unbranch_issue.n" + ret i1 0 } diff --git a/test-cases/final-dump/undef_bug.exp b/test-cases/final-dump/undef_bug.exp index 16051e0bd..b8ddf9b44 100644 --- a/test-cases/final-dump/undef_bug.exp +++ b/test-cases/final-dump/undef_bug.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module undef_bug representation : (not a type) public submods : @@ -33,7 +36,7 @@ is_true(check##0:wybe.bool, ?res##1:wybe.bool)<{}; {}; {}>: proc is_true#cont#1 > (2 calls) -0: undef_bug.is_true#cont#1<0>[785a827a1b] +0: undef_bug.is_true#cont#1<0> is_true#cont#1(check##0:wybe.bool, res##0:wybe.bool, tmp#1##0:wybe.range, ?res##1:wybe.bool)<{}; {}; {}>: AliasPairs: [] InterestingCallProperties: [InterestingUnaliased 2] @@ -70,84 +73,64 @@ is_true#cont#1(check##0:wybe.bool, res##0:wybe.bool, tmp#1##0:wybe.range, ?res## LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'undef_bug' +source_filename = "!ROOT!/final-dump/undef_bug.wybe" +target triple ???? - - - -declare external fastcc {i64, i64, i1} @"wybe.range.[|]<0>[785a827a1b]"(i64) - - -declare external fastcc {i64, i64, i1} @"wybe.range.[|]<0>"(i64) - - -declare external fastcc i64 @"wybe.range...<0>"(i64, i64) - - -declare external ccc void @putchar(i8) +declare external fastcc void @"wybe.bool.print<0>"(i1) +declare external fastcc i64 @"wybe.range...<0>"(i64, i64) +declare external fastcc {i64, i64, i1} @"wybe.range.[|]<0>"(i64) +declare external fastcc {i64, i64, i1} @"wybe.range.[|]<0>[785a827a1b]"(i64) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -declare external fastcc void @"wybe.bool.print<0>"(i1) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"undef_bug.<0>"() { -entry: - %0 = tail call fastcc i64 @"wybe.range...<0>"(i64 0, i64 1) - %1 = tail call fastcc i1 @"undef_bug.is_true#cont#1<0>[785a827a1b]"(i1 0, i1 0, i64 %0) - tail call fastcc void @"wybe.bool.print<0>"(i1 %1) - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"undef_bug.<0>"() { + %"tmp#3##0" = tail call fastcc i64 @"wybe.range...<0>"(i64 0, i64 1) + %"tmp#0##0" = tail call fastcc i1 @"undef_bug.is_true#cont#1<0>[785a827a1b]"(i1 0, i1 0, i64 %"tmp#3##0") + tail call fastcc void @"wybe.bool.print<0>"(i1 %"tmp#0##0") + call ccc void @putchar(i8 10) + ret void } - -define external fastcc i1 @"undef_bug.is_true<0>"(i1 %"check##0") alwaysinline { -entry: - %0 = tail call fastcc i64 @"wybe.range...<0>"(i64 0, i64 1) - %1 = tail call fastcc i1 @"undef_bug.is_true#cont#1<0>"(i1 %"check##0", i1 0, i64 %0) - ret i1 %1 +define external fastcc i1 @"undef_bug.is_true<0>"(i1 %"check##0") { + %"tmp#2##0" = tail call fastcc i64 @"wybe.range...<0>"(i64 0, i64 1) + %"tmp#6##0" = tail call fastcc i1 @"undef_bug.is_true#cont#1<0>"(i1 %"check##0", i1 0, i64 %"tmp#2##0") + ret i1 %"tmp#6##0" } - -define external fastcc i1 @"undef_bug.is_true#cont#1<0>"(i1 %"check##0", i1 %"res##0", i64 %"tmp#1##0") { -entry: - %0 = tail call fastcc {i64, i64, i1} @"wybe.range.[|]<0>"(i64 %"tmp#1##0") - %1 = extractvalue {i64, i64, i1} %0, 0 - %2 = extractvalue {i64, i64, i1} %0, 1 - %3 = extractvalue {i64, i64, i1} %0, 2 - br i1 %3, label %if.then, label %if.else -if.then: - br i1 %"check##0", label %if.then1, label %if.else1 -if.else: - ret i1 %"res##0" -if.then1: - ret i1 1 -if.else1: - %4 = musttail call fastcc i1 @"undef_bug.is_true#cont#1<0>[785a827a1b]"(i1 0, i1 %"res##0", i64 %2) - ret i1 %4 +define external fastcc i1 @"undef_bug.is_true#cont#1<0>"(i1 %"check##0", i1 %"res##0", i64 %"tmp#1##0") { + %"tmp#6##0" = tail call fastcc {i64, i64, i1} @"wybe.range.[|]<0>"(i64 %"tmp#1##0") + %"i##0" = extractvalue {i64, i64, i1}%"tmp#6##0", 0 + %"tmp#1##1" = extractvalue {i64, i64, i1}%"tmp#6##0", 1 + %"tmp#5##0" = extractvalue {i64, i64, i1}%"tmp#6##0", 2 + br i1 %"tmp#5##0", label %if.then.0, label %if.else.0 +if.then.0: + br i1 %"check##0", label %if.then.1, label %if.else.1 +if.then.1: + ret i1 1 +if.else.1: + %"tmp#7##0" = tail call fastcc i1 @"undef_bug.is_true#cont#1<0>[785a827a1b]"(i1 0, i1 %"res##0", i64 %"tmp#1##1") + ret i1 %"tmp#7##0" +if.else.0: + ret i1 %"res##0" } - -define external fastcc i1 @"undef_bug.is_true#cont#1<0>[785a827a1b]"(i1 %"check##0", i1 %"res##0", i64 %"tmp#1##0") { -entry: - %0 = tail call fastcc {i64, i64, i1} @"wybe.range.[|]<0>[785a827a1b]"(i64 %"tmp#1##0") - %1 = extractvalue {i64, i64, i1} %0, 0 - %2 = extractvalue {i64, i64, i1} %0, 1 - %3 = extractvalue {i64, i64, i1} %0, 2 - br i1 %3, label %if.then, label %if.else -if.then: - br i1 %"check##0", label %if.then1, label %if.else1 -if.else: - ret i1 %"res##0" -if.then1: - ret i1 1 -if.else1: - %4 = musttail call fastcc i1 @"undef_bug.is_true#cont#1<0>[785a827a1b]"(i1 0, i1 %"res##0", i64 %2) - ret i1 %4 +define external fastcc i1 @"undef_bug.is_true#cont#1<0>[785a827a1b]"(i1 %"check##0", i1 %"res##0", i64 %"tmp#1##0") { + %"tmp#6##0" = tail call fastcc {i64, i64, i1} @"wybe.range.[|]<0>[785a827a1b]"(i64 %"tmp#1##0") + %"i##0" = extractvalue {i64, i64, i1}%"tmp#6##0", 0 + %"tmp#1##1" = extractvalue {i64, i64, i1}%"tmp#6##0", 1 + %"tmp#5##0" = extractvalue {i64, i64, i1}%"tmp#6##0", 2 + br i1 %"tmp#5##0", label %if.then.0, label %if.else.0 +if.then.0: + br i1 %"check##0", label %if.then.1, label %if.else.1 +if.then.1: + ret i1 1 +if.else.1: + %"tmp#7##0" = tail call fastcc i1 @"undef_bug.is_true#cont#1<0>[785a827a1b]"(i1 0, i1 %"res##0", i64 %"tmp#1##1") + ret i1 %"tmp#7##0" +if.else.0: + ret i1 %"res##0" } diff --git a/test-cases/final-dump/uneeded_closure_args.exp b/test-cases/final-dump/uneeded_closure_args.exp index 3376e6237..52ca79577 100644 --- a/test-cases/final-dump/uneeded_closure_args.exp +++ b/test-cases/final-dump/uneeded_closure_args.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module uneeded_closure_args representation : (not a type) public submods : @@ -45,49 +48,34 @@ second([a##0:A <{}; {}; {0}>], b##0:B <{}; {}; {1}>, ?#result##0:B <{}; {}; {1}> LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'uneeded_closure_args' +source_filename = "!ROOT!/final-dump/uneeded_closure_args.wybe" +target triple ???? - - - -@uneeded_closure_args.0 = constant [1 x i64] [i64 ptrtoint (i64 (i64, i64)* @"uneeded_closure_args.#closure#1<0>" to i64)] - - -declare external ccc void @print_int(i64) - +@"closure#0" = private unnamed_addr constant {ptr, i64} { ptr @"uneeded_closure_args.#closure#1<0>", i64 undef }, align 8 -declare external ccc i8* @wybe_malloc(i32) +declare external ccc void @print_int(i64) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"uneeded_closure_args.<0>"() { -entry: - %0 = tail call fastcc i64 @"uneeded_closure_args.call<0>"(i64 ptrtoint (i64* getelementptr inbounds ([1 x i64], [1 x i64]* @uneeded_closure_args.0, i32 0, i32 0) to i64), i64 2) - tail call ccc void @print_int(i64 %0) - ret void +define external fastcc void @"uneeded_closure_args.<0>"() { + %"tmp#0##0" = tail call fastcc i64 @"uneeded_closure_args.call<0>"(i64 ptrtoint( ptr @"closure#0" to i64 ), i64 2) + call ccc void @print_int(i64 %"tmp#0##0") + ret void } - -define external fastcc i64 @"uneeded_closure_args.#closure#1<0>"(i64 %"#env##0", i64 %"b##0") alwaysinline { -entry: - ret i64 %"b##0" +define external fastcc i64 @"uneeded_closure_args.#closure#1<0>"(i64 %"#env##0", i64 %"generic#b##0") { + ret i64 %"generic#b##0" } - -define external fastcc i64 @"uneeded_closure_args.call<0>"(i64 %"f##0", i64 %"a##0") noinline { -entry: - %0 = inttoptr i64 %"f##0" to i64* - %1 = load i64, i64* %0 - %2 = inttoptr i64 %1 to i64 (i64, i64)* - %3 = tail call fastcc i64 %2(i64 %"f##0", i64 %"a##0") - ret i64 %3 +define external fastcc i64 @"uneeded_closure_args.call<0>"(i64 %"f##0", i64 %"a##0") { + %"tmp#2##0" = inttoptr i64 %"f##0" to ptr + %"tmp#1##0" = load ptr, ptr %"tmp#2##0" + %"tmp#3##0" = tail call fastcc i64 %"tmp#1##0"(i64 %"f##0", i64 %"a##0") + ret i64 %"tmp#3##0" } - -define external fastcc i64 @"uneeded_closure_args.second<0>"(i64 %"b##0") alwaysinline { -entry: - ret i64 %"b##0" +define external fastcc i64 @"uneeded_closure_args.second<0>"(i64 %"b##0") { + ret i64 %"b##0" } diff --git a/test-cases/final-dump/unique_conditional.exp b/test-cases/final-dump/unique_conditional.exp index 37724151c..5539648c5 100644 --- a/test-cases/final-dump/unique_conditional.exp +++ b/test-cases/final-dump/unique_conditional.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module unique_conditional modifiers : {unique} representation : 32 bit signed @@ -38,35 +41,27 @@ foo(b##0:wybe.bool, [a##0:unique_conditional])<{}; {}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'unique_conditional' +source_filename = "!ROOT!/final-dump/unique_conditional.wybe" +target triple ???? - - - -declare external ccc i8* @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"unique_conditional.bar<0>"() alwaysinline { -entry: - ret void +define external fastcc void @"unique_conditional.bar<0>"() { + ret void } - -define external fastcc void @"unique_conditional.baz<0>"() alwaysinline { -entry: - ret void +define external fastcc void @"unique_conditional.baz<0>"() { + ret void } - -define external fastcc void @"unique_conditional.foo<0>"(i1 %"b##0") { -entry: - br i1 %"b##0", label %if.then, label %if.else -if.then: - ret void -if.else: - ret void +define external fastcc void @"unique_conditional.foo<0>"(i1 %"b##0") { + br i1 %"b##0", label %if.then.0, label %if.else.0 +if.then.0: + ret void +if.else.0: + ret void } diff --git a/test-cases/final-dump/unique_position.exp b/test-cases/final-dump/unique_position.exp index c08cb028b..8763c0711 100644 --- a/test-cases/final-dump/unique_position.exp +++ b/test-cases/final-dump/unique_position.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module unique_position representation : (not a type) public submods : unique_position -> unique_position.unique_position @@ -52,81 +55,58 @@ printPosition(pos##0:unique_position.unique_position)<{<>}; {<"(i64) - - -declare external ccc void @print_int(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"unique_position.<0>"() { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 3, i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 4, i64* %5 - %6 = inttoptr i64 %2 to i64* - store i64 5, i64* %6 - tail call fastcc void @"unique_position.printPosition<0>"(i64 %2) - ret void +source_filename = "!ROOT!/final-dump/unique_position.wybe" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c" (\00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c")\00", align 8 +@"cstring#2" = private unnamed_addr constant [ ?? x i8 ] c",\00", align 8 +@"string#3" = private unnamed_addr constant {i64, i64} { i64 2, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +@"string#4" = private unnamed_addr constant {i64, i64} { i64 1, i64 ptrtoint( ptr @"cstring#1" to i64 ) }, align 8 +@"string#5" = private unnamed_addr constant {i64, i64} { i64 1, i64 ptrtoint( ptr @"cstring#2" to i64 ) }, align 8 + +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) + +define external fastcc void @"unique_position.<0>"() { + %"tmp#8##0" = call ccc ptr @wybe_malloc(i32 16) + %"tmp#3##0" = ptrtoint ptr %"tmp#8##0" to i64 + %"tmp#9##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 3, ptr %"tmp#9##0" + %"tmp#10##0" = add i64 %"tmp#3##0", 8 + %"tmp#11##0" = inttoptr i64 %"tmp#10##0" to ptr + store i64 4, ptr %"tmp#11##0" + %"tmp#12##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 5, ptr %"tmp#12##0" + tail call fastcc void @"unique_position.printPosition<0>"(i64 %"tmp#3##0") + ret void } - -define external fastcc void @"unique_position.printPosition<0>"(i64 %"pos##0") { -entry: - %0 = inttoptr i64 %"pos##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"pos##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @unique_position.1, i32 0, i32 0) to i64)) - tail call ccc void @print_int(i64 %1) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @unique_position.3, i32 0, i32 0) to i64)) - tail call ccc void @print_int(i64 %4) - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @unique_position.5, i32 0, i32 0) to i64)) - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"unique_position.printPosition<0>"(i64 %"pos##0") { + %"tmp#10##0" = inttoptr i64 %"pos##0" to ptr + %"x##0" = load i64, ptr %"tmp#10##0" + %"tmp#11##0" = add i64 %"pos##0", 8 + %"tmp#12##0" = inttoptr i64 %"tmp#11##0" to ptr + %"y##0" = load i64, ptr %"tmp#12##0" + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#3" to i64 )) + call ccc void @print_int(i64 %"x##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#5" to i64 )) + call ccc void @print_int(i64 %"y##0") + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#4" to i64 )) + call ccc void @putchar(i8 10) + ret void } + -------------------------------------------------- Module unique_position.unique_position modifiers : {unique} - representation : address + representation : pointer public submods : public resources: public procs : unique_position.unique_position.unique_position<0> @@ -186,88 +166,68 @@ y(#rec##0:unique_position.unique_position, ?#rec##1:unique_position.unique_posit LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'unique_position.unique_position' +source_filename = "!ROOT!/final-dump/unique_position.wybe" +target triple ???? - +declare external ccc ptr @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i64 @"unique_position.unique_position.unique_position<0>"(i64 %"x##0", i64 %"y##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i64* - store i64 %"x##0", i64* %3 - %4 = add i64 %2, 8 - %5 = inttoptr i64 %4 to i64* - store i64 %"y##0", i64* %5 - ret i64 %2 +define external fastcc i64 @"unique_position.unique_position.unique_position<0>"(i64 %"x##0", i64 %"y##0") { + %"tmp#0##0" = call ccc ptr @wybe_malloc(i32 16) + %"#rec##0" = ptrtoint ptr %"tmp#0##0" to i64 + %"tmp#1##0" = inttoptr i64 %"#rec##0" to ptr + store i64 %"x##0", ptr %"tmp#1##0" + %"tmp#2##0" = add i64 %"#rec##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"y##0", ptr %"tmp#3##0" + ret i64 %"#rec##0" } - -define external fastcc {i64, i64} @"unique_position.unique_position.unique_position<1>"(i64 %"#result##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#result##0" to i64* - %1 = load i64, i64* %0 - %2 = add i64 %"#result##0", 8 - %3 = inttoptr i64 %2 to i64* - %4 = load i64, i64* %3 - %5 = insertvalue {i64, i64} undef, i64 %1, 0 - %6 = insertvalue {i64, i64} %5, i64 %4, 1 - ret {i64, i64} %6 +define external fastcc {i64, i64} @"unique_position.unique_position.unique_position<1>"(i64 %"#result##0") { + %"tmp#0##0" = inttoptr i64 %"#result##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + %"tmp#2##0" = add i64 %"#result##0", 8 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + %"tmp#4##0" = load i64, ptr %"tmp#3##0" + %"tmp#5##0" = insertvalue {i64, i64} undef, i64 %"tmp#1##0", 0 + %"tmp#6##0" = insertvalue {i64, i64} %"tmp#5##0", i64 %"tmp#4##0", 1 + ret {i64, i64} %"tmp#6##0" } - -define external fastcc i64 @"unique_position.unique_position.x<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = inttoptr i64 %"#rec##0" to i64* - %1 = load i64, i64* %0 - ret i64 %1 +define external fastcc i64 @"unique_position.unique_position.x<0>"(i64 %"#rec##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = load i64, ptr %"tmp#0##0" + ret i64 %"tmp#1##0" } - -define external fastcc i64 @"unique_position.unique_position.x<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = inttoptr i64 %2 to i64* - store i64 %"#field##0", i64* %6 - ret i64 %2 +define external fastcc i64 @"unique_position.unique_position.x<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = inttoptr i64 %"tmp#2##0" to ptr + store i64 %"#field##0", ptr %"tmp#3##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"unique_position.unique_position.y<0>"(i64 %"#rec##0") alwaysinline { -entry: - %0 = add i64 %"#rec##0", 8 - %1 = inttoptr i64 %0 to i64* - %2 = load i64, i64* %1 - ret i64 %2 +define external fastcc i64 @"unique_position.unique_position.y<0>"(i64 %"#rec##0") { + %"tmp#0##0" = add i64 %"#rec##0", 8 + %"tmp#1##0" = inttoptr i64 %"tmp#0##0" to ptr + %"tmp#2##0" = load i64, ptr %"tmp#1##0" + ret i64 %"tmp#2##0" } - -define external fastcc i64 @"unique_position.unique_position.y<1>"(i64 %"#rec##0", i64 %"#field##0") alwaysinline { -entry: - %0 = trunc i64 16 to i32 - %1 = tail call ccc i8* @wybe_malloc(i32 %0) - %2 = ptrtoint i8* %1 to i64 - %3 = inttoptr i64 %2 to i8* - %4 = inttoptr i64 %"#rec##0" to i8* - %5 = trunc i64 16 to i32 - tail call ccc void @llvm.memcpy.p0i8.p0i8.i32(i8* %3, i8* %4, i32 %5, i1 0) - %6 = add i64 %2, 8 - %7 = inttoptr i64 %6 to i64* - store i64 %"#field##0", i64* %7 - ret i64 %2 +define external fastcc i64 @"unique_position.unique_position.y<1>"(i64 %"#rec##0", i64 %"#field##0") { + %"tmp#0##0" = inttoptr i64 %"#rec##0" to ptr + %"tmp#1##0" = call ccc ptr @wybe_malloc(i32 16) + call ccc void @llvm.memcpy.p0.p0.i64(ptr %"tmp#1##0", ptr %"tmp#0##0", i64 16, i1 0) + %"tmp#2##0" = ptrtoint ptr %"tmp#1##0" to i64 + %"tmp#3##0" = add i64 %"tmp#2##0", 8 + %"tmp#4##0" = inttoptr i64 %"tmp#3##0" to ptr + store i64 %"#field##0", ptr %"tmp#4##0" + ret i64 %"tmp#2##0" } diff --git a/test-cases/final-dump/unneeded.exp b/test-cases/final-dump/unneeded.exp index 6b467d8f6..0378c3485 100644 --- a/test-cases/final-dump/unneeded.exp +++ b/test-cases/final-dump/unneeded.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module unneeded representation : (not a type) public submods : @@ -18,20 +21,16 @@ unneeded(x##0:wybe.int, [y##0:wybe.int], ?z##0:wybe.int, q##0:wybe.int, [?q##0:w LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'unneeded' +source_filename = "!ROOT!/final-dump/unneeded.wybe" +target triple ???? - - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -define external fastcc i64 @"unneeded.unneeded<0>"(i64 %"x##0", i64 %"q##0") alwaysinline { -entry: - %0 = add i64 %"x##0", 1 - ret i64 %0 +define external fastcc i64 @"unneeded.unneeded<0>"(i64 %"x##0", i64 %"q##0") { + %"tmp#3##0" = add i64 %"x##0", 1 + ret i64 %"tmp#3##0" } diff --git a/test-cases/final-dump/update.exp b/test-cases/final-dump/update.exp index aa6cc13c6..a70fd5cd1 100644 --- a/test-cases/final-dump/update.exp +++ b/test-cases/final-dump/update.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module update representation : (not a type) public submods : @@ -27,29 +30,23 @@ inc2(?x##0:wybe.int, y##0:wybe.int)<{}; {}; {}>: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'update' +source_filename = "!ROOT!/final-dump/update.wybe" +target triple ???? - - - -declare external ccc i8* @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i64 @"update.inc2<0>"(i64 %"x##0") alwaysinline { -entry: - %0 = add i64 %"x##0", 1 - %1 = add i64 %0, 1 - ret i64 %1 +define external fastcc i64 @"update.inc2<0>"(i64 %"x##0") { + %"tmp#1##0" = add i64 %"x##0", 1 + %"tmp#6##0" = add i64 %"tmp#1##0", 1 + ret i64 %"tmp#6##0" } - -define external fastcc i64 @"update.inc2<1>"(i64 %"y##0") alwaysinline { -entry: - %0 = sub i64 %"y##0", 1 - %1 = sub i64 %0, 1 - ret i64 %1 +define external fastcc i64 @"update.inc2<1>"(i64 %"y##0") { + %"tmp#0##0" = sub i64 %"y##0", 1 + %"tmp#5##0" = sub i64 %"tmp#0##0", 1 + ret i64 %"tmp#5##0" } diff --git a/test-cases/final-dump/use_resource.exp b/test-cases/final-dump/use_resource.exp index 664a4a7fd..953c4e3fa 100644 --- a/test-cases/final-dump/use_resource.exp +++ b/test-cases/final-dump/use_resource.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module use_resource representation : (not a type) public submods : @@ -66,82 +69,58 @@ use_test()<{<>, <>}; {<>, << LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'use_resource' - - - - -@"resource#use_resource.count" = global i64 undef - - -@use_resource.1 = constant {i64, i64} { i64 17, i64 ptrtoint ([?? x i8]* @use_resource.0 to i64) } - - -@use_resource.3 = constant {i64, i64} { i64 17, i64 ptrtoint ([?? x i8]* @use_resource.2 to i64) } - - -@use_resource.0 = constant [?? x i8] c"Inner count (4): \00" - - -@use_resource.2 = constant [?? x i8] c"Outer count (1): \00" - - -declare external ccc void @putchar(i8) - - -declare external ccc void @print_int(i64) - - -declare external fastcc void @"wybe.string.print<0>"(i64) - - -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"use_resource.<0>"() { -entry: - %0 = load i64, i64* @"resource#use_resource.count" - %1 = add i64 %0, 1 - %2 = add i64 %1, 1 - %3 = add i64 %2, 1 - %4 = add i64 %3, 1 - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @use_resource.1, i32 0, i32 0) to i64)) - tail call ccc void @print_int(i64 %4) - tail call ccc void @putchar(i8 10) - store i64 %1, i64* @"resource#use_resource.count" - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @use_resource.3, i32 0, i32 0) to i64)) - tail call ccc void @print_int(i64 %1) - tail call ccc void @putchar(i8 10) - ret void +source_filename = "!ROOT!/final-dump/use_resource.wybe" +target triple ???? + +@"cstring#0" = private unnamed_addr constant [ ?? x i8 ] c"Inner count (4): \00", align 8 +@"cstring#1" = private unnamed_addr constant [ ?? x i8 ] c"Outer count (1): \00", align 8 +@"string#2" = private unnamed_addr constant {i64, i64} { i64 17, i64 ptrtoint( ptr @"cstring#0" to i64 ) }, align 8 +@"string#3" = private unnamed_addr constant {i64, i64} { i64 17, i64 ptrtoint( ptr @"cstring#1" to i64 ) }, align 8 + +declare external fastcc void @"wybe.string.print<0>"(i64) +declare external ccc void @print_int(i64) +declare external ccc void @putchar(i8) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) +@"resource#use_resource.count" = global i64 undef + +define external fastcc void @"use_resource.<0>"() { + %"tmp#0##0" = load i64, ptr @"resource#use_resource.count" + %"tmp#1##0" = add i64 %"tmp#0##0", 1 + %"tmp#2##0" = add i64 %"tmp#1##0", 1 + %"tmp#3##0" = add i64 %"tmp#2##0", 1 + %"tmp#4##0" = add i64 %"tmp#3##0", 1 + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#2" to i64 )) + call ccc void @print_int(i64 %"tmp#4##0") + call ccc void @putchar(i8 10) + store i64 %"tmp#1##0", ptr @"resource#use_resource.count" + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#3" to i64 )) + call ccc void @print_int(i64 %"tmp#1##0") + call ccc void @putchar(i8 10) + ret void } - -define external fastcc void @"use_resource.inc_count<0>"() alwaysinline { -entry: - %0 = load i64, i64* @"resource#use_resource.count" - %1 = add i64 %0, 1 - store i64 %1, i64* @"resource#use_resource.count" - ret void +define external fastcc void @"use_resource.inc_count<0>"() { + %"count##0" = load i64, ptr @"resource#use_resource.count" + %"tmp#0##0" = add i64 %"count##0", 1 + store i64 %"tmp#0##0", ptr @"resource#use_resource.count" + ret void } - -define external fastcc void @"use_resource.use_test<0>"() alwaysinline { -entry: - %0 = load i64, i64* @"resource#use_resource.count" - %1 = add i64 %0, 1 - %2 = add i64 %1, 1 - %3 = add i64 %2, 1 - %4 = add i64 %3, 1 - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @use_resource.1, i32 0, i32 0) to i64)) - tail call ccc void @print_int(i64 %4) - tail call ccc void @putchar(i8 10) - store i64 %1, i64* @"resource#use_resource.count" - tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint (i64* getelementptr inbounds ({i64, i64}, {i64, i64}* @use_resource.3, i32 0, i32 0) to i64)) - tail call ccc void @print_int(i64 %1) - tail call ccc void @putchar(i8 10) - ret void +define external fastcc void @"use_resource.use_test<0>"() { + %"tmp#2##0" = load i64, ptr @"resource#use_resource.count" + %"tmp#3##0" = add i64 %"tmp#2##0", 1 + %"tmp#5##0" = add i64 %"tmp#3##0", 1 + %"tmp#7##0" = add i64 %"tmp#5##0", 1 + %"tmp#9##0" = add i64 %"tmp#7##0", 1 + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#2" to i64 )) + call ccc void @print_int(i64 %"tmp#9##0") + call ccc void @putchar(i8 10) + store i64 %"tmp#3##0", ptr @"resource#use_resource.count" + tail call fastcc void @"wybe.string.print<0>"(i64 ptrtoint( ptr @"string#3" to i64 )) + call ccc void @print_int(i64 %"tmp#3##0") + call ccc void @putchar(i8 10) + ret void } diff --git a/test-cases/final-dump/weird_err_b.exp b/test-cases/final-dump/weird_err_b.exp index bb56fd54d..534b08718 100644 --- a/test-cases/final-dump/weird_err_b.exp +++ b/test-cases/final-dump/weird_err_b.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module weird_err_b representation : (not a type) public submods : @@ -18,22 +21,19 @@ module top-level code > public {inline,semipure} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'weird_err_b' +source_filename = "!ROOT!/final-dump/weird_err_b.wybe" +target triple ???? - - - -declare external ccc i8* @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc void @"weird_err_b.<0>"() alwaysinline { -entry: - ret void +define external fastcc void @"weird_err_b.<0>"() { + ret void } + -------------------------------------------------- Module weird_err_d representation : 0 bit unsigned @@ -75,37 +75,30 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'weird_err_d' +source_filename = "!ROOT!/final-dump/weird_err_d.wybe" +target triple ???? - - - -declare external ccc i8* @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i1 @"weird_err_d.=<0>"() alwaysinline { -entry: - ret i1 1 +define external fastcc i1 @"weird_err_d.=<0>"() { + ret i1 1 } - -define external fastcc void @"weird_err_d.empty<0>"() alwaysinline { -entry: - ret void +define external fastcc void @"weird_err_d.empty<0>"() { + ret void } - -define external fastcc i1 @"weird_err_d.~=<0>"() alwaysinline { -entry: - ret i1 0 +define external fastcc i1 @"weird_err_d.~=<0>"() { + ret i1 0 } + -------------------------------------------------- Module weird_err_d.a - representation : address + representation : pointer public submods : public resources: public procs : @@ -117,19 +110,18 @@ entry: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'weird_err_d.a' +source_filename = "!ROOT!/final-dump/weird_err_d.wybe" +target triple ???? - +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -declare external ccc i8* @wybe_malloc(i32) - - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) -------------------------------------------------- Module weird_err_d.c - representation : address + representation : pointer public submods : public resources: public procs : @@ -141,13 +133,11 @@ declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'weird_err_d.c' - - - - -declare external ccc i8* @wybe_malloc(i32) +source_filename = "!ROOT!/final-dump/weird_err_d.wybe" +target triple ???? -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) diff --git a/test-cases/final-dump/weird_err_d.exp b/test-cases/final-dump/weird_err_d.exp index cc3f14a49..c0d3edca5 100644 --- a/test-cases/final-dump/weird_err_d.exp +++ b/test-cases/final-dump/weird_err_d.exp @@ -1,5 +1,8 @@ ====================================================================== AFTER EVERYTHING: + + +-------------------------------------------------- Module weird_err_d representation : 0 bit unsigned public submods : a -> weird_err_d.a @@ -40,37 +43,30 @@ proc ~= > public {inline} (0 calls) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'weird_err_d' - - +source_filename = "!ROOT!/final-dump/weird_err_d.wybe" +target triple ???? -declare external ccc i8* @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) - -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) - - -define external fastcc i1 @"weird_err_d.=<0>"() alwaysinline { -entry: - ret i1 1 +define external fastcc i1 @"weird_err_d.=<0>"() { + ret i1 1 } - -define external fastcc void @"weird_err_d.empty<0>"() alwaysinline { -entry: - ret void +define external fastcc void @"weird_err_d.empty<0>"() { + ret void } - -define external fastcc i1 @"weird_err_d.~=<0>"() alwaysinline { -entry: - ret i1 0 +define external fastcc i1 @"weird_err_d.~=<0>"() { + ret i1 0 } + -------------------------------------------------- Module weird_err_d.a - representation : address + representation : pointer public submods : public resources: public procs : @@ -82,19 +78,18 @@ entry: LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'weird_err_d.a' +source_filename = "!ROOT!/final-dump/weird_err_d.wybe" +target triple ???? - - - -declare external ccc i8* @wybe_malloc(i32) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) -------------------------------------------------- Module weird_err_d.c - representation : address + representation : pointer public submods : public resources: public procs : @@ -106,13 +101,11 @@ declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) LLVM code : +;; FILE GENERATED BY wybemk 0.2 -- see https://github.com/pschachte/wybe ; ModuleID = 'weird_err_d.c' - - - - -declare external ccc i8* @wybe_malloc(i32) +source_filename = "!ROOT!/final-dump/weird_err_d.wybe" +target triple ???? -declare external ccc void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) +declare external ccc void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1) diff --git a/update-exp b/update-exp index 8b16ec10a..58742fb66 100755 --- a/update-exp +++ b/update-exp @@ -36,7 +36,7 @@ agree () { case "$action" in [dD]*) (prefix "$1" 'Output Changes' ; \ - dwdiff -c -d '()<>~!@:?.%#' "$3" "$2" ) | $destination ;; + dwdiff -c -d '()<>~!@:?.%#,\"' "$3" "$2" ) | $destination ;; [uU]*) (prefix "$1" 'Output Changes' ; \ diff -u "$3" "$2" ) | $destination ;; diff --git a/wybe.cabal b/wybe.cabal index 20b38e0e9..636ca09b2 100644 --- a/wybe.cabal +++ b/wybe.cabal @@ -10,66 +10,79 @@ executable wybemk main-is: wybemk.hs hs-source-dirs: src build-depends: array >= 0.5.1.0 - , base >=4.6 - , binary >= 0.7.5.0 - , bytedump - , bytestring - , Cabal - , containers - , directory >= 1.2.5.0 - , filepath >= 1.4.0.0 - , flow - , haskeline - , llvm-hs == 9.0.* - , llvm-hs-pure == 9.0.* - , llvm-hs-pretty == 0.9.0.* - , list-predicate - , temporary - , text - , mtl - , old-time - , parsec >=3.1.3 - , process >= 1.4.2.0 - , transformers - , cryptonite - , tuple >= 0.3.0.2 - , extra >= 1.5.1 - , ansi-terminal - , utility-ht - , Diff - other-modules: AST, BinaryFactory, Blocks, BodyBuilder, Builder, Callers, - Clause, Codegen, Config, Emit, Expansion, Flatten, - Macho, Parser, Normalise, ObjectInterface, Optimise, + , base >=4.6 + , binary >= 0.8.9.1 + , bytedump + , bytestring >= 0.11.5.3 + , Cabal + , containers + , directory >= 1.2.5.0 + , filepath >= 1.4.0.0 + , flow + , haskeline + , list-predicate + , temporary + , text + , mtl + , old-time + , parsec >=3.1.3 + , process >= 1.4.2.0 + , transformers + , cryptonite >= 0.30 + , tuple >= 0.3.0.2 + , extra >= 1.5.1 + , ansi-terminal + , utility-ht + , Diff + , extra >= 1.7.14 + , flow >= 2.0.0.4 + other-modules: AST, BinaryFactory, BodyBuilder, Builder, Callers, + CConfig, Clause, LLVM, Config, Emit, Expansion, + Flatten, Macho, Parser, Normalise, ObjectInterface, Optimise, Analysis, AliasAnalysis, Transform, - Options, Resources, Scanner, Snippets, Types, Unbranch, UnivSet, Util, - Version, ASTShow, Unique, LastCallAnalysis + Options, Resources, Scanner, Snippets, Types, Unbranch, + UnivSet, Util, Version, ASTShow, Unique, LastCallAnalysis extra-libraries: gc - + extra-lib-dirs:/opt/homebrew/lib test-suite wybe-test type: exitcode-stdio-1.0 default-language: Haskell2010 hs-source-dirs: src main-is: Test.hs - build-depends: base >=4.6 && <5 - , array >= 0.5.1.0 - , HUnit >=1.3.1.0 - , hspec >=2.2.0 - , containers - , directory >= 1.2.5.0 - , filepath >= 1.4.0.0 - , llvm-hs - , llvm-hs-pure - , llvm-hs-pretty - , mtl - , parsec >=3.1.3 - , transformers - , ansi-terminal - , utility-ht - , Diff - other-modules: AST, BinaryFactory, Blocks, BodyBuilder, Builder, Callers, - Clause, Codegen, Config, Emit, Expansion, Flatten, - Macho, Parser, Normalise, ObjectInterface, Optimise, + build-depends: array >= 0.5.1.0 + , base >=4.6 + , binary >= 0.8.9.1 + , bytedump + , bytestring >= 0.11.5.3 + , Cabal + , containers + , directory >= 1.2.5.0 + , filepath >= 1.4.0.0 + , flow + , haskeline + , list-predicate + , temporary + , text + , mtl + , old-time + , parsec >=3.1.3 + , process >= 1.4.2.0 + , transformers + , cryptonite >= 0.30 + , tuple >= 0.3.0.2 + , ansi-terminal + , utility-ht + , Diff + , extra >= 1.7.14 + , flow >= 2.0.0.4 + , HUnit >=1.3.1.0 + , hspec >=2.2.0 + other-modules: AST, BinaryFactory, BodyBuilder, Builder, Callers, + CConfig, Clause, LLVM, Config, Emit, Expansion, + Flatten, Macho, Parser, Normalise, ObjectInterface, Optimise, Analysis, AliasAnalysis, Transform, - Options, Resources, Scanner, Snippets, Types, Unbranch, Util, - Version, ASTShow, Unique + Options, Resources, Scanner, Snippets, Types, Unbranch, + UnivSet, Util, Version, ASTShow, Unique, LastCallAnalysis + extra-libraries: gc + extra-lib-dirs:/opt/homebrew/lib diff --git a/wybelibs/wybe/cbits.c b/wybelibs/wybe/cbits.c index bc7097cc4..87d539599 100644 --- a/wybelibs/wybe/cbits.c +++ b/wybelibs/wybe/cbits.c @@ -93,6 +93,10 @@ int64_t isqrt(int64_t x) { return (int64_t)s; } +int64_t signum(int64_t x) { + return (x > 0) - (x < 0); +} + // Boehm GC void *wybe_malloc(int64_t size) { diff --git a/wybelibs/wybe/float.wybe b/wybelibs/wybe/float.wybe index c16efdd3f..eb93f1085 100644 --- a/wybelibs/wybe/float.wybe +++ b/wybelibs/wybe/float.wybe @@ -67,14 +67,14 @@ pub def abs(x:_):_ = foreign c `llvm.fabs.f64`(x) ## Comparisons # Equality and disequality. -pub def {test} (x:_ = y:_) { foreign llvm {test} fcmp_eq(x,y) } -pub def {test} (x:_ ~= y:_) { foreign llvm {test} fcmp_ne(x,y) } +pub def {test} (x:_ = y:_) { foreign llvm {test} fcmp_oeq(x,y) } +pub def {test} (x:_ ~= y:_) { foreign llvm {test} fcmp_one(x,y) } # Inequalities. -pub def {test} (x:_ < y:_) { foreign llvm {test} fcmp_slt(x,y) } -pub def {test} (x:_ <= y:_) { foreign llvm {test} fcmp_sle(x,y) } -pub def {test} (x:_ > y:_) { foreign llvm {test} fcmp_sgt(x,y) } -pub def {test} (x:_ >= y:_) { foreign llvm {test} fcmp_sge(x,y) } +pub def {test} (x:_ < y:_) { foreign llvm {test} fcmp_olt(x,y) } +pub def {test} (x:_ <= y:_) { foreign llvm {test} fcmp_ole(x,y) } +pub def {test} (x:_ > y:_) { foreign llvm {test} fcmp_ogt(x,y) } +pub def {test} (x:_ >= y:_) { foreign llvm {test} fcmp_oge(x,y) } # Three-way comparison. pub def (x:_ <=> y:_):comparison = diff --git a/wybelibs/wybe/opaque_pointer.wybe b/wybelibs/wybe/opaque_pointer.wybe new file mode 100644 index 000000000..a2e0083a3 --- /dev/null +++ b/wybelibs/wybe/opaque_pointer.wybe @@ -0,0 +1,7 @@ +# purpose: Standard opaque pointer type, mostly used for interfacing to other +# programming languages. +# since : 0.2 + +pragma no_standard_library # Standard library can't depend on itself! + +representation is opaque