octave-nkf: src/interp-core/pt-jit.cc annotate

annotate src/interp-core/pt-jit.cc @ 15182:a7a56b436de2

Factor out jit_block_list and jit_factory from jit_convert * jit-ir.cc (jit_factory, jit_block_list): New class. (jit_block::maybe_split): Use jit_factory and jit_block_list instead of jit_convert. (jit_magic_end::context::context): Use jit_factory instead of jit_convert. * jit-ir.h (jit_factory, jit_block_list): New class. (jit_block::maybe_split): Use jit_block_list and jit_factory. (jit_magic_end::context::context) Use jit_factory. * pt-jit.cc (jit_convert): Use jit_factory and jit_block_list instead of internal methods. (jit_convert::append): Removed method. (jit_convert::create_checked_impl): Merg in jit_convert::create_check. (jit_convert::insert_before, jit_convert;:insert_after, jit_convert::~jit_convert, jit_convert::append): Remove method. (jit_convert_llvm::convert): Use jit_block_list. * pt-jit.h (jit_convert::~jit_convert, jit_convert::append): Remove declaration. (jit_convert::create, jit_convert::insert_before, jit_convert::insert_after, jit_convert::track_value): Remove method. (jit_convert_llvm::convert): Use jit_block_list.

author	Max Brister <max@2bass.com>
date	Wed, 15 Aug 2012 23:30:02 -0500
parents	ed2b911a2fb3
children	ed4f4fb78586

rev	line source
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	1 /*
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	2
14901 516b4a15b775 doc: Copyright fix in pt-jit.h and pt-jit.cc Max Brister <max@2bass.com> parents: 14899 diff changeset	3 Copyright (C) 2012 Max Brister <max@2bass.com>
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	4
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	5 This file is part of Octave.
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	6
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	7 Octave is free software; you can redistribute it and/or modify it
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	8 under the terms of the GNU General Public License as published by the
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	9 Free Software Foundation; either version 3 of the License, or (at your
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	10 option) any later version.
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	11
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	12 Octave is distributed in the hope that it will be useful, but WITHOUT
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	13 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	15 for more details.
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	16
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	17 You should have received a copy of the GNU General Public License
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	18 along with Octave; see the file COPYING. If not, see
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	19 <http://www.gnu.org/licenses/>.
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	20
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	21 */
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	22
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	23 #define __STDC_LIMIT_MACROS
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	24 #define __STDC_CONSTANT_MACROS
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	25
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	26 #ifdef HAVE_CONFIG_H
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	27 #include <config.h>
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	28 #endif
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	29
14932 1f914446157d Locate and link with LLVM properly Max Brister <max@2bass.com> parents: 14928 diff changeset	30 #ifdef HAVE_LLVM
1f914446157d Locate and link with LLVM properly Max Brister <max@2bass.com> parents: 14928 diff changeset	31
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	32 #include "pt-jit.h"
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	33
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	34 #include <llvm/Analysis/CallGraph.h>
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	35 #include <llvm/Analysis/Passes.h>
15016 005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	36 #include <llvm/Analysis/Verifier.h>
15030 86a95d6ada0d src/pt-jit.cc: Fix JIT build with LLVM 3.0. Max Brister <max@2bass.com> parents: 15027 diff changeset	37 #include <llvm/LLVMContext.h>
15016 005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	38 #include <llvm/ExecutionEngine/ExecutionEngine.h>
005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	39 #include <llvm/ExecutionEngine/JIT.h>
005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	40 #include <llvm/Module.h>
005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	41 #include <llvm/PassManager.h>
005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	42 #include <llvm/Support/IRBuilder.h>
005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	43 #include <llvm/Support/raw_os_ostream.h>
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	44 #include <llvm/Support/TargetSelect.h>
15016 005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	45 #include <llvm/Target/TargetData.h>
005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	46 #include <llvm/Transforms/IPO.h>
005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	47 #include <llvm/Transforms/Scalar.h>
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	48
15016 005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	49 #ifdef OCTAVE_JIT_DEBUG
005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	50 #include <llvm/Bitcode/ReaderWriter.h>
005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	51 #endif
005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	52
005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	53 #include "symtab.h"
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	54 #include "pt-all.h"
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	55
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	56 static llvm::IRBuilder<> builder (llvm::getGlobalContext ());
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	57
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	58 static llvm::LLVMContext& context = llvm::getGlobalContext ();
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	59
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	60 // -------------------- jit_convert --------------------
15027 741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	61 jit_convert::jit_convert (llvm::Module *module, tree &tee,
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	62 jit_type *for_bounds)
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	63 : iterator_count (0), for_bounds_count (0), short_count (0), breaking (false)
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	64 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	65 jit_instruction::reset_ids ();
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	66
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	67 entry_block = factory.create<jit_block> ("body");
a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	68 final_block = factory.create<jit_block> ("final");
a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	69 blocks.push_back (entry_block);
14945 591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	70 entry_block->mark_alive ();
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	71 block = entry_block;
15027 741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	72
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	73 if (for_bounds)
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	74 create_variable (next_for_bounds (false), for_bounds);
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	75
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	76 visit (tee);
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	77
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	78 // FIXME: Remove if we no longer only compile loops
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	79 assert (! breaking);
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	80 assert (breaks.empty ());
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	81 assert (continues.empty ());
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	82
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	83 block->append (factory.create<jit_branch> (final_block));
a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	84 blocks.push_back (final_block);
14959 12fd4a62d633 Fix whitespace issues and update documentation Max Brister <max@2bass.com> parents: 14958 diff changeset	85
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	86 for (vmap_t::iterator iter = vmap.begin (); iter != vmap.end (); ++iter)
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	87 {
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	88 jit_variable *var = iter->second;
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	89 const std::string& name = var->name ();
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	90 if (name.size () && name[0] != '#')
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	91 final_block->append (factory.create<jit_store_argument> (var));
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	92 }
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	93
14938 bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	94 construct_ssa ();
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	95
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	96 // initialize the worklist to instructions derived from constants
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	97 const std::list<jit_value *>& constants = factory.constants ();
a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	98 for (std::list<jit_value *>::const_iterator iter = constants.begin ();
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	99 iter != constants.end (); ++iter)
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	100 append_users (*iter);
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	101
15023 75d1bc2fd6d2 Compile top level while loops in JIT. Max Brister <max@2bass.com> parents: 15016 diff changeset	102 // the entry block terminator may be a regular branch statement
75d1bc2fd6d2 Compile top level while loops in JIT. Max Brister <max@2bass.com> parents: 15016 diff changeset	103 if (entry_block->terminator ())
75d1bc2fd6d2 Compile top level while loops in JIT. Max Brister <max@2bass.com> parents: 15016 diff changeset	104 push_worklist (entry_block->terminator ());
75d1bc2fd6d2 Compile top level while loops in JIT. Max Brister <max@2bass.com> parents: 15016 diff changeset	105
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	106 // FIXME: Describe algorithm here
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	107 while (worklist.size ())
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	108 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	109 jit_instruction *next = worklist.front ();
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	110 worklist.pop_front ();
14946 3564bb141396 Only add items to worklist in type inferece if not already there Max Brister <max@2bass.com> parents: 14945 diff changeset	111 next->stash_in_worklist (false);
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	112
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	113 if (next->infer ())
14945 591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	114 {
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	115 // terminators need to be handles specially
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	116 if (jit_terminator term = dynamic_cast<jit_terminator > (next))
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	117 append_users_term (term);
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	118 else
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	119 append_users (next);
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	120 }
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	121 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	122
14945 591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	123 remove_dead ();
14963 709f50069722 Change algorithm for placing releases and simplify PHIs in low level Octave IR Max Brister <max@2bass.com> parents: 14962 diff changeset	124 final_block->label ();
14935 5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	125 place_releases ();
14966 b7b647bc4b90 Place releases for temporaries on error Max Brister <max@2bass.com> parents: 14965 diff changeset	126 simplify_phi ();
14935 5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	127
14932 1f914446157d Locate and link with LLVM properly Max Brister <max@2bass.com> parents: 14928 diff changeset	128 #ifdef OCTAVE_JIT_DEBUG
14966 b7b647bc4b90 Place releases for temporaries on error Max Brister <max@2bass.com> parents: 14965 diff changeset	129 final_block->label ();
14932 1f914446157d Locate and link with LLVM properly Max Brister <max@2bass.com> parents: 14928 diff changeset	130 std::cout << "-------------------- Compiling tree --------------------\n";
1f914446157d Locate and link with LLVM properly Max Brister <max@2bass.com> parents: 14928 diff changeset	131 std::cout << tee.str_print_code () << std::endl;
1f914446157d Locate and link with LLVM properly Max Brister <max@2bass.com> parents: 14928 diff changeset	132 print_blocks ("octave jit ir");
1f914446157d Locate and link with LLVM properly Max Brister <max@2bass.com> parents: 14928 diff changeset	133 #endif
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	134
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	135 // for now just init arguments from entry, later we will have to do something
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	136 // more interesting
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	137 for (jit_block::iterator iter = entry_block->begin ();
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	138 iter != entry_block->end (); ++iter)
14959 12fd4a62d633 Fix whitespace issues and update documentation Max Brister <max@2bass.com> parents: 14958 diff changeset	139 if (jit_extract_argument *extract
12fd4a62d633 Fix whitespace issues and update documentation Max Brister <max@2bass.com> parents: 14958 diff changeset	140 = dynamic_cast<jit_extract_argument > (iter))
14937 78e1457c5bf5 Remove some macros from pt-jit.h and pt-jit.cc Max Brister <max@2bass.com> parents: 14936 diff changeset	141 arguments.push_back (std::make_pair (extract->name (), true));
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	142
15181 ed2b911a2fb3 Rename jit_convert::convert_llvm to jit_convert_llvm Max Brister <max@2bass.com> parents: 15171 diff changeset	143 jit_convert_llvm to_llvm (*this);
14944 c0a5ab3b9278 jit_const no longer inherits from jit_instruction Max Brister <max@2bass.com> parents: 14943 diff changeset	144 function = to_llvm.convert (module, arguments, blocks, constants);
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	145
14932 1f914446157d Locate and link with LLVM properly Max Brister <max@2bass.com> parents: 14928 diff changeset	146 #ifdef OCTAVE_JIT_DEBUG
1f914446157d Locate and link with LLVM properly Max Brister <max@2bass.com> parents: 14928 diff changeset	147 std::cout << "-------------------- llvm ir --------------------";
1f914446157d Locate and link with LLVM properly Max Brister <max@2bass.com> parents: 14928 diff changeset	148 llvm::raw_os_ostream llvm_cout (std::cout);
1f914446157d Locate and link with LLVM properly Max Brister <max@2bass.com> parents: 14928 diff changeset	149 function->print (llvm_cout);
1f914446157d Locate and link with LLVM properly Max Brister <max@2bass.com> parents: 14928 diff changeset	150 std::cout << std::endl;
1f914446157d Locate and link with LLVM properly Max Brister <max@2bass.com> parents: 14928 diff changeset	151 llvm::verifyFunction (*function);
1f914446157d Locate and link with LLVM properly Max Brister <max@2bass.com> parents: 14928 diff changeset	152 #endif
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	153 }
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	154
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	155 void
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	156 jit_convert::visit_anon_fcn_handle (tree_anon_fcn_handle&)
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	157 {
15016 005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	158 throw jit_fail_exception ();
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	159 }
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	160
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	161 void
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	162 jit_convert::visit_argument_list (tree_argument_list&)
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	163 {
15016 005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	164 throw jit_fail_exception ();
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	165 }
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	166
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	167 void
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	168 jit_convert::visit_binary_expression (tree_binary_expression& be)
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	169 {
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	170 if (be.op_type () >= octave_value::num_binary_ops)
14978 f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	171 {
f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	172 tree_boolean_expression *boole;
f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	173 boole = dynamic_cast<tree_boolean_expression *> (&be);
f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	174 assert (boole);
f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	175 bool is_and = boole->op_type () == tree_boolean_expression::bool_and;
f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	176
15027 741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	177 std::string short_name = next_shortcircut_result ();
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	178 jit_variable *short_result = factory.create<jit_variable> (short_name);
14978 f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	179 vmap[short_name] = short_result;
f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	180
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	181 jit_block *done = factory.create<jit_block> (block->name ());
14978 f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	182 tree_expression *lhs = be.lhs ();
f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	183 jit_value *lhsv = visit (lhs);
f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	184 lhsv = create_checked (&jit_typeinfo::logically_true, lhsv);
f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	185
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	186 jit_block *short_early = factory.create<jit_block> ("short_early");
a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	187 blocks.push_back (short_early);
14978 f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	188
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	189 jit_block *short_cont = factory.create<jit_block> ("short_cont");
14978 f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	190
f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	191 if (is_and)
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	192 block->append (factory.create<jit_cond_branch> (lhsv, short_cont, short_early));
14978 f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	193 else
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	194 block->append (factory.create<jit_cond_branch> (lhsv, short_early, short_cont));
14978 f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	195
f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	196 block = short_early;
f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	197
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	198 jit_value *early_result = factory.create<jit_const_bool> (! is_and);
a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	199 block->append (factory.create<jit_assign> (short_result, early_result));
a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	200 block->append (factory.create<jit_branch> (done));
14978 f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	201
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	202 blocks.push_back (short_cont);
14978 f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	203 block = short_cont;
f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	204
f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	205 tree_expression *rhs = be.rhs ();
f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	206 jit_value *rhsv = visit (rhs);
f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	207 rhsv = create_checked (&jit_typeinfo::logically_true, rhsv);
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	208 block->append (factory.create<jit_assign> (short_result, rhsv));
a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	209 block->append (factory.create<jit_branch> (done));
14978 f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	210
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	211 blocks.push_back (done);
14978 f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	212 block = done;
f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	213 result = short_result;
f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	214 }
f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	215 else
f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	216 {
f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	217 tree_expression *lhs = be.lhs ();
f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	218 jit_value *lhsv = visit (lhs);
f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	219
f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	220 tree_expression *rhs = be.rhs ();
f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	221 jit_value *rhsv = visit (rhs);
f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	222
14983 a5f75de0dab1 Rename jit_function to jit_operation Max Brister <max@2bass.com> parents: 14978 diff changeset	223 const jit_operation& fn = jit_typeinfo::binary_op (be.op_type ());
14978 f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	224 result = create_checked (fn, lhsv, rhsv);
f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	225 }
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	226 }
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	227
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	228 void
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	229 jit_convert::visit_break_command (tree_break_command&)
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	230 {
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	231 breaks.push_back (block);
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	232 breaking = true;
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	233 }
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	234
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	235 void
14936 32deb562ae77 Allow for construction of ranges during jit Max Brister <max@2bass.com> parents: 14935 diff changeset	236 jit_convert::visit_colon_expression (tree_colon_expression& expr)
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	237 {
14936 32deb562ae77 Allow for construction of ranges during jit Max Brister <max@2bass.com> parents: 14935 diff changeset	238 // in the futher we need to add support for classes and deal with rvalues
14944 c0a5ab3b9278 jit_const no longer inherits from jit_instruction Max Brister <max@2bass.com> parents: 14943 diff changeset	239 jit_value *base = visit (expr.base ());
c0a5ab3b9278 jit_const no longer inherits from jit_instruction Max Brister <max@2bass.com> parents: 14943 diff changeset	240 jit_value *limit = visit (expr.limit ());
c0a5ab3b9278 jit_const no longer inherits from jit_instruction Max Brister <max@2bass.com> parents: 14943 diff changeset	241 jit_value *increment;
14936 32deb562ae77 Allow for construction of ranges during jit Max Brister <max@2bass.com> parents: 14935 diff changeset	242 tree_expression *tinc = expr.increment ();
32deb562ae77 Allow for construction of ranges during jit Max Brister <max@2bass.com> parents: 14935 diff changeset	243
32deb562ae77 Allow for construction of ranges during jit Max Brister <max@2bass.com> parents: 14935 diff changeset	244 if (tinc)
32deb562ae77 Allow for construction of ranges during jit Max Brister <max@2bass.com> parents: 14935 diff changeset	245 increment = visit (tinc);
32deb562ae77 Allow for construction of ranges during jit Max Brister <max@2bass.com> parents: 14935 diff changeset	246 else
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	247 increment = factory.create<jit_const_scalar> (1);
14936 32deb562ae77 Allow for construction of ranges during jit Max Brister <max@2bass.com> parents: 14935 diff changeset	248
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	249 result = block->append (factory.create<jit_call> (jit_typeinfo::make_range, base,
14936 32deb562ae77 Allow for construction of ranges during jit Max Brister <max@2bass.com> parents: 14935 diff changeset	250 limit, increment));
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	251 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	252
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	253 void
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	254 jit_convert::visit_continue_command (tree_continue_command&)
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	255 {
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	256 continues.push_back (block);
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	257 breaking = true;
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	258 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	259
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	260 void
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	261 jit_convert::visit_global_command (tree_global_command&)
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	262 {
15016 005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	263 throw jit_fail_exception ();
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	264 }
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	265
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	266 void
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	267 jit_convert::visit_persistent_command (tree_persistent_command&)
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	268 {
15016 005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	269 throw jit_fail_exception ();
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	270 }
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	271
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	272 void
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	273 jit_convert::visit_decl_elt (tree_decl_elt&)
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	274 {
15016 005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	275 throw jit_fail_exception ();
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	276 }
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	277
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	278 void
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	279 jit_convert::visit_decl_init_list (tree_decl_init_list&)
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	280 {
15016 005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	281 throw jit_fail_exception ();
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	282 }
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	283
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	284 void
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	285 jit_convert::visit_simple_for_command (tree_simple_for_command& cmd)
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	286 {
14938 bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	287 // Note we do an initial check to see if the loop will run atleast once.
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	288 // This allows us to get better type inference bounds on variables defined
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	289 // and used only inside the for loop (e.g. the index variable)
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	290
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	291 // If we are a nested for loop we need to store the previous breaks
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	292 assert (! breaking);
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	293 unwind_protect prot;
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	294 prot.protect_var (breaks);
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	295 prot.protect_var (continues);
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	296 prot.protect_var (breaking);
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	297 breaks.clear ();
14989 dfaa8da46364 Support while loops in JIT Max Brister <max@2bass.com> parents: 14988 diff changeset	298 continues.clear ();
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	299
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	300 // we need a variable for our iterator, because it is used in multiple blocks
15027 741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	301 std::string iter_name = next_iterator ();
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	302 jit_variable *iterator = factory.create<jit_variable> (iter_name);
a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	303 factory.create<jit_variable> (iter_name);
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	304 vmap[iter_name] = iterator;
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	305
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	306 jit_block *body = factory.create<jit_block> ("for_body");
a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	307 blocks.push_back (body);
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	308
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	309 jit_block *tail = factory.create<jit_block> ("for_tail");
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	310
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	311 // do control expression, iter init, and condition check in prev_block (block)
15027 741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	312 // if we are the top level for loop, the bounds is an input argument.
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	313 jit_value *control = find_variable (next_for_bounds ());
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	314 if (! control)
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	315 control = visit (cmd.control_expr ());
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	316 jit_call *init_iter = factory.create<jit_call> (jit_typeinfo::for_init,
a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	317 control);
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	318 block->append (init_iter);
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	319 block->append (factory.create<jit_assign> (iterator, init_iter));
14959 12fd4a62d633 Fix whitespace issues and update documentation Max Brister <max@2bass.com> parents: 14958 diff changeset	320
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	321 jit_call *check = factory.create<jit_call> (jit_typeinfo::for_check, control,
a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	322 iterator);
a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	323 block->append (check);
a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	324 block->append (factory.create<jit_cond_branch> (check, body, tail));
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	325 block = body;
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	326
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	327 // compute the syntactical iterator
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	328 jit_call *idx_rhs = factory.create<jit_call> (jit_typeinfo::for_index,
a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	329 control, iterator);
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	330 block->append (idx_rhs);
14969 bbeef7b8ea2e Add support for matrix indexed assignment to JIT Max Brister <max@2bass.com> parents: 14968 diff changeset	331 do_assign (cmd.left_hand_side (), idx_rhs);
14959 12fd4a62d633 Fix whitespace issues and update documentation Max Brister <max@2bass.com> parents: 14958 diff changeset	332
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	333 // do loop
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	334 tree_statement_list *pt_body = cmd.body ();
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	335 pt_body->accept (*this);
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	336
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	337 if (breaking && continues.empty ())
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	338 {
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	339 // WTF are you doing user? Every branch was a continue, why did you have
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	340 // a loop??? Users are silly people...
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	341 finish_breaks (tail, breaks);
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	342 blocks.push_back (tail);
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	343 block = tail;
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	344 return;
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	345 }
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	346
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	347 // check our condition, continues jump to this block
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	348 jit_block *check_block = factory.create<jit_block> ("for_check");
a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	349 blocks.push_back (check_block);
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	350
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	351 if (! breaking)
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	352 block->append (factory.create<jit_branch> (check_block));
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	353 finish_breaks (check_block, continues);
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	354
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	355 block = check_block;
14983 a5f75de0dab1 Rename jit_function to jit_operation Max Brister <max@2bass.com> parents: 14978 diff changeset	356 const jit_operation& add_fn = jit_typeinfo::binary_op (octave_value::op_add);
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	357 jit_value *one = factory.create<jit_const_index> (1);
a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	358 jit_call *iter_inc = factory.create<jit_call> (add_fn, iterator, one);
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	359 block->append (iter_inc);
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	360 block->append (factory.create<jit_assign> (iterator, iter_inc));
a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	361 check = block->append (factory.create<jit_call> (jit_typeinfo::for_check, control,
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	362 iterator));
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	363 block->append (factory.create<jit_cond_branch> (check, body, tail));
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	364
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	365 // breaks will go to our tail
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	366 blocks.push_back (tail);
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	367 finish_breaks (tail, breaks);
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	368 block = tail;
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	369 }
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	370
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	371 void
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	372 jit_convert::visit_complex_for_command (tree_complex_for_command&)
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	373 {
15016 005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	374 throw jit_fail_exception ();
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	375 }
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	376
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	377 void
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	378 jit_convert::visit_octave_user_script (octave_user_script&)
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	379 {
15016 005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	380 throw jit_fail_exception ();
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	381 }
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	382
14915 cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14913 diff changeset	383 void
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	384 jit_convert::visit_octave_user_function (octave_user_function&)
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	385 {
15016 005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	386 throw jit_fail_exception ();
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	387 }
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	388
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	389 void
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	390 jit_convert::visit_octave_user_function_header (octave_user_function&)
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	391 {
15016 005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	392 throw jit_fail_exception ();
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	393 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	394
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	395 void
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	396 jit_convert::visit_octave_user_function_trailer (octave_user_function&)
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	397 {
15016 005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	398 throw jit_fail_exception ();
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	399 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	400
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	401 void
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	402 jit_convert::visit_function_def (tree_function_def&)
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	403 {
15016 005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	404 throw jit_fail_exception ();
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	405 }
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	406
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	407 void
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	408 jit_convert::visit_identifier (tree_identifier& ti)
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	409 {
15056 bc32288f4a42 Support the end keyword for one dimentional indexing in JIT. Max Brister <max@2bass.com> parents: 15030 diff changeset	410 if (ti.has_magic_end ())
bc32288f4a42 Support the end keyword for one dimentional indexing in JIT. Max Brister <max@2bass.com> parents: 15030 diff changeset	411 {
bc32288f4a42 Support the end keyword for one dimentional indexing in JIT. Max Brister <max@2bass.com> parents: 15030 diff changeset	412 if (!end_context.size ())
bc32288f4a42 Support the end keyword for one dimentional indexing in JIT. Max Brister <max@2bass.com> parents: 15030 diff changeset	413 throw jit_fail_exception ("Illegal end");
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	414 result = block->append (factory.create<jit_magic_end> (end_context));
15056 bc32288f4a42 Support the end keyword for one dimentional indexing in JIT. Max Brister <max@2bass.com> parents: 15030 diff changeset	415 }
bc32288f4a42 Support the end keyword for one dimentional indexing in JIT. Max Brister <max@2bass.com> parents: 15030 diff changeset	416 else
bc32288f4a42 Support the end keyword for one dimentional indexing in JIT. Max Brister <max@2bass.com> parents: 15030 diff changeset	417 result = get_variable (ti.name ());
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	418 }
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	419
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	420 void
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	421 jit_convert::visit_if_clause (tree_if_clause&)
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	422 {
15016 005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	423 throw jit_fail_exception ();
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	424 }
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	425
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	426 void
14923 168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	427 jit_convert::visit_if_command (tree_if_command& cmd)
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	428 {
14923 168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	429 tree_if_command_list *lst = cmd.cmd_list ();
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	430 assert (lst); // jwe: Can this be null?
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	431 lst->accept (*this);
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	432 }
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	433
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	434 void
14923 168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	435 jit_convert::visit_if_command_list (tree_if_command_list& lst)
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	436 {
14923 168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	437 tree_if_clause *last = lst.back ();
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	438 size_t last_else = static_cast<size_t> (last->is_else_clause ());
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	439
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	440 // entry_blocks represents the block you need to enter in order to execute
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	441 // the condition check for the ith clause. For the else, it is simple the
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	442 // else body. If there is no else body, then it is padded with the tail
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	443 std::vector<jit_block *> entry_blocks (lst.size () + 1 - last_else);
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	444 std::vector<jit_block *> branch_blocks (lst.size (), 0); // final blocks
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	445 entry_blocks[0] = block;
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	446
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	447 // we need to construct blocks first, because they have jumps to eachother
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	448 tree_if_command_list::iterator iter = lst.begin ();
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	449 ++iter;
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	450 for (size_t i = 1; iter != lst.end (); ++iter, ++i)
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	451 {
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	452 tree_if_clause tic = iter;
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	453 if (tic->is_else_clause ())
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	454 entry_blocks[i] = factory.create<jit_block> ("else");
14923 168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	455 else
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	456 entry_blocks[i] = factory.create<jit_block> ("ifelse_cond");
14923 168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	457 }
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	458
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	459 jit_block *tail = factory.create<jit_block> ("if_tail");
14923 168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	460 if (! last_else)
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	461 entry_blocks[entry_blocks.size () - 1] = tail;
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	462
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	463 size_t num_incomming = 0; // number of incomming blocks to our tail
14923 168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	464 iter = lst.begin ();
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	465 for (size_t i = 0; iter != lst.end (); ++iter, ++i)
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	466 {
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	467 tree_if_clause tic = iter;
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	468 block = entry_blocks[i];
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	469 assert (block);
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	470
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	471 if (i) // the first block is prev_block, so it has already been added
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	472 blocks.push_back (entry_blocks[i]);
14923 168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	473
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	474 if (! tic->is_else_clause ())
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	475 {
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	476 tree_expression *expr = tic->condition ();
14944 c0a5ab3b9278 jit_const no longer inherits from jit_instruction Max Brister <max@2bass.com> parents: 14943 diff changeset	477 jit_value *cond = visit (expr);
14961 903a5ee2cdde Simplify the creation of error checks in jit Max Brister <max@2bass.com> parents: 14960 diff changeset	478 jit_call *check = create_checked (&jit_typeinfo::logically_true,
903a5ee2cdde Simplify the creation of error checks in jit Max Brister <max@2bass.com> parents: 14960 diff changeset	479 cond);
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	480 jit_block *body = factory.create<jit_block> (i == 0 ? "if_body"
a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	481 : "ifelse_body");
a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	482 blocks.push_back (body);
14923 168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	483
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	484 jit_instruction *br = factory.create<jit_cond_branch> (check, body,
14925 8697e3e9d77a Properly cleanup the low level IR Max Brister <max@2bass.com> parents: 14924 diff changeset	485 entry_blocks[i + 1]);
14923 168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	486 block->append (br);
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	487 block = body;
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	488 }
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	489
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	490 tree_statement_list *stmt_lst = tic->commands ();
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	491 assert (stmt_lst); // jwe: Can this be null?
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	492 stmt_lst->accept (*this);
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	493
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	494 if (breaking)
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	495 breaking = false;
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	496 else
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	497 {
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	498 ++num_incomming;
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	499 block->append (factory.create<jit_branch> (tail));
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	500 }
14923 168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	501 }
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	502
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	503 if (num_incomming \|\| ! last_else)
14923 168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	504 {
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	505 blocks.push_back (tail);
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	506 block = tail;
14923 168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	507 }
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	508 else
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	509 // every branch broke, so we don't have a tail
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	510 breaking = true;
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	511 }
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	512
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	513 void
14951 4c9fd3e31436 Start of jit support for double matricies Max Brister <max@2bass.com> parents: 14949 diff changeset	514 jit_convert::visit_index_expression (tree_index_expression& exp)
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	515 {
15067 df4538e3b50b ND scalar indexing in JIT. Max Brister <max@2bass.com> parents: 15056 diff changeset	516 result = resolve (jit_typeinfo::paren_subsref (), exp);
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	517 }
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	518
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	519 void
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	520 jit_convert::visit_matrix (tree_matrix&)
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	521 {
15016 005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	522 throw jit_fail_exception ();
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	523 }
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	524
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	525 void
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	526 jit_convert::visit_cell (tree_cell&)
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	527 {
15016 005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	528 throw jit_fail_exception ();
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	529 }
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	530
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	531 void
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	532 jit_convert::visit_multi_assignment (tree_multi_assignment&)
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	533 {
15016 005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	534 throw jit_fail_exception ();
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	535 }
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	536
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	537 void
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	538 jit_convert::visit_no_op_command (tree_no_op_command&)
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	539 {
15016 005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	540 throw jit_fail_exception ();
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	541 }
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	542
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	543 void
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	544 jit_convert::visit_constant (tree_constant& tc)
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	545 {
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	546 octave_value v = tc.rvalue1 ();
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	547 if (v.is_real_scalar () && v.is_double_type ())
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	548 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	549 double dv = v.double_value ();
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	550 result = factory.create<jit_const_scalar> (dv);
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	551 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	552 else if (v.is_range ())
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	553 {
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	554 Range rv = v.range_value ();
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	555 result = factory.create<jit_const_range> (rv);
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	556 }
14984 561aad6a9e4b Initial support for complex numbers in JIT Max Brister <max@2bass.com> parents: 14983 diff changeset	557 else if (v.is_complex_scalar ())
561aad6a9e4b Initial support for complex numbers in JIT Max Brister <max@2bass.com> parents: 14983 diff changeset	558 {
561aad6a9e4b Initial support for complex numbers in JIT Max Brister <max@2bass.com> parents: 14983 diff changeset	559 Complex cv = v.complex_value ();
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	560 result = factory.create<jit_const_complex> (cv);
14984 561aad6a9e4b Initial support for complex numbers in JIT Max Brister <max@2bass.com> parents: 14983 diff changeset	561 }
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	562 else
15016 005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	563 throw jit_fail_exception ("Unknown constant");
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	564 }
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	565
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	566 void
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	567 jit_convert::visit_fcn_handle (tree_fcn_handle&)
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	568 {
15016 005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	569 throw jit_fail_exception ();
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	570 }
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	571
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	572 void
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	573 jit_convert::visit_parameter_list (tree_parameter_list&)
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	574 {
15016 005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	575 throw jit_fail_exception ();
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	576 }
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	577
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	578 void
15146 709e8928e68c Scalar unary operation support in JIT Max Brister <max@2bass.com> parents: 15140 diff changeset	579 jit_convert::visit_postfix_expression (tree_postfix_expression& tpe)
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	580 {
15146 709e8928e68c Scalar unary operation support in JIT Max Brister <max@2bass.com> parents: 15140 diff changeset	581 octave_value::unary_op etype = tpe.op_type ();
709e8928e68c Scalar unary operation support in JIT Max Brister <max@2bass.com> parents: 15140 diff changeset	582 tree_expression *operand = tpe.operand ();
709e8928e68c Scalar unary operation support in JIT Max Brister <max@2bass.com> parents: 15140 diff changeset	583 jit_value *operandv = visit (operand);
709e8928e68c Scalar unary operation support in JIT Max Brister <max@2bass.com> parents: 15140 diff changeset	584
709e8928e68c Scalar unary operation support in JIT Max Brister <max@2bass.com> parents: 15140 diff changeset	585 const jit_operation& fn = jit_typeinfo::unary_op (etype);
709e8928e68c Scalar unary operation support in JIT Max Brister <max@2bass.com> parents: 15140 diff changeset	586 result = create_checked (fn, operandv);
709e8928e68c Scalar unary operation support in JIT Max Brister <max@2bass.com> parents: 15140 diff changeset	587
709e8928e68c Scalar unary operation support in JIT Max Brister <max@2bass.com> parents: 15140 diff changeset	588 if (etype == octave_value::op_incr \|\| etype == octave_value::op_decr)
709e8928e68c Scalar unary operation support in JIT Max Brister <max@2bass.com> parents: 15140 diff changeset	589 {
15148 1b2fbc30e4e7 Postfix increment and decrement operations in JIT Max Brister <max@2bass.com> parents: 15147 diff changeset	590 jit_value *ret = create_checked (&jit_typeinfo::copy, operandv);
1b2fbc30e4e7 Postfix increment and decrement operations in JIT Max Brister <max@2bass.com> parents: 15147 diff changeset	591 do_assign (operand, result);
1b2fbc30e4e7 Postfix increment and decrement operations in JIT Max Brister <max@2bass.com> parents: 15147 diff changeset	592 result = ret;
15146 709e8928e68c Scalar unary operation support in JIT Max Brister <max@2bass.com> parents: 15140 diff changeset	593 }
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	594 }
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	595
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	596 void
15146 709e8928e68c Scalar unary operation support in JIT Max Brister <max@2bass.com> parents: 15140 diff changeset	597 jit_convert::visit_prefix_expression (tree_prefix_expression& tpe)
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	598 {
15146 709e8928e68c Scalar unary operation support in JIT Max Brister <max@2bass.com> parents: 15140 diff changeset	599 octave_value::unary_op etype = tpe.op_type ();
709e8928e68c Scalar unary operation support in JIT Max Brister <max@2bass.com> parents: 15140 diff changeset	600 tree_expression *operand = tpe.operand ();
709e8928e68c Scalar unary operation support in JIT Max Brister <max@2bass.com> parents: 15140 diff changeset	601 const jit_operation& fn = jit_typeinfo::unary_op (etype);
709e8928e68c Scalar unary operation support in JIT Max Brister <max@2bass.com> parents: 15140 diff changeset	602 result = create_checked (fn, visit (operand));
709e8928e68c Scalar unary operation support in JIT Max Brister <max@2bass.com> parents: 15140 diff changeset	603
709e8928e68c Scalar unary operation support in JIT Max Brister <max@2bass.com> parents: 15140 diff changeset	604 if (etype == octave_value::op_incr \|\| etype == octave_value::op_decr)
709e8928e68c Scalar unary operation support in JIT Max Brister <max@2bass.com> parents: 15140 diff changeset	605 do_assign (operand, result);
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	606 }
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	607
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	608 void
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	609 jit_convert::visit_return_command (tree_return_command&)
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	610 {
15016 005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	611 throw jit_fail_exception ();
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	612 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	613
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	614 void
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	615 jit_convert::visit_return_list (tree_return_list&)
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	616 {
15016 005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	617 throw jit_fail_exception ();
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	618 }
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	619
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	620 void
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	621 jit_convert::visit_simple_assignment (tree_simple_assignment& tsa)
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	622 {
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	623 tree_expression *rhs = tsa.right_hand_side ();
14944 c0a5ab3b9278 jit_const no longer inherits from jit_instruction Max Brister <max@2bass.com> parents: 14943 diff changeset	624 jit_value *rhsv = visit (rhs);
15140 6ea86e1d0f5f Support +=, -=, =, ect. in JIT Max Brister <max@2bass.com>* parents: 15135 diff changeset	625 octave_value::assign_op op = tsa.op_type ();
6ea86e1d0f5f Support +=, -=, =, ect. in JIT Max Brister <max@2bass.com>* parents: 15135 diff changeset	626
6ea86e1d0f5f Support +=, -=, =, ect. in JIT Max Brister <max@2bass.com>* parents: 15135 diff changeset	627 if (op != octave_value::op_asn_eq)
6ea86e1d0f5f Support +=, -=, =, ect. in JIT Max Brister <max@2bass.com>* parents: 15135 diff changeset	628 {
6ea86e1d0f5f Support +=, -=, =, ect. in JIT Max Brister <max@2bass.com>* parents: 15135 diff changeset	629 // do the equivlent binary operation, then assign. This is always correct,
6ea86e1d0f5f Support +=, -=, =, ect. in JIT Max Brister <max@2bass.com>* parents: 15135 diff changeset	630 // but isn't always optimal.
6ea86e1d0f5f Support +=, -=, =, ect. in JIT Max Brister <max@2bass.com>* parents: 15135 diff changeset	631 tree_expression *lhs = tsa.left_hand_side ();
6ea86e1d0f5f Support +=, -=, =, ect. in JIT Max Brister <max@2bass.com>* parents: 15135 diff changeset	632 jit_value *lhsv = visit (lhs);
6ea86e1d0f5f Support +=, -=, =, ect. in JIT Max Brister <max@2bass.com>* parents: 15135 diff changeset	633 octave_value::binary_op bop = octave_value::assign_op_to_binary_op (op);
6ea86e1d0f5f Support +=, -=, =, ect. in JIT Max Brister <max@2bass.com>* parents: 15135 diff changeset	634 const jit_operation& fn = jit_typeinfo::binary_op (bop);
6ea86e1d0f5f Support +=, -=, =, ect. in JIT Max Brister <max@2bass.com>* parents: 15135 diff changeset	635 rhsv = create_checked (fn, lhsv, rhsv);
6ea86e1d0f5f Support +=, -=, =, ect. in JIT Max Brister <max@2bass.com>* parents: 15135 diff changeset	636 }
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	637
14978 f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	638 result = do_assign (tsa.left_hand_side (), rhsv);
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	639 }
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	640
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	641 void
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	642 jit_convert::visit_statement (tree_statement& stmt)
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	643 {
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	644 tree_command *cmd = stmt.command ();
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	645 tree_expression *expr = stmt.expression ();
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	646
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	647 if (cmd)
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	648 visit (cmd);
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	649 else
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	650 {
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	651 // stolen from tree_evaluator::visit_statement
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	652 bool do_bind_ans = false;
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	653
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	654 if (expr->is_identifier ())
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	655 {
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	656 tree_identifier id = dynamic_cast<tree_identifier > (expr);
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	657
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	658 do_bind_ans = (! id->is_variable ());
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	659 }
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	660 else
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	661 do_bind_ans = (! expr->is_assignment_expression ());
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	662
14944 c0a5ab3b9278 jit_const no longer inherits from jit_instruction Max Brister <max@2bass.com> parents: 14943 diff changeset	663 jit_value *expr_result = visit (expr);
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	664
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	665 if (do_bind_ans)
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	666 do_assign ("ans", expr_result, expr->print_result ());
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	667 else if (expr->is_identifier () && expr->print_result ())
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	668 {
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	669 // FIXME: ugly hack, we need to come up with a way to pass
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	670 // nargout to visit_identifier
14983 a5f75de0dab1 Rename jit_function to jit_operation Max Brister <max@2bass.com> parents: 14978 diff changeset	671 const jit_operation& fn = jit_typeinfo::print_value ();
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	672 jit_const_string *name = factory.create<jit_const_string> (expr->name ());
a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	673 block->append (factory.create<jit_call> (fn, name, expr_result));
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	674 }
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	675 }
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	676 }
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	677
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	678 void
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	679 jit_convert::visit_statement_list (tree_statement_list& lst)
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	680 {
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	681 for (tree_statement_list::iterator iter = lst.begin (); iter != lst.end();
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	682 ++iter)
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	683 {
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	684 tree_statement elt = iter;
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	685 // jwe: Can this ever be null?
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	686 assert (elt);
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	687 elt->accept (*this);
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	688
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	689 if (breaking)
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	690 break;
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	691 }
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	692 }
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	693
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	694 void
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	695 jit_convert::visit_switch_case (tree_switch_case&)
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	696 {
15016 005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	697 throw jit_fail_exception ();
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	698 }
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	699
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	700 void
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	701 jit_convert::visit_switch_case_list (tree_switch_case_list&)
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	702 {
15016 005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	703 throw jit_fail_exception ();
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	704 }
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	705
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	706 void
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	707 jit_convert::visit_switch_command (tree_switch_command&)
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	708 {
15016 005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	709 throw jit_fail_exception ();
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	710 }
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	711
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	712 void
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	713 jit_convert::visit_try_catch_command (tree_try_catch_command&)
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	714 {
15016 005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	715 throw jit_fail_exception ();
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	716 }
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	717
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	718 void
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	719 jit_convert::visit_unwind_protect_command (tree_unwind_protect_command&)
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	720 {
15016 005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	721 throw jit_fail_exception ();
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	722 }
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	723
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	724 void
14989 dfaa8da46364 Support while loops in JIT Max Brister <max@2bass.com> parents: 14988 diff changeset	725 jit_convert::visit_while_command (tree_while_command& wc)
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	726 {
14989 dfaa8da46364 Support while loops in JIT Max Brister <max@2bass.com> parents: 14988 diff changeset	727 assert (! breaking);
dfaa8da46364 Support while loops in JIT Max Brister <max@2bass.com> parents: 14988 diff changeset	728 unwind_protect prot;
dfaa8da46364 Support while loops in JIT Max Brister <max@2bass.com> parents: 14988 diff changeset	729 prot.protect_var (breaks);
dfaa8da46364 Support while loops in JIT Max Brister <max@2bass.com> parents: 14988 diff changeset	730 prot.protect_var (continues);
dfaa8da46364 Support while loops in JIT Max Brister <max@2bass.com> parents: 14988 diff changeset	731 prot.protect_var (breaking);
dfaa8da46364 Support while loops in JIT Max Brister <max@2bass.com> parents: 14988 diff changeset	732 breaks.clear ();
dfaa8da46364 Support while loops in JIT Max Brister <max@2bass.com> parents: 14988 diff changeset	733 continues.clear ();
dfaa8da46364 Support while loops in JIT Max Brister <max@2bass.com> parents: 14988 diff changeset	734
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	735 jit_block *cond_check = factory.create<jit_block> ("while_cond_check");
a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	736 block->append (factory.create<jit_branch> (cond_check));
a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	737 blocks.push_back (cond_check);
14989 dfaa8da46364 Support while loops in JIT Max Brister <max@2bass.com> parents: 14988 diff changeset	738 block = cond_check;
dfaa8da46364 Support while loops in JIT Max Brister <max@2bass.com> parents: 14988 diff changeset	739
dfaa8da46364 Support while loops in JIT Max Brister <max@2bass.com> parents: 14988 diff changeset	740 tree_expression *expr = wc.condition ();
dfaa8da46364 Support while loops in JIT Max Brister <max@2bass.com> parents: 14988 diff changeset	741 assert (expr && "While expression can not be null");
dfaa8da46364 Support while loops in JIT Max Brister <max@2bass.com> parents: 14988 diff changeset	742 jit_value *check = visit (expr);
dfaa8da46364 Support while loops in JIT Max Brister <max@2bass.com> parents: 14988 diff changeset	743 check = create_checked (&jit_typeinfo::logically_true, check);
dfaa8da46364 Support while loops in JIT Max Brister <max@2bass.com> parents: 14988 diff changeset	744
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	745 jit_block *body = factory.create<jit_block> ("while_body");
a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	746 blocks.push_back (body);
14989 dfaa8da46364 Support while loops in JIT Max Brister <max@2bass.com> parents: 14988 diff changeset	747
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	748 jit_block *tail = factory.create<jit_block> ("while_tail");
a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	749 block->append (factory.create<jit_cond_branch> (check, body, tail));
14989 dfaa8da46364 Support while loops in JIT Max Brister <max@2bass.com> parents: 14988 diff changeset	750 block = body;
dfaa8da46364 Support while loops in JIT Max Brister <max@2bass.com> parents: 14988 diff changeset	751
dfaa8da46364 Support while loops in JIT Max Brister <max@2bass.com> parents: 14988 diff changeset	752 tree_statement_list *loop_body = wc.body ();
dfaa8da46364 Support while loops in JIT Max Brister <max@2bass.com> parents: 14988 diff changeset	753 if (loop_body)
dfaa8da46364 Support while loops in JIT Max Brister <max@2bass.com> parents: 14988 diff changeset	754 loop_body->accept (*this);
dfaa8da46364 Support while loops in JIT Max Brister <max@2bass.com> parents: 14988 diff changeset	755
dfaa8da46364 Support while loops in JIT Max Brister <max@2bass.com> parents: 14988 diff changeset	756 finish_breaks (tail, breaks);
dfaa8da46364 Support while loops in JIT Max Brister <max@2bass.com> parents: 14988 diff changeset	757 finish_breaks (cond_check, continues);
dfaa8da46364 Support while loops in JIT Max Brister <max@2bass.com> parents: 14988 diff changeset	758
dfaa8da46364 Support while loops in JIT Max Brister <max@2bass.com> parents: 14988 diff changeset	759 if (! breaking)
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	760 block->append (factory.create<jit_branch> (cond_check));
14989 dfaa8da46364 Support while loops in JIT Max Brister <max@2bass.com> parents: 14988 diff changeset	761
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	762 blocks.push_back (tail);
14989 dfaa8da46364 Support while loops in JIT Max Brister <max@2bass.com> parents: 14988 diff changeset	763 block = tail;
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	764 }
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	765
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	766 void
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	767 jit_convert::visit_do_until_command (tree_do_until_command&)
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	768 {
15016 005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	769 throw jit_fail_exception ();
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	770 }
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	771
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	772 jit_call *
a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	773 jit_convert::create_checked_impl (jit_call *ret)
14963 709f50069722 Change algorithm for placing releases and simplify PHIs in low level Octave IR Max Brister <max@2bass.com> parents: 14962 diff changeset	774 {
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	775 block->append (ret);
14963 709f50069722 Change algorithm for placing releases and simplify PHIs in low level Octave IR Max Brister <max@2bass.com> parents: 14962 diff changeset	776
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	777 jit_block *normal = factory.create<jit_block> (block->name ());
a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	778 jit_error_check *check = factory.create<jit_error_check> (ret, normal,
a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	779 final_block);
a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	780 block->append (check);
a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	781 blocks.push_back (normal);
a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	782 block = normal;
a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	783
a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	784 return ret;
14963 709f50069722 Change algorithm for placing releases and simplify PHIs in low level Octave IR Max Brister <max@2bass.com> parents: 14962 diff changeset	785 }
709f50069722 Change algorithm for placing releases and simplify PHIs in low level Octave IR Max Brister <max@2bass.com> parents: 14962 diff changeset	786
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	787 jit_variable *
15027 741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	788 jit_convert::find_variable (const std::string& vname) const
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	789 {
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	790 vmap_t::const_iterator iter;
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	791 iter = vmap.find (vname);
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	792 return iter != vmap.end () ? iter->second : 0;
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	793 }
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	794
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	795 jit_variable *
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	796 jit_convert::get_variable (const std::string& vname)
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	797 {
15027 741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	798 jit_variable *ret = find_variable (vname);
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	799 if (ret)
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	800 return ret;
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	801
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	802 octave_value val = symbol_table::find (vname);
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	803 jit_type *type = jit_typeinfo::type_of (val);
15027 741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	804 return create_variable (vname, type);
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	805 }
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	806
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	807 jit_variable *
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	808 jit_convert::create_variable (const std::string& vname, jit_type *type)
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	809 {
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	810 jit_variable *var = factory.create<jit_variable> (vname);
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	811 jit_extract_argument *extract;
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	812 extract = factory.create<jit_extract_argument> (type, var);
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	813 entry_block->prepend (extract);
15027 741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	814 return vmap[vname] = var;
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	815 }
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	816
15027 741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	817 std::string
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	818 jit_convert::next_name (const char *prefix, size_t& count, bool inc)
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	819 {
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	820 std::stringstream ss;
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	821 ss << prefix << count;
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	822 if (inc)
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	823 ++count;
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	824 return ss.str ();
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	825 }
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	826
15067 df4538e3b50b ND scalar indexing in JIT. Max Brister <max@2bass.com> parents: 15056 diff changeset	827 jit_instruction *
15068 f57d7578c1a6 Support ND matrix indexing with scalar assignment in JIT. Max Brister <max@2bass.com> parents: 15067 diff changeset	828 jit_convert::resolve (const jit_operation& fres, tree_index_expression& exp,
f57d7578c1a6 Support ND matrix indexing with scalar assignment in JIT. Max Brister <max@2bass.com> parents: 15067 diff changeset	829 jit_value *extra_arg)
14969 bbeef7b8ea2e Add support for matrix indexed assignment to JIT Max Brister <max@2bass.com> parents: 14968 diff changeset	830 {
bbeef7b8ea2e Add support for matrix indexed assignment to JIT Max Brister <max@2bass.com> parents: 14968 diff changeset	831 std::string type = exp.type_tags ();
bbeef7b8ea2e Add support for matrix indexed assignment to JIT Max Brister <max@2bass.com> parents: 14968 diff changeset	832 if (! (type.size () == 1 && type[0] == '('))
15016 005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	833 throw jit_fail_exception ("Unsupported index operation");
14969 bbeef7b8ea2e Add support for matrix indexed assignment to JIT Max Brister <max@2bass.com> parents: 14968 diff changeset	834
bbeef7b8ea2e Add support for matrix indexed assignment to JIT Max Brister <max@2bass.com> parents: 14968 diff changeset	835 std::list<tree_argument_list *> args = exp.arg_lists ();
bbeef7b8ea2e Add support for matrix indexed assignment to JIT Max Brister <max@2bass.com> parents: 14968 diff changeset	836 if (args.size () != 1)
15016 005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	837 throw jit_fail_exception ("Bad number of arguments in tree_index_expression");
14969 bbeef7b8ea2e Add support for matrix indexed assignment to JIT Max Brister <max@2bass.com> parents: 14968 diff changeset	838
bbeef7b8ea2e Add support for matrix indexed assignment to JIT Max Brister <max@2bass.com> parents: 14968 diff changeset	839 tree_argument_list *arg_list = args.front ();
bbeef7b8ea2e Add support for matrix indexed assignment to JIT Max Brister <max@2bass.com> parents: 14968 diff changeset	840 if (! arg_list)
15016 005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	841 throw jit_fail_exception ("null argument list");
14969 bbeef7b8ea2e Add support for matrix indexed assignment to JIT Max Brister <max@2bass.com> parents: 14968 diff changeset	842
15067 df4538e3b50b ND scalar indexing in JIT. Max Brister <max@2bass.com> parents: 15056 diff changeset	843 if (arg_list->size () < 1)
df4538e3b50b ND scalar indexing in JIT. Max Brister <max@2bass.com> parents: 15056 diff changeset	844 throw jit_fail_exception ("Empty arg_list");
14969 bbeef7b8ea2e Add support for matrix indexed assignment to JIT Max Brister <max@2bass.com> parents: 14968 diff changeset	845
bbeef7b8ea2e Add support for matrix indexed assignment to JIT Max Brister <max@2bass.com> parents: 14968 diff changeset	846 tree_expression *tree_object = exp.expression ();
bbeef7b8ea2e Add support for matrix indexed assignment to JIT Max Brister <max@2bass.com> parents: 14968 diff changeset	847 jit_value *object = visit (tree_object);
15056 bc32288f4a42 Support the end keyword for one dimentional indexing in JIT. Max Brister <max@2bass.com> parents: 15030 diff changeset	848
15067 df4538e3b50b ND scalar indexing in JIT. Max Brister <max@2bass.com> parents: 15056 diff changeset	849 size_t narg = arg_list->size ();
df4538e3b50b ND scalar indexing in JIT. Max Brister <max@2bass.com> parents: 15056 diff changeset	850 tree_argument_list::iterator iter = arg_list->begin ();
15068 f57d7578c1a6 Support ND matrix indexing with scalar assignment in JIT. Max Brister <max@2bass.com> parents: 15067 diff changeset	851 bool have_extra = extra_arg;
f57d7578c1a6 Support ND matrix indexing with scalar assignment in JIT. Max Brister <max@2bass.com> parents: 15067 diff changeset	852 std::vector<jit_value *> call_args (narg + 1 + have_extra);
15067 df4538e3b50b ND scalar indexing in JIT. Max Brister <max@2bass.com> parents: 15056 diff changeset	853 call_args[0] = object;
15056 bc32288f4a42 Support the end keyword for one dimentional indexing in JIT. Max Brister <max@2bass.com> parents: 15030 diff changeset	854
15067 df4538e3b50b ND scalar indexing in JIT. Max Brister <max@2bass.com> parents: 15056 diff changeset	855 for (size_t idx = 0; iter != arg_list->end (); ++idx, ++iter)
df4538e3b50b ND scalar indexing in JIT. Max Brister <max@2bass.com> parents: 15056 diff changeset	856 {
df4538e3b50b ND scalar indexing in JIT. Max Brister <max@2bass.com> parents: 15056 diff changeset	857 unwind_protect prot;
df4538e3b50b ND scalar indexing in JIT. Max Brister <max@2bass.com> parents: 15056 diff changeset	858 prot.add_method (&end_context,
df4538e3b50b ND scalar indexing in JIT. Max Brister <max@2bass.com> parents: 15056 diff changeset	859 &std::vector<jit_magic_end::context>::pop_back);
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	860
a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	861 jit_magic_end::context ctx (factory, object, idx, narg);
a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	862 end_context.push_back (ctx);
15067 df4538e3b50b ND scalar indexing in JIT. Max Brister <max@2bass.com> parents: 15056 diff changeset	863 call_args[idx + 1] = visit (*iter);
df4538e3b50b ND scalar indexing in JIT. Max Brister <max@2bass.com> parents: 15056 diff changeset	864 }
14969 bbeef7b8ea2e Add support for matrix indexed assignment to JIT Max Brister <max@2bass.com> parents: 14968 diff changeset	865
15068 f57d7578c1a6 Support ND matrix indexing with scalar assignment in JIT. Max Brister <max@2bass.com> parents: 15067 diff changeset	866 if (extra_arg)
f57d7578c1a6 Support ND matrix indexing with scalar assignment in JIT. Max Brister <max@2bass.com> parents: 15067 diff changeset	867 call_args[call_args.size () - 1] = extra_arg;
f57d7578c1a6 Support ND matrix indexing with scalar assignment in JIT. Max Brister <max@2bass.com> parents: 15067 diff changeset	868
15067 df4538e3b50b ND scalar indexing in JIT. Max Brister <max@2bass.com> parents: 15056 diff changeset	869 return create_checked (fres, call_args);
14969 bbeef7b8ea2e Add support for matrix indexed assignment to JIT Max Brister <max@2bass.com> parents: 14968 diff changeset	870 }
bbeef7b8ea2e Add support for matrix indexed assignment to JIT Max Brister <max@2bass.com> parents: 14968 diff changeset	871
bbeef7b8ea2e Add support for matrix indexed assignment to JIT Max Brister <max@2bass.com> parents: 14968 diff changeset	872 jit_value *
bbeef7b8ea2e Add support for matrix indexed assignment to JIT Max Brister <max@2bass.com> parents: 14968 diff changeset	873 jit_convert::do_assign (tree_expression exp, jit_value rhs, bool artificial)
bbeef7b8ea2e Add support for matrix indexed assignment to JIT Max Brister <max@2bass.com> parents: 14968 diff changeset	874 {
bbeef7b8ea2e Add support for matrix indexed assignment to JIT Max Brister <max@2bass.com> parents: 14968 diff changeset	875 if (! exp)
15016 005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	876 throw jit_fail_exception ("NULL lhs in assign");
14969 bbeef7b8ea2e Add support for matrix indexed assignment to JIT Max Brister <max@2bass.com> parents: 14968 diff changeset	877
bbeef7b8ea2e Add support for matrix indexed assignment to JIT Max Brister <max@2bass.com> parents: 14968 diff changeset	878 if (isa<tree_identifier> (exp))
bbeef7b8ea2e Add support for matrix indexed assignment to JIT Max Brister <max@2bass.com> parents: 14968 diff changeset	879 return do_assign (exp->name (), rhs, exp->print_result (), artificial);
bbeef7b8ea2e Add support for matrix indexed assignment to JIT Max Brister <max@2bass.com> parents: 14968 diff changeset	880 else if (tree_index_expression *idx
bbeef7b8ea2e Add support for matrix indexed assignment to JIT Max Brister <max@2bass.com> parents: 14968 diff changeset	881 = dynamic_cast<tree_index_expression *> (exp))
bbeef7b8ea2e Add support for matrix indexed assignment to JIT Max Brister <max@2bass.com> parents: 14968 diff changeset	882 {
15068 f57d7578c1a6 Support ND matrix indexing with scalar assignment in JIT. Max Brister <max@2bass.com> parents: 15067 diff changeset	883 jit_value new_object = resolve (jit_typeinfo::paren_subsasgn (), idx,
f57d7578c1a6 Support ND matrix indexing with scalar assignment in JIT. Max Brister <max@2bass.com> parents: 15067 diff changeset	884 rhs);
14969 bbeef7b8ea2e Add support for matrix indexed assignment to JIT Max Brister <max@2bass.com> parents: 14968 diff changeset	885 do_assign (idx->expression (), new_object, true);
bbeef7b8ea2e Add support for matrix indexed assignment to JIT Max Brister <max@2bass.com> parents: 14968 diff changeset	886
bbeef7b8ea2e Add support for matrix indexed assignment to JIT Max Brister <max@2bass.com> parents: 14968 diff changeset	887 // FIXME: Will not work for values that must be release/grabed
bbeef7b8ea2e Add support for matrix indexed assignment to JIT Max Brister <max@2bass.com> parents: 14968 diff changeset	888 return rhs;
bbeef7b8ea2e Add support for matrix indexed assignment to JIT Max Brister <max@2bass.com> parents: 14968 diff changeset	889 }
bbeef7b8ea2e Add support for matrix indexed assignment to JIT Max Brister <max@2bass.com> parents: 14968 diff changeset	890 else
15016 005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	891 throw jit_fail_exception ("Unsupported assignment");
14969 bbeef7b8ea2e Add support for matrix indexed assignment to JIT Max Brister <max@2bass.com> parents: 14968 diff changeset	892 }
bbeef7b8ea2e Add support for matrix indexed assignment to JIT Max Brister <max@2bass.com> parents: 14968 diff changeset	893
14944 c0a5ab3b9278 jit_const no longer inherits from jit_instruction Max Brister <max@2bass.com> parents: 14943 diff changeset	894 jit_value *
c0a5ab3b9278 jit_const no longer inherits from jit_instruction Max Brister <max@2bass.com> parents: 14943 diff changeset	895 jit_convert::do_assign (const std::string& lhs, jit_value *rhs,
14969 bbeef7b8ea2e Add support for matrix indexed assignment to JIT Max Brister <max@2bass.com> parents: 14968 diff changeset	896 bool print, bool artificial)
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	897 {
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	898 jit_variable *var = get_variable (lhs);
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	899 jit_assign *assign = block->append (factory.create<jit_assign> (var, rhs));
14969 bbeef7b8ea2e Add support for matrix indexed assignment to JIT Max Brister <max@2bass.com> parents: 14968 diff changeset	900
bbeef7b8ea2e Add support for matrix indexed assignment to JIT Max Brister <max@2bass.com> parents: 14968 diff changeset	901 if (artificial)
bbeef7b8ea2e Add support for matrix indexed assignment to JIT Max Brister <max@2bass.com> parents: 14968 diff changeset	902 assign->mark_artificial ();
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	903
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	904 if (print)
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	905 {
14983 a5f75de0dab1 Rename jit_function to jit_operation Max Brister <max@2bass.com> parents: 14978 diff changeset	906 const jit_operation& print_fn = jit_typeinfo::print_value ();
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	907 jit_const_string *name = factory.create<jit_const_string> (lhs);
a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	908 block->append (factory.create<jit_call> (print_fn, name, var));
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	909 }
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	910
14944 c0a5ab3b9278 jit_const no longer inherits from jit_instruction Max Brister <max@2bass.com> parents: 14943 diff changeset	911 return var;
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	912 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	913
14944 c0a5ab3b9278 jit_const no longer inherits from jit_instruction Max Brister <max@2bass.com> parents: 14943 diff changeset	914 jit_value *
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	915 jit_convert::visit (tree& tee)
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	916 {
15146 709e8928e68c Scalar unary operation support in JIT Max Brister <max@2bass.com> parents: 15140 diff changeset	917 unwind_protect prot;
709e8928e68c Scalar unary operation support in JIT Max Brister <max@2bass.com> parents: 15140 diff changeset	918 prot.protect_var (result);
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	919
15146 709e8928e68c Scalar unary operation support in JIT Max Brister <max@2bass.com> parents: 15140 diff changeset	920 tee.accept (*this);
709e8928e68c Scalar unary operation support in JIT Max Brister <max@2bass.com> parents: 15140 diff changeset	921 return result;
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	922 }
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	923
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	924 void
14945 591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	925 jit_convert::append_users_term (jit_terminator *term)
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	926 {
14948 006570a76b90 Cleanup and optimization of JIT Max Brister <max@2bass.com> parents: 14946 diff changeset	927 for (size_t i = 0; i < term->successor_count (); ++i)
14945 591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	928 {
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	929 if (term->alive (i))
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	930 {
14948 006570a76b90 Cleanup and optimization of JIT Max Brister <max@2bass.com> parents: 14946 diff changeset	931 jit_block *succ = term->successor (i);
14945 591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	932 for (jit_block::iterator iter = succ->begin (); iter != succ->end ()
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	933 && isa<jit_phi> (*iter); ++iter)
14946 3564bb141396 Only add items to worklist in type inferece if not already there Max Brister <max@2bass.com> parents: 14945 diff changeset	934 push_worklist (*iter);
3564bb141396 Only add items to worklist in type inferece if not already there Max Brister <max@2bass.com> parents: 14945 diff changeset	935
3564bb141396 Only add items to worklist in type inferece if not already there Max Brister <max@2bass.com> parents: 14945 diff changeset	936 jit_terminator *sterm = succ->terminator ();
3564bb141396 Only add items to worklist in type inferece if not already there Max Brister <max@2bass.com> parents: 14945 diff changeset	937 if (sterm)
3564bb141396 Only add items to worklist in type inferece if not already there Max Brister <max@2bass.com> parents: 14945 diff changeset	938 push_worklist (sterm);
14945 591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	939 }
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	940 }
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	941 }
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	942
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	943 void
14938 bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	944 jit_convert::construct_ssa (void)
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	945 {
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	946 final_block->label ();
14939 4488022820c9 No longer segfault when compiling nested for loops Max Brister <max@2bass.com> parents: 14938 diff changeset	947 final_block->compute_idom (entry_block);
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	948 entry_block->compute_df ();
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	949 entry_block->create_dom_tree ();
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	950
14935 5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	951 // insert phi nodes where needed, this is done on a per variable basis
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	952 for (vmap_t::iterator iter = vmap.begin (); iter != vmap.end (); ++iter)
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	953 {
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	954 jit_block::df_set visited, added_phi;
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	955 std::list<jit_block *> ssa_worklist;
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	956 iter->second->use_blocks (visited);
14959 12fd4a62d633 Fix whitespace issues and update documentation Max Brister <max@2bass.com> parents: 14958 diff changeset	957 ssa_worklist.insert (ssa_worklist.begin (), visited.begin (),
12fd4a62d633 Fix whitespace issues and update documentation Max Brister <max@2bass.com> parents: 14958 diff changeset	958 visited.end ());
14923 168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	959
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	960 while (ssa_worklist.size ())
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	961 {
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	962 jit_block *b = ssa_worklist.front ();
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	963 ssa_worklist.pop_front ();
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	964
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	965 for (jit_block::df_iterator diter = b->df_begin ();
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	966 diter != b->df_end (); ++diter)
14923 168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	967 {
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	968 jit_block dblock = diter;
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	969 if (! added_phi.count (dblock))
14925 8697e3e9d77a Properly cleanup the low level IR Max Brister <max@2bass.com> parents: 14924 diff changeset	970 {
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	971 jit_phi *phi = factory.create<jit_phi> (iter->second,
14948 006570a76b90 Cleanup and optimization of JIT Max Brister <max@2bass.com> parents: 14946 diff changeset	972 dblock->use_count ());
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	973 dblock->prepend (phi);
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	974 added_phi.insert (dblock);
14925 8697e3e9d77a Properly cleanup the low level IR Max Brister <max@2bass.com> parents: 14924 diff changeset	975 }
8697e3e9d77a Properly cleanup the low level IR Max Brister <max@2bass.com> parents: 14924 diff changeset	976
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	977 if (! visited.count (dblock))
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	978 {
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	979 ssa_worklist.push_back (dblock);
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	980 visited.insert (dblock);
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	981 }
14923 168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	982 }
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	983 }
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	984 }
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	985
14971 b23a98ca0e43 Remove jit_block::visit_dom and simplify release placement Max Brister <max@2bass.com> parents: 14969 diff changeset	986 do_construct_ssa (*entry_block, entry_block->visit_count ());
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	987 }
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	988
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	989 void
14971 b23a98ca0e43 Remove jit_block::visit_dom and simplify release placement Max Brister <max@2bass.com> parents: 14969 diff changeset	990 jit_convert::do_construct_ssa (jit_block& ablock, size_t avisit_count)
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	991 {
14971 b23a98ca0e43 Remove jit_block::visit_dom and simplify release placement Max Brister <max@2bass.com> parents: 14969 diff changeset	992 if (ablock.visited (avisit_count))
b23a98ca0e43 Remove jit_block::visit_dom and simplify release placement Max Brister <max@2bass.com> parents: 14969 diff changeset	993 return;
b23a98ca0e43 Remove jit_block::visit_dom and simplify release placement Max Brister <max@2bass.com> parents: 14969 diff changeset	994
14935 5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	995 // replace variables with their current SSA value
14971 b23a98ca0e43 Remove jit_block::visit_dom and simplify release placement Max Brister <max@2bass.com> parents: 14969 diff changeset	996 for (jit_block::iterator iter = ablock.begin (); iter != ablock.end (); ++iter)
14935 5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	997 {
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	998 jit_instruction instr = iter;
14962 90a7a2af2cd5 Keep track of variables after SSA construction Max Brister <max@2bass.com> parents: 14961 diff changeset	999 instr->construct_ssa ();
14935 5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1000 instr->push_variable ();
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1001 }
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1002
14948 006570a76b90 Cleanup and optimization of JIT Max Brister <max@2bass.com> parents: 14946 diff changeset	1003 // finish phi nodes of successors
14971 b23a98ca0e43 Remove jit_block::visit_dom and simplify release placement Max Brister <max@2bass.com> parents: 14969 diff changeset	1004 for (size_t i = 0; i < ablock.successor_count (); ++i)
14935 5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1005 {
14971 b23a98ca0e43 Remove jit_block::visit_dom and simplify release placement Max Brister <max@2bass.com> parents: 14969 diff changeset	1006 jit_block *finish = ablock.successor (i);
14935 5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1007
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1008 for (jit_block::iterator iter = finish->begin (); iter != finish->end ()
14938 bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1009 && isa<jit_phi> (*iter);)
14935 5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1010 {
14948 006570a76b90 Cleanup and optimization of JIT Max Brister <max@2bass.com> parents: 14946 diff changeset	1011 jit_phi phi = static_cast<jit_phi > (*iter);
14938 bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1012 jit_variable *var = phi->dest ();
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1013 if (var->has_top ())
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1014 {
14971 b23a98ca0e43 Remove jit_block::visit_dom and simplify release placement Max Brister <max@2bass.com> parents: 14969 diff changeset	1015 phi->add_incomming (&ablock, var->top ());
14938 bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1016 ++iter;
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1017 }
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1018 else
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1019 {
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1020 // temporaries may have extranious phi nodes which can be removed
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1021 assert (! phi->use_count ());
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1022 assert (var->name ().size () && var->name ()[0] == '#');
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1023 iter = finish->remove (iter);
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1024 }
14935 5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1025 }
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1026 }
14971 b23a98ca0e43 Remove jit_block::visit_dom and simplify release placement Max Brister <max@2bass.com> parents: 14969 diff changeset	1027
b23a98ca0e43 Remove jit_block::visit_dom and simplify release placement Max Brister <max@2bass.com> parents: 14969 diff changeset	1028 for (size_t i = 0; i < ablock.dom_successor_count (); ++i)
b23a98ca0e43 Remove jit_block::visit_dom and simplify release placement Max Brister <max@2bass.com> parents: 14969 diff changeset	1029 do_construct_ssa (*ablock.dom_successor (i), avisit_count);
b23a98ca0e43 Remove jit_block::visit_dom and simplify release placement Max Brister <max@2bass.com> parents: 14969 diff changeset	1030
b23a98ca0e43 Remove jit_block::visit_dom and simplify release placement Max Brister <max@2bass.com> parents: 14969 diff changeset	1031 ablock.pop_all ();
14935 5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1032 }
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1033
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1034 void
14945 591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1035 jit_convert::remove_dead ()
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1036 {
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1037 block_list::iterator biter;
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1038 for (biter = blocks.begin (); biter != blocks.end (); ++biter)
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1039 {
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1040 jit_block b = biter;
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1041 if (b->alive ())
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1042 {
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1043 for (jit_block::iterator iter = b->begin (); iter != b->end ()
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1044 && isa<jit_phi> (*iter);)
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1045 {
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1046 jit_phi phi = static_cast<jit_phi > (*iter);
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1047 if (phi->prune ())
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1048 iter = b->remove (iter);
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1049 else
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1050 ++iter;
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1051 }
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1052 }
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1053 }
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1054
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1055 for (biter = blocks.begin (); biter != blocks.end ();)
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1056 {
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1057 jit_block b = biter;
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1058 if (b->alive ())
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1059 {
14960 c959136f8c3e Rename jit_check_error to jit_error_check Max Brister <max@2bass.com> parents: 14959 diff changeset	1060 // FIXME: A special case for jit_error_check, if we generalize to
14945 591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1061 // we will need to change!
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1062 jit_terminator *term = b->terminator ();
14948 006570a76b90 Cleanup and optimization of JIT Max Brister <max@2bass.com> parents: 14946 diff changeset	1063 if (term && term->successor_count () == 2 && ! term->alive (0))
14945 591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1064 {
14948 006570a76b90 Cleanup and optimization of JIT Max Brister <max@2bass.com> parents: 14946 diff changeset	1065 jit_block *succ = term->successor (1);
14945 591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1066 term->remove ();
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	1067 jit_branch *abreak = factory.create<jit_branch> (succ);
a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	1068 b->append (abreak);
14945 591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1069 abreak->infer ();
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1070 }
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1071
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1072 ++biter;
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1073 }
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1074 else
14948 006570a76b90 Cleanup and optimization of JIT Max Brister <max@2bass.com> parents: 14946 diff changeset	1075 {
006570a76b90 Cleanup and optimization of JIT Max Brister <max@2bass.com> parents: 14946 diff changeset	1076 jit_terminator *term = b->terminator ();
006570a76b90 Cleanup and optimization of JIT Max Brister <max@2bass.com> parents: 14946 diff changeset	1077 if (term)
006570a76b90 Cleanup and optimization of JIT Max Brister <max@2bass.com> parents: 14946 diff changeset	1078 term->remove ();
006570a76b90 Cleanup and optimization of JIT Max Brister <max@2bass.com> parents: 14946 diff changeset	1079 biter = blocks.erase (biter);
006570a76b90 Cleanup and optimization of JIT Max Brister <max@2bass.com> parents: 14946 diff changeset	1080 }
14945 591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1081 }
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1082 }
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1083
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1084 void
14935 5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1085 jit_convert::place_releases (void)
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1086 {
14971 b23a98ca0e43 Remove jit_block::visit_dom and simplify release placement Max Brister <max@2bass.com> parents: 14969 diff changeset	1087 std::set<jit_value *> temporaries;
14966 b7b647bc4b90 Place releases for temporaries on error Max Brister <max@2bass.com> parents: 14965 diff changeset	1088 for (block_list::iterator iter = blocks.begin (); iter != blocks.end ();
b7b647bc4b90 Place releases for temporaries on error Max Brister <max@2bass.com> parents: 14965 diff changeset	1089 ++iter)
b7b647bc4b90 Place releases for temporaries on error Max Brister <max@2bass.com> parents: 14965 diff changeset	1090 {
b7b647bc4b90 Place releases for temporaries on error Max Brister <max@2bass.com> parents: 14965 diff changeset	1091 jit_block& ablock = **iter;
b7b647bc4b90 Place releases for temporaries on error Max Brister <max@2bass.com> parents: 14965 diff changeset	1092 if (ablock.id () != jit_block::NO_ID)
b7b647bc4b90 Place releases for temporaries on error Max Brister <max@2bass.com> parents: 14965 diff changeset	1093 {
14971 b23a98ca0e43 Remove jit_block::visit_dom and simplify release placement Max Brister <max@2bass.com> parents: 14969 diff changeset	1094 release_temp (ablock, temporaries);
14966 b7b647bc4b90 Place releases for temporaries on error Max Brister <max@2bass.com> parents: 14965 diff changeset	1095 release_dead_phi (ablock);
b7b647bc4b90 Place releases for temporaries on error Max Brister <max@2bass.com> parents: 14965 diff changeset	1096 }
b7b647bc4b90 Place releases for temporaries on error Max Brister <max@2bass.com> parents: 14965 diff changeset	1097 }
b7b647bc4b90 Place releases for temporaries on error Max Brister <max@2bass.com> parents: 14965 diff changeset	1098 }
b7b647bc4b90 Place releases for temporaries on error Max Brister <max@2bass.com> parents: 14965 diff changeset	1099
b7b647bc4b90 Place releases for temporaries on error Max Brister <max@2bass.com> parents: 14965 diff changeset	1100 void
14971 b23a98ca0e43 Remove jit_block::visit_dom and simplify release placement Max Brister <max@2bass.com> parents: 14969 diff changeset	1101 jit_convert::release_temp (jit_block& ablock, std::set<jit_value *>& temp)
14966 b7b647bc4b90 Place releases for temporaries on error Max Brister <max@2bass.com> parents: 14965 diff changeset	1102 {
14971 b23a98ca0e43 Remove jit_block::visit_dom and simplify release placement Max Brister <max@2bass.com> parents: 14969 diff changeset	1103 for (jit_block::iterator iter = ablock.begin (); iter != ablock.end ();
14966 b7b647bc4b90 Place releases for temporaries on error Max Brister <max@2bass.com> parents: 14965 diff changeset	1104 ++iter)
b7b647bc4b90 Place releases for temporaries on error Max Brister <max@2bass.com> parents: 14965 diff changeset	1105 {
b7b647bc4b90 Place releases for temporaries on error Max Brister <max@2bass.com> parents: 14965 diff changeset	1106 jit_instruction instr = iter;
14971 b23a98ca0e43 Remove jit_block::visit_dom and simplify release placement Max Brister <max@2bass.com> parents: 14969 diff changeset	1107
b23a98ca0e43 Remove jit_block::visit_dom and simplify release placement Max Brister <max@2bass.com> parents: 14969 diff changeset	1108 // check for temporaries that require release and live across
b23a98ca0e43 Remove jit_block::visit_dom and simplify release placement Max Brister <max@2bass.com> parents: 14969 diff changeset	1109 // multiple blocks
b23a98ca0e43 Remove jit_block::visit_dom and simplify release placement Max Brister <max@2bass.com> parents: 14969 diff changeset	1110 if (instr->needs_release ())
b23a98ca0e43 Remove jit_block::visit_dom and simplify release placement Max Brister <max@2bass.com> parents: 14969 diff changeset	1111 {
b23a98ca0e43 Remove jit_block::visit_dom and simplify release placement Max Brister <max@2bass.com> parents: 14969 diff changeset	1112 jit_block *fu_block = instr->first_use_block ();
15147 98a65d9e426f Remove uneeded release overloads Max Brister <max@2bass.com> parents: 15146 diff changeset	1113 if (fu_block && fu_block != &ablock && instr->needs_release ())
14971 b23a98ca0e43 Remove jit_block::visit_dom and simplify release placement Max Brister <max@2bass.com> parents: 14969 diff changeset	1114 temp.insert (instr);
b23a98ca0e43 Remove jit_block::visit_dom and simplify release placement Max Brister <max@2bass.com> parents: 14969 diff changeset	1115 }
b23a98ca0e43 Remove jit_block::visit_dom and simplify release placement Max Brister <max@2bass.com> parents: 14969 diff changeset	1116
b23a98ca0e43 Remove jit_block::visit_dom and simplify release placement Max Brister <max@2bass.com> parents: 14969 diff changeset	1117 if (isa<jit_call> (instr))
b23a98ca0e43 Remove jit_block::visit_dom and simplify release placement Max Brister <max@2bass.com> parents: 14969 diff changeset	1118 {
b23a98ca0e43 Remove jit_block::visit_dom and simplify release placement Max Brister <max@2bass.com> parents: 14969 diff changeset	1119 // place releases for temporary arguments
b23a98ca0e43 Remove jit_block::visit_dom and simplify release placement Max Brister <max@2bass.com> parents: 14969 diff changeset	1120 for (size_t i = 0; i < instr->argument_count (); ++i)
b23a98ca0e43 Remove jit_block::visit_dom and simplify release placement Max Brister <max@2bass.com> parents: 14969 diff changeset	1121 {
b23a98ca0e43 Remove jit_block::visit_dom and simplify release placement Max Brister <max@2bass.com> parents: 14969 diff changeset	1122 jit_value *arg = instr->argument (i);
15147 98a65d9e426f Remove uneeded release overloads Max Brister <max@2bass.com> parents: 15146 diff changeset	1123 if (! arg->needs_release ())
98a65d9e426f Remove uneeded release overloads Max Brister <max@2bass.com> parents: 15146 diff changeset	1124 continue;
98a65d9e426f Remove uneeded release overloads Max Brister <max@2bass.com> parents: 15146 diff changeset	1125
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	1126 jit_call *release
a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	1127 = factory.create<jit_call> (&jit_typeinfo::release, arg);
15147 98a65d9e426f Remove uneeded release overloads Max Brister <max@2bass.com> parents: 15146 diff changeset	1128 release->infer ();
98a65d9e426f Remove uneeded release overloads Max Brister <max@2bass.com> parents: 15146 diff changeset	1129 ablock.insert_after (iter, release);
98a65d9e426f Remove uneeded release overloads Max Brister <max@2bass.com> parents: 15146 diff changeset	1130 ++iter;
98a65d9e426f Remove uneeded release overloads Max Brister <max@2bass.com> parents: 15146 diff changeset	1131 temp.erase (arg);
14971 b23a98ca0e43 Remove jit_block::visit_dom and simplify release placement Max Brister <max@2bass.com> parents: 14969 diff changeset	1132 }
b23a98ca0e43 Remove jit_block::visit_dom and simplify release placement Max Brister <max@2bass.com> parents: 14969 diff changeset	1133 }
b23a98ca0e43 Remove jit_block::visit_dom and simplify release placement Max Brister <max@2bass.com> parents: 14969 diff changeset	1134 }
b23a98ca0e43 Remove jit_block::visit_dom and simplify release placement Max Brister <max@2bass.com> parents: 14969 diff changeset	1135
b23a98ca0e43 Remove jit_block::visit_dom and simplify release placement Max Brister <max@2bass.com> parents: 14969 diff changeset	1136 if (! temp.size () \|\| ! isa<jit_error_check> (ablock.terminator ()))
b23a98ca0e43 Remove jit_block::visit_dom and simplify release placement Max Brister <max@2bass.com> parents: 14969 diff changeset	1137 return;
b23a98ca0e43 Remove jit_block::visit_dom and simplify release placement Max Brister <max@2bass.com> parents: 14969 diff changeset	1138
b23a98ca0e43 Remove jit_block::visit_dom and simplify release placement Max Brister <max@2bass.com> parents: 14969 diff changeset	1139 // FIXME: If we support try/catch or unwind_protect final_block may not be the
b23a98ca0e43 Remove jit_block::visit_dom and simplify release placement Max Brister <max@2bass.com> parents: 14969 diff changeset	1140 // destination
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	1141 jit_block *split = ablock.maybe_split (factory, blocks, final_block);
14971 b23a98ca0e43 Remove jit_block::visit_dom and simplify release placement Max Brister <max@2bass.com> parents: 14969 diff changeset	1142 jit_terminator *term = split->terminator ();
b23a98ca0e43 Remove jit_block::visit_dom and simplify release placement Max Brister <max@2bass.com> parents: 14969 diff changeset	1143 for (std::set<jit_value *>::const_iterator iter = temp.begin ();
b23a98ca0e43 Remove jit_block::visit_dom and simplify release placement Max Brister <max@2bass.com> parents: 14969 diff changeset	1144 iter != temp.end (); ++iter)
b23a98ca0e43 Remove jit_block::visit_dom and simplify release placement Max Brister <max@2bass.com> parents: 14969 diff changeset	1145 {
b23a98ca0e43 Remove jit_block::visit_dom and simplify release placement Max Brister <max@2bass.com> parents: 14969 diff changeset	1146 jit_value value = iter;
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	1147 jit_call *release
a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	1148 = factory.create<jit_call> (&jit_typeinfo::release, value);
14966 b7b647bc4b90 Place releases for temporaries on error Max Brister <max@2bass.com> parents: 14965 diff changeset	1149 split->insert_before (term, release);
b7b647bc4b90 Place releases for temporaries on error Max Brister <max@2bass.com> parents: 14965 diff changeset	1150 release->infer ();
b7b647bc4b90 Place releases for temporaries on error Max Brister <max@2bass.com> parents: 14965 diff changeset	1151 }
b7b647bc4b90 Place releases for temporaries on error Max Brister <max@2bass.com> parents: 14965 diff changeset	1152 }
b7b647bc4b90 Place releases for temporaries on error Max Brister <max@2bass.com> parents: 14965 diff changeset	1153
b7b647bc4b90 Place releases for temporaries on error Max Brister <max@2bass.com> parents: 14965 diff changeset	1154 void
b7b647bc4b90 Place releases for temporaries on error Max Brister <max@2bass.com> parents: 14965 diff changeset	1155 jit_convert::release_dead_phi (jit_block& ablock)
b7b647bc4b90 Place releases for temporaries on error Max Brister <max@2bass.com> parents: 14965 diff changeset	1156 {
b7b647bc4b90 Place releases for temporaries on error Max Brister <max@2bass.com> parents: 14965 diff changeset	1157 jit_block::iterator iter = ablock.begin ();
b7b647bc4b90 Place releases for temporaries on error Max Brister <max@2bass.com> parents: 14965 diff changeset	1158 while (iter != ablock.end () && isa<jit_phi> (*iter))
b7b647bc4b90 Place releases for temporaries on error Max Brister <max@2bass.com> parents: 14965 diff changeset	1159 {
b7b647bc4b90 Place releases for temporaries on error Max Brister <max@2bass.com> parents: 14965 diff changeset	1160 jit_phi phi = static_cast<jit_phi > (*iter);
b7b647bc4b90 Place releases for temporaries on error Max Brister <max@2bass.com> parents: 14965 diff changeset	1161 ++iter;
b7b647bc4b90 Place releases for temporaries on error Max Brister <max@2bass.com> parents: 14965 diff changeset	1162
b7b647bc4b90 Place releases for temporaries on error Max Brister <max@2bass.com> parents: 14965 diff changeset	1163 jit_use *use = phi->first_use ();
b7b647bc4b90 Place releases for temporaries on error Max Brister <max@2bass.com> parents: 14965 diff changeset	1164 if (phi->use_count () == 1 && isa<jit_assign> (use->user ()))
b7b647bc4b90 Place releases for temporaries on error Max Brister <max@2bass.com> parents: 14965 diff changeset	1165 {
b7b647bc4b90 Place releases for temporaries on error Max Brister <max@2bass.com> parents: 14965 diff changeset	1166 // instead of releasing on assign, release on all incomming branches,
b7b647bc4b90 Place releases for temporaries on error Max Brister <max@2bass.com> parents: 14965 diff changeset	1167 // this can get rid of casts inside loops
b7b647bc4b90 Place releases for temporaries on error Max Brister <max@2bass.com> parents: 14965 diff changeset	1168 for (size_t i = 0; i < phi->argument_count (); ++i)
b7b647bc4b90 Place releases for temporaries on error Max Brister <max@2bass.com> parents: 14965 diff changeset	1169 {
b7b647bc4b90 Place releases for temporaries on error Max Brister <max@2bass.com> parents: 14965 diff changeset	1170 jit_value *arg = phi->argument (i);
15147 98a65d9e426f Remove uneeded release overloads Max Brister <max@2bass.com> parents: 15146 diff changeset	1171 if (! arg->needs_release ())
98a65d9e426f Remove uneeded release overloads Max Brister <max@2bass.com> parents: 15146 diff changeset	1172 continue;
98a65d9e426f Remove uneeded release overloads Max Brister <max@2bass.com> parents: 15146 diff changeset	1173
14966 b7b647bc4b90 Place releases for temporaries on error Max Brister <max@2bass.com> parents: 14965 diff changeset	1174 jit_block *inc = phi->incomming (i);
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	1175 jit_block *split = inc->maybe_split (factory, blocks, ablock);
14966 b7b647bc4b90 Place releases for temporaries on error Max Brister <max@2bass.com> parents: 14965 diff changeset	1176 jit_terminator *term = split->terminator ();
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	1177 jit_call *release
a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	1178 = factory.create<jit_call> (jit_typeinfo::release, arg);
14966 b7b647bc4b90 Place releases for temporaries on error Max Brister <max@2bass.com> parents: 14965 diff changeset	1179 release->infer ();
b7b647bc4b90 Place releases for temporaries on error Max Brister <max@2bass.com> parents: 14965 diff changeset	1180 split->insert_before (term, release);
b7b647bc4b90 Place releases for temporaries on error Max Brister <max@2bass.com> parents: 14965 diff changeset	1181 }
b7b647bc4b90 Place releases for temporaries on error Max Brister <max@2bass.com> parents: 14965 diff changeset	1182
b7b647bc4b90 Place releases for temporaries on error Max Brister <max@2bass.com> parents: 14965 diff changeset	1183 phi->replace_with (0);
b7b647bc4b90 Place releases for temporaries on error Max Brister <max@2bass.com> parents: 14965 diff changeset	1184 phi->remove ();
b7b647bc4b90 Place releases for temporaries on error Max Brister <max@2bass.com> parents: 14965 diff changeset	1185 }
b7b647bc4b90 Place releases for temporaries on error Max Brister <max@2bass.com> parents: 14965 diff changeset	1186 }
14963 709f50069722 Change algorithm for placing releases and simplify PHIs in low level Octave IR Max Brister <max@2bass.com> parents: 14962 diff changeset	1187 }
709f50069722 Change algorithm for placing releases and simplify PHIs in low level Octave IR Max Brister <max@2bass.com> parents: 14962 diff changeset	1188
709f50069722 Change algorithm for placing releases and simplify PHIs in low level Octave IR Max Brister <max@2bass.com> parents: 14962 diff changeset	1189 void
709f50069722 Change algorithm for placing releases and simplify PHIs in low level Octave IR Max Brister <max@2bass.com> parents: 14962 diff changeset	1190 jit_convert::simplify_phi (void)
709f50069722 Change algorithm for placing releases and simplify PHIs in low level Octave IR Max Brister <max@2bass.com> parents: 14962 diff changeset	1191 {
709f50069722 Change algorithm for placing releases and simplify PHIs in low level Octave IR Max Brister <max@2bass.com> parents: 14962 diff changeset	1192 for (block_list::iterator biter = blocks.begin (); biter != blocks.end ();
709f50069722 Change algorithm for placing releases and simplify PHIs in low level Octave IR Max Brister <max@2bass.com> parents: 14962 diff changeset	1193 ++biter)
709f50069722 Change algorithm for placing releases and simplify PHIs in low level Octave IR Max Brister <max@2bass.com> parents: 14962 diff changeset	1194 {
709f50069722 Change algorithm for placing releases and simplify PHIs in low level Octave IR Max Brister <max@2bass.com> parents: 14962 diff changeset	1195 jit_block &ablock = **biter;
709f50069722 Change algorithm for placing releases and simplify PHIs in low level Octave IR Max Brister <max@2bass.com> parents: 14962 diff changeset	1196 for (jit_block::iterator iter = ablock.begin (); iter != ablock.end ()
709f50069722 Change algorithm for placing releases and simplify PHIs in low level Octave IR Max Brister <max@2bass.com> parents: 14962 diff changeset	1197 && isa<jit_phi> (*iter); ++iter)
709f50069722 Change algorithm for placing releases and simplify PHIs in low level Octave IR Max Brister <max@2bass.com> parents: 14962 diff changeset	1198 simplify_phi (static_cast<jit_phi > (*iter));
709f50069722 Change algorithm for placing releases and simplify PHIs in low level Octave IR Max Brister <max@2bass.com> parents: 14962 diff changeset	1199 }
709f50069722 Change algorithm for placing releases and simplify PHIs in low level Octave IR Max Brister <max@2bass.com> parents: 14962 diff changeset	1200 }
709f50069722 Change algorithm for placing releases and simplify PHIs in low level Octave IR Max Brister <max@2bass.com> parents: 14962 diff changeset	1201
709f50069722 Change algorithm for placing releases and simplify PHIs in low level Octave IR Max Brister <max@2bass.com> parents: 14962 diff changeset	1202 void
709f50069722 Change algorithm for placing releases and simplify PHIs in low level Octave IR Max Brister <max@2bass.com> parents: 14962 diff changeset	1203 jit_convert::simplify_phi (jit_phi& phi)
709f50069722 Change algorithm for placing releases and simplify PHIs in low level Octave IR Max Brister <max@2bass.com> parents: 14962 diff changeset	1204 {
709f50069722 Change algorithm for placing releases and simplify PHIs in low level Octave IR Max Brister <max@2bass.com> parents: 14962 diff changeset	1205 jit_block& pblock = *phi.parent ();
14983 a5f75de0dab1 Rename jit_function to jit_operation Max Brister <max@2bass.com> parents: 14978 diff changeset	1206 const jit_operation& cast_fn = jit_typeinfo::cast (phi.type ());
14963 709f50069722 Change algorithm for placing releases and simplify PHIs in low level Octave IR Max Brister <max@2bass.com> parents: 14962 diff changeset	1207 jit_variable *dest = phi.dest ();
709f50069722 Change algorithm for placing releases and simplify PHIs in low level Octave IR Max Brister <max@2bass.com> parents: 14962 diff changeset	1208 for (size_t i = 0; i < phi.argument_count (); ++i)
709f50069722 Change algorithm for placing releases and simplify PHIs in low level Octave IR Max Brister <max@2bass.com> parents: 14962 diff changeset	1209 {
709f50069722 Change algorithm for placing releases and simplify PHIs in low level Octave IR Max Brister <max@2bass.com> parents: 14962 diff changeset	1210 jit_value *arg = phi.argument (i);
709f50069722 Change algorithm for placing releases and simplify PHIs in low level Octave IR Max Brister <max@2bass.com> parents: 14962 diff changeset	1211 if (arg->type () != phi.type ())
709f50069722 Change algorithm for placing releases and simplify PHIs in low level Octave IR Max Brister <max@2bass.com> parents: 14962 diff changeset	1212 {
709f50069722 Change algorithm for placing releases and simplify PHIs in low level Octave IR Max Brister <max@2bass.com> parents: 14962 diff changeset	1213 jit_block *pred = phi.incomming (i);
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	1214 jit_block *split = pred->maybe_split (factory, blocks, pblock);
14963 709f50069722 Change algorithm for placing releases and simplify PHIs in low level Octave IR Max Brister <max@2bass.com> parents: 14962 diff changeset	1215 jit_terminator *term = split->terminator ();
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	1216 jit_instruction *cast = factory.create<jit_call> (cast_fn, arg);
a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	1217 jit_assign *assign = factory.create<jit_assign> (dest, cast);
14963 709f50069722 Change algorithm for placing releases and simplify PHIs in low level Octave IR Max Brister <max@2bass.com> parents: 14962 diff changeset	1218
709f50069722 Change algorithm for placing releases and simplify PHIs in low level Octave IR Max Brister <max@2bass.com> parents: 14962 diff changeset	1219 split->insert_before (term, cast);
709f50069722 Change algorithm for placing releases and simplify PHIs in low level Octave IR Max Brister <max@2bass.com> parents: 14962 diff changeset	1220 split->insert_before (term, assign);
709f50069722 Change algorithm for placing releases and simplify PHIs in low level Octave IR Max Brister <max@2bass.com> parents: 14962 diff changeset	1221 cast->infer ();
709f50069722 Change algorithm for placing releases and simplify PHIs in low level Octave IR Max Brister <max@2bass.com> parents: 14962 diff changeset	1222 assign->infer ();
709f50069722 Change algorithm for placing releases and simplify PHIs in low level Octave IR Max Brister <max@2bass.com> parents: 14962 diff changeset	1223 phi.stash_argument (i, assign);
709f50069722 Change algorithm for placing releases and simplify PHIs in low level Octave IR Max Brister <max@2bass.com> parents: 14962 diff changeset	1224 }
709f50069722 Change algorithm for placing releases and simplify PHIs in low level Octave IR Max Brister <max@2bass.com> parents: 14962 diff changeset	1225 }
14935 5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1226 }
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1227
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1228 void
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1229 jit_convert::finish_breaks (jit_block *dest, const block_list& lst)
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1230 {
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1231 for (block_list::const_iterator iter = lst.begin (); iter != lst.end ();
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	1232 ++iter)
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	1233 {
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	1234 jit_block b = iter;
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	1235 b->append (factory.create<jit_branch> (dest));
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	1236 }
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1237 }
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1238
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1239 // -------------------- jit_convert::convert_llvm --------------------
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1240 llvm::Function *
15181 ed2b911a2fb3 Rename jit_convert::convert_llvm to jit_convert_llvm Max Brister <max@2bass.com> parents: 15171 diff changeset	1241 jit_convert_llvm::convert (llvm::Module *module,
ed2b911a2fb3 Rename jit_convert::convert_llvm to jit_convert_llvm Max Brister <max@2bass.com> parents: 15171 diff changeset	1242 const std::vector<std::pair<std::string, bool> >&
ed2b911a2fb3 Rename jit_convert::convert_llvm to jit_convert_llvm Max Brister <max@2bass.com> parents: 15171 diff changeset	1243 args,
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	1244 const jit_block_list& blocks,
15181 ed2b911a2fb3 Rename jit_convert::convert_llvm to jit_convert_llvm Max Brister <max@2bass.com> parents: 15171 diff changeset	1245 const std::list<jit_value *>& constants)
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1246 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1247 jit_type *any = jit_typeinfo::get_any ();
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	1248
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1249 // argument is an array of octave_base_value, or octave_base_value*
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1250 llvm::Type arg_type = any->to_llvm (); // this is octave_base_value
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1251 arg_type = arg_type->getPointerTo ();
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1252 llvm::FunctionType *ft = llvm::FunctionType::get (llvm::Type::getVoidTy (context),
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1253 arg_type, false);
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1254 function = llvm::Function::Create (ft, llvm::Function::ExternalLinkage,
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1255 "foobar", module);
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1256
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1257 try
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1258 {
14968 7f60cdfcc0e5 Do not smash stack when passing structures in JIT Max Brister <max@2bass.com> parents: 14967 diff changeset	1259 prelude = llvm::BasicBlock::Create (context, "prelude", function);
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1260 builder.SetInsertPoint (prelude);
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1261
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1262 llvm::Value *arg = function->arg_begin ();
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1263 for (size_t i = 0; i < args.size (); ++i)
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1264 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1265 llvm::Value *loaded_arg = builder.CreateConstInBoundsGEP1_32 (arg, i);
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1266 arguments[args[i].first] = loaded_arg;
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1267 }
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1268
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1269 std::list<jit_block *>::const_iterator biter;
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1270 for (biter = blocks.begin (); biter != blocks.end (); ++biter)
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1271 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1272 jit_block jblock = biter;
14959 12fd4a62d633 Fix whitespace issues and update documentation Max Brister <max@2bass.com> parents: 14958 diff changeset	1273 llvm::BasicBlock *block = llvm::BasicBlock::Create (context,
12fd4a62d633 Fix whitespace issues and update documentation Max Brister <max@2bass.com> parents: 14958 diff changeset	1274 jblock->name (),
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1275 function);
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1276 jblock->stash_llvm (block);
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1277 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1278
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1279 jit_block first = blocks.begin ();
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1280 builder.CreateBr (first->to_llvm ());
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1281
14944 c0a5ab3b9278 jit_const no longer inherits from jit_instruction Max Brister <max@2bass.com> parents: 14943 diff changeset	1282 // constants aren't in the IR, we visit those first
c0a5ab3b9278 jit_const no longer inherits from jit_instruction Max Brister <max@2bass.com> parents: 14943 diff changeset	1283 for (std::list<jit_value *>::const_iterator iter = constants.begin ();
c0a5ab3b9278 jit_const no longer inherits from jit_instruction Max Brister <max@2bass.com> parents: 14943 diff changeset	1284 iter != constants.end (); ++iter)
c0a5ab3b9278 jit_const no longer inherits from jit_instruction Max Brister <max@2bass.com> parents: 14943 diff changeset	1285 if (! isa<jit_instruction> (*iter))
c0a5ab3b9278 jit_const no longer inherits from jit_instruction Max Brister <max@2bass.com> parents: 14943 diff changeset	1286 visit (*iter);
c0a5ab3b9278 jit_const no longer inherits from jit_instruction Max Brister <max@2bass.com> parents: 14943 diff changeset	1287
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1288 // convert all instructions
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1289 for (biter = blocks.begin (); biter != blocks.end (); ++biter)
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1290 visit (*biter);
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1291
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1292 // now finish phi nodes
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1293 for (biter = blocks.begin (); biter != blocks.end (); ++biter)
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1294 {
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1295 jit_block& block = **biter;
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1296 for (jit_block::iterator piter = block.begin ();
14937 78e1457c5bf5 Remove some macros from pt-jit.h and pt-jit.cc Max Brister <max@2bass.com> parents: 14936 diff changeset	1297 piter != block.end () && isa<jit_phi> (*piter); ++piter)
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1298 {
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1299 jit_instruction phi = piter;
14963 709f50069722 Change algorithm for placing releases and simplify PHIs in low level Octave IR Max Brister <max@2bass.com> parents: 14962 diff changeset	1300 finish_phi (static_cast<jit_phi *> (phi));
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1301 }
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1302 }
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1303
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1304 jit_block *last = blocks.back ();
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1305 builder.SetInsertPoint (last->to_llvm ());
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1306 builder.CreateRetVoid ();
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1307 } catch (const jit_fail_exception& e)
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1308 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1309 function->eraseFromParent ();
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1310 throw;
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1311 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1312
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1313 return function;
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	1314 }
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	1315
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	1316 void
15181 ed2b911a2fb3 Rename jit_convert::convert_llvm to jit_convert_llvm Max Brister <max@2bass.com> parents: 15171 diff changeset	1317 jit_convert_llvm::finish_phi (jit_phi *phi)
14935 5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1318 {
14963 709f50069722 Change algorithm for placing releases and simplify PHIs in low level Octave IR Max Brister <max@2bass.com> parents: 14962 diff changeset	1319 llvm::PHINode *llvm_phi = phi->to_llvm ();
709f50069722 Change algorithm for placing releases and simplify PHIs in low level Octave IR Max Brister <max@2bass.com> parents: 14962 diff changeset	1320 for (size_t i = 0; i < phi->argument_count (); ++i)
14935 5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1321 {
14963 709f50069722 Change algorithm for placing releases and simplify PHIs in low level Octave IR Max Brister <max@2bass.com> parents: 14962 diff changeset	1322 llvm::BasicBlock *pred = phi->incomming_llvm (i);
709f50069722 Change algorithm for placing releases and simplify PHIs in low level Octave IR Max Brister <max@2bass.com> parents: 14962 diff changeset	1323 llvm_phi->addIncoming (phi->argument_llvm (i), pred);
14935 5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1324 }
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1325 }
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1326
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1327 void
15181 ed2b911a2fb3 Rename jit_convert::convert_llvm to jit_convert_llvm Max Brister <max@2bass.com> parents: 15171 diff changeset	1328 jit_convert_llvm::visit (jit_const_string& cs)
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1329 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1330 cs.stash_llvm (builder.CreateGlobalStringPtr (cs.value ()));
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1331 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1332
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1333 void
15181 ed2b911a2fb3 Rename jit_convert::convert_llvm to jit_convert_llvm Max Brister <max@2bass.com> parents: 15171 diff changeset	1334 jit_convert_llvm::visit (jit_const_bool& cb)
14978 f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	1335 {
f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	1336 cb.stash_llvm (llvm::ConstantInt::get (cb.type_llvm (), cb.value ()));
f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	1337 }
f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	1338
f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	1339 void
15181 ed2b911a2fb3 Rename jit_convert::convert_llvm to jit_convert_llvm Max Brister <max@2bass.com> parents: 15171 diff changeset	1340 jit_convert_llvm::visit (jit_const_scalar& cs)
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1341 {
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1342 cs.stash_llvm (llvm::ConstantFP::get (cs.type_llvm (), cs.value ()));
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1343 }
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1344
14984 561aad6a9e4b Initial support for complex numbers in JIT Max Brister <max@2bass.com> parents: 14983 diff changeset	1345 void
15181 ed2b911a2fb3 Rename jit_convert::convert_llvm to jit_convert_llvm Max Brister <max@2bass.com> parents: 15171 diff changeset	1346 jit_convert_llvm::visit (jit_const_complex& cc)
14984 561aad6a9e4b Initial support for complex numbers in JIT Max Brister <max@2bass.com> parents: 14983 diff changeset	1347 {
561aad6a9e4b Initial support for complex numbers in JIT Max Brister <max@2bass.com> parents: 14983 diff changeset	1348 llvm::Type *scalar_t = jit_typeinfo::get_scalar_llvm ();
561aad6a9e4b Initial support for complex numbers in JIT Max Brister <max@2bass.com> parents: 14983 diff changeset	1349 llvm::Constant *values[2];
561aad6a9e4b Initial support for complex numbers in JIT Max Brister <max@2bass.com> parents: 14983 diff changeset	1350 Complex value = cc.value ();
561aad6a9e4b Initial support for complex numbers in JIT Max Brister <max@2bass.com> parents: 14983 diff changeset	1351 values[0] = llvm::ConstantFP::get (scalar_t, value.real ());
561aad6a9e4b Initial support for complex numbers in JIT Max Brister <max@2bass.com> parents: 14983 diff changeset	1352 values[1] = llvm::ConstantFP::get (scalar_t, value.imag ());
561aad6a9e4b Initial support for complex numbers in JIT Max Brister <max@2bass.com> parents: 14983 diff changeset	1353 cc.stash_llvm (llvm::ConstantVector::get (values));
561aad6a9e4b Initial support for complex numbers in JIT Max Brister <max@2bass.com> parents: 14983 diff changeset	1354 }
561aad6a9e4b Initial support for complex numbers in JIT Max Brister <max@2bass.com> parents: 14983 diff changeset	1355
15181 ed2b911a2fb3 Rename jit_convert::convert_llvm to jit_convert_llvm Max Brister <max@2bass.com> parents: 15171 diff changeset	1356 void jit_convert_llvm::visit (jit_const_index& ci)
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1357 {
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1358 ci.stash_llvm (llvm::ConstantInt::get (ci.type_llvm (), ci.value ()));
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1359 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1360
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1361 void
15181 ed2b911a2fb3 Rename jit_convert::convert_llvm to jit_convert_llvm Max Brister <max@2bass.com> parents: 15171 diff changeset	1362 jit_convert_llvm::visit (jit_const_range& cr)
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1363 {
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1364 llvm::StructType *stype = llvm::cast<llvm::StructType>(cr.type_llvm ());
14951 4c9fd3e31436 Start of jit support for double matricies Max Brister <max@2bass.com> parents: 14949 diff changeset	1365 llvm::Type *scalar_t = jit_typeinfo::get_scalar_llvm ();
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1366 llvm::Type *idx = jit_typeinfo::get_index_llvm ();
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1367 const jit_range& rng = cr.value ();
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1368
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1369 llvm::Constant *constants[4];
14951 4c9fd3e31436 Start of jit support for double matricies Max Brister <max@2bass.com> parents: 14949 diff changeset	1370 constants[0] = llvm::ConstantFP::get (scalar_t, rng.base);
4c9fd3e31436 Start of jit support for double matricies Max Brister <max@2bass.com> parents: 14949 diff changeset	1371 constants[1] = llvm::ConstantFP::get (scalar_t, rng.limit);
4c9fd3e31436 Start of jit support for double matricies Max Brister <max@2bass.com> parents: 14949 diff changeset	1372 constants[2] = llvm::ConstantFP::get (scalar_t, rng.inc);
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1373 constants[3] = llvm::ConstantInt::get (idx, rng.nelem);
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1374
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1375 llvm::Value *as_llvm;
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1376 as_llvm = llvm::ConstantStruct::get (stype,
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1377 llvm::makeArrayRef (constants, 4));
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1378 cr.stash_llvm (as_llvm);
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1379 }
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1380
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1381 void
15181 ed2b911a2fb3 Rename jit_convert::convert_llvm to jit_convert_llvm Max Brister <max@2bass.com> parents: 15171 diff changeset	1382 jit_convert_llvm::visit (jit_block& b)
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	1383 {
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1384 llvm::BasicBlock *block = b.to_llvm ();
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1385 builder.SetInsertPoint (block);
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1386 for (jit_block::iterator iter = b.begin (); iter != b.end (); ++iter)
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1387 visit (*iter);
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1388 }
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	1389
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1390 void
15181 ed2b911a2fb3 Rename jit_convert::convert_llvm to jit_convert_llvm Max Brister <max@2bass.com> parents: 15171 diff changeset	1391 jit_convert_llvm::visit (jit_branch& b)
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1392 {
14948 006570a76b90 Cleanup and optimization of JIT Max Brister <max@2bass.com> parents: 14946 diff changeset	1393 b.stash_llvm (builder.CreateBr (b.successor_llvm ()));
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1394 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1395
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1396 void
15181 ed2b911a2fb3 Rename jit_convert::convert_llvm to jit_convert_llvm Max Brister <max@2bass.com> parents: 15171 diff changeset	1397 jit_convert_llvm::visit (jit_cond_branch& cb)
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1398 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1399 llvm::Value *cond = cb.cond_llvm ();
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1400 llvm::Value *br;
14959 12fd4a62d633 Fix whitespace issues and update documentation Max Brister <max@2bass.com> parents: 14958 diff changeset	1401 br = builder.CreateCondBr (cond, cb.successor_llvm (0),
12fd4a62d633 Fix whitespace issues and update documentation Max Brister <max@2bass.com> parents: 14958 diff changeset	1402 cb.successor_llvm (1));
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1403 cb.stash_llvm (br);
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	1404 }
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	1405
14913 c7071907a641 Use symbol_record_ref instead of names in JIT Max Brister <max@2bass.com> parents: 14911 diff changeset	1406 void
15181 ed2b911a2fb3 Rename jit_convert::convert_llvm to jit_convert_llvm Max Brister <max@2bass.com> parents: 15171 diff changeset	1407 jit_convert_llvm::visit (jit_call& call)
14913 c7071907a641 Use symbol_record_ref instead of names in JIT Max Brister <max@2bass.com> parents: 14911 diff changeset	1408 {
15014 094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1409 const jit_function& ol = call.overload ();
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1410
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1411 std::vector<jit_value *> args (call.arguments ().size ());
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1412 for (size_t i = 0; i < args.size (); ++i)
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1413 args[i] = call.argument (i);
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1414
15016 005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	1415 llvm::Value *ret = ol.call (builder, args);
14951 4c9fd3e31436 Start of jit support for double matricies Max Brister <max@2bass.com> parents: 14949 diff changeset	1416 call.stash_llvm (ret);
14913 c7071907a641 Use symbol_record_ref instead of names in JIT Max Brister <max@2bass.com> parents: 14911 diff changeset	1417 }
c7071907a641 Use symbol_record_ref instead of names in JIT Max Brister <max@2bass.com> parents: 14911 diff changeset	1418
c7071907a641 Use symbol_record_ref instead of names in JIT Max Brister <max@2bass.com> parents: 14911 diff changeset	1419 void
15181 ed2b911a2fb3 Rename jit_convert::convert_llvm to jit_convert_llvm Max Brister <max@2bass.com> parents: 15171 diff changeset	1420 jit_convert_llvm::visit (jit_extract_argument& extract)
14913 c7071907a641 Use symbol_record_ref instead of names in JIT Max Brister <max@2bass.com> parents: 14911 diff changeset	1421 {
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	1422 llvm::Value *arg = arguments[extract.name ()];
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1423 assert (arg);
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1424 arg = builder.CreateLoad (arg);
14951 4c9fd3e31436 Start of jit support for double matricies Max Brister <max@2bass.com> parents: 14949 diff changeset	1425
15014 094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1426 const jit_function& ol = extract.overload ();
15016 005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	1427 extract.stash_llvm (ol.call (builder, arg));
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1428 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1429
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1430 void
15181 ed2b911a2fb3 Rename jit_convert::convert_llvm to jit_convert_llvm Max Brister <max@2bass.com> parents: 15171 diff changeset	1431 jit_convert_llvm::visit (jit_store_argument& store)
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1432 {
15014 094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1433 const jit_function& ol = store.overload ();
15016 005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	1434 llvm::Value *arg_value = ol.call (builder, store.result ());
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	1435 llvm::Value *arg = arguments[store.name ()];
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1436 store.stash_llvm (builder.CreateStore (arg_value, arg));
14913 c7071907a641 Use symbol_record_ref instead of names in JIT Max Brister <max@2bass.com> parents: 14911 diff changeset	1437 }
c7071907a641 Use symbol_record_ref instead of names in JIT Max Brister <max@2bass.com> parents: 14911 diff changeset	1438
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1439 void
15181 ed2b911a2fb3 Rename jit_convert::convert_llvm to jit_convert_llvm Max Brister <max@2bass.com> parents: 15171 diff changeset	1440 jit_convert_llvm::visit (jit_phi& phi)
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1441 {
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1442 // we might not have converted all incoming branches, so we don't
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1443 // set incomming branches now
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1444 llvm::PHINode *node = llvm::PHINode::Create (phi.type_llvm (),
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	1445 phi.argument_count ());
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1446 builder.Insert (node);
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1447 phi.stash_llvm (node);
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1448 }
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1449
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	1450 void
15181 ed2b911a2fb3 Rename jit_convert::convert_llvm to jit_convert_llvm Max Brister <max@2bass.com> parents: 15171 diff changeset	1451 jit_convert_llvm::visit (jit_variable&)
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	1452 {
15016 005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	1453 throw jit_fail_exception ("ERROR: SSA construction should remove all variables");
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	1454 }
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	1455
14938 bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1456 void
15181 ed2b911a2fb3 Rename jit_convert::convert_llvm to jit_convert_llvm Max Brister <max@2bass.com> parents: 15171 diff changeset	1457 jit_convert_llvm::visit (jit_error_check& check)
14938 bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1458 {
15016 005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	1459 llvm::Value *cond = jit_typeinfo::insert_error_check (builder);
14948 006570a76b90 Cleanup and optimization of JIT Max Brister <max@2bass.com> parents: 14946 diff changeset	1460 llvm::Value *br = builder.CreateCondBr (cond, check.successor_llvm (0),
006570a76b90 Cleanup and optimization of JIT Max Brister <max@2bass.com> parents: 14946 diff changeset	1461 check.successor_llvm (1));
14938 bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1462 check.stash_llvm (br);
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1463 }
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1464
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1465 void
15181 ed2b911a2fb3 Rename jit_convert::convert_llvm to jit_convert_llvm Max Brister <max@2bass.com> parents: 15171 diff changeset	1466 jit_convert_llvm::visit (jit_assign& assign)
14962 90a7a2af2cd5 Keep track of variables after SSA construction Max Brister <max@2bass.com> parents: 14961 diff changeset	1467 {
15014 094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1468 jit_value *new_value = assign.src ();
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1469 assign.stash_llvm (new_value->to_llvm ());
14965 f2117a963c54 Place grab/release for assignments Max Brister <max@2bass.com> parents: 14964 diff changeset	1470
14969 bbeef7b8ea2e Add support for matrix indexed assignment to JIT Max Brister <max@2bass.com> parents: 14968 diff changeset	1471 if (assign.artificial ())
bbeef7b8ea2e Add support for matrix indexed assignment to JIT Max Brister <max@2bass.com> parents: 14968 diff changeset	1472 return;
bbeef7b8ea2e Add support for matrix indexed assignment to JIT Max Brister <max@2bass.com> parents: 14968 diff changeset	1473
14966 b7b647bc4b90 Place releases for temporaries on error Max Brister <max@2bass.com> parents: 14965 diff changeset	1474 if (isa<jit_assign_base> (new_value))
14965 f2117a963c54 Place grab/release for assignments Max Brister <max@2bass.com> parents: 14964 diff changeset	1475 {
15014 094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1476 const jit_function& ol = jit_typeinfo::get_grab (new_value->type ());
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1477 if (ol.valid ())
15016 005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	1478 assign.stash_llvm (ol.call (builder, new_value));
14965 f2117a963c54 Place grab/release for assignments Max Brister <max@2bass.com> parents: 14964 diff changeset	1479 }
f2117a963c54 Place grab/release for assignments Max Brister <max@2bass.com> parents: 14964 diff changeset	1480
f2117a963c54 Place grab/release for assignments Max Brister <max@2bass.com> parents: 14964 diff changeset	1481 jit_value *overwrite = assign.overwrite ();
f2117a963c54 Place grab/release for assignments Max Brister <max@2bass.com> parents: 14964 diff changeset	1482 if (isa<jit_assign_base> (overwrite))
f2117a963c54 Place grab/release for assignments Max Brister <max@2bass.com> parents: 14964 diff changeset	1483 {
15014 094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1484 const jit_function& ol = jit_typeinfo::get_release (overwrite->type ());
15147 98a65d9e426f Remove uneeded release overloads Max Brister <max@2bass.com> parents: 15146 diff changeset	1485 if (ol.valid ())
98a65d9e426f Remove uneeded release overloads Max Brister <max@2bass.com> parents: 15146 diff changeset	1486 ol.call (builder, overwrite);
14965 f2117a963c54 Place grab/release for assignments Max Brister <max@2bass.com> parents: 14964 diff changeset	1487 }
14962 90a7a2af2cd5 Keep track of variables after SSA construction Max Brister <max@2bass.com> parents: 14961 diff changeset	1488 }
14938 bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1489
14951 4c9fd3e31436 Start of jit support for double matricies Max Brister <max@2bass.com> parents: 14949 diff changeset	1490 void
15181 ed2b911a2fb3 Rename jit_convert::convert_llvm to jit_convert_llvm Max Brister <max@2bass.com> parents: 15171 diff changeset	1491 jit_convert_llvm::visit (jit_argument&)
14951 4c9fd3e31436 Start of jit support for double matricies Max Brister <max@2bass.com> parents: 14949 diff changeset	1492 {}
4c9fd3e31436 Start of jit support for double matricies Max Brister <max@2bass.com> parents: 14949 diff changeset	1493
15056 bc32288f4a42 Support the end keyword for one dimentional indexing in JIT. Max Brister <max@2bass.com> parents: 15030 diff changeset	1494 void
15181 ed2b911a2fb3 Rename jit_convert::convert_llvm to jit_convert_llvm Max Brister <max@2bass.com> parents: 15171 diff changeset	1495 jit_convert_llvm::visit (jit_magic_end& me)
15056 bc32288f4a42 Support the end keyword for one dimentional indexing in JIT. Max Brister <max@2bass.com> parents: 15030 diff changeset	1496 {
bc32288f4a42 Support the end keyword for one dimentional indexing in JIT. Max Brister <max@2bass.com> parents: 15030 diff changeset	1497 const jit_function& ol = me.overload ();
15102 d29f2583cf7b Support end in multi indexing in JIT Max Brister <max@2bass.com> parents: 15096 diff changeset	1498
d29f2583cf7b Support end in multi indexing in JIT Max Brister <max@2bass.com> parents: 15096 diff changeset	1499 jit_magic_end::context ctx = me.resolve_context ();
d29f2583cf7b Support end in multi indexing in JIT Max Brister <max@2bass.com> parents: 15096 diff changeset	1500 llvm::Value *ret = ol.call (builder, ctx.value, ctx.index, ctx.count);
15056 bc32288f4a42 Support the end keyword for one dimentional indexing in JIT. Max Brister <max@2bass.com> parents: 15030 diff changeset	1501 me.stash_llvm (ret);
bc32288f4a42 Support the end keyword for one dimentional indexing in JIT. Max Brister <max@2bass.com> parents: 15030 diff changeset	1502 }
bc32288f4a42 Support the end keyword for one dimentional indexing in JIT. Max Brister <max@2bass.com> parents: 15030 diff changeset	1503
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1504 // -------------------- tree_jit --------------------
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1505
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1506 tree_jit::tree_jit (void) : module (0), engine (0)
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1507 {
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1508 }
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1509
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1510 tree_jit::~tree_jit (void)
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1511 {}
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1512
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1513 bool
15027 741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1514 tree_jit::execute (tree_simple_for_command& cmd, const octave_value& bounds)
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1515 {
15027 741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1516 const size_t MIN_TRIP_COUNT = 1000;
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1517
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1518 size_t tc = trip_count (bounds);
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1519 if (! tc \|\| ! initialize ())
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1520 return false;
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1521
15027 741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1522 jit_info::vmap extra_vars;
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1523 extra_vars["#for_bounds0"] = &bounds;
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1524
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1525 jit_info *info = cmd.get_info ();
15027 741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1526 if (! info \|\| ! info->match (extra_vars))
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1527 {
15027 741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1528 if (tc < MIN_TRIP_COUNT)
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1529 return false;
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1530
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1531 delete info;
15027 741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1532 info = new jit_info (*this, cmd, bounds);
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1533 cmd.stash_info (info);
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1534 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1535
15027 741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1536 return info->execute (extra_vars);
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1537 }
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1538
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1539 bool
15023 75d1bc2fd6d2 Compile top level while loops in JIT. Max Brister <max@2bass.com> parents: 15016 diff changeset	1540 tree_jit::execute (tree_while_command& cmd)
75d1bc2fd6d2 Compile top level while loops in JIT. Max Brister <max@2bass.com> parents: 15016 diff changeset	1541 {
75d1bc2fd6d2 Compile top level while loops in JIT. Max Brister <max@2bass.com> parents: 15016 diff changeset	1542 if (! initialize ())
75d1bc2fd6d2 Compile top level while loops in JIT. Max Brister <max@2bass.com> parents: 15016 diff changeset	1543 return false;
75d1bc2fd6d2 Compile top level while loops in JIT. Max Brister <max@2bass.com> parents: 15016 diff changeset	1544
75d1bc2fd6d2 Compile top level while loops in JIT. Max Brister <max@2bass.com> parents: 15016 diff changeset	1545 jit_info *info = cmd.get_info ();
75d1bc2fd6d2 Compile top level while loops in JIT. Max Brister <max@2bass.com> parents: 15016 diff changeset	1546 if (! info \|\| ! info->match ())
75d1bc2fd6d2 Compile top level while loops in JIT. Max Brister <max@2bass.com> parents: 15016 diff changeset	1547 {
75d1bc2fd6d2 Compile top level while loops in JIT. Max Brister <max@2bass.com> parents: 15016 diff changeset	1548 delete info;
75d1bc2fd6d2 Compile top level while loops in JIT. Max Brister <max@2bass.com> parents: 15016 diff changeset	1549 info = new jit_info (*this, cmd);
75d1bc2fd6d2 Compile top level while loops in JIT. Max Brister <max@2bass.com> parents: 15016 diff changeset	1550 cmd.stash_info (info);
75d1bc2fd6d2 Compile top level while loops in JIT. Max Brister <max@2bass.com> parents: 15016 diff changeset	1551 }
75d1bc2fd6d2 Compile top level while loops in JIT. Max Brister <max@2bass.com> parents: 15016 diff changeset	1552
75d1bc2fd6d2 Compile top level while loops in JIT. Max Brister <max@2bass.com> parents: 15016 diff changeset	1553 return info->execute ();
75d1bc2fd6d2 Compile top level while loops in JIT. Max Brister <max@2bass.com> parents: 15016 diff changeset	1554 }
75d1bc2fd6d2 Compile top level while loops in JIT. Max Brister <max@2bass.com> parents: 15016 diff changeset	1555
75d1bc2fd6d2 Compile top level while loops in JIT. Max Brister <max@2bass.com> parents: 15016 diff changeset	1556 bool
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1557 tree_jit::initialize (void)
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	1558 {
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1559 if (engine)
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1560 return true;
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1561
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1562 if (! module)
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1563 {
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1564 llvm::InitializeNativeTarget ();
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1565 module = new llvm::Module ("octave", context);
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1566 }
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1567
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1568 // sometimes this fails pre main
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1569 engine = llvm::ExecutionEngine::createJIT (module);
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1570
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1571 if (! engine)
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1572 return false;
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1573
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1574 module_pass_manager = new llvm::PassManager ();
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1575 module_pass_manager->add (llvm::createAlwaysInlinerPass ());
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1576
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1577 pass_manager = new llvm::FunctionPassManager (module);
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1578 pass_manager->add (new llvm::TargetData(*engine->getTargetData ()));
15171 7a19e8275d41 Do not simplify the CFG during type inference Max Brister <max@2bass.com> parents: 15169 diff changeset	1579 pass_manager->add (llvm::createCFGSimplificationPass ());
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1580 pass_manager->add (llvm::createBasicAliasAnalysisPass ());
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1581 pass_manager->add (llvm::createPromoteMemoryToRegisterPass ());
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1582 pass_manager->add (llvm::createInstructionCombiningPass ());
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1583 pass_manager->add (llvm::createReassociatePass ());
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1584 pass_manager->add (llvm::createGVNPass ());
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1585 pass_manager->add (llvm::createCFGSimplificationPass ());
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1586 pass_manager->doInitialization ();
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1587
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1588 jit_typeinfo::initialize (module, engine);
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1589
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1590 return true;
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1591 }
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1592
15027 741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1593 size_t
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1594 tree_jit::trip_count (const octave_value& bounds) const
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1595 {
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1596 if (bounds.is_range ())
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1597 {
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1598 Range rng = bounds.range_value ();
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1599 return rng.nelem ();
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1600 }
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1601
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1602 // unsupported type
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1603 return 0;
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1604 }
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1605
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1606
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1607 void
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1608 tree_jit::optimize (llvm::Function *fn)
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1609 {
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1610 module_pass_manager->run (*module);
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1611 pass_manager->run (*fn);
14985 f5925478bc15 More support for complex numbers in JIT Max Brister <max@2bass.com> parents: 14984 diff changeset	1612
f5925478bc15 More support for complex numbers in JIT Max Brister <max@2bass.com> parents: 14984 diff changeset	1613 #ifdef OCTAVE_JIT_DEBUG
f5925478bc15 More support for complex numbers in JIT Max Brister <max@2bass.com> parents: 14984 diff changeset	1614 std::string error;
f5925478bc15 More support for complex numbers in JIT Max Brister <max@2bass.com> parents: 14984 diff changeset	1615 llvm::raw_fd_ostream fout ("test.bc", error,
f5925478bc15 More support for complex numbers in JIT Max Brister <max@2bass.com> parents: 14984 diff changeset	1616 llvm::raw_fd_ostream::F_Binary);
f5925478bc15 More support for complex numbers in JIT Max Brister <max@2bass.com> parents: 14984 diff changeset	1617 llvm::WriteBitcodeToFile (module, fout);
f5925478bc15 More support for complex numbers in JIT Max Brister <max@2bass.com> parents: 14984 diff changeset	1618 #endif
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1619 }
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1620
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1621 // -------------------- jit_info --------------------
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1622 jit_info::jit_info (tree_jit& tjit, tree& tee)
15027 741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1623 : engine (tjit.get_engine ()), function (0), llvm_function (0)
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1624 {
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	1625 try
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	1626 {
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1627 jit_convert conv (tjit.get_module (), tee);
15027 741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1628 initialize (tjit, conv);
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	1629 }
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1630 catch (const jit_fail_exception& e)
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1631 {
14932 1f914446157d Locate and link with LLVM properly Max Brister <max@2bass.com> parents: 14928 diff changeset	1632 #ifdef OCTAVE_JIT_DEBUG
1f914446157d Locate and link with LLVM properly Max Brister <max@2bass.com> parents: 14928 diff changeset	1633 if (e.known ())
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1634 std::cout << "jit fail: " << e.what () << std::endl;
14932 1f914446157d Locate and link with LLVM properly Max Brister <max@2bass.com> parents: 14928 diff changeset	1635 #endif
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1636 }
15027 741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1637 }
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1638
15027 741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1639 jit_info::jit_info (tree_jit& tjit, tree& tee, const octave_value& for_bounds)
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1640 : engine (tjit.get_engine ()), function (0), llvm_function (0)
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1641 {
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1642 try
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1643 {
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1644 jit_convert conv (tjit.get_module (), tee,
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1645 jit_typeinfo::type_of (for_bounds));
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1646 initialize (tjit, conv);
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1647 }
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1648 catch (const jit_fail_exception& e)
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1649 {
14932 1f914446157d Locate and link with LLVM properly Max Brister <max@2bass.com> parents: 14928 diff changeset	1650 #ifdef OCTAVE_JIT_DEBUG
15027 741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1651 if (e.known ())
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1652 std::cout << "jit fail: " << e.what () << std::endl;
14932 1f914446157d Locate and link with LLVM properly Max Brister <max@2bass.com> parents: 14928 diff changeset	1653 #endif
15027 741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1654 }
14955 609dcc297db5 src/pt-jit.cc (jit_info::~jit_info): New function Max Brister <max@2bass.com> parents: 14954 diff changeset	1655 }
609dcc297db5 src/pt-jit.cc (jit_info::~jit_info): New function Max Brister <max@2bass.com> parents: 14954 diff changeset	1656
609dcc297db5 src/pt-jit.cc (jit_info::~jit_info): New function Max Brister <max@2bass.com> parents: 14954 diff changeset	1657 jit_info::~jit_info (void)
609dcc297db5 src/pt-jit.cc (jit_info::~jit_info): New function Max Brister <max@2bass.com> parents: 14954 diff changeset	1658 {
609dcc297db5 src/pt-jit.cc (jit_info::~jit_info): New function Max Brister <max@2bass.com> parents: 14954 diff changeset	1659 if (llvm_function)
609dcc297db5 src/pt-jit.cc (jit_info::~jit_info): New function Max Brister <max@2bass.com> parents: 14954 diff changeset	1660 llvm_function->eraseFromParent ();
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	1661 }
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	1662
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	1663 bool
15027 741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1664 jit_info::execute (const vmap& extra_vars) const
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	1665 {
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	1666 if (! function)
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	1667 return false;
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	1668
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1669 std::vector<octave_base_value *> real_arguments (arguments.size ());
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1670 for (size_t i = 0; i < arguments.size (); ++i)
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	1671 {
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1672 if (arguments[i].second)
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	1673 {
15027 741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1674 octave_value current = find (extra_vars, arguments[i].first);
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1675 octave_base_value *obv = current.internal_rep ();
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1676 obv->grab ();
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1677 real_arguments[i] = obv;
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	1678 }
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	1679 }
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	1680
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1681 function (&real_arguments[0]);
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	1682
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1683 for (size_t i = 0; i < arguments.size (); ++i)
15027 741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1684 {
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1685 const std::string& name = arguments[i].first;
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1686
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1687 // do not store for loop bounds temporary
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1688 if (name.size () && name[0] != '#')
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1689 symbol_table::varref (arguments[i].first) = real_arguments[i];
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1690 }
14910 a8f1e08de8fc Simplified llvm::GenericValue creation Max Brister <max@2bass.com> parents: 14906 diff changeset	1691
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	1692 return true;
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	1693 }
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	1694
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	1695 bool
15027 741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1696 jit_info::match (const vmap& extra_vars) const
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	1697 {
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1698 if (! function)
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1699 return true;
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1700
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1701 for (size_t i = 0; i < bounds.size (); ++i)
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	1702 {
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1703 const std::string& arg_name = bounds[i].second;
15027 741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1704 octave_value value = find (extra_vars, arg_name);
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1705 jit_type *type = jit_typeinfo::type_of (value);
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1706
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1707 // FIXME: Check for a parent relationship
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1708 if (type != bounds[i].first)
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1709 return false;
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	1710 }
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	1711
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	1712 return true;
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	1713 }
15027 741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1714
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1715 void
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1716 jit_info::initialize (tree_jit& tjit, jit_convert& conv)
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1717 {
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1718 llvm_function = conv.get_function ();
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1719 arguments = conv.get_arguments ();
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1720 bounds = conv.get_bounds ();
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1721
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1722 if (llvm_function)
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1723 {
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1724 tjit.optimize (llvm_function);
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1725
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1726 #ifdef OCTAVE_JIT_DEBUG
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1727 std::cout << "-------------------- optimized llvm ir "
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1728 << "--------------------\n";
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1729 llvm::raw_os_ostream llvm_cout (std::cout);
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1730 llvm_function->print (llvm_cout);
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1731 llvm_cout.flush ();
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1732 std::cout << std::endl;
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1733 #endif
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1734
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1735 void *void_fn = engine->getPointerToFunction (llvm_function);
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1736 function = reinterpret_cast<jited_function> (void_fn);
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1737 }
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1738 }
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1739
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1740 octave_value
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1741 jit_info::find (const vmap& extra_vars, const std::string& vname) const
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1742 {
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1743 vmap::const_iterator iter = extra_vars.find (vname);
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1744 return iter == extra_vars.end () ? symbol_table::varval (vname)
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1745 : *iter->second;
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1746 }
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1747
14932 1f914446157d Locate and link with LLVM properly Max Brister <max@2bass.com> parents: 14928 diff changeset	1748 #endif
15014 094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1749
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1750
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1751 /*
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1752 Test some simple cases that compile.
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1753
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1754 %!test
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1755 %! inc = 1e-5;
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1756 %! result = 0;
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1757 %! for ii = 0:inc:1
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1758 %! result = result + inc * (1/3 * ii * ii);
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1759 %! endfor
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1760 %! assert (abs (result - 1/9) < 1e-5);
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1761
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1762 %!test
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1763 %! inc = 1e-5;
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1764 %! result = 0;
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1765 %! for ii = 0:inc:1
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1766 %! # the ^ operator's result is complex
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1767 %! result = result + inc * (1/3 * ii ^ 2);
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1768 %! endfor
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1769 %! assert (abs (result - 1/9) < 1e-5);
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1770
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1771 %!test
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1772 %! nr = 1001;
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1773 %! mat = zeros (1, nr);
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1774 %! for i = 1:nr
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1775 %! mat(i) = i;
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1776 %! endfor
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1777 %! assert (mat == 1:nr);
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1778
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1779 %!test
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1780 %! nr = 1001;
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1781 %! mat = 1:nr;
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1782 %! mat(end) = 0; # force mat to a matrix
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1783 %! total = 0;
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1784 %! for i = 1:nr
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1785 %! total = mat(i) + total;
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1786 %! endfor
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1787 %! assert (sum (mat) == total);
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1788
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1789 %!test
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1790 %! nr = 1001;
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1791 %! mat = [3 1 5];
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1792 %! try
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1793 %! for i = 1:nr
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1794 %! if i > 500
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1795 %! result = mat(100);
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1796 %! else
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1797 %! result = i;
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1798 %! endif
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1799 %! endfor
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1800 %! catch
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1801 %! end
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1802 %! assert (result == 500);
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1803
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1804 %!function result = gen_test (n)
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1805 %! result = double (rand (1, n) > .01);
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1806 %!endfunction
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1807
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1808 %!function z = vectorized (A, K)
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1809 %! temp = ones (1, K);
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1810 %! z = conv (A, temp);
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1811 %! z = z > K-1;
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1812 %! z = conv (z, temp);
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1813 %! z = z(K:end-K+1);
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1814 %! z = z >= 1;
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1815 %!endfunction
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1816
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1817 %!function z = loopy (A, K)
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1818 %! z = A;
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1819 %! n = numel (A);
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1820 %! counter = 0;
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1821 %! for ii=1:n
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1822 %! if z(ii)
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1823 %! counter = counter + 1;
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1824 %! else
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1825 %! if counter > 0 && counter < K
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1826 %! z(ii-counter:ii-1) = 0;
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1827 %! endif
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1828 %! counter = 0;
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1829 %! endif
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1830 %! endfor
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1831 %!
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1832 %! if counter > 0 && counter < K
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1833 %! z(end-counter+1:end) = 0;
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1834 %! endif
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1835 %!endfunction
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1836
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1837 %!test
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1838 %! test_set = gen_test (10000);
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1839 %! assert (all (vectorized (test_set, 3) == loopy (test_set, 3)));
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1840
15023 75d1bc2fd6d2 Compile top level while loops in JIT. Max Brister <max@2bass.com> parents: 15016 diff changeset	1841 %!test
75d1bc2fd6d2 Compile top level while loops in JIT. Max Brister <max@2bass.com> parents: 15016 diff changeset	1842 %! niter = 1001;
75d1bc2fd6d2 Compile top level while loops in JIT. Max Brister <max@2bass.com> parents: 15016 diff changeset	1843 %! i = 0;
75d1bc2fd6d2 Compile top level while loops in JIT. Max Brister <max@2bass.com> parents: 15016 diff changeset	1844 %! while (i < niter)
75d1bc2fd6d2 Compile top level while loops in JIT. Max Brister <max@2bass.com> parents: 15016 diff changeset	1845 %! i = i + 1;
75d1bc2fd6d2 Compile top level while loops in JIT. Max Brister <max@2bass.com> parents: 15016 diff changeset	1846 %! endwhile
75d1bc2fd6d2 Compile top level while loops in JIT. Max Brister <max@2bass.com> parents: 15016 diff changeset	1847 %! assert (i == niter);
75d1bc2fd6d2 Compile top level while loops in JIT. Max Brister <max@2bass.com> parents: 15016 diff changeset	1848
15056 bc32288f4a42 Support the end keyword for one dimentional indexing in JIT. Max Brister <max@2bass.com> parents: 15030 diff changeset	1849 %!test
bc32288f4a42 Support the end keyword for one dimentional indexing in JIT. Max Brister <max@2bass.com> parents: 15030 diff changeset	1850 %! niter = 1001;
bc32288f4a42 Support the end keyword for one dimentional indexing in JIT. Max Brister <max@2bass.com> parents: 15030 diff changeset	1851 %! result = 0;
bc32288f4a42 Support the end keyword for one dimentional indexing in JIT. Max Brister <max@2bass.com> parents: 15030 diff changeset	1852 %! m = [5 10];
bc32288f4a42 Support the end keyword for one dimentional indexing in JIT. Max Brister <max@2bass.com> parents: 15030 diff changeset	1853 %! for i=1:niter
bc32288f4a42 Support the end keyword for one dimentional indexing in JIT. Max Brister <max@2bass.com> parents: 15030 diff changeset	1854 %! result = result + m(end);
bc32288f4a42 Support the end keyword for one dimentional indexing in JIT. Max Brister <max@2bass.com> parents: 15030 diff changeset	1855 %! endfor
bc32288f4a42 Support the end keyword for one dimentional indexing in JIT. Max Brister <max@2bass.com> parents: 15030 diff changeset	1856 %! assert (result == m(end) * niter);
bc32288f4a42 Support the end keyword for one dimentional indexing in JIT. Max Brister <max@2bass.com> parents: 15030 diff changeset	1857
15067 df4538e3b50b ND scalar indexing in JIT. Max Brister <max@2bass.com> parents: 15056 diff changeset	1858 %!test
df4538e3b50b ND scalar indexing in JIT. Max Brister <max@2bass.com> parents: 15056 diff changeset	1859 %! ndim = 100;
df4538e3b50b ND scalar indexing in JIT. Max Brister <max@2bass.com> parents: 15056 diff changeset	1860 %! result = 0;
df4538e3b50b ND scalar indexing in JIT. Max Brister <max@2bass.com> parents: 15056 diff changeset	1861 %! m = zeros (ndim);
df4538e3b50b ND scalar indexing in JIT. Max Brister <max@2bass.com> parents: 15056 diff changeset	1862 %! m(:) = 1:ndim^2;
df4538e3b50b ND scalar indexing in JIT. Max Brister <max@2bass.com> parents: 15056 diff changeset	1863 %! i = 1;
df4538e3b50b ND scalar indexing in JIT. Max Brister <max@2bass.com> parents: 15056 diff changeset	1864 %! while (i <= ndim)
df4538e3b50b ND scalar indexing in JIT. Max Brister <max@2bass.com> parents: 15056 diff changeset	1865 %! for j = 1:ndim
df4538e3b50b ND scalar indexing in JIT. Max Brister <max@2bass.com> parents: 15056 diff changeset	1866 %! result = result + m(i, j);
df4538e3b50b ND scalar indexing in JIT. Max Brister <max@2bass.com> parents: 15056 diff changeset	1867 %! endfor
df4538e3b50b ND scalar indexing in JIT. Max Brister <max@2bass.com> parents: 15056 diff changeset	1868 %! i = i + 1;
df4538e3b50b ND scalar indexing in JIT. Max Brister <max@2bass.com> parents: 15056 diff changeset	1869 %! endwhile
df4538e3b50b ND scalar indexing in JIT. Max Brister <max@2bass.com> parents: 15056 diff changeset	1870 %! assert (result == sum (sum (m)));
15068 f57d7578c1a6 Support ND matrix indexing with scalar assignment in JIT. Max Brister <max@2bass.com> parents: 15067 diff changeset	1871
f57d7578c1a6 Support ND matrix indexing with scalar assignment in JIT. Max Brister <max@2bass.com> parents: 15067 diff changeset	1872 %!test
f57d7578c1a6 Support ND matrix indexing with scalar assignment in JIT. Max Brister <max@2bass.com> parents: 15067 diff changeset	1873 %! ndim = 100;
f57d7578c1a6 Support ND matrix indexing with scalar assignment in JIT. Max Brister <max@2bass.com> parents: 15067 diff changeset	1874 %! m = zeros (ndim);
f57d7578c1a6 Support ND matrix indexing with scalar assignment in JIT. Max Brister <max@2bass.com> parents: 15067 diff changeset	1875 %! i = 1;
f57d7578c1a6 Support ND matrix indexing with scalar assignment in JIT. Max Brister <max@2bass.com> parents: 15067 diff changeset	1876 %! while (i <= ndim)
f57d7578c1a6 Support ND matrix indexing with scalar assignment in JIT. Max Brister <max@2bass.com> parents: 15067 diff changeset	1877 %! for j = 1:ndim
f57d7578c1a6 Support ND matrix indexing with scalar assignment in JIT. Max Brister <max@2bass.com> parents: 15067 diff changeset	1878 %! m(i, j) = (j - 1) * ndim + i;
f57d7578c1a6 Support ND matrix indexing with scalar assignment in JIT. Max Brister <max@2bass.com> parents: 15067 diff changeset	1879 %! endfor
f57d7578c1a6 Support ND matrix indexing with scalar assignment in JIT. Max Brister <max@2bass.com> parents: 15067 diff changeset	1880 %! i = i + 1;
f57d7578c1a6 Support ND matrix indexing with scalar assignment in JIT. Max Brister <max@2bass.com> parents: 15067 diff changeset	1881 %! endwhile
f57d7578c1a6 Support ND matrix indexing with scalar assignment in JIT. Max Brister <max@2bass.com> parents: 15067 diff changeset	1882 %! m2 = zeros (ndim);
f57d7578c1a6 Support ND matrix indexing with scalar assignment in JIT. Max Brister <max@2bass.com> parents: 15067 diff changeset	1883 %! m2(:) = 1:(ndim^2);
f57d7578c1a6 Support ND matrix indexing with scalar assignment in JIT. Max Brister <max@2bass.com> parents: 15067 diff changeset	1884 %! assert (all (m == m2));
f57d7578c1a6 Support ND matrix indexing with scalar assignment in JIT. Max Brister <max@2bass.com> parents: 15067 diff changeset	1885
15078 fe4752f772e2 Generate ND indexing functions on demand in JIT. Max Brister <max@2bass.com> parents: 15068 diff changeset	1886 %!test
fe4752f772e2 Generate ND indexing functions on demand in JIT. Max Brister <max@2bass.com> parents: 15068 diff changeset	1887 %! ndim = 2;
fe4752f772e2 Generate ND indexing functions on demand in JIT. Max Brister <max@2bass.com> parents: 15068 diff changeset	1888 %! m = zeros (ndim, ndim, ndim, ndim);
fe4752f772e2 Generate ND indexing functions on demand in JIT. Max Brister <max@2bass.com> parents: 15068 diff changeset	1889 %! result = 0;
fe4752f772e2 Generate ND indexing functions on demand in JIT. Max Brister <max@2bass.com> parents: 15068 diff changeset	1890 %! i0 = 1;
fe4752f772e2 Generate ND indexing functions on demand in JIT. Max Brister <max@2bass.com> parents: 15068 diff changeset	1891 %! while (i0 <= ndim)
fe4752f772e2 Generate ND indexing functions on demand in JIT. Max Brister <max@2bass.com> parents: 15068 diff changeset	1892 %! for i1 = 1:ndim
fe4752f772e2 Generate ND indexing functions on demand in JIT. Max Brister <max@2bass.com> parents: 15068 diff changeset	1893 %! for i2 = 1:ndim
fe4752f772e2 Generate ND indexing functions on demand in JIT. Max Brister <max@2bass.com> parents: 15068 diff changeset	1894 %! for i3 = 1:ndim
fe4752f772e2 Generate ND indexing functions on demand in JIT. Max Brister <max@2bass.com> parents: 15068 diff changeset	1895 %! m(i0, i1, i2, i3) = 1;
fe4752f772e2 Generate ND indexing functions on demand in JIT. Max Brister <max@2bass.com> parents: 15068 diff changeset	1896 %! m(i0, i1, i2, i3, 1, 1, 1, 1, 1, 1) = 1;
fe4752f772e2 Generate ND indexing functions on demand in JIT. Max Brister <max@2bass.com> parents: 15068 diff changeset	1897 %! result = result + m(i0, i1, i2, i3);
fe4752f772e2 Generate ND indexing functions on demand in JIT. Max Brister <max@2bass.com> parents: 15068 diff changeset	1898 %! endfor
fe4752f772e2 Generate ND indexing functions on demand in JIT. Max Brister <max@2bass.com> parents: 15068 diff changeset	1899 %! endfor
fe4752f772e2 Generate ND indexing functions on demand in JIT. Max Brister <max@2bass.com> parents: 15068 diff changeset	1900 %! endfor
fe4752f772e2 Generate ND indexing functions on demand in JIT. Max Brister <max@2bass.com> parents: 15068 diff changeset	1901 %! i0 = i0 + 1;
fe4752f772e2 Generate ND indexing functions on demand in JIT. Max Brister <max@2bass.com> parents: 15068 diff changeset	1902 %! endwhile
fe4752f772e2 Generate ND indexing functions on demand in JIT. Max Brister <max@2bass.com> parents: 15068 diff changeset	1903 %! expected = ones (ndim, ndim, ndim, ndim);
fe4752f772e2 Generate ND indexing functions on demand in JIT. Max Brister <max@2bass.com> parents: 15068 diff changeset	1904 %! assert (all (m == expected));
fe4752f772e2 Generate ND indexing functions on demand in JIT. Max Brister <max@2bass.com> parents: 15068 diff changeset	1905 %! assert (result == sum (expected (:)));
fe4752f772e2 Generate ND indexing functions on demand in JIT. Max Brister <max@2bass.com> parents: 15068 diff changeset	1906
15095 9df70a18aa27 Correct division by zero check in JIT Max Brister <max@2bass.com> parents: 15078 diff changeset	1907 %!function test_divide ()
9df70a18aa27 Correct division by zero check in JIT Max Brister <max@2bass.com> parents: 15078 diff changeset	1908 %! state = warning ("query", "Octave:divide-by-zero").state;
9df70a18aa27 Correct division by zero check in JIT Max Brister <max@2bass.com> parents: 15078 diff changeset	1909 %! unwind_protect
9df70a18aa27 Correct division by zero check in JIT Max Brister <max@2bass.com> parents: 15078 diff changeset	1910 %! warning ("error", "Octave:divide-by-zero");
9df70a18aa27 Correct division by zero check in JIT Max Brister <max@2bass.com> parents: 15078 diff changeset	1911 %! for i=1:1e5
9df70a18aa27 Correct division by zero check in JIT Max Brister <max@2bass.com> parents: 15078 diff changeset	1912 %! a = 1;
9df70a18aa27 Correct division by zero check in JIT Max Brister <max@2bass.com> parents: 15078 diff changeset	1913 %! a / 0;
9df70a18aa27 Correct division by zero check in JIT Max Brister <max@2bass.com> parents: 15078 diff changeset	1914 %! endfor
9df70a18aa27 Correct division by zero check in JIT Max Brister <max@2bass.com> parents: 15078 diff changeset	1915 %! unwind_protect_cleanup
9df70a18aa27 Correct division by zero check in JIT Max Brister <max@2bass.com> parents: 15078 diff changeset	1916 %! warning (state, "Octave:divide-by-zero");
9df70a18aa27 Correct division by zero check in JIT Max Brister <max@2bass.com> parents: 15078 diff changeset	1917 %! end_unwind_protect
9df70a18aa27 Correct division by zero check in JIT Max Brister <max@2bass.com> parents: 15078 diff changeset	1918 %!endfunction
9df70a18aa27 Correct division by zero check in JIT Max Brister <max@2bass.com> parents: 15078 diff changeset	1919
9df70a18aa27 Correct division by zero check in JIT Max Brister <max@2bass.com> parents: 15078 diff changeset	1920 %!error <division by zero> test_divide ()
9df70a18aa27 Correct division by zero check in JIT Max Brister <max@2bass.com> parents: 15078 diff changeset	1921
9df70a18aa27 Correct division by zero check in JIT Max Brister <max@2bass.com> parents: 15078 diff changeset	1922 %!test
9df70a18aa27 Correct division by zero check in JIT Max Brister <max@2bass.com> parents: 15078 diff changeset	1923 %! while 1
9df70a18aa27 Correct division by zero check in JIT Max Brister <max@2bass.com> parents: 15078 diff changeset	1924 %! a = 0;
9df70a18aa27 Correct division by zero check in JIT Max Brister <max@2bass.com> parents: 15078 diff changeset	1925 %! result = a / 1;
9df70a18aa27 Correct division by zero check in JIT Max Brister <max@2bass.com> parents: 15078 diff changeset	1926 %! break;
9df70a18aa27 Correct division by zero check in JIT Max Brister <max@2bass.com> parents: 15078 diff changeset	1927 %! endwhile
9df70a18aa27 Correct division by zero check in JIT Max Brister <max@2bass.com> parents: 15078 diff changeset	1928 %! assert (result, 0);
9df70a18aa27 Correct division by zero check in JIT Max Brister <max@2bass.com> parents: 15078 diff changeset	1929
15102 d29f2583cf7b Support end in multi indexing in JIT Max Brister <max@2bass.com> parents: 15096 diff changeset	1930 %!test
d29f2583cf7b Support end in multi indexing in JIT Max Brister <max@2bass.com> parents: 15096 diff changeset	1931 %! m = zeros (2, 1001);
d29f2583cf7b Support end in multi indexing in JIT Max Brister <max@2bass.com> parents: 15096 diff changeset	1932 %! for i=1:1001
d29f2583cf7b Support end in multi indexing in JIT Max Brister <max@2bass.com> parents: 15096 diff changeset	1933 %! m(end, i) = i;
d29f2583cf7b Support end in multi indexing in JIT Max Brister <max@2bass.com> parents: 15096 diff changeset	1934 %! m(end - 1, end - i + 1) = i;
d29f2583cf7b Support end in multi indexing in JIT Max Brister <max@2bass.com> parents: 15096 diff changeset	1935 %! endfor
d29f2583cf7b Support end in multi indexing in JIT Max Brister <max@2bass.com> parents: 15096 diff changeset	1936 %! m2 = zeros (2, 1001);
d29f2583cf7b Support end in multi indexing in JIT Max Brister <max@2bass.com> parents: 15096 diff changeset	1937 %! m2(1, :) = fliplr (1:1001);
d29f2583cf7b Support end in multi indexing in JIT Max Brister <max@2bass.com> parents: 15096 diff changeset	1938 %! m2(2, :) = 1:1001;
d29f2583cf7b Support end in multi indexing in JIT Max Brister <max@2bass.com> parents: 15096 diff changeset	1939 %! assert (m, m2);
d29f2583cf7b Support end in multi indexing in JIT Max Brister <max@2bass.com> parents: 15096 diff changeset	1940
15135 bd6bb87e2bea Support sin, cos, and exp with matrix arguments in JIT Max Brister <max@2bass.com> parents: 15102 diff changeset	1941 %!test
bd6bb87e2bea Support sin, cos, and exp with matrix arguments in JIT Max Brister <max@2bass.com> parents: 15102 diff changeset	1942 %! m = [1 2 3];
bd6bb87e2bea Support sin, cos, and exp with matrix arguments in JIT Max Brister <max@2bass.com> parents: 15102 diff changeset	1943 %! for i=1:1001
bd6bb87e2bea Support sin, cos, and exp with matrix arguments in JIT Max Brister <max@2bass.com> parents: 15102 diff changeset	1944 %! m = sin (m);
bd6bb87e2bea Support sin, cos, and exp with matrix arguments in JIT Max Brister <max@2bass.com> parents: 15102 diff changeset	1945 %! break;
bd6bb87e2bea Support sin, cos, and exp with matrix arguments in JIT Max Brister <max@2bass.com> parents: 15102 diff changeset	1946 %! endfor
bd6bb87e2bea Support sin, cos, and exp with matrix arguments in JIT Max Brister <max@2bass.com> parents: 15102 diff changeset	1947 %! assert (m == sin ([1 2 3]));
bd6bb87e2bea Support sin, cos, and exp with matrix arguments in JIT Max Brister <max@2bass.com> parents: 15102 diff changeset	1948
15140 6ea86e1d0f5f Support +=, -=, =, ect. in JIT Max Brister <max@2bass.com>* parents: 15135 diff changeset	1949 %!test
6ea86e1d0f5f Support +=, -=, =, ect. in JIT Max Brister <max@2bass.com>* parents: 15135 diff changeset	1950 %! i = 0;
6ea86e1d0f5f Support +=, -=, =, ect. in JIT Max Brister <max@2bass.com>* parents: 15135 diff changeset	1951 %! while i < 10
6ea86e1d0f5f Support +=, -=, =, ect. in JIT Max Brister <max@2bass.com>* parents: 15135 diff changeset	1952 %! i += 1;
6ea86e1d0f5f Support +=, -=, =, ect. in JIT Max Brister <max@2bass.com>* parents: 15135 diff changeset	1953 %! endwhile
6ea86e1d0f5f Support +=, -=, =, ect. in JIT Max Brister <max@2bass.com>* parents: 15135 diff changeset	1954 %! assert (i == 10);
6ea86e1d0f5f Support +=, -=, =, ect. in JIT Max Brister <max@2bass.com>* parents: 15135 diff changeset	1955
15146 709e8928e68c Scalar unary operation support in JIT Max Brister <max@2bass.com> parents: 15140 diff changeset	1956 %!test
709e8928e68c Scalar unary operation support in JIT Max Brister <max@2bass.com> parents: 15140 diff changeset	1957 %! i = 0;
709e8928e68c Scalar unary operation support in JIT Max Brister <max@2bass.com> parents: 15140 diff changeset	1958 %! while i < 10
709e8928e68c Scalar unary operation support in JIT Max Brister <max@2bass.com> parents: 15140 diff changeset	1959 %! a = ++i;
709e8928e68c Scalar unary operation support in JIT Max Brister <max@2bass.com> parents: 15140 diff changeset	1960 %! endwhile
709e8928e68c Scalar unary operation support in JIT Max Brister <max@2bass.com> parents: 15140 diff changeset	1961 %! assert (i == 10);
709e8928e68c Scalar unary operation support in JIT Max Brister <max@2bass.com> parents: 15140 diff changeset	1962 %! assert (a == 10);
15148 1b2fbc30e4e7 Postfix increment and decrement operations in JIT Max Brister <max@2bass.com> parents: 15147 diff changeset	1963 %!test
1b2fbc30e4e7 Postfix increment and decrement operations in JIT Max Brister <max@2bass.com> parents: 15147 diff changeset	1964 %! i = 0;
1b2fbc30e4e7 Postfix increment and decrement operations in JIT Max Brister <max@2bass.com> parents: 15147 diff changeset	1965 %! while i < 10
1b2fbc30e4e7 Postfix increment and decrement operations in JIT Max Brister <max@2bass.com> parents: 15147 diff changeset	1966 %! a = i++;
1b2fbc30e4e7 Postfix increment and decrement operations in JIT Max Brister <max@2bass.com> parents: 15147 diff changeset	1967 %! endwhile
1b2fbc30e4e7 Postfix increment and decrement operations in JIT Max Brister <max@2bass.com> parents: 15147 diff changeset	1968 %! assert (i == 10);
1b2fbc30e4e7 Postfix increment and decrement operations in JIT Max Brister <max@2bass.com> parents: 15147 diff changeset	1969 %! assert (a == 9);
15146 709e8928e68c Scalar unary operation support in JIT Max Brister <max@2bass.com> parents: 15140 diff changeset	1970
15169 6242904370bd Support balance, cond, det, norm, rand, magic, eye, and mod in JIT Max Brister <max@2bass.com> parents: 15148 diff changeset	1971 %!test
6242904370bd Support balance, cond, det, norm, rand, magic, eye, and mod in JIT Max Brister <max@2bass.com> parents: 15148 diff changeset	1972 %! num = 2;
6242904370bd Support balance, cond, det, norm, rand, magic, eye, and mod in JIT Max Brister <max@2bass.com> parents: 15148 diff changeset	1973 %! a = zeros (1, num);
6242904370bd Support balance, cond, det, norm, rand, magic, eye, and mod in JIT Max Brister <max@2bass.com> parents: 15148 diff changeset	1974 %! i = 1;
6242904370bd Support balance, cond, det, norm, rand, magic, eye, and mod in JIT Max Brister <max@2bass.com> parents: 15148 diff changeset	1975 %! while i <= num
6242904370bd Support balance, cond, det, norm, rand, magic, eye, and mod in JIT Max Brister <max@2bass.com> parents: 15148 diff changeset	1976 %! a(i) = norm (eye (i));
6242904370bd Support balance, cond, det, norm, rand, magic, eye, and mod in JIT Max Brister <max@2bass.com> parents: 15148 diff changeset	1977 %! ++i;
6242904370bd Support balance, cond, det, norm, rand, magic, eye, and mod in JIT Max Brister <max@2bass.com> parents: 15148 diff changeset	1978 %! endwhile
6242904370bd Support balance, cond, det, norm, rand, magic, eye, and mod in JIT Max Brister <max@2bass.com> parents: 15148 diff changeset	1979 %! assert (a, ones (1, num));
6242904370bd Support balance, cond, det, norm, rand, magic, eye, and mod in JIT Max Brister <max@2bass.com> parents: 15148 diff changeset	1980
15171 7a19e8275d41 Do not simplify the CFG during type inference Max Brister <max@2bass.com> parents: 15169 diff changeset	1981 %!function test_compute_idom ()
7a19e8275d41 Do not simplify the CFG during type inference Max Brister <max@2bass.com> parents: 15169 diff changeset	1982 %! while (li <= length (l1) && si <= length (s1))
7a19e8275d41 Do not simplify the CFG during type inference Max Brister <max@2bass.com> parents: 15169 diff changeset	1983 %! if (l1 (li) < s1 (si))
7a19e8275d41 Do not simplify the CFG during type inference Max Brister <max@2bass.com> parents: 15169 diff changeset	1984 %! if (li == si)
7a19e8275d41 Do not simplify the CFG during type inference Max Brister <max@2bass.com> parents: 15169 diff changeset	1985 %! break;
7a19e8275d41 Do not simplify the CFG during type inference Max Brister <max@2bass.com> parents: 15169 diff changeset	1986 %! endif;
7a19e8275d41 Do not simplify the CFG during type inference Max Brister <max@2bass.com> parents: 15169 diff changeset	1987 %! li++;
7a19e8275d41 Do not simplify the CFG during type inference Max Brister <max@2bass.com> parents: 15169 diff changeset	1988 %! else
7a19e8275d41 Do not simplify the CFG during type inference Max Brister <max@2bass.com> parents: 15169 diff changeset	1989 %! si++;
7a19e8275d41 Do not simplify the CFG during type inference Max Brister <max@2bass.com> parents: 15169 diff changeset	1990 %! endif;
7a19e8275d41 Do not simplify the CFG during type inference Max Brister <max@2bass.com> parents: 15169 diff changeset	1991 %! endwhile
7a19e8275d41 Do not simplify the CFG during type inference Max Brister <max@2bass.com> parents: 15169 diff changeset	1992
7a19e8275d41 Do not simplify the CFG during type inference Max Brister <max@2bass.com> parents: 15169 diff changeset	1993 %!error test_compute_idom ()
7a19e8275d41 Do not simplify the CFG during type inference Max Brister <max@2bass.com> parents: 15169 diff changeset	1994
15014 094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1995 */

Mercurial > octave-nkf

annotate src/interp-core/pt-jit.cc @ 15182:a7a56b436de2