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

annotate libinterp/interp-core/pt-jit.cc @ 15603:44272909d926

Stop JIT on interrupt * jit-ir.cc (jit_call::needs_release): Move to cc file and do not release artificial assigns. (jit_error_check::variable_to_strign): New function. (jit_error_check::print): Move to cc file and improve output. * jit-ir.h (jit_call::needs_release): Move to cc file. (jit_error_check::variable): New enum. (jit_error_check::variable_to_string): New declaration. (jit_error_check::jit_error_check): Add variable argument and new overload. (jit_error_check::check_variable, jit_error_check::has_check_for): New function. (jit_error_check::check_for): Ensure has_check_for is true. (jit_error_check::print): Move to cc file. (jit_error_check::check_alive): Always true if has_check_for is false. (jit_error_check::mvariable): New variable. * jit-typeinfo.cc (jit_typeinfo::jit_typeinfo): Initialize loctave_interrupt_state and fix name of cast to any. (jit_typeinfo::do_insert_interrupt_check): New function. * jit-typeinfo.h (jit_typeinfo::insert_interrupt_check): New function. (jit_typeinfo::do_insert_interrupt_check): New declaration. (jit_typeinfo::loctave_interrupt_state): New variable. * pt-jit.cc (jit_convert::visit_simple_for_command, jit_convert::visit_while_command): Check interrupt state. (jit_convert::create_check_impl): Specify var_error_state check. (jit_convert_llvm::visit): Generate var_interrupt error check. (jit_function_info::execute, jit_info::execute): Call octave_quit.

author	Max Brister <max@2bass.com>
date	Sun, 04 Nov 2012 21:11:33 -0700
parents	f3e339aee38f
children	896cf5769537 1f076c40c133

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
15582 52df2e7baabe Disable JIT when breakpoints are present Max Brister <max@2bass.com> parents: 15539 diff changeset	30 #include "debug.h"
15310 b055fc077224 allow jit compiler to be enabled at run-time John W. Eaton <jwe@octave.org> parents: 15245 diff changeset	31 #include "defun.h"
b055fc077224 allow jit compiler to be enabled at run-time John W. Eaton <jwe@octave.org> parents: 15245 diff changeset	32 #include "ov.h"
b055fc077224 allow jit compiler to be enabled at run-time John W. Eaton <jwe@octave.org> parents: 15245 diff changeset	33 #include "pt-all.h"
b055fc077224 allow jit compiler to be enabled at run-time John W. Eaton <jwe@octave.org> parents: 15245 diff changeset	34 #include "pt-jit.h"
15595 6e780fb15c14 Make Vdebug_on_interrupt not be static Max Brister <max@2bass.com> parents: 15593 diff changeset	35 #include "sighandlers.h"
15310 b055fc077224 allow jit compiler to be enabled at run-time John W. Eaton <jwe@octave.org> parents: 15245 diff changeset	36 #include "symtab.h"
b055fc077224 allow jit compiler to be enabled at run-time John W. Eaton <jwe@octave.org> parents: 15245 diff changeset	37 #include "variables.h"
14932 1f914446157d Locate and link with LLVM properly Max Brister <max@2bass.com> parents: 14928 diff changeset	38
15582 52df2e7baabe Disable JIT when breakpoints are present Max Brister <max@2bass.com> parents: 15539 diff changeset	39 static bool Venable_jit_debugging = false;
15310 b055fc077224 allow jit compiler to be enabled at run-time John W. Eaton <jwe@octave.org> parents: 15245 diff changeset	40
15582 52df2e7baabe Disable JIT when breakpoints are present Max Brister <max@2bass.com> parents: 15539 diff changeset	41 static bool Venable_jit_compiler = true;
15310 b055fc077224 allow jit compiler to be enabled at run-time John W. Eaton <jwe@octave.org> parents: 15245 diff changeset	42
b055fc077224 allow jit compiler to be enabled at run-time John W. Eaton <jwe@octave.org> parents: 15245 diff changeset	43 #ifdef HAVE_LLVM
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	44
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	45 #include <llvm/Analysis/CallGraph.h>
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	46 #include <llvm/Analysis/Passes.h>
15016 005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	47 #include <llvm/Analysis/Verifier.h>
15346 6bdf379592d9 Remove --enable-jit-debug configure option Max Brister <max@2bass.com> parents: 15339 diff changeset	48 #include <llvm/Bitcode/ReaderWriter.h>
15030 86a95d6ada0d src/pt-jit.cc: Fix JIT build with LLVM 3.0. Max Brister <max@2bass.com> parents: 15027 diff changeset	49 #include <llvm/LLVMContext.h>
15016 005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	50 #include <llvm/ExecutionEngine/ExecutionEngine.h>
005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	51 #include <llvm/ExecutionEngine/JIT.h>
005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	52 #include <llvm/Module.h>
005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	53 #include <llvm/PassManager.h>
005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	54 #include <llvm/Support/IRBuilder.h>
005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	55 #include <llvm/Support/raw_os_ostream.h>
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	56 #include <llvm/Support/TargetSelect.h>
15016 005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	57 #include <llvm/Target/TargetData.h>
005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	58 #include <llvm/Transforms/IPO.h>
005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	59 #include <llvm/Transforms/Scalar.h>
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	60
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	61 static llvm::IRBuilder<> builder (llvm::getGlobalContext ());
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	62
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	63 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	64
15592 6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	65 // -------------------- jit_break_exception --------------------
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	66
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	67 // jit_break is thrown whenever a branch we are converting has only breaks or
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	68 // continues. This is because all code that follows a break or continue is dead.
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	69 class jit_break_exception : public std::exception {};
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	70
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	71 // -------------------- jit_convert --------------------
15191 ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	72 jit_convert::jit_convert (tree &tee, jit_type *for_bounds)
15337 3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	73 : converting_function (false)
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	74 {
15337 3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	75 initialize (symbol_table::current_scope ());
15027 741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	76
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	77 if (for_bounds)
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	78 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	79
15592 6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	80 try
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	81 {
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	82 visit (tee);
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	83 }
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	84 catch (const jit_break_exception&)
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	85 {}
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	86
15337 3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	87 // breaks must have been handled by the top level loop
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	88 assert (breaks.empty ());
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	89 assert (continues.empty ());
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	90
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	91 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	92 blocks.push_back (final_block);
14959 12fd4a62d633 Fix whitespace issues and update documentation Max Brister <max@2bass.com> parents: 14958 diff changeset	93
15191 ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	94 for (variable_map::iterator iter = vmap.begin (); iter != vmap.end (); ++iter)
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	95 {
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	96 jit_variable *var = iter->second;
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	97 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	98 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	99 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	100 }
15337 3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	101
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	102 final_block->append (factory.create<jit_return> ());
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	103 }
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	104
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	105 jit_convert::jit_convert (octave_user_function& fcn,
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	106 const std::vector<jit_type *>& args)
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	107 : converting_function (true)
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	108 {
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	109 initialize (fcn.scope ());
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	110
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	111 tree_parameter_list *plist = fcn.parameter_list ();
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	112 tree_parameter_list *rlist = fcn.return_list ();
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	113 if (plist && plist->takes_varargs ())
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	114 throw jit_fail_exception ("varags not supported");
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	115
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	116 if (rlist && (rlist->size () > 1 \|\| rlist->takes_varargs ()))
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	117 throw jit_fail_exception ("multiple returns not supported");
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	118
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	119 if (plist)
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	120 {
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	121 tree_parameter_list::iterator piter = plist->begin ();
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	122 for (size_t i = 0; i < args.size (); ++i, ++piter)
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	123 {
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	124 if (piter == plist->end ())
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	125 throw jit_fail_exception ("Too many parameter to function");
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	126
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	127 tree_decl_elt elt = piter;
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	128 std::string name = elt->name ();
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	129 create_variable (name, args[i]);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	130 }
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	131 }
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	132
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	133 jit_value *return_value = 0;
15592 6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	134 bool all_breaking = false;
15337 3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	135 if (fcn.is_special_expr ())
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	136 {
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	137 tree_expression *expr = fcn.special_expr ();
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	138 if (expr)
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	139 {
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	140 jit_variable *retvar = get_variable ("#return");
15592 6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	141 jit_value *retval;
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	142 try
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	143 {
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	144 retval = visit (expr);
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	145 }
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	146 catch (const jit_break_exception&)
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	147 {}
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	148
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	149 if (breaks.size () \|\| continues.size ())
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	150 throw jit_fail_exception ("break/continue not supported in "
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	151 "anonymous functions");
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	152
15337 3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	153 block->append (factory.create<jit_assign> (retvar, retval));
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	154 return_value = retvar;
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	155 }
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	156 }
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	157 else
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	158 {
15592 6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	159 try
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	160 {
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	161 visit_statement_list (*fcn.body ());
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	162 }
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	163 catch (const jit_break_exception&)
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	164 {
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	165 all_breaking = true;
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	166 }
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	167
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	168 // the user may use break or continue to exit the function
15337 3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	169 finish_breaks (final_block, continues);
15592 6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	170 finish_breaks (final_block, breaks);
15337 3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	171 }
15592 6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	172
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	173 if (! all_breaking)
15337 3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	174 block->append (factory.create<jit_branch> (final_block));
15592 6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	175
15337 3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	176 blocks.push_back (final_block);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	177 block = final_block;
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	178
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	179 if (! return_value && rlist && rlist->size () == 1)
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	180 {
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	181 tree_decl_elt *elt = rlist->front ();
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	182 return_value = get_variable (elt->name ());
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	183 }
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	184
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	185 // FIXME: We should use live range analysis to delete variables where needed.
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	186 // For now we just delete everything at the end of the function.
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	187 for (variable_map::iterator iter = vmap.begin (); iter != vmap.end (); ++iter)
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	188 {
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	189 if (iter->second != return_value)
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	190 {
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	191 jit_call *call;
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	192 call = factory.create<jit_call> (&jit_typeinfo::destroy,
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	193 iter->second);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	194 final_block->append (call);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	195 }
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	196 }
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	197
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	198 if (return_value)
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	199 final_block->append (factory.create<jit_return> (return_value));
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	200 else
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	201 final_block->append (factory.create<jit_return> ());
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	202 }
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	203
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	204 void
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	205 jit_convert::visit_anon_fcn_handle (tree_anon_fcn_handle&)
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	206 {
15016 005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	207 throw jit_fail_exception ();
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	208 }
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	209
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	210 void
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	211 jit_convert::visit_argument_list (tree_argument_list&)
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	212 {
15016 005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	213 throw jit_fail_exception ();
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	214 }
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	215
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	216 void
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	217 jit_convert::visit_binary_expression (tree_binary_expression& be)
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	218 {
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	219 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	220 {
f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	221 tree_boolean_expression *boole;
f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	222 boole = dynamic_cast<tree_boolean_expression *> (&be);
f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	223 assert (boole);
f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	224 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	225
15027 741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	226 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	227 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	228 vmap[short_name] = short_result;
f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	229
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	230 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	231 tree_expression *lhs = be.lhs ();
f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	232 jit_value *lhsv = visit (lhs);
f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	233 lhsv = create_checked (&jit_typeinfo::logically_true, lhsv);
f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	234
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	235 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	236 blocks.push_back (short_early);
14978 f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	237
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	238 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	239
f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	240 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	241 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	242 else
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	243 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	244
f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	245 block = short_early;
f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	246
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	247 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	248 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	249 block->append (factory.create<jit_branch> (done));
14978 f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	250
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	251 blocks.push_back (short_cont);
14978 f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	252 block = short_cont;
f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	253
f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	254 tree_expression *rhs = be.rhs ();
f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	255 jit_value *rhsv = visit (rhs);
f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	256 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	257 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	258 block->append (factory.create<jit_branch> (done));
14978 f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	259
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	260 blocks.push_back (done);
14978 f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	261 block = done;
f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	262 result = short_result;
f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	263 }
f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	264 else
f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	265 {
f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	266 tree_expression *lhs = be.lhs ();
f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	267 jit_value *lhsv = visit (lhs);
f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	268
f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	269 tree_expression *rhs = be.rhs ();
f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	270 jit_value *rhsv = visit (rhs);
f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	271
14983 a5f75de0dab1 Rename jit_function to jit_operation Max Brister <max@2bass.com> parents: 14978 diff changeset	272 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	273 result = create_checked (fn, lhsv, rhsv);
f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	274 }
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	275 }
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 void
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	278 jit_convert::visit_break_command (tree_break_command&)
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	279 {
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	280 breaks.push_back (block);
15592 6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	281 throw jit_break_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
14936 32deb562ae77 Allow for construction of ranges during jit Max Brister <max@2bass.com> parents: 14935 diff changeset	285 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	286 {
14936 32deb562ae77 Allow for construction of ranges during jit Max Brister <max@2bass.com> parents: 14935 diff changeset	287 // 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	288 jit_value *base = visit (expr.base ());
c0a5ab3b9278 jit_const no longer inherits from jit_instruction Max Brister <max@2bass.com> parents: 14943 diff changeset	289 jit_value *limit = visit (expr.limit ());
c0a5ab3b9278 jit_const no longer inherits from jit_instruction Max Brister <max@2bass.com> parents: 14943 diff changeset	290 jit_value *increment;
14936 32deb562ae77 Allow for construction of ranges during jit Max Brister <max@2bass.com> parents: 14935 diff changeset	291 tree_expression *tinc = expr.increment ();
32deb562ae77 Allow for construction of ranges during jit Max Brister <max@2bass.com> parents: 14935 diff changeset	292
32deb562ae77 Allow for construction of ranges during jit Max Brister <max@2bass.com> parents: 14935 diff changeset	293 if (tinc)
32deb562ae77 Allow for construction of ranges during jit Max Brister <max@2bass.com> parents: 14935 diff changeset	294 increment = visit (tinc);
32deb562ae77 Allow for construction of ranges during jit Max Brister <max@2bass.com> parents: 14935 diff changeset	295 else
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	296 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	297
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	298 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	299 limit, increment));
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	300 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	301
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	302 void
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	303 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	304 {
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	305 continues.push_back (block);
15592 6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	306 throw jit_break_exception ();
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	307 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	308
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	309 void
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	310 jit_convert::visit_global_command (tree_global_command&)
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	311 {
15016 005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	312 throw jit_fail_exception ();
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	313 }
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	314
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	315 void
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	316 jit_convert::visit_persistent_command (tree_persistent_command&)
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	317 {
15016 005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	318 throw jit_fail_exception ();
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	319 }
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	320
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	321 void
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	322 jit_convert::visit_decl_elt (tree_decl_elt&)
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	323 {
15016 005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	324 throw jit_fail_exception ();
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	325 }
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	326
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	327 void
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	328 jit_convert::visit_decl_init_list (tree_decl_init_list&)
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	329 {
15016 005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	330 throw jit_fail_exception ();
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	331 }
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	332
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	333 void
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	334 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	335 {
14938 bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	336 // 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	337 // 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	338 // 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	339
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	340 // 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	341 unwind_protect prot;
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	342 prot.protect_var (breaks);
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	343 prot.protect_var (continues);
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	344 breaks.clear ();
14989 dfaa8da46364 Support while loops in JIT Max Brister <max@2bass.com> parents: 14988 diff changeset	345 continues.clear ();
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	346
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	347 // 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	348 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	349 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	350 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	351 vmap[iter_name] = iterator;
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	352
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	353 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	354 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	355
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	356 // 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	357 // 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	358 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	359 if (! control)
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	360 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	361 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	362 control);
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	363 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	364 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	365
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	366 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	367 iterator);
a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	368 block->append (check);
a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	369 block->append (factory.create<jit_cond_branch> (check, body, tail));
15233 c27a1e131b16 pt-jit.cc (jit_convert::visit_simple_for_command): Fix block order Max Brister <max@2bass.com> parents: 15230 diff changeset	370
c27a1e131b16 pt-jit.cc (jit_convert::visit_simple_for_command): Fix block order Max Brister <max@2bass.com> parents: 15230 diff changeset	371 blocks.push_back (body);
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	372 block = body;
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	373
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	374 // 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	375 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	376 control, iterator);
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	377 block->append (idx_rhs);
14969 bbeef7b8ea2e Add support for matrix indexed assignment to JIT Max Brister <max@2bass.com> parents: 14968 diff changeset	378 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	379
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	380 // do loop
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	381 tree_statement_list *pt_body = cmd.body ();
15592 6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	382 bool all_breaking = false;
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	383 try
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	384 {
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	385 pt_body->accept (*this);
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	386 }
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	387 catch (const jit_break_exception&)
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	388 {
15592 6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	389 if (continues.empty ())
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	390 {
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	391 // WTF are you doing user? Every branch was a break, why did you have
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	392 // a loop??? Users are silly people...
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	393 finish_breaks (tail, breaks);
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	394 blocks.push_back (tail);
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	395 block = tail;
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	396 return;
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	397 }
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	398
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	399 all_breaking = true;
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	400 }
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	401
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	402 // 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	403 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	404 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	405
15603 44272909d926 Stop JIT on interrupt Max Brister <max@2bass.com> parents: 15602 diff changeset	406 jit_block *interrupt_check = factory.create<jit_block> ("for_interrupt");
44272909d926 Stop JIT on interrupt Max Brister <max@2bass.com> parents: 15602 diff changeset	407 blocks.push_back (interrupt_check);
44272909d926 Stop JIT on interrupt Max Brister <max@2bass.com> parents: 15602 diff changeset	408
15592 6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	409 if (! all_breaking)
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	410 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	411 finish_breaks (check_block, continues);
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	412
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	413 block = check_block;
14983 a5f75de0dab1 Rename jit_function to jit_operation Max Brister <max@2bass.com> parents: 14978 diff changeset	414 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	415 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	416 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	417 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	418 block->append (factory.create<jit_assign> (iterator, iter_inc));
15592 6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	419 check = block->append (factory.create<jit_call> (jit_typeinfo::for_check,
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	420 control, iterator));
15603 44272909d926 Stop JIT on interrupt Max Brister <max@2bass.com> parents: 15602 diff changeset	421 block->append (factory.create<jit_cond_branch> (check, interrupt_check,
44272909d926 Stop JIT on interrupt Max Brister <max@2bass.com> parents: 15602 diff changeset	422 tail));
44272909d926 Stop JIT on interrupt Max Brister <max@2bass.com> parents: 15602 diff changeset	423
44272909d926 Stop JIT on interrupt Max Brister <max@2bass.com> parents: 15602 diff changeset	424 block = interrupt_check;
44272909d926 Stop JIT on interrupt Max Brister <max@2bass.com> parents: 15602 diff changeset	425 jit_error_check *ec
44272909d926 Stop JIT on interrupt Max Brister <max@2bass.com> parents: 15602 diff changeset	426 = factory.create<jit_error_check> (jit_error_check::var_interrupt,
44272909d926 Stop JIT on interrupt Max Brister <max@2bass.com> parents: 15602 diff changeset	427 body, final_block);
44272909d926 Stop JIT on interrupt Max Brister <max@2bass.com> parents: 15602 diff changeset	428 block->append (ec);
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	429
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	430 // 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	431 blocks.push_back (tail);
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	432 finish_breaks (tail, breaks);
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	433 block = tail;
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	434 }
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	435
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	436 void
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	437 jit_convert::visit_complex_for_command (tree_complex_for_command&)
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	438 {
15016 005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	439 throw jit_fail_exception ();
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	440 }
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	441
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	442 void
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	443 jit_convert::visit_octave_user_script (octave_user_script&)
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	444 {
15016 005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	445 throw jit_fail_exception ();
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	446 }
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	447
14915 cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14913 diff changeset	448 void
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	449 jit_convert::visit_octave_user_function (octave_user_function&)
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	450 {
15016 005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	451 throw jit_fail_exception ();
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	452 }
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	453
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	454 void
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	455 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	456 {
15016 005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	457 throw jit_fail_exception ();
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	458 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	459
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	460 void
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	461 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	462 {
15016 005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	463 throw jit_fail_exception ();
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	464 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	465
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	466 void
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	467 jit_convert::visit_function_def (tree_function_def&)
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	468 {
15016 005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	469 throw jit_fail_exception ();
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	470 }
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	471
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	472 void
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	473 jit_convert::visit_identifier (tree_identifier& ti)
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	474 {
15056 bc32288f4a42 Support the end keyword for one dimentional indexing in JIT. Max Brister <max@2bass.com> parents: 15030 diff changeset	475 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	476 {
bc32288f4a42 Support the end keyword for one dimentional indexing in JIT. Max Brister <max@2bass.com> parents: 15030 diff changeset	477 if (!end_context.size ())
bc32288f4a42 Support the end keyword for one dimentional indexing in JIT. Max Brister <max@2bass.com> parents: 15030 diff changeset	478 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	479 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	480 }
bc32288f4a42 Support the end keyword for one dimentional indexing in JIT. Max Brister <max@2bass.com> parents: 15030 diff changeset	481 else
15334 8125773322d4 Error on undefined an unused variables in JIT Max Brister <max@2bass.com> parents: 15311 diff changeset	482 {
8125773322d4 Error on undefined an unused variables in JIT Max Brister <max@2bass.com> parents: 15311 diff changeset	483 jit_variable *var = get_variable (ti.name ());
8125773322d4 Error on undefined an unused variables in JIT Max Brister <max@2bass.com> parents: 15311 diff changeset	484 jit_instruction *instr;
8125773322d4 Error on undefined an unused variables in JIT Max Brister <max@2bass.com> parents: 15311 diff changeset	485 instr = factory.create<jit_call> (&jit_typeinfo::grab, var);
8125773322d4 Error on undefined an unused variables in JIT Max Brister <max@2bass.com> parents: 15311 diff changeset	486 result = block->append (instr);
8125773322d4 Error on undefined an unused variables in JIT Max Brister <max@2bass.com> parents: 15311 diff changeset	487 }
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	488 }
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	489
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	490 void
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	491 jit_convert::visit_if_clause (tree_if_clause&)
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	492 {
15016 005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	493 throw jit_fail_exception ();
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	494 }
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	495
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	496 void
14923 168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	497 jit_convert::visit_if_command (tree_if_command& cmd)
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	498 {
14923 168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	499 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	500 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	501 lst->accept (*this);
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	502 }
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	503
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	504 void
14923 168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	505 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	506 {
14923 168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	507 tree_if_clause *last = lst.back ();
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	508 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	509
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	510 // 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	511 // 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	512 // 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	513 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	514 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	515 entry_blocks[0] = block;
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	516
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	517 // 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	518 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	519 ++iter;
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	520 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	521 {
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	522 tree_if_clause tic = iter;
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	523 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	524 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	525 else
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	526 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	527 }
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	528
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	529 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	530 if (! last_else)
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	531 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	532
15592 6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	533
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	534 // each branch in the if statement will have different breaks/continues
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	535 block_list current_breaks = breaks;
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	536 block_list current_continues = continues;
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	537 breaks.clear ();
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	538 continues.clear ();
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	539
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	540 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	541 iter = lst.begin ();
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	542 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	543 {
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	544 tree_if_clause tic = iter;
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	545 block = entry_blocks[i];
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	546 assert (block);
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	547
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	548 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	549 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	550
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	551 if (! tic->is_else_clause ())
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	552 {
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	553 tree_expression *expr = tic->condition ();
14944 c0a5ab3b9278 jit_const no longer inherits from jit_instruction Max Brister <max@2bass.com> parents: 14943 diff changeset	554 jit_value *cond = visit (expr);
14961 903a5ee2cdde Simplify the creation of error checks in jit Max Brister <max@2bass.com> parents: 14960 diff changeset	555 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	556 cond);
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	557 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	558 : "ifelse_body");
a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	559 blocks.push_back (body);
14923 168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	560
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	561 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	562 entry_blocks[i + 1]);
14923 168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	563 block->append (br);
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	564 block = body;
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	565 }
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	566
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	567 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	568 assert (stmt_lst); // jwe: Can this be null?
15592 6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	569
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	570 try
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	571 {
15592 6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	572 stmt_lst->accept (*this);
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	573 ++num_incomming;
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	574 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	575 }
15592 6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	576 catch(const jit_break_exception&)
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	577 {}
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	578
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	579 current_breaks.splice (current_breaks.end (), breaks);
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	580 current_continues.splice (current_continues.end (), continues);
14923 168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	581 }
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	582
15592 6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	583 breaks.splice (breaks.end (), current_breaks);
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	584 continues.splice (continues.end (), current_continues);
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	585
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	586 if (num_incomming \|\| ! last_else)
14923 168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	587 {
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	588 blocks.push_back (tail);
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	589 block = tail;
14923 168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	590 }
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	591 else
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	592 // every branch broke, so we don't have a tail
15592 6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	593 throw jit_break_exception ();
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	594 }
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	595
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	596 void
14951 4c9fd3e31436 Start of jit support for double matricies Max Brister <max@2bass.com> parents: 14949 diff changeset	597 jit_convert::visit_index_expression (tree_index_expression& exp)
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	598 {
15334 8125773322d4 Error on undefined an unused variables in JIT Max Brister <max@2bass.com> parents: 15311 diff changeset	599 result = resolve (exp);
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	600 }
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	601
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	602 void
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	603 jit_convert::visit_matrix (tree_matrix&)
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	604 {
15016 005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	605 throw jit_fail_exception ();
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_cell (tree_cell&)
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 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 ();
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	612 }
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	613
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	614 void
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	615 jit_convert::visit_multi_assignment (tree_multi_assignment&)
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 ();
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	618 }
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	619
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 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_no_op_command (tree_no_op_command&)
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	622 {
15016 005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	623 throw jit_fail_exception ();
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	624 }
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	625
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	626 void
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	627 jit_convert::visit_constant (tree_constant& tc)
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	628 {
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	629 octave_value v = tc.rvalue1 ();
15583 0754bdfbc8fe Correct multiplication complex multiplication with NaN in JIT Max Brister <max@2bass.com> parents: 15582 diff changeset	630 jit_type *ty = jit_typeinfo::type_of (v);
0754bdfbc8fe Correct multiplication complex multiplication with NaN in JIT Max Brister <max@2bass.com> parents: 15582 diff changeset	631
0754bdfbc8fe Correct multiplication complex multiplication with NaN in JIT Max Brister <max@2bass.com> parents: 15582 diff changeset	632 if (ty == jit_typeinfo::get_scalar ())
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	633 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	634 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	635 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	636 }
15583 0754bdfbc8fe Correct multiplication complex multiplication with NaN in JIT Max Brister <max@2bass.com> parents: 15582 diff changeset	637 else if (ty == jit_typeinfo::get_range ())
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	638 {
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	639 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	640 result = factory.create<jit_const_range> (rv);
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	641 }
15583 0754bdfbc8fe Correct multiplication complex multiplication with NaN in JIT Max Brister <max@2bass.com> parents: 15582 diff changeset	642 else if (ty == jit_typeinfo::get_complex ())
14984 561aad6a9e4b Initial support for complex numbers in JIT Max Brister <max@2bass.com> parents: 14983 diff changeset	643 {
561aad6a9e4b Initial support for complex numbers in JIT Max Brister <max@2bass.com> parents: 14983 diff changeset	644 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	645 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	646 }
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	647 else
15016 005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	648 throw jit_fail_exception ("Unknown constant");
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	649 }
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	650
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	651 void
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	652 jit_convert::visit_fcn_handle (tree_fcn_handle&)
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	653 {
15016 005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	654 throw jit_fail_exception ();
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	655 }
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	656
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	657 void
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	658 jit_convert::visit_parameter_list (tree_parameter_list&)
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	659 {
15016 005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	660 throw jit_fail_exception ();
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	661 }
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	662
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	663 void
15146 709e8928e68c Scalar unary operation support in JIT Max Brister <max@2bass.com> parents: 15140 diff changeset	664 jit_convert::visit_postfix_expression (tree_postfix_expression& tpe)
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	665 {
15146 709e8928e68c Scalar unary operation support in JIT Max Brister <max@2bass.com> parents: 15140 diff changeset	666 octave_value::unary_op etype = tpe.op_type ();
709e8928e68c Scalar unary operation support in JIT Max Brister <max@2bass.com> parents: 15140 diff changeset	667 tree_expression *operand = tpe.operand ();
709e8928e68c Scalar unary operation support in JIT Max Brister <max@2bass.com> parents: 15140 diff changeset	668 jit_value *operandv = visit (operand);
709e8928e68c Scalar unary operation support in JIT Max Brister <max@2bass.com> parents: 15140 diff changeset	669
709e8928e68c Scalar unary operation support in JIT Max Brister <max@2bass.com> parents: 15140 diff changeset	670 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	671 result = create_checked (fn, operandv);
709e8928e68c Scalar unary operation support in JIT Max Brister <max@2bass.com> parents: 15140 diff changeset	672
709e8928e68c Scalar unary operation support in JIT Max Brister <max@2bass.com> parents: 15140 diff changeset	673 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	674 {
15334 8125773322d4 Error on undefined an unused variables in JIT Max Brister <max@2bass.com> parents: 15311 diff changeset	675 jit_value *ret = create_checked (&jit_typeinfo::grab, operandv);
15148 1b2fbc30e4e7 Postfix increment and decrement operations in JIT Max Brister <max@2bass.com> parents: 15147 diff changeset	676 do_assign (operand, result);
1b2fbc30e4e7 Postfix increment and decrement operations in JIT Max Brister <max@2bass.com> parents: 15147 diff changeset	677 result = ret;
15146 709e8928e68c Scalar unary operation support in JIT Max Brister <max@2bass.com> parents: 15140 diff changeset	678 }
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	679 }
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	680
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	681 void
15146 709e8928e68c Scalar unary operation support in JIT Max Brister <max@2bass.com> parents: 15140 diff changeset	682 jit_convert::visit_prefix_expression (tree_prefix_expression& tpe)
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	683 {
15146 709e8928e68c Scalar unary operation support in JIT Max Brister <max@2bass.com> parents: 15140 diff changeset	684 octave_value::unary_op etype = tpe.op_type ();
709e8928e68c Scalar unary operation support in JIT Max Brister <max@2bass.com> parents: 15140 diff changeset	685 tree_expression *operand = tpe.operand ();
709e8928e68c Scalar unary operation support in JIT Max Brister <max@2bass.com> parents: 15140 diff changeset	686 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	687 result = create_checked (fn, visit (operand));
709e8928e68c Scalar unary operation support in JIT Max Brister <max@2bass.com> parents: 15140 diff changeset	688
709e8928e68c Scalar unary operation support in JIT Max Brister <max@2bass.com> parents: 15140 diff changeset	689 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	690 do_assign (operand, result);
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	691 }
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	692
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	693 void
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	694 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	695 {
15016 005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	696 throw jit_fail_exception ();
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	697 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	698
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	699 void
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	700 jit_convert::visit_return_list (tree_return_list&)
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	701 {
15016 005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	702 throw jit_fail_exception ();
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	703 }
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 void
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	706 jit_convert::visit_simple_assignment (tree_simple_assignment& tsa)
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	707 {
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	708 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	709 jit_value *rhsv = visit (rhs);
15140 6ea86e1d0f5f Support +=, -=, =, ect. in JIT Max Brister <max@2bass.com>* parents: 15135 diff changeset	710 octave_value::assign_op op = tsa.op_type ();
6ea86e1d0f5f Support +=, -=, =, ect. in JIT Max Brister <max@2bass.com>* parents: 15135 diff changeset	711
6ea86e1d0f5f Support +=, -=, =, ect. in JIT Max Brister <max@2bass.com>* parents: 15135 diff changeset	712 if (op != octave_value::op_asn_eq)
6ea86e1d0f5f Support +=, -=, =, ect. in JIT Max Brister <max@2bass.com>* parents: 15135 diff changeset	713 {
6ea86e1d0f5f Support +=, -=, =, ect. in JIT Max Brister <max@2bass.com>* parents: 15135 diff changeset	714 // 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	715 // but isn't always optimal.
6ea86e1d0f5f Support +=, -=, =, ect. in JIT Max Brister <max@2bass.com>* parents: 15135 diff changeset	716 tree_expression *lhs = tsa.left_hand_side ();
6ea86e1d0f5f Support +=, -=, =, ect. in JIT Max Brister <max@2bass.com>* parents: 15135 diff changeset	717 jit_value *lhsv = visit (lhs);
6ea86e1d0f5f Support +=, -=, =, ect. in JIT Max Brister <max@2bass.com>* parents: 15135 diff changeset	718 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	719 const jit_operation& fn = jit_typeinfo::binary_op (bop);
6ea86e1d0f5f Support +=, -=, =, ect. in JIT Max Brister <max@2bass.com>* parents: 15135 diff changeset	720 rhsv = create_checked (fn, lhsv, rhsv);
6ea86e1d0f5f Support +=, -=, =, ect. in JIT Max Brister <max@2bass.com>* parents: 15135 diff changeset	721 }
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	722
14978 f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	723 result = do_assign (tsa.left_hand_side (), rhsv);
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	724 }
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	725
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	726 void
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	727 jit_convert::visit_statement (tree_statement& stmt)
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	728 {
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	729 tree_command *cmd = stmt.command ();
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	730 tree_expression *expr = stmt.expression ();
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	731
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	732 if (cmd)
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	733 visit (cmd);
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	734 else
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	735 {
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	736 // stolen from tree_evaluator::visit_statement
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	737 bool do_bind_ans = false;
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	738
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	739 if (expr->is_identifier ())
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	740 {
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	741 tree_identifier id = dynamic_cast<tree_identifier > (expr);
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	742
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	743 do_bind_ans = (! id->is_variable ());
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	744 }
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	745 else
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	746 do_bind_ans = (! expr->is_assignment_expression ());
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	747
14944 c0a5ab3b9278 jit_const no longer inherits from jit_instruction Max Brister <max@2bass.com> parents: 14943 diff changeset	748 jit_value *expr_result = visit (expr);
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	749
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	750 if (do_bind_ans)
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	751 do_assign ("ans", expr_result, expr->print_result ());
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	752 else if (expr->is_identifier () && expr->print_result ())
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	753 {
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	754 // 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	755 // nargout to visit_identifier
14983 a5f75de0dab1 Rename jit_function to jit_operation Max Brister <max@2bass.com> parents: 14978 diff changeset	756 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	757 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	758 block->append (factory.create<jit_call> (fn, name, expr_result));
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	759 }
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	760 }
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	761 }
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	762
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	763 void
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	764 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	765 {
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	766 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	767 ++iter)
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	768 {
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	769 tree_statement elt = iter;
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	770 // jwe: Can this ever be null?
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	771 assert (elt);
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	772 elt->accept (*this);
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	773 }
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	774 }
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	775
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	776 void
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	777 jit_convert::visit_switch_case (tree_switch_case&)
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	778 {
15016 005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	779 throw jit_fail_exception ();
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	780 }
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	781
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	782 void
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	783 jit_convert::visit_switch_case_list (tree_switch_case_list&)
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	784 {
15016 005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	785 throw jit_fail_exception ();
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	786 }
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	787
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	788 void
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	789 jit_convert::visit_switch_command (tree_switch_command&)
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	790 {
15016 005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	791 throw jit_fail_exception ();
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	792 }
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	793
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	794 void
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	795 jit_convert::visit_try_catch_command (tree_try_catch_command&)
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	796 {
15016 005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	797 throw jit_fail_exception ();
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	798 }
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	799
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	800 void
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	801 jit_convert::visit_unwind_protect_command (tree_unwind_protect_command&)
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	802 {
15016 005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	803 throw jit_fail_exception ();
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	804 }
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	805
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	806 void
14989 dfaa8da46364 Support while loops in JIT Max Brister <max@2bass.com> parents: 14988 diff changeset	807 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	808 {
14989 dfaa8da46364 Support while loops in JIT Max Brister <max@2bass.com> parents: 14988 diff changeset	809 unwind_protect prot;
dfaa8da46364 Support while loops in JIT Max Brister <max@2bass.com> parents: 14988 diff changeset	810 prot.protect_var (breaks);
dfaa8da46364 Support while loops in JIT Max Brister <max@2bass.com> parents: 14988 diff changeset	811 prot.protect_var (continues);
dfaa8da46364 Support while loops in JIT Max Brister <max@2bass.com> parents: 14988 diff changeset	812 breaks.clear ();
dfaa8da46364 Support while loops in JIT Max Brister <max@2bass.com> parents: 14988 diff changeset	813 continues.clear ();
dfaa8da46364 Support while loops in JIT Max Brister <max@2bass.com> parents: 14988 diff changeset	814
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	815 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	816 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	817 blocks.push_back (cond_check);
14989 dfaa8da46364 Support while loops in JIT Max Brister <max@2bass.com> parents: 14988 diff changeset	818 block = cond_check;
dfaa8da46364 Support while loops in JIT Max Brister <max@2bass.com> parents: 14988 diff changeset	819
dfaa8da46364 Support while loops in JIT Max Brister <max@2bass.com> parents: 14988 diff changeset	820 tree_expression *expr = wc.condition ();
dfaa8da46364 Support while loops in JIT Max Brister <max@2bass.com> parents: 14988 diff changeset	821 assert (expr && "While expression can not be null");
dfaa8da46364 Support while loops in JIT Max Brister <max@2bass.com> parents: 14988 diff changeset	822 jit_value *check = visit (expr);
dfaa8da46364 Support while loops in JIT Max Brister <max@2bass.com> parents: 14988 diff changeset	823 check = create_checked (&jit_typeinfo::logically_true, check);
dfaa8da46364 Support while loops in JIT Max Brister <max@2bass.com> parents: 14988 diff changeset	824
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	825 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	826 blocks.push_back (body);
14989 dfaa8da46364 Support while loops in JIT Max Brister <max@2bass.com> parents: 14988 diff changeset	827
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	828 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	829 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	830 block = body;
dfaa8da46364 Support while loops in JIT Max Brister <max@2bass.com> parents: 14988 diff changeset	831
dfaa8da46364 Support while loops in JIT Max Brister <max@2bass.com> parents: 14988 diff changeset	832 tree_statement_list *loop_body = wc.body ();
15592 6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	833 bool all_breaking = false;
14989 dfaa8da46364 Support while loops in JIT Max Brister <max@2bass.com> parents: 14988 diff changeset	834 if (loop_body)
15592 6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	835 {
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	836 try
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	837 {
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	838 loop_body->accept (*this);
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	839 }
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	840 catch (const jit_break_exception&)
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	841 {
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	842 all_breaking = true;
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	843 }
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	844 }
14989 dfaa8da46364 Support while loops in JIT Max Brister <max@2bass.com> parents: 14988 diff changeset	845
dfaa8da46364 Support while loops in JIT Max Brister <max@2bass.com> parents: 14988 diff changeset	846 finish_breaks (tail, breaks);
15603 44272909d926 Stop JIT on interrupt Max Brister <max@2bass.com> parents: 15602 diff changeset	847
44272909d926 Stop JIT on interrupt Max Brister <max@2bass.com> parents: 15602 diff changeset	848 if (! all_breaking \|\| continues.size ())
44272909d926 Stop JIT on interrupt Max Brister <max@2bass.com> parents: 15602 diff changeset	849 {
44272909d926 Stop JIT on interrupt Max Brister <max@2bass.com> parents: 15602 diff changeset	850 jit_block *interrupt_check
44272909d926 Stop JIT on interrupt Max Brister <max@2bass.com> parents: 15602 diff changeset	851 = factory.create<jit_block> ("interrupt_check");
44272909d926 Stop JIT on interrupt Max Brister <max@2bass.com> parents: 15602 diff changeset	852 blocks.push_back (interrupt_check);
44272909d926 Stop JIT on interrupt Max Brister <max@2bass.com> parents: 15602 diff changeset	853 finish_breaks (interrupt_check, continues);
44272909d926 Stop JIT on interrupt Max Brister <max@2bass.com> parents: 15602 diff changeset	854 if (! all_breaking)
44272909d926 Stop JIT on interrupt Max Brister <max@2bass.com> parents: 15602 diff changeset	855 block->append (factory.create<jit_branch> (interrupt_check));
44272909d926 Stop JIT on interrupt Max Brister <max@2bass.com> parents: 15602 diff changeset	856
44272909d926 Stop JIT on interrupt Max Brister <max@2bass.com> parents: 15602 diff changeset	857 block = interrupt_check;
44272909d926 Stop JIT on interrupt Max Brister <max@2bass.com> parents: 15602 diff changeset	858 jit_error_check *ec
44272909d926 Stop JIT on interrupt Max Brister <max@2bass.com> parents: 15602 diff changeset	859 = factory.create<jit_error_check> (jit_error_check::var_interrupt,
44272909d926 Stop JIT on interrupt Max Brister <max@2bass.com> parents: 15602 diff changeset	860 cond_check, final_block);
44272909d926 Stop JIT on interrupt Max Brister <max@2bass.com> parents: 15602 diff changeset	861 block->append (ec);
44272909d926 Stop JIT on interrupt Max Brister <max@2bass.com> parents: 15602 diff changeset	862 }
14989 dfaa8da46364 Support while loops in JIT Max Brister <max@2bass.com> parents: 14988 diff changeset	863
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	864 blocks.push_back (tail);
14989 dfaa8da46364 Support while loops in JIT Max Brister <max@2bass.com> parents: 14988 diff changeset	865 block = tail;
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	866 }
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	867
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	868 void
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	869 jit_convert::visit_do_until_command (tree_do_until_command&)
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	870 {
15016 005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	871 throw jit_fail_exception ();
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	872 }
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	873
15337 3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	874 void
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	875 jit_convert::initialize (symbol_table::scope_id s)
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	876 {
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	877 scope = s;
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	878 iterator_count = 0;
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	879 for_bounds_count = 0;
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	880 short_count = 0;
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	881 jit_instruction::reset_ids ();
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	882
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	883 entry_block = factory.create<jit_block> ("body");
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	884 final_block = factory.create<jit_block> ("final");
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	885 blocks.push_back (entry_block);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	886 entry_block->mark_alive ();
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	887 block = entry_block;
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	888 }
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	889
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	890 jit_call *
a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	891 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	892 {
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	893 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	894
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	895 jit_block *normal = factory.create<jit_block> (block->name ());
15603 44272909d926 Stop JIT on interrupt Max Brister <max@2bass.com> parents: 15602 diff changeset	896 jit_error_check *check
44272909d926 Stop JIT on interrupt Max Brister <max@2bass.com> parents: 15602 diff changeset	897 = factory.create<jit_error_check> (jit_error_check::var_error_state, ret,
44272909d926 Stop JIT on interrupt Max Brister <max@2bass.com> parents: 15602 diff changeset	898 normal, final_block);
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	899 block->append (check);
a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	900 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	901 block = normal;
a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	902
a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	903 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	904 }
709f50069722 Change algorithm for placing releases and simplify PHIs in low level Octave IR Max Brister <max@2bass.com> parents: 14962 diff changeset	905
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	906 jit_variable *
15027 741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	907 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	908 {
15191 ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	909 variable_map::const_iterator iter;
15027 741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	910 iter = vmap.find (vname);
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	911 return iter != vmap.end () ? iter->second : 0;
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	912 }
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	913
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	914 jit_variable *
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	915 jit_convert::get_variable (const std::string& vname)
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	916 {
15027 741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	917 jit_variable *ret = find_variable (vname);
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	918 if (ret)
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	919 return ret;
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	920
15337 3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	921 symbol_table::symbol_record record = symbol_table::find_symbol (vname, scope);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	922 if (record.is_persistent () \|\| record.is_global ())
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	923 throw jit_fail_exception ("Persistent and global not yet supported");
15230 b0c08e995950 pt-jit.cc (jit_convert::get_variable): Add type bound Max Brister <max@2bass.com> parents: 15195 diff changeset	924
15337 3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	925 if (converting_function)
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	926 return create_variable (vname, jit_typeinfo::get_any (), false);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	927 else
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	928 {
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	929 octave_value val = record.varval ();
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	930 jit_type *type = jit_typeinfo::type_of (val);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	931 bounds.push_back (type_bound (type, vname));
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	932
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	933 return create_variable (vname, type);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	934 }
15027 741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	935 }
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	936
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	937 jit_variable *
15337 3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	938 jit_convert::create_variable (const std::string& vname, jit_type *type,
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	939 bool isarg)
15027 741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	940 {
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	941 jit_variable *var = factory.create<jit_variable> (vname);
15337 3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	942
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	943 if (isarg)
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	944 {
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	945 jit_extract_argument *extract;
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	946 extract = factory.create<jit_extract_argument> (type, var);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	947 entry_block->prepend (extract);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	948 }
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	949 else
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	950 {
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	951 jit_call *init = factory.create<jit_call> (&jit_typeinfo::create_undef);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	952 jit_assign *assign = factory.create<jit_assign> (var, init);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	953 entry_block->prepend (assign);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	954 entry_block->prepend (init);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	955 }
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	956
15027 741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	957 return vmap[vname] = var;
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	958 }
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	959
15027 741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	960 std::string
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	961 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	962 {
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	963 std::stringstream ss;
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	964 ss << prefix << count;
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	965 if (inc)
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	966 ++count;
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	967 return ss.str ();
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	968 }
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	969
15067 df4538e3b50b ND scalar indexing in JIT. Max Brister <max@2bass.com> parents: 15056 diff changeset	970 jit_instruction *
15334 8125773322d4 Error on undefined an unused variables in JIT Max Brister <max@2bass.com> parents: 15311 diff changeset	971 jit_convert::resolve (tree_index_expression& exp, jit_value *extra_arg,
8125773322d4 Error on undefined an unused variables in JIT Max Brister <max@2bass.com> parents: 15311 diff changeset	972 bool lhs)
14969 bbeef7b8ea2e Add support for matrix indexed assignment to JIT Max Brister <max@2bass.com> parents: 14968 diff changeset	973 {
bbeef7b8ea2e Add support for matrix indexed assignment to JIT Max Brister <max@2bass.com> parents: 14968 diff changeset	974 std::string type = exp.type_tags ();
bbeef7b8ea2e Add support for matrix indexed assignment to JIT Max Brister <max@2bass.com> parents: 14968 diff changeset	975 if (! (type.size () == 1 && type[0] == '('))
15016 005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	976 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	977
bbeef7b8ea2e Add support for matrix indexed assignment to JIT Max Brister <max@2bass.com> parents: 14968 diff changeset	978 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	979 if (args.size () != 1)
15334 8125773322d4 Error on undefined an unused variables in JIT Max Brister <max@2bass.com> parents: 15311 diff changeset	980 throw jit_fail_exception ("Bad number of arguments in "
8125773322d4 Error on undefined an unused variables in JIT Max Brister <max@2bass.com> parents: 15311 diff changeset	981 "tree_index_expression");
14969 bbeef7b8ea2e Add support for matrix indexed assignment to JIT Max Brister <max@2bass.com> parents: 14968 diff changeset	982
bbeef7b8ea2e Add support for matrix indexed assignment to JIT Max Brister <max@2bass.com> parents: 14968 diff changeset	983 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	984 if (! arg_list)
15016 005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	985 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	986
15067 df4538e3b50b ND scalar indexing in JIT. Max Brister <max@2bass.com> parents: 15056 diff changeset	987 if (arg_list->size () < 1)
df4538e3b50b ND scalar indexing in JIT. Max Brister <max@2bass.com> parents: 15056 diff changeset	988 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	989
bbeef7b8ea2e Add support for matrix indexed assignment to JIT Max Brister <max@2bass.com> parents: 14968 diff changeset	990 tree_expression *tree_object = exp.expression ();
15334 8125773322d4 Error on undefined an unused variables in JIT Max Brister <max@2bass.com> parents: 15311 diff changeset	991 jit_value *object;
8125773322d4 Error on undefined an unused variables in JIT Max Brister <max@2bass.com> parents: 15311 diff changeset	992 if (lhs)
8125773322d4 Error on undefined an unused variables in JIT Max Brister <max@2bass.com> parents: 15311 diff changeset	993 {
8125773322d4 Error on undefined an unused variables in JIT Max Brister <max@2bass.com> parents: 15311 diff changeset	994 tree_identifier id = dynamic_cast<tree_identifier > (tree_object);
8125773322d4 Error on undefined an unused variables in JIT Max Brister <max@2bass.com> parents: 15311 diff changeset	995 if (! id)
8125773322d4 Error on undefined an unused variables in JIT Max Brister <max@2bass.com> parents: 15311 diff changeset	996 throw jit_fail_exception ("expected identifier");
8125773322d4 Error on undefined an unused variables in JIT Max Brister <max@2bass.com> parents: 15311 diff changeset	997 object = get_variable (id->name ());
8125773322d4 Error on undefined an unused variables in JIT Max Brister <max@2bass.com> parents: 15311 diff changeset	998 }
8125773322d4 Error on undefined an unused variables in JIT Max Brister <max@2bass.com> parents: 15311 diff changeset	999 else
8125773322d4 Error on undefined an unused variables in JIT Max Brister <max@2bass.com> parents: 15311 diff changeset	1000 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	1001
15067 df4538e3b50b ND scalar indexing in JIT. Max Brister <max@2bass.com> parents: 15056 diff changeset	1002 size_t narg = arg_list->size ();
df4538e3b50b ND scalar indexing in JIT. Max Brister <max@2bass.com> parents: 15056 diff changeset	1003 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	1004 bool have_extra = extra_arg;
f57d7578c1a6 Support ND matrix indexing with scalar assignment in JIT. Max Brister <max@2bass.com> parents: 15067 diff changeset	1005 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	1006 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	1007
15067 df4538e3b50b ND scalar indexing in JIT. Max Brister <max@2bass.com> parents: 15056 diff changeset	1008 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	1009 {
df4538e3b50b ND scalar indexing in JIT. Max Brister <max@2bass.com> parents: 15056 diff changeset	1010 unwind_protect prot;
df4538e3b50b ND scalar indexing in JIT. Max Brister <max@2bass.com> parents: 15056 diff changeset	1011 prot.add_method (&end_context,
df4538e3b50b ND scalar indexing in JIT. Max Brister <max@2bass.com> parents: 15056 diff changeset	1012 &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	1013
a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	1014 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	1015 end_context.push_back (ctx);
15067 df4538e3b50b ND scalar indexing in JIT. Max Brister <max@2bass.com> parents: 15056 diff changeset	1016 call_args[idx + 1] = visit (*iter);
df4538e3b50b ND scalar indexing in JIT. Max Brister <max@2bass.com> parents: 15056 diff changeset	1017 }
14969 bbeef7b8ea2e Add support for matrix indexed assignment to JIT Max Brister <max@2bass.com> parents: 14968 diff changeset	1018
15068 f57d7578c1a6 Support ND matrix indexing with scalar assignment in JIT. Max Brister <max@2bass.com> parents: 15067 diff changeset	1019 if (extra_arg)
f57d7578c1a6 Support ND matrix indexing with scalar assignment in JIT. Max Brister <max@2bass.com> parents: 15067 diff changeset	1020 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	1021
15334 8125773322d4 Error on undefined an unused variables in JIT Max Brister <max@2bass.com> parents: 15311 diff changeset	1022 const jit_operation& fres = lhs ? jit_typeinfo::paren_subsasgn ()
8125773322d4 Error on undefined an unused variables in JIT Max Brister <max@2bass.com> parents: 15311 diff changeset	1023 : jit_typeinfo::paren_subsref ();
8125773322d4 Error on undefined an unused variables in JIT Max Brister <max@2bass.com> parents: 15311 diff changeset	1024
15067 df4538e3b50b ND scalar indexing in JIT. Max Brister <max@2bass.com> parents: 15056 diff changeset	1025 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	1026 }
bbeef7b8ea2e Add support for matrix indexed assignment to JIT Max Brister <max@2bass.com> parents: 14968 diff changeset	1027
bbeef7b8ea2e Add support for matrix indexed assignment to JIT Max Brister <max@2bass.com> parents: 14968 diff changeset	1028 jit_value *
bbeef7b8ea2e Add support for matrix indexed assignment to JIT Max Brister <max@2bass.com> parents: 14968 diff changeset	1029 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	1030 {
bbeef7b8ea2e Add support for matrix indexed assignment to JIT Max Brister <max@2bass.com> parents: 14968 diff changeset	1031 if (! exp)
15016 005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	1032 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	1033
bbeef7b8ea2e Add support for matrix indexed assignment to JIT Max Brister <max@2bass.com> parents: 14968 diff changeset	1034 if (isa<tree_identifier> (exp))
bbeef7b8ea2e Add support for matrix indexed assignment to JIT Max Brister <max@2bass.com> parents: 14968 diff changeset	1035 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	1036 else if (tree_index_expression *idx
bbeef7b8ea2e Add support for matrix indexed assignment to JIT Max Brister <max@2bass.com> parents: 14968 diff changeset	1037 = dynamic_cast<tree_index_expression *> (exp))
bbeef7b8ea2e Add support for matrix indexed assignment to JIT Max Brister <max@2bass.com> parents: 14968 diff changeset	1038 {
15334 8125773322d4 Error on undefined an unused variables in JIT Max Brister <max@2bass.com> parents: 15311 diff changeset	1039 jit_value new_object = resolve (idx, rhs, true);
14969 bbeef7b8ea2e Add support for matrix indexed assignment to JIT Max Brister <max@2bass.com> parents: 14968 diff changeset	1040 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	1041
bbeef7b8ea2e Add support for matrix indexed assignment to JIT Max Brister <max@2bass.com> parents: 14968 diff changeset	1042 // 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	1043 return rhs;
bbeef7b8ea2e Add support for matrix indexed assignment to JIT Max Brister <max@2bass.com> parents: 14968 diff changeset	1044 }
bbeef7b8ea2e Add support for matrix indexed assignment to JIT Max Brister <max@2bass.com> parents: 14968 diff changeset	1045 else
15016 005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	1046 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	1047 }
bbeef7b8ea2e Add support for matrix indexed assignment to JIT Max Brister <max@2bass.com> parents: 14968 diff changeset	1048
14944 c0a5ab3b9278 jit_const no longer inherits from jit_instruction Max Brister <max@2bass.com> parents: 14943 diff changeset	1049 jit_value *
c0a5ab3b9278 jit_const no longer inherits from jit_instruction Max Brister <max@2bass.com> parents: 14943 diff changeset	1050 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	1051 bool print, bool artificial)
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	1052 {
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	1053 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	1054 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	1055
bbeef7b8ea2e Add support for matrix indexed assignment to JIT Max Brister <max@2bass.com> parents: 14968 diff changeset	1056 if (artificial)
bbeef7b8ea2e Add support for matrix indexed assignment to JIT Max Brister <max@2bass.com> parents: 14968 diff changeset	1057 assign->mark_artificial ();
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1058
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1059 if (print)
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1060 {
14983 a5f75de0dab1 Rename jit_function to jit_operation Max Brister <max@2bass.com> parents: 14978 diff changeset	1061 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	1062 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	1063 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	1064 }
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	1065
14944 c0a5ab3b9278 jit_const no longer inherits from jit_instruction Max Brister <max@2bass.com> parents: 14943 diff changeset	1066 return var;
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1067 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1068
14944 c0a5ab3b9278 jit_const no longer inherits from jit_instruction Max Brister <max@2bass.com> parents: 14943 diff changeset	1069 jit_value *
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1070 jit_convert::visit (tree& tee)
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1071 {
15146 709e8928e68c Scalar unary operation support in JIT Max Brister <max@2bass.com> parents: 15140 diff changeset	1072 unwind_protect prot;
709e8928e68c Scalar unary operation support in JIT Max Brister <max@2bass.com> parents: 15140 diff changeset	1073 prot.protect_var (result);
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1074
15146 709e8928e68c Scalar unary operation support in JIT Max Brister <max@2bass.com> parents: 15140 diff changeset	1075 tee.accept (*this);
709e8928e68c Scalar unary operation support in JIT Max Brister <max@2bass.com> parents: 15140 diff changeset	1076 return result;
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1077 }
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1078
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1079 void
14935 5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1080 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	1081 {
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1082 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	1083 ++iter)
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	1084 {
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	1085 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	1086 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	1087 }
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1088 }
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1089
15191 ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1090 // -------------------- jit_convert_llvm --------------------
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1091 llvm::Function *
15337 3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1092 jit_convert_llvm::convert_loop (llvm::Module *module,
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1093 const jit_block_list& blocks,
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1094 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	1095 {
15337 3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1096 converting_function = false;
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1097
15191 ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1098 // for now just init arguments from entry, later we will have to do something
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1099 // more interesting
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1100 jit_block *entry_block = blocks.front ();
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1101 for (jit_block::iterator iter = entry_block->begin ();
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1102 iter != entry_block->end (); ++iter)
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1103 if (jit_extract_argument *extract
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1104 = dynamic_cast<jit_extract_argument > (iter))
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1105 argument_vec.push_back (std::make_pair (extract->name (), true));
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1106
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1107
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1108 jit_type *any = jit_typeinfo::get_any ();
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	1109
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1110 // 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	1111 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	1112 arg_type = arg_type->getPointerTo ();
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1113 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	1114 arg_type, false);
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1115 function = llvm::Function::Create (ft, llvm::Function::ExternalLinkage,
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1116 "foobar", module);
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1117
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1118 try
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1119 {
14968 7f60cdfcc0e5 Do not smash stack when passing structures in JIT Max Brister <max@2bass.com> parents: 14967 diff changeset	1120 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	1121 builder.SetInsertPoint (prelude);
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1122
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1123 llvm::Value *arg = function->arg_begin ();
15191 ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1124 for (size_t i = 0; i < argument_vec.size (); ++i)
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1125 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1126 llvm::Value *loaded_arg = builder.CreateConstInBoundsGEP1_32 (arg, i);
15191 ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1127 arguments[argument_vec[i].first] = loaded_arg;
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1128 }
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1129
15337 3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1130 convert (blocks, constants);
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1131 } 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	1132 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1133 function->eraseFromParent ();
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1134 throw;
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1135 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1136
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1137 return function;
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	1138 }
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	1139
15337 3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1140
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1141 jit_function
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1142 jit_convert_llvm::convert_function (llvm::Module *module,
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1143 const jit_block_list& blocks,
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1144 const std::list<jit_value *>& constants,
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1145 octave_user_function& fcn,
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1146 const std::vector<jit_type *>& args)
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1147 {
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1148 converting_function = true;
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1149
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1150 jit_block *final_block = blocks.back ();
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1151 jit_return ret = dynamic_cast<jit_return > (final_block->back ());
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1152 assert (ret);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1153
15370 8355fddce815 Use sret and do not use save/restore stack (bug #37308) Max Brister <max@2bass.com> parents: 15346 diff changeset	1154 creating = jit_function (module, jit_convention::internal,
8355fddce815 Use sret and do not use save/restore stack (bug #37308) Max Brister <max@2bass.com> parents: 15346 diff changeset	1155 "foobar", ret->result_type (), args);
15337 3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1156 function = creating.to_llvm ();
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1157
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1158 try
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1159 {
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1160 prelude = creating.new_block ("prelude");
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1161 builder.SetInsertPoint (prelude);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1162
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1163 tree_parameter_list *plist = fcn.parameter_list ();
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1164 if (plist)
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1165 {
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1166 tree_parameter_list::iterator piter = plist->begin ();
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1167 tree_parameter_list::iterator pend = plist->end ();
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1168 for (size_t i = 0; i < args.size () && piter != pend; ++i, ++piter)
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1169 {
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1170 tree_decl_elt elt = piter;
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1171 std::string arg_name = elt->name ();
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1172 arguments[arg_name] = creating.argument (builder, i);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1173 }
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1174 }
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1175
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1176 convert (blocks, constants);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1177 } catch (const jit_fail_exception& e)
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1178 {
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1179 function->eraseFromParent ();
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1180 throw;
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1181 }
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1182
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1183 return creating;
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1184 }
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1185
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1186 void
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1187 jit_convert_llvm::convert (const jit_block_list& blocks,
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1188 const std::list<jit_value *>& constants)
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1189 {
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1190 std::list<jit_block *>::const_iterator biter;
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1191 for (biter = blocks.begin (); biter != blocks.end (); ++biter)
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1192 {
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1193 jit_block jblock = biter;
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1194 llvm::BasicBlock *block = llvm::BasicBlock::Create (context,
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1195 jblock->name (),
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1196 function);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1197 jblock->stash_llvm (block);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1198 }
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1199
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1200 jit_block first = blocks.begin ();
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1201 builder.CreateBr (first->to_llvm ());
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1202
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1203 // constants aren't in the IR, we visit those first
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1204 for (std::list<jit_value *>::const_iterator iter = constants.begin ();
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1205 iter != constants.end (); ++iter)
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1206 if (! isa<jit_instruction> (*iter))
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1207 visit (*iter);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1208
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1209 // convert all instructions
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1210 for (biter = blocks.begin (); biter != blocks.end (); ++biter)
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1211 visit (*biter);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1212
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1213 // now finish phi nodes
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1214 for (biter = blocks.begin (); biter != blocks.end (); ++biter)
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1215 {
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1216 jit_block& block = **biter;
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1217 for (jit_block::iterator piter = block.begin ();
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1218 piter != block.end () && isa<jit_phi> (*piter); ++piter)
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1219 {
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1220 jit_instruction phi = piter;
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1221 finish_phi (static_cast<jit_phi *> (phi));
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1222 }
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1223 }
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1224 }
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1225
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	1226 void
15181 ed2b911a2fb3 Rename jit_convert::convert_llvm to jit_convert_llvm Max Brister <max@2bass.com> parents: 15171 diff changeset	1227 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	1228 {
14963 709f50069722 Change algorithm for placing releases and simplify PHIs in low level Octave IR Max Brister <max@2bass.com> parents: 14962 diff changeset	1229 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	1230 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	1231 {
14963 709f50069722 Change algorithm for placing releases and simplify PHIs in low level Octave IR Max Brister <max@2bass.com> parents: 14962 diff changeset	1232 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	1233 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	1234 }
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1235 }
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1236
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1237 void
15181 ed2b911a2fb3 Rename jit_convert::convert_llvm to jit_convert_llvm Max Brister <max@2bass.com> parents: 15171 diff changeset	1238 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	1239 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1240 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	1241 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1242
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1243 void
15181 ed2b911a2fb3 Rename jit_convert::convert_llvm to jit_convert_llvm Max Brister <max@2bass.com> parents: 15171 diff changeset	1244 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	1245 {
f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	1246 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	1247 }
f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	1248
f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	1249 void
15181 ed2b911a2fb3 Rename jit_convert::convert_llvm to jit_convert_llvm Max Brister <max@2bass.com> parents: 15171 diff changeset	1250 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	1251 {
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1252 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	1253 }
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1254
14984 561aad6a9e4b Initial support for complex numbers in JIT Max Brister <max@2bass.com> parents: 14983 diff changeset	1255 void
15181 ed2b911a2fb3 Rename jit_convert::convert_llvm to jit_convert_llvm Max Brister <max@2bass.com> parents: 15171 diff changeset	1256 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	1257 {
561aad6a9e4b Initial support for complex numbers in JIT Max Brister <max@2bass.com> parents: 14983 diff changeset	1258 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	1259 llvm::Constant *values[2];
561aad6a9e4b Initial support for complex numbers in JIT Max Brister <max@2bass.com> parents: 14983 diff changeset	1260 Complex value = cc.value ();
561aad6a9e4b Initial support for complex numbers in JIT Max Brister <max@2bass.com> parents: 14983 diff changeset	1261 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	1262 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	1263 cc.stash_llvm (llvm::ConstantVector::get (values));
561aad6a9e4b Initial support for complex numbers in JIT Max Brister <max@2bass.com> parents: 14983 diff changeset	1264 }
561aad6a9e4b Initial support for complex numbers in JIT Max Brister <max@2bass.com> parents: 14983 diff changeset	1265
15181 ed2b911a2fb3 Rename jit_convert::convert_llvm to jit_convert_llvm Max Brister <max@2bass.com> parents: 15171 diff changeset	1266 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	1267 {
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1268 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	1269 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1270
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1271 void
15181 ed2b911a2fb3 Rename jit_convert::convert_llvm to jit_convert_llvm Max Brister <max@2bass.com> parents: 15171 diff changeset	1272 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	1273 {
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1274 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	1275 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	1276 llvm::Type *idx = jit_typeinfo::get_index_llvm ();
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1277 const jit_range& rng = cr.value ();
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1278
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1279 llvm::Constant *constants[4];
14951 4c9fd3e31436 Start of jit support for double matricies Max Brister <max@2bass.com> parents: 14949 diff changeset	1280 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	1281 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	1282 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	1283 constants[3] = llvm::ConstantInt::get (idx, rng.nelem);
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1284
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1285 llvm::Value *as_llvm;
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1286 as_llvm = llvm::ConstantStruct::get (stype,
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1287 llvm::makeArrayRef (constants, 4));
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1288 cr.stash_llvm (as_llvm);
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1289 }
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1290
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1291 void
15181 ed2b911a2fb3 Rename jit_convert::convert_llvm to jit_convert_llvm Max Brister <max@2bass.com> parents: 15171 diff changeset	1292 jit_convert_llvm::visit (jit_block& b)
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	1293 {
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1294 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	1295 builder.SetInsertPoint (block);
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1296 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	1297 visit (*iter);
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1298 }
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	1299
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1300 void
15181 ed2b911a2fb3 Rename jit_convert::convert_llvm to jit_convert_llvm Max Brister <max@2bass.com> parents: 15171 diff changeset	1301 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	1302 {
14948 006570a76b90 Cleanup and optimization of JIT Max Brister <max@2bass.com> parents: 14946 diff changeset	1303 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	1304 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1305
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1306 void
15181 ed2b911a2fb3 Rename jit_convert::convert_llvm to jit_convert_llvm Max Brister <max@2bass.com> parents: 15171 diff changeset	1307 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	1308 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1309 llvm::Value *cond = cb.cond_llvm ();
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1310 llvm::Value *br;
14959 12fd4a62d633 Fix whitespace issues and update documentation Max Brister <max@2bass.com> parents: 14958 diff changeset	1311 br = builder.CreateCondBr (cond, cb.successor_llvm (0),
12fd4a62d633 Fix whitespace issues and update documentation Max Brister <max@2bass.com> parents: 14958 diff changeset	1312 cb.successor_llvm (1));
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1313 cb.stash_llvm (br);
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
14913 c7071907a641 Use symbol_record_ref instead of names in JIT Max Brister <max@2bass.com> parents: 14911 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::visit (jit_call& call)
14913 c7071907a641 Use symbol_record_ref instead of names in JIT Max Brister <max@2bass.com> parents: 14911 diff changeset	1318 {
15014 094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1319 const jit_function& ol = call.overload ();
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1320
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1321 std::vector<jit_value *> args (call.arguments ().size ());
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1322 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	1323 args[i] = call.argument (i);
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1324
15016 005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	1325 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	1326 call.stash_llvm (ret);
14913 c7071907a641 Use symbol_record_ref instead of names in JIT Max Brister <max@2bass.com> parents: 14911 diff changeset	1327 }
c7071907a641 Use symbol_record_ref instead of names in JIT Max Brister <max@2bass.com> parents: 14911 diff changeset	1328
c7071907a641 Use symbol_record_ref instead of names in JIT Max Brister <max@2bass.com> parents: 14911 diff changeset	1329 void
15181 ed2b911a2fb3 Rename jit_convert::convert_llvm to jit_convert_llvm Max Brister <max@2bass.com> parents: 15171 diff changeset	1330 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	1331 {
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	1332 llvm::Value *arg = arguments[extract.name ()];
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1333 assert (arg);
14951 4c9fd3e31436 Start of jit support for double matricies Max Brister <max@2bass.com> parents: 14949 diff changeset	1334
15337 3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1335 if (converting_function)
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1336 extract.stash_llvm (arg);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1337 else
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1338 {
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1339 arg = builder.CreateLoad (arg);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1340
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1341 const jit_function& ol = extract.overload ();
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1342 extract.stash_llvm (ol.call (builder, arg));
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1343 }
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1344 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1345
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1346 void
15181 ed2b911a2fb3 Rename jit_convert::convert_llvm to jit_convert_llvm Max Brister <max@2bass.com> parents: 15171 diff changeset	1347 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	1348 {
15014 094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1349 const jit_function& ol = store.overload ();
15016 005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	1350 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	1351 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	1352 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	1353 }
c7071907a641 Use symbol_record_ref instead of names in JIT Max Brister <max@2bass.com> parents: 14911 diff changeset	1354
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1355 void
15337 3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1356 jit_convert_llvm::visit (jit_return& ret)
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1357 {
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1358 jit_value *res = ret.result ();
15370 8355fddce815 Use sret and do not use save/restore stack (bug #37308) Max Brister <max@2bass.com> parents: 15346 diff changeset	1359
8355fddce815 Use sret and do not use save/restore stack (bug #37308) Max Brister <max@2bass.com> parents: 15346 diff changeset	1360 if (converting_function)
8355fddce815 Use sret and do not use save/restore stack (bug #37308) Max Brister <max@2bass.com> parents: 15346 diff changeset	1361 creating.do_return (builder, res->to_llvm (), false);
15337 3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1362 else
15370 8355fddce815 Use sret and do not use save/restore stack (bug #37308) Max Brister <max@2bass.com> parents: 15346 diff changeset	1363 {
8355fddce815 Use sret and do not use save/restore stack (bug #37308) Max Brister <max@2bass.com> parents: 15346 diff changeset	1364 if (res)
8355fddce815 Use sret and do not use save/restore stack (bug #37308) Max Brister <max@2bass.com> parents: 15346 diff changeset	1365 builder.CreateRet (res->to_llvm ());
8355fddce815 Use sret and do not use save/restore stack (bug #37308) Max Brister <max@2bass.com> parents: 15346 diff changeset	1366 else
8355fddce815 Use sret and do not use save/restore stack (bug #37308) Max Brister <max@2bass.com> parents: 15346 diff changeset	1367 builder.CreateRetVoid ();
8355fddce815 Use sret and do not use save/restore stack (bug #37308) Max Brister <max@2bass.com> parents: 15346 diff changeset	1368 }
15337 3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1369 }
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1370
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1371 void
15181 ed2b911a2fb3 Rename jit_convert::convert_llvm to jit_convert_llvm Max Brister <max@2bass.com> parents: 15171 diff changeset	1372 jit_convert_llvm::visit (jit_phi& phi)
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1373 {
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1374 // 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	1375 // set incomming branches now
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1376 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	1377 phi.argument_count ());
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1378 builder.Insert (node);
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1379 phi.stash_llvm (node);
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
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	1382 void
15181 ed2b911a2fb3 Rename jit_convert::convert_llvm to jit_convert_llvm Max Brister <max@2bass.com> parents: 15171 diff changeset	1383 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	1384 {
15016 005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	1385 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	1386 }
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	1387
14938 bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1388 void
15181 ed2b911a2fb3 Rename jit_convert::convert_llvm to jit_convert_llvm Max Brister <max@2bass.com> parents: 15171 diff changeset	1389 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	1390 {
15603 44272909d926 Stop JIT on interrupt Max Brister <max@2bass.com> parents: 15602 diff changeset	1391 llvm::Value *cond;
44272909d926 Stop JIT on interrupt Max Brister <max@2bass.com> parents: 15602 diff changeset	1392
44272909d926 Stop JIT on interrupt Max Brister <max@2bass.com> parents: 15602 diff changeset	1393 switch (check.check_variable ())
44272909d926 Stop JIT on interrupt Max Brister <max@2bass.com> parents: 15602 diff changeset	1394 {
44272909d926 Stop JIT on interrupt Max Brister <max@2bass.com> parents: 15602 diff changeset	1395 case jit_error_check::var_error_state:
44272909d926 Stop JIT on interrupt Max Brister <max@2bass.com> parents: 15602 diff changeset	1396 cond = jit_typeinfo::insert_error_check (builder);
44272909d926 Stop JIT on interrupt Max Brister <max@2bass.com> parents: 15602 diff changeset	1397 break;
44272909d926 Stop JIT on interrupt Max Brister <max@2bass.com> parents: 15602 diff changeset	1398 case jit_error_check::var_interrupt:
44272909d926 Stop JIT on interrupt Max Brister <max@2bass.com> parents: 15602 diff changeset	1399 cond = jit_typeinfo::insert_interrupt_check (builder);
44272909d926 Stop JIT on interrupt Max Brister <max@2bass.com> parents: 15602 diff changeset	1400 break;
44272909d926 Stop JIT on interrupt Max Brister <max@2bass.com> parents: 15602 diff changeset	1401 default:
44272909d926 Stop JIT on interrupt Max Brister <max@2bass.com> parents: 15602 diff changeset	1402 panic_impossible ();
44272909d926 Stop JIT on interrupt Max Brister <max@2bass.com> parents: 15602 diff changeset	1403 }
44272909d926 Stop JIT on interrupt Max Brister <max@2bass.com> parents: 15602 diff changeset	1404
14948 006570a76b90 Cleanup and optimization of JIT Max Brister <max@2bass.com> parents: 14946 diff changeset	1405 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	1406 check.successor_llvm (1));
14938 bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1407 check.stash_llvm (br);
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1408 }
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1409
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1410 void
15181 ed2b911a2fb3 Rename jit_convert::convert_llvm to jit_convert_llvm Max Brister <max@2bass.com> parents: 15171 diff changeset	1411 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	1412 {
15014 094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1413 jit_value *new_value = assign.src ();
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1414 assign.stash_llvm (new_value->to_llvm ());
14965 f2117a963c54 Place grab/release for assignments Max Brister <max@2bass.com> parents: 14964 diff changeset	1415
14969 bbeef7b8ea2e Add support for matrix indexed assignment to JIT Max Brister <max@2bass.com> parents: 14968 diff changeset	1416 if (assign.artificial ())
bbeef7b8ea2e Add support for matrix indexed assignment to JIT Max Brister <max@2bass.com> parents: 14968 diff changeset	1417 return;
bbeef7b8ea2e Add support for matrix indexed assignment to JIT Max Brister <max@2bass.com> parents: 14968 diff changeset	1418
14965 f2117a963c54 Place grab/release for assignments Max Brister <max@2bass.com> parents: 14964 diff changeset	1419 jit_value *overwrite = assign.overwrite ();
f2117a963c54 Place grab/release for assignments Max Brister <max@2bass.com> parents: 14964 diff changeset	1420 if (isa<jit_assign_base> (overwrite))
f2117a963c54 Place grab/release for assignments Max Brister <max@2bass.com> parents: 14964 diff changeset	1421 {
15014 094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	1422 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	1423 if (ol.valid ())
98a65d9e426f Remove uneeded release overloads Max Brister <max@2bass.com> parents: 15146 diff changeset	1424 ol.call (builder, overwrite);
14965 f2117a963c54 Place grab/release for assignments Max Brister <max@2bass.com> parents: 14964 diff changeset	1425 }
14962 90a7a2af2cd5 Keep track of variables after SSA construction Max Brister <max@2bass.com> parents: 14961 diff changeset	1426 }
14938 bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1427
14951 4c9fd3e31436 Start of jit support for double matricies Max Brister <max@2bass.com> parents: 14949 diff changeset	1428 void
15181 ed2b911a2fb3 Rename jit_convert::convert_llvm to jit_convert_llvm Max Brister <max@2bass.com> parents: 15171 diff changeset	1429 jit_convert_llvm::visit (jit_argument&)
14951 4c9fd3e31436 Start of jit support for double matricies Max Brister <max@2bass.com> parents: 14949 diff changeset	1430 {}
4c9fd3e31436 Start of jit support for double matricies Max Brister <max@2bass.com> parents: 14949 diff changeset	1431
15056 bc32288f4a42 Support the end keyword for one dimentional indexing in JIT. Max Brister <max@2bass.com> parents: 15030 diff changeset	1432 void
15181 ed2b911a2fb3 Rename jit_convert::convert_llvm to jit_convert_llvm Max Brister <max@2bass.com> parents: 15171 diff changeset	1433 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	1434 {
bc32288f4a42 Support the end keyword for one dimentional indexing in JIT. Max Brister <max@2bass.com> parents: 15030 diff changeset	1435 const jit_function& ol = me.overload ();
15102 d29f2583cf7b Support end in multi indexing in JIT Max Brister <max@2bass.com> parents: 15096 diff changeset	1436
d29f2583cf7b Support end in multi indexing in JIT Max Brister <max@2bass.com> parents: 15096 diff changeset	1437 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	1438 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	1439 me.stash_llvm (ret);
bc32288f4a42 Support the end keyword for one dimentional indexing in JIT. Max Brister <max@2bass.com> parents: 15030 diff changeset	1440 }
bc32288f4a42 Support the end keyword for one dimentional indexing in JIT. Max Brister <max@2bass.com> parents: 15030 diff changeset	1441
15191 ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1442 // -------------------- jit_infer --------------------
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1443 jit_infer::jit_infer (jit_factory& afactory, jit_block_list& ablocks,
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1444 const variable_map& avmap)
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1445 : blocks (ablocks), factory (afactory), vmap (avmap) {}
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1446
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1447 void
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1448 jit_infer::infer (void)
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1449 {
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1450 construct_ssa ();
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1451
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1452 // initialize the worklist to instructions derived from constants
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1453 const std::list<jit_value *>& constants = factory.constants ();
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1454 for (std::list<jit_value *>::const_iterator iter = constants.begin ();
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1455 iter != constants.end (); ++iter)
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1456 append_users (*iter);
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1457
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1458 // the entry block terminator may be a regular branch statement
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1459 if (entry_block ().terminator ())
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1460 push_worklist (entry_block ().terminator ());
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1461
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1462 // FIXME: Describe algorithm here
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1463 while (worklist.size ())
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1464 {
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1465 jit_instruction *next = worklist.front ();
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1466 worklist.pop_front ();
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1467 next->stash_in_worklist (false);
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1468
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1469 if (next->infer ())
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1470 {
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1471 // terminators need to be handles specially
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1472 if (jit_terminator term = dynamic_cast<jit_terminator > (next))
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1473 append_users_term (term);
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1474 else
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1475 append_users (next);
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1476 }
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1477 }
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1478
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1479 remove_dead ();
15602 f3e339aee38f Fix block labeling in JIT debug output Max Brister <max@2bass.com> parents: 15595 diff changeset	1480 blocks.label ();
15191 ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1481 place_releases ();
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1482 simplify_phi ();
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1483 }
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1484
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1485 void
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1486 jit_infer::append_users (jit_value *v)
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1487 {
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1488 for (jit_use *use = v->first_use (); use; use = use->next ())
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1489 push_worklist (use->user ());
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1490 }
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1491
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1492 void
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1493 jit_infer::append_users_term (jit_terminator *term)
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1494 {
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1495 for (size_t i = 0; i < term->successor_count (); ++i)
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1496 {
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1497 if (term->alive (i))
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1498 {
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1499 jit_block *succ = term->successor (i);
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1500 for (jit_block::iterator iter = succ->begin (); iter != succ->end ()
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1501 && isa<jit_phi> (*iter); ++iter)
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1502 push_worklist (*iter);
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1503
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1504 jit_terminator *sterm = succ->terminator ();
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1505 if (sterm)
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1506 push_worklist (sterm);
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1507 }
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1508 }
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1509 }
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1510
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1511 void
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1512 jit_infer::construct_ssa (void)
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1513 {
15602 f3e339aee38f Fix block labeling in JIT debug output Max Brister <max@2bass.com> parents: 15595 diff changeset	1514 blocks.label ();
15191 ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1515 final_block ().compute_idom (entry_block ());
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1516 entry_block ().compute_df ();
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1517 entry_block ().create_dom_tree ();
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1518
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1519 // insert phi nodes where needed, this is done on a per variable basis
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1520 for (variable_map::const_iterator iter = vmap.begin (); iter != vmap.end ();
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1521 ++iter)
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1522 {
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1523 jit_block::df_set visited, added_phi;
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1524 std::list<jit_block *> ssa_worklist;
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1525 iter->second->use_blocks (visited);
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1526 ssa_worklist.insert (ssa_worklist.begin (), visited.begin (),
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1527 visited.end ());
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1528
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1529 while (ssa_worklist.size ())
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1530 {
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1531 jit_block *b = ssa_worklist.front ();
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1532 ssa_worklist.pop_front ();
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1533
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1534 for (jit_block::df_iterator diter = b->df_begin ();
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1535 diter != b->df_end (); ++diter)
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1536 {
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1537 jit_block dblock = diter;
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1538 if (! added_phi.count (dblock))
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1539 {
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1540 jit_phi *phi = factory.create<jit_phi> (iter->second,
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1541 dblock->use_count ());
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1542 dblock->prepend (phi);
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1543 added_phi.insert (dblock);
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1544 }
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1545
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1546 if (! visited.count (dblock))
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1547 {
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1548 ssa_worklist.push_back (dblock);
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1549 visited.insert (dblock);
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1550 }
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1551 }
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1552 }
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1553 }
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1554
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1555 do_construct_ssa (entry_block (), entry_block ().visit_count ());
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1556 }
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1557
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1558 void
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1559 jit_infer::do_construct_ssa (jit_block& ablock, size_t avisit_count)
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1560 {
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1561 if (ablock.visited (avisit_count))
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1562 return;
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1563
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1564 // replace variables with their current SSA value
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1565 for (jit_block::iterator iter = ablock.begin (); iter != ablock.end ();
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1566 ++iter)
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1567 {
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1568 jit_instruction instr = iter;
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1569 instr->construct_ssa ();
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1570 instr->push_variable ();
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1571 }
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1572
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1573 // finish phi nodes of successors
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1574 for (size_t i = 0; i < ablock.successor_count (); ++i)
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1575 {
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1576 jit_block *finish = ablock.successor (i);
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1577
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1578 for (jit_block::iterator iter = finish->begin (); iter != finish->end ()
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1579 && isa<jit_phi> (*iter);)
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1580 {
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1581 jit_phi phi = static_cast<jit_phi > (*iter);
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1582 jit_variable *var = phi->dest ();
15245 4c0cef65c55f pt-jit.cc (jit_infer::do_construct_ir): Correct extraious phi removal Max Brister <max@2bass.com> parents: 15234 diff changeset	1583 ++iter;
4c0cef65c55f pt-jit.cc (jit_infer::do_construct_ir): Correct extraious phi removal Max Brister <max@2bass.com> parents: 15234 diff changeset	1584
15191 ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1585 if (var->has_top ())
15245 4c0cef65c55f pt-jit.cc (jit_infer::do_construct_ir): Correct extraious phi removal Max Brister <max@2bass.com> parents: 15234 diff changeset	1586 phi->add_incomming (&ablock, var->top ());
15191 ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1587 else
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1588 {
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1589 // temporaries may have extranious phi nodes which can be removed
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1590 assert (! phi->use_count ());
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1591 assert (var->name ().size () && var->name ()[0] == '#');
15245 4c0cef65c55f pt-jit.cc (jit_infer::do_construct_ir): Correct extraious phi removal Max Brister <max@2bass.com> parents: 15234 diff changeset	1592 phi->remove ();
15191 ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1593 }
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1594 }
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1595 }
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1596
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1597 for (size_t i = 0; i < ablock.dom_successor_count (); ++i)
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1598 do_construct_ssa (*ablock.dom_successor (i), avisit_count);
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1599
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1600 ablock.pop_all ();
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1601 }
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1602
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1603 void
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1604 jit_infer::place_releases (void)
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1605 {
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1606 std::set<jit_value *> temporaries;
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1607 for (jit_block_list::iterator iter = blocks.begin (); iter != blocks.end ();
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1608 ++iter)
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1609 {
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1610 jit_block& ablock = **iter;
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1611 if (ablock.id () != jit_block::NO_ID)
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1612 {
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1613 release_temp (ablock, temporaries);
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1614 release_dead_phi (ablock);
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1615 }
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1616 }
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1617 }
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1618
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1619 void
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1620 jit_infer::push_worklist (jit_instruction *instr)
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1621 {
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1622 if (! instr->in_worklist ())
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1623 {
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1624 instr->stash_in_worklist (true);
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1625 worklist.push_back (instr);
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1626 }
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1627 }
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1628
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1629 void
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1630 jit_infer::remove_dead ()
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1631 {
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1632 jit_block_list::iterator biter;
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1633 for (biter = blocks.begin (); biter != blocks.end (); ++biter)
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1634 {
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1635 jit_block b = biter;
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1636 if (b->alive ())
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1637 {
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1638 for (jit_block::iterator iter = b->begin (); iter != b->end ()
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1639 && isa<jit_phi> (*iter);)
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1640 {
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1641 jit_phi phi = static_cast<jit_phi > (*iter);
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1642 if (phi->prune ())
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1643 iter = b->remove (iter);
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1644 else
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1645 ++iter;
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1646 }
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1647 }
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1648 }
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1649
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1650 for (biter = blocks.begin (); biter != blocks.end ();)
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1651 {
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1652 jit_block b = biter;
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1653 if (b->alive ())
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1654 {
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1655 // FIXME: A special case for jit_error_check, if we generalize to
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1656 // we will need to change!
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1657 jit_terminator *term = b->terminator ();
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1658 if (term && term->successor_count () == 2 && ! term->alive (0))
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1659 {
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1660 jit_block *succ = term->successor (1);
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1661 term->remove ();
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1662 jit_branch *abreak = factory.create<jit_branch> (succ);
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1663 b->append (abreak);
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1664 abreak->infer ();
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1665 }
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1666
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1667 ++biter;
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1668 }
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1669 else
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1670 {
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1671 jit_terminator *term = b->terminator ();
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1672 if (term)
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1673 term->remove ();
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1674 biter = blocks.erase (biter);
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1675 }
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1676 }
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1677 }
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1678
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1679 void
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1680 jit_infer::release_dead_phi (jit_block& ablock)
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1681 {
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1682 jit_block::iterator iter = ablock.begin ();
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1683 while (iter != ablock.end () && isa<jit_phi> (*iter))
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1684 {
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1685 jit_phi phi = static_cast<jit_phi > (*iter);
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1686 ++iter;
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1687
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1688 jit_use *use = phi->first_use ();
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1689 if (phi->use_count () == 1 && isa<jit_assign> (use->user ()))
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1690 {
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1691 // instead of releasing on assign, release on all incomming branches,
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1692 // this can get rid of casts inside loops
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1693 for (size_t i = 0; i < phi->argument_count (); ++i)
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1694 {
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1695 jit_value *arg = phi->argument (i);
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1696 if (! arg->needs_release ())
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1697 continue;
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1698
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1699 jit_block *inc = phi->incomming (i);
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1700 jit_block *split = inc->maybe_split (factory, blocks, ablock);
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1701 jit_terminator *term = split->terminator ();
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1702 jit_call *release
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1703 = factory.create<jit_call> (jit_typeinfo::release, arg);
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1704 release->infer ();
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1705 split->insert_before (term, release);
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1706 }
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1707
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1708 phi->replace_with (0);
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1709 phi->remove ();
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1710 }
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1711 }
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1712 }
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1713
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1714 void
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1715 jit_infer::release_temp (jit_block& ablock, std::set<jit_value *>& temp)
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1716 {
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1717 for (jit_block::iterator iter = ablock.begin (); iter != ablock.end ();
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1718 ++iter)
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1719 {
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1720 jit_instruction instr = iter;
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1721
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1722 // check for temporaries that require release and live across
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1723 // multiple blocks
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1724 if (instr->needs_release ())
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1725 {
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1726 jit_block *fu_block = instr->first_use_block ();
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1727 if (fu_block && fu_block != &ablock && instr->needs_release ())
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1728 temp.insert (instr);
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1729 }
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1730
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1731 if (isa<jit_call> (instr))
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1732 {
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1733 // place releases for temporary arguments
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1734 for (size_t i = 0; i < instr->argument_count (); ++i)
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1735 {
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1736 jit_value *arg = instr->argument (i);
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1737 if (! arg->needs_release ())
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1738 continue;
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1739
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1740 jit_call *release
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1741 = factory.create<jit_call> (&jit_typeinfo::release, arg);
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1742 release->infer ();
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1743 ablock.insert_after (iter, release);
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1744 ++iter;
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1745 temp.erase (arg);
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1746 }
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1747 }
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1748 }
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1749
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1750 if (! temp.size () \|\| ! isa<jit_error_check> (ablock.terminator ()))
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1751 return;
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1752
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1753 // FIXME: If we support try/catch or unwind_protect final_block may not be the
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1754 // destination
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1755 jit_block *split = ablock.maybe_split (factory, blocks, final_block ());
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1756 jit_terminator *term = split->terminator ();
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1757 for (std::set<jit_value *>::const_iterator iter = temp.begin ();
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1758 iter != temp.end (); ++iter)
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1759 {
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1760 jit_value value = iter;
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1761 jit_call *release
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1762 = factory.create<jit_call> (&jit_typeinfo::release, value);
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1763 split->insert_before (term, release);
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1764 release->infer ();
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1765 }
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1766 }
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1767
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1768 void
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1769 jit_infer::simplify_phi (void)
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1770 {
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1771 for (jit_block_list::iterator biter = blocks.begin (); biter != blocks.end ();
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1772 ++biter)
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1773 {
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1774 jit_block &ablock = **biter;
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1775 for (jit_block::iterator iter = ablock.begin (); iter != ablock.end ()
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1776 && isa<jit_phi> (*iter); ++iter)
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1777 simplify_phi (static_cast<jit_phi > (*iter));
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1778 }
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1779 }
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1780
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1781 void
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1782 jit_infer::simplify_phi (jit_phi& phi)
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1783 {
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1784 jit_block& pblock = *phi.parent ();
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1785 const jit_operation& cast_fn = jit_typeinfo::cast (phi.type ());
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1786 jit_variable *dest = phi.dest ();
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1787 for (size_t i = 0; i < phi.argument_count (); ++i)
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1788 {
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1789 jit_value *arg = phi.argument (i);
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1790 if (arg->type () != phi.type ())
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1791 {
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1792 jit_block *pred = phi.incomming (i);
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1793 jit_block *split = pred->maybe_split (factory, blocks, pblock);
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1794 jit_terminator *term = split->terminator ();
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1795 jit_instruction *cast = factory.create<jit_call> (cast_fn, arg);
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1796 jit_assign *assign = factory.create<jit_assign> (dest, cast);
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1797
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1798 split->insert_before (term, cast);
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1799 split->insert_before (term, assign);
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1800 cast->infer ();
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1801 assign->infer ();
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1802 phi.stash_argument (i, assign);
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1803 }
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1804 }
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1805 }
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1806
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1807 // -------------------- tree_jit --------------------
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1808
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1809 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	1810 {
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1811 }
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1812
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1813 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	1814 {}
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1815
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1816 bool
15027 741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1817 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	1818 {
15337 3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1819 return instance ().do_execute (cmd, bounds);
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1820 }
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1821
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1822 bool
15023 75d1bc2fd6d2 Compile top level while loops in JIT. Max Brister <max@2bass.com> parents: 15016 diff changeset	1823 tree_jit::execute (tree_while_command& cmd)
75d1bc2fd6d2 Compile top level while loops in JIT. Max Brister <max@2bass.com> parents: 15016 diff changeset	1824 {
15337 3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1825 return instance ().do_execute (cmd);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1826 }
15023 75d1bc2fd6d2 Compile top level while loops in JIT. Max Brister <max@2bass.com> parents: 15016 diff changeset	1827
15337 3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1828 bool
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1829 tree_jit::execute (octave_user_function& fcn, const octave_value_list& args,
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1830 octave_value_list& retval)
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1831 {
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1832 return instance ().do_execute (fcn, args, retval);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1833 }
15023 75d1bc2fd6d2 Compile top level while loops in JIT. Max Brister <max@2bass.com> parents: 15016 diff changeset	1834
15337 3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1835 tree_jit&
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1836 tree_jit::instance (void)
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1837 {
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1838 static tree_jit ret;
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1839 return ret;
15023 75d1bc2fd6d2 Compile top level while loops in JIT. Max Brister <max@2bass.com> parents: 15016 diff changeset	1840 }
75d1bc2fd6d2 Compile top level while loops in JIT. Max Brister <max@2bass.com> parents: 15016 diff changeset	1841
75d1bc2fd6d2 Compile top level while loops in JIT. Max Brister <max@2bass.com> parents: 15016 diff changeset	1842 bool
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1843 tree_jit::initialize (void)
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	1844 {
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1845 if (engine)
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1846 return true;
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1847
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1848 if (! module)
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1849 {
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1850 llvm::InitializeNativeTarget ();
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1851 module = new llvm::Module ("octave", context);
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1852 }
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1853
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1854 // sometimes this fails pre main
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1855 engine = llvm::ExecutionEngine::createJIT (module);
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1856
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1857 if (! engine)
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1858 return false;
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1859
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1860 module_pass_manager = new llvm::PassManager ();
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1861 module_pass_manager->add (llvm::createAlwaysInlinerPass ());
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1862
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1863 pass_manager = new llvm::FunctionPassManager (module);
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1864 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	1865 pass_manager->add (llvm::createCFGSimplificationPass ());
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1866 pass_manager->add (llvm::createBasicAliasAnalysisPass ());
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1867 pass_manager->add (llvm::createPromoteMemoryToRegisterPass ());
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1868 pass_manager->add (llvm::createInstructionCombiningPass ());
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1869 pass_manager->add (llvm::createReassociatePass ());
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1870 pass_manager->add (llvm::createGVNPass ());
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1871 pass_manager->add (llvm::createCFGSimplificationPass ());
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1872 pass_manager->doInitialization ();
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1873
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1874 jit_typeinfo::initialize (module, engine);
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1875
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1876 return true;
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1877 }
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1878
15337 3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1879 bool
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1880 tree_jit::do_execute (tree_simple_for_command& cmd, const octave_value& bounds)
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1881 {
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1882 const size_t MIN_TRIP_COUNT = 1000;
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1883
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1884 size_t tc = trip_count (bounds);
15582 52df2e7baabe Disable JIT when breakpoints are present Max Brister <max@2bass.com> parents: 15539 diff changeset	1885 if (! tc \|\| ! initialize () \|\| ! enabled ())
15337 3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1886 return false;
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1887
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1888 jit_info::vmap extra_vars;
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1889 extra_vars["#for_bounds0"] = &bounds;
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1890
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1891 jit_info *info = cmd.get_info ();
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1892 if (! info \|\| ! info->match (extra_vars))
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1893 {
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1894 if (tc < MIN_TRIP_COUNT)
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1895 return false;
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1896
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1897 delete info;
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1898 info = new jit_info (*this, cmd, bounds);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1899 cmd.stash_info (info);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1900 }
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1901
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1902 return info->execute (extra_vars);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1903 }
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1904
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1905 bool
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1906 tree_jit::do_execute (tree_while_command& cmd)
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1907 {
15582 52df2e7baabe Disable JIT when breakpoints are present Max Brister <max@2bass.com> parents: 15539 diff changeset	1908 if (! initialize () \|\| ! enabled ())
15337 3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1909 return false;
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1910
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1911 jit_info *info = cmd.get_info ();
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1912 if (! info \|\| ! info->match ())
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1913 {
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1914 delete info;
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1915 info = new jit_info (*this, cmd);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1916 cmd.stash_info (info);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1917 }
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1918
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1919 return info->execute ();
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1920 }
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1921
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1922 bool
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1923 tree_jit::do_execute (octave_user_function& fcn, const octave_value_list& args,
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1924 octave_value_list& retval)
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1925 {
15582 52df2e7baabe Disable JIT when breakpoints are present Max Brister <max@2bass.com> parents: 15539 diff changeset	1926 if (! initialize () \|\| ! enabled ())
15337 3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1927 return false;
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1928
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1929 jit_function_info *info = fcn.get_info ();
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1930 if (! info \|\| ! info->match (args))
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1931 {
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1932 delete info;
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1933 info = new jit_function_info (*this, fcn, args);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1934 fcn.stash_info (info);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1935 }
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1936
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1937 return info->execute (args, retval);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1938 }
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1939
15582 52df2e7baabe Disable JIT when breakpoints are present Max Brister <max@2bass.com> parents: 15539 diff changeset	1940 bool
52df2e7baabe Disable JIT when breakpoints are present Max Brister <max@2bass.com> parents: 15539 diff changeset	1941 tree_jit::enabled (void)
52df2e7baabe Disable JIT when breakpoints are present Max Brister <max@2bass.com> parents: 15539 diff changeset	1942 {
52df2e7baabe Disable JIT when breakpoints are present Max Brister <max@2bass.com> parents: 15539 diff changeset	1943 // Ideally, we should only disable JIT if there is a breakpoint in the code we
52df2e7baabe Disable JIT when breakpoints are present Max Brister <max@2bass.com> parents: 15539 diff changeset	1944 // are about to run. However, we can't figure this out in O(1) time, so we
52df2e7baabe Disable JIT when breakpoints are present Max Brister <max@2bass.com> parents: 15539 diff changeset	1945 // conservatively check for the existence of any breakpoints.
15593 24bbd2efea12 pt-jit.cc (tree_jit::enabled): Do not jit if Vdebug_on_interrupt or Vdebug_on_error Max Brister <max@2bass.com> parents: 15592 diff changeset	1946 return Venable_jit_compiler && ! bp_table::have_breakpoints ()
24bbd2efea12 pt-jit.cc (tree_jit::enabled): Do not jit if Vdebug_on_interrupt or Vdebug_on_error Max Brister <max@2bass.com> parents: 15592 diff changeset	1947 && ! Vdebug_on_interrupt && ! Vdebug_on_error;
15582 52df2e7baabe Disable JIT when breakpoints are present Max Brister <max@2bass.com> parents: 15539 diff changeset	1948 }
52df2e7baabe Disable JIT when breakpoints are present Max Brister <max@2bass.com> parents: 15539 diff changeset	1949
15027 741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1950 size_t
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1951 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	1952 {
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1953 if (bounds.is_range ())
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1954 {
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1955 Range rng = bounds.range_value ();
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1956 return rng.nelem ();
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1957 }
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1958
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1959 // unsupported type
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1960 return 0;
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1961 }
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1962
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1963
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1964 void
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1965 tree_jit::optimize (llvm::Function *fn)
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1966 {
15479 3f447bcc8488 set Venable_jit_debugging and Venable_jit_compiler variables directly from command line options John W. Eaton <jwe@octave.org> parents: 15385 diff changeset	1967 if (Venable_jit_debugging)
15385 8ccb187b24e9 Erase partially created functions on JIT compilation failure (bug #37308) Max Brister <max@2bass.com> parents: 15370 diff changeset	1968 llvm::verifyModule (*module);
8ccb187b24e9 Erase partially created functions on JIT compilation failure (bug #37308) Max Brister <max@2bass.com> parents: 15370 diff changeset	1969
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1970 module_pass_manager->run (*module);
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1971 pass_manager->run (*fn);
14985 f5925478bc15 More support for complex numbers in JIT Max Brister <max@2bass.com> parents: 14984 diff changeset	1972
15479 3f447bcc8488 set Venable_jit_debugging and Venable_jit_compiler variables directly from command line options John W. Eaton <jwe@octave.org> parents: 15385 diff changeset	1973 if (Venable_jit_debugging)
15346 6bdf379592d9 Remove --enable-jit-debug configure option Max Brister <max@2bass.com> parents: 15339 diff changeset	1974 {
6bdf379592d9 Remove --enable-jit-debug configure option Max Brister <max@2bass.com> parents: 15339 diff changeset	1975 std::string error;
6bdf379592d9 Remove --enable-jit-debug configure option Max Brister <max@2bass.com> parents: 15339 diff changeset	1976 llvm::raw_fd_ostream fout ("test.bc", error,
6bdf379592d9 Remove --enable-jit-debug configure option Max Brister <max@2bass.com> parents: 15339 diff changeset	1977 llvm::raw_fd_ostream::F_Binary);
6bdf379592d9 Remove --enable-jit-debug configure option Max Brister <max@2bass.com> parents: 15339 diff changeset	1978 llvm::WriteBitcodeToFile (module, fout);
6bdf379592d9 Remove --enable-jit-debug configure option Max Brister <max@2bass.com> parents: 15339 diff changeset	1979 }
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1980 }
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1981
15337 3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1982 // -------------------- jit_function_info --------------------
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1983 jit_function_info::jit_function_info (tree_jit& tjit,
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1984 octave_user_function& fcn,
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1985 const octave_value_list& ov_args)
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1986 : argument_types (ov_args.length ()), function (0)
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1987 {
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1988 size_t nargs = ov_args.length ();
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1989 for (size_t i = 0; i < nargs; ++i)
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1990 argument_types[i] = jit_typeinfo::type_of (ov_args(i));
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1991
15385 8ccb187b24e9 Erase partially created functions on JIT compilation failure (bug #37308) Max Brister <max@2bass.com> parents: 15370 diff changeset	1992 jit_function raw_fn;
8ccb187b24e9 Erase partially created functions on JIT compilation failure (bug #37308) Max Brister <max@2bass.com> parents: 15370 diff changeset	1993 jit_function wrapper;
8ccb187b24e9 Erase partially created functions on JIT compilation failure (bug #37308) Max Brister <max@2bass.com> parents: 15370 diff changeset	1994
15337 3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1995 try
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1996 {
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1997 jit_convert conv (fcn, argument_types);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1998 jit_infer infer (conv.get_factory (), conv.get_blocks (),
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1999 conv.get_variable_map ());
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2000 infer.infer ();
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2001
15479 3f447bcc8488 set Venable_jit_debugging and Venable_jit_compiler variables directly from command line options John W. Eaton <jwe@octave.org> parents: 15385 diff changeset	2002 if (Venable_jit_debugging)
15337 3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2003 {
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2004 jit_block_list& blocks = infer.get_blocks ();
15602 f3e339aee38f Fix block labeling in JIT debug output Max Brister <max@2bass.com> parents: 15595 diff changeset	2005 blocks.label ();
15337 3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2006 std::cout << "-------------------- Compiling function ";
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2007 std::cout << "--------------------\n";
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2008
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2009 tree_print_code tpc (std::cout);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2010 tpc.visit_octave_user_function_header (fcn);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2011 tpc.visit_statement_list (*fcn.body ());
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2012 tpc.visit_octave_user_function_trailer (fcn);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2013 blocks.print (std::cout, "octave jit ir");
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2014 }
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2015
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2016 jit_factory& factory = conv.get_factory ();
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2017 llvm::Module *module = tjit.get_module ();
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2018 jit_convert_llvm to_llvm;
15385 8ccb187b24e9 Erase partially created functions on JIT compilation failure (bug #37308) Max Brister <max@2bass.com> parents: 15370 diff changeset	2019 raw_fn = to_llvm.convert_function (module, infer.get_blocks (),
8ccb187b24e9 Erase partially created functions on JIT compilation failure (bug #37308) Max Brister <max@2bass.com> parents: 15370 diff changeset	2020 factory.constants (), fcn,
8ccb187b24e9 Erase partially created functions on JIT compilation failure (bug #37308) Max Brister <max@2bass.com> parents: 15370 diff changeset	2021 argument_types);
15337 3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2022
15479 3f447bcc8488 set Venable_jit_debugging and Venable_jit_compiler variables directly from command line options John W. Eaton <jwe@octave.org> parents: 15385 diff changeset	2023 if (Venable_jit_debugging)
15337 3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2024 {
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2025 std::cout << "-------------------- raw function ";
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2026 std::cout << "--------------------\n";
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2027 std::cout << *raw_fn.to_llvm () << std::endl;
15339 b49d707fe9d7 pt-jit.cc (jit_function_info::jit_function_info): Verify llvm IR when debugging Max Brister <max@2bass.com> parents: 15337 diff changeset	2028 llvm::verifyFunction (*raw_fn.to_llvm ());
15337 3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2029 }
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2030
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2031 std::string wrapper_name = fcn.name () + "_wrapper";
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2032 jit_type *any_t = jit_typeinfo::get_any ();
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2033 std::vector<jit_type *> wrapper_args (1, jit_typeinfo::get_any_ptr ());
15385 8ccb187b24e9 Erase partially created functions on JIT compilation failure (bug #37308) Max Brister <max@2bass.com> parents: 15370 diff changeset	2034 wrapper = jit_function (module, jit_convention::internal, wrapper_name,
8ccb187b24e9 Erase partially created functions on JIT compilation failure (bug #37308) Max Brister <max@2bass.com> parents: 15370 diff changeset	2035 any_t, wrapper_args);
8ccb187b24e9 Erase partially created functions on JIT compilation failure (bug #37308) Max Brister <max@2bass.com> parents: 15370 diff changeset	2036
15337 3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2037 llvm::BasicBlock *wrapper_body = wrapper.new_block ();
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2038 builder.SetInsertPoint (wrapper_body);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2039
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2040 llvm::Value *wrapper_arg = wrapper.argument (builder, 0);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2041 std::vector<llvm::Value *> raw_args (nargs);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2042 for (size_t i = 0; i < nargs; ++i)
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2043 {
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2044 llvm::Value *arg;
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2045 arg = builder.CreateConstInBoundsGEP1_32 (wrapper_arg, i);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2046 arg = builder.CreateLoad (arg);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2047
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2048 jit_type *arg_type = argument_types[i];
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2049 const jit_function& cast = jit_typeinfo::cast (arg_type, any_t);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2050 raw_args[i] = cast.call (builder, arg);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2051 }
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2052
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2053 llvm::Value *result = raw_fn.call (builder, raw_args);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2054 if (raw_fn.result ())
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2055 {
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2056 jit_type *raw_result_t = raw_fn.result ();
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2057 const jit_function& cast = jit_typeinfo::cast (any_t, raw_result_t);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2058 result = cast.call (builder, result);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2059 }
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2060 else
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2061 {
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2062 llvm::Value *zero = builder.getInt32 (0);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2063 result = builder.CreateBitCast (zero, any_t->to_llvm ());
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2064 }
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2065
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2066 wrapper.do_return (builder, result);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2067
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2068 llvm::Function *llvm_function = wrapper.to_llvm ();
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2069 tjit.optimize (llvm_function);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2070
15479 3f447bcc8488 set Venable_jit_debugging and Venable_jit_compiler variables directly from command line options John W. Eaton <jwe@octave.org> parents: 15385 diff changeset	2071 if (Venable_jit_debugging)
15337 3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2072 {
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2073 std::cout << "-------------------- optimized and wrapped ";
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2074 std::cout << "--------------------\n";
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2075 std::cout << *llvm_function << std::endl;
15339 b49d707fe9d7 pt-jit.cc (jit_function_info::jit_function_info): Verify llvm IR when debugging Max Brister <max@2bass.com> parents: 15337 diff changeset	2076 llvm::verifyFunction (*llvm_function);
15337 3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2077 }
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2078
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2079 llvm::ExecutionEngine* engine = tjit.get_engine ();
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2080 void *void_fn = engine->getPointerToFunction (llvm_function);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2081 function = reinterpret_cast<jited_function> (void_fn);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2082 }
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2083 catch (const jit_fail_exception& e)
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2084 {
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2085 argument_types.clear ();
15346 6bdf379592d9 Remove --enable-jit-debug configure option Max Brister <max@2bass.com> parents: 15339 diff changeset	2086
15479 3f447bcc8488 set Venable_jit_debugging and Venable_jit_compiler variables directly from command line options John W. Eaton <jwe@octave.org> parents: 15385 diff changeset	2087 if (Venable_jit_debugging)
15337 3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2088 {
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2089 if (e.known ())
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2090 std::cout << "jit fail: " << e.what () << std::endl;
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2091 }
15385 8ccb187b24e9 Erase partially created functions on JIT compilation failure (bug #37308) Max Brister <max@2bass.com> parents: 15370 diff changeset	2092
8ccb187b24e9 Erase partially created functions on JIT compilation failure (bug #37308) Max Brister <max@2bass.com> parents: 15370 diff changeset	2093 wrapper.erase ();
8ccb187b24e9 Erase partially created functions on JIT compilation failure (bug #37308) Max Brister <max@2bass.com> parents: 15370 diff changeset	2094 raw_fn.erase ();
15337 3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2095 }
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2096 }
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2097
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2098 bool
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2099 jit_function_info::execute (const octave_value_list& ov_args,
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2100 octave_value_list& retval) const
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2101 {
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2102 if (! function)
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2103 return false;
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2104
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2105 // TODO figure out a way to delete ov_args so we avoid duplicating refcount
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2106 size_t nargs = ov_args.length ();
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2107 std::vector<octave_base_value *> args (nargs);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2108 for (size_t i = 0; i < nargs; ++i)
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2109 {
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2110 octave_base_value *obv = ov_args(i).internal_rep ();
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2111 obv->grab ();
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2112 args[i] = obv;
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2113 }
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2114
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2115 octave_base_value *ret = function (&args[0]);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2116 if (ret)
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2117 retval(0) = octave_value (ret);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2118
15603 44272909d926 Stop JIT on interrupt Max Brister <max@2bass.com> parents: 15602 diff changeset	2119 octave_quit ();
44272909d926 Stop JIT on interrupt Max Brister <max@2bass.com> parents: 15602 diff changeset	2120
15337 3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2121 return true;
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2122 }
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2123
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2124 bool
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2125 jit_function_info::match (const octave_value_list& ov_args) const
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2126 {
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2127 if (! function)
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2128 return true;
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2129
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2130 size_t nargs = ov_args.length ();
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2131 if (nargs != argument_types.size ())
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2132 return false;
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2133
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2134 for (size_t i = 0; i < nargs; ++i)
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2135 if (jit_typeinfo::type_of (ov_args(i)) != argument_types[i])
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2136 return false;
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2137
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2138 return true;
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2139 }
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2140
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	2141 // -------------------- jit_info --------------------
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	2142 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	2143 : 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	2144 {
15191 ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2145 compile (tjit, tee);
15027 741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	2146 }
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	2147
15027 741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	2148 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	2149 : 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	2150 {
15191 ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2151 compile (tjit, tee, jit_typeinfo::type_of (for_bounds));
14955 609dcc297db5 src/pt-jit.cc (jit_info::~jit_info): New function Max Brister <max@2bass.com> parents: 14954 diff changeset	2152 }
609dcc297db5 src/pt-jit.cc (jit_info::~jit_info): New function Max Brister <max@2bass.com> parents: 14954 diff changeset	2153
609dcc297db5 src/pt-jit.cc (jit_info::~jit_info): New function Max Brister <max@2bass.com> parents: 14954 diff changeset	2154 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	2155 {
609dcc297db5 src/pt-jit.cc (jit_info::~jit_info): New function Max Brister <max@2bass.com> parents: 14954 diff changeset	2156 if (llvm_function)
609dcc297db5 src/pt-jit.cc (jit_info::~jit_info): New function Max Brister <max@2bass.com> parents: 14954 diff changeset	2157 llvm_function->eraseFromParent ();
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	2158 }
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	2159
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	2160 bool
15027 741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	2161 jit_info::execute (const vmap& extra_vars) const
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	2162 {
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	2163 if (! function)
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	2164 return false;
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	2165
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	2166 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	2167 for (size_t i = 0; i < arguments.size (); ++i)
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	2168 {
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	2169 if (arguments[i].second)
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	2170 {
15027 741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	2171 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	2172 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	2173 obv->grab ();
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	2174 real_arguments[i] = obv;
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	2175 }
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	2176 }
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	2177
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	2178 function (&real_arguments[0]);
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	2179
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	2180 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	2181 {
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	2182 const std::string& name = arguments[i].first;
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	2183
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	2184 // do not store for loop bounds temporary
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	2185 if (name.size () && name[0] != '#')
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	2186 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	2187 }
14910 a8f1e08de8fc Simplified llvm::GenericValue creation Max Brister <max@2bass.com> parents: 14906 diff changeset	2188
15603 44272909d926 Stop JIT on interrupt Max Brister <max@2bass.com> parents: 15602 diff changeset	2189 octave_quit ();
44272909d926 Stop JIT on interrupt Max Brister <max@2bass.com> parents: 15602 diff changeset	2190
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	2191 return true;
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	2192 }
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	2193
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	2194 bool
15027 741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	2195 jit_info::match (const vmap& extra_vars) const
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	2196 {
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	2197 if (! function)
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	2198 return true;
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	2199
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	2200 for (size_t i = 0; i < bounds.size (); ++i)
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	2201 {
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	2202 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	2203 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	2204 jit_type *type = jit_typeinfo::type_of (value);
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	2205
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	2206 // 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	2207 if (type != bounds[i].first)
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	2208 return false;
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	2209 }
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	2210
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	2211 return true;
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	2212 }
15027 741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	2213
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	2214 void
15191 ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2215 jit_info::compile (tree_jit& tjit, tree& tee, jit_type *for_bounds)
15027 741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	2216 {
15191 ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2217 try
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2218 {
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2219 jit_convert conv (tee, for_bounds);
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2220 jit_infer infer (conv.get_factory (), conv.get_blocks (),
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2221 conv.get_variable_map ());
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2222
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2223 infer.infer ();
15346 6bdf379592d9 Remove --enable-jit-debug configure option Max Brister <max@2bass.com> parents: 15339 diff changeset	2224
15479 3f447bcc8488 set Venable_jit_debugging and Venable_jit_compiler variables directly from command line options John W. Eaton <jwe@octave.org> parents: 15385 diff changeset	2225 if (Venable_jit_debugging)
15310 b055fc077224 allow jit compiler to be enabled at run-time John W. Eaton <jwe@octave.org> parents: 15245 diff changeset	2226 {
b055fc077224 allow jit compiler to be enabled at run-time John W. Eaton <jwe@octave.org> parents: 15245 diff changeset	2227 jit_block_list& blocks = infer.get_blocks ();
15602 f3e339aee38f Fix block labeling in JIT debug output Max Brister <max@2bass.com> parents: 15595 diff changeset	2228 blocks.label ();
15310 b055fc077224 allow jit compiler to be enabled at run-time John W. Eaton <jwe@octave.org> parents: 15245 diff changeset	2229 std::cout << "-------------------- Compiling tree --------------------\n";
b055fc077224 allow jit compiler to be enabled at run-time John W. Eaton <jwe@octave.org> parents: 15245 diff changeset	2230 std::cout << tee.str_print_code () << std::endl;
b055fc077224 allow jit compiler to be enabled at run-time John W. Eaton <jwe@octave.org> parents: 15245 diff changeset	2231 blocks.print (std::cout, "octave jit ir");
b055fc077224 allow jit compiler to be enabled at run-time John W. Eaton <jwe@octave.org> parents: 15245 diff changeset	2232 }
15191 ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2233
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2234 jit_factory& factory = conv.get_factory ();
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2235 jit_convert_llvm to_llvm;
15337 3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2236 llvm_function = to_llvm.convert_loop (tjit.get_module (),
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2237 infer.get_blocks (),
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2238 factory.constants ());
15191 ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2239 arguments = to_llvm.get_arguments ();
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2240 bounds = conv.get_bounds ();
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2241 }
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2242 catch (const jit_fail_exception& e)
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2243 {
15479 3f447bcc8488 set Venable_jit_debugging and Venable_jit_compiler variables directly from command line options John W. Eaton <jwe@octave.org> parents: 15385 diff changeset	2244 if (Venable_jit_debugging)
15310 b055fc077224 allow jit compiler to be enabled at run-time John W. Eaton <jwe@octave.org> parents: 15245 diff changeset	2245 {
b055fc077224 allow jit compiler to be enabled at run-time John W. Eaton <jwe@octave.org> parents: 15245 diff changeset	2246 if (e.known ())
b055fc077224 allow jit compiler to be enabled at run-time John W. Eaton <jwe@octave.org> parents: 15245 diff changeset	2247 std::cout << "jit fail: " << e.what () << std::endl;
b055fc077224 allow jit compiler to be enabled at run-time John W. Eaton <jwe@octave.org> parents: 15245 diff changeset	2248 }
15191 ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2249 }
15027 741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	2250
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	2251 if (llvm_function)
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	2252 {
15479 3f447bcc8488 set Venable_jit_debugging and Venable_jit_compiler variables directly from command line options John W. Eaton <jwe@octave.org> parents: 15385 diff changeset	2253 if (Venable_jit_debugging)
15310 b055fc077224 allow jit compiler to be enabled at run-time John W. Eaton <jwe@octave.org> parents: 15245 diff changeset	2254 {
b055fc077224 allow jit compiler to be enabled at run-time John W. Eaton <jwe@octave.org> parents: 15245 diff changeset	2255 std::cout << "-------------------- llvm ir --------------------";
15346 6bdf379592d9 Remove --enable-jit-debug configure option Max Brister <max@2bass.com> parents: 15339 diff changeset	2256 std::cout << *llvm_function << std::endl;
15310 b055fc077224 allow jit compiler to be enabled at run-time John W. Eaton <jwe@octave.org> parents: 15245 diff changeset	2257 llvm::verifyFunction (*llvm_function);
b055fc077224 allow jit compiler to be enabled at run-time John W. Eaton <jwe@octave.org> parents: 15245 diff changeset	2258 }
15191 ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2259
15027 741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	2260 tjit.optimize (llvm_function);
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	2261
15479 3f447bcc8488 set Venable_jit_debugging and Venable_jit_compiler variables directly from command line options John W. Eaton <jwe@octave.org> parents: 15385 diff changeset	2262 if (Venable_jit_debugging)
15310 b055fc077224 allow jit compiler to be enabled at run-time John W. Eaton <jwe@octave.org> parents: 15245 diff changeset	2263 {
b055fc077224 allow jit compiler to be enabled at run-time John W. Eaton <jwe@octave.org> parents: 15245 diff changeset	2264 std::cout << "-------------------- optimized llvm ir "
b055fc077224 allow jit compiler to be enabled at run-time John W. Eaton <jwe@octave.org> parents: 15245 diff changeset	2265 << "--------------------\n";
15346 6bdf379592d9 Remove --enable-jit-debug configure option Max Brister <max@2bass.com> parents: 15339 diff changeset	2266 std::cout << *llvm_function << std::endl;
15310 b055fc077224 allow jit compiler to be enabled at run-time John W. Eaton <jwe@octave.org> parents: 15245 diff changeset	2267 }
15027 741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	2268
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	2269 void *void_fn = engine->getPointerToFunction (llvm_function);
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	2270 function = reinterpret_cast<jited_function> (void_fn);
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	2271 }
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	2272 }
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	2273
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	2274 octave_value
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	2275 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	2276 {
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	2277 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	2278 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	2279 : *iter->second;
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	2280 }
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	2281
14932 1f914446157d Locate and link with LLVM properly Max Brister <max@2bass.com> parents: 14928 diff changeset	2282 #endif
15014 094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	2283
15495 29382eb90285 Fix compilation when JIT is enabled. Rik <rik@octave.org> parents: 15494 diff changeset	2284 DEFUN (enable_jit_debugging, args, nargout,
15310 b055fc077224 allow jit compiler to be enabled at run-time John W. Eaton <jwe@octave.org> parents: 15245 diff changeset	2285 "-- texinfo --\n\
15539 4d6e5fa37899 doc: Update docstrings for enable_jit_debugging and enable_jit_compiler. Rik <rik@octave.org> parents: 15495 diff changeset	2286 @deftypefn {Built-in Function} {@var{val} =} enable_jit_debugging ()\n\
4d6e5fa37899 doc: Update docstrings for enable_jit_debugging and enable_jit_compiler. Rik <rik@octave.org> parents: 15495 diff changeset	2287 @deftypefnx {Built-in Function} {@var{old_val} =} enable_jit_debugging (@var{new_val})\n\
4d6e5fa37899 doc: Update docstrings for enable_jit_debugging and enable_jit_compiler. Rik <rik@octave.org> parents: 15495 diff changeset	2288 @deftypefnx {Built-in Function} {} enable_jit_debugging (@var{new_val}, \"local\")\n\
15310 b055fc077224 allow jit compiler to be enabled at run-time John W. Eaton <jwe@octave.org> parents: 15245 diff changeset	2289 Query or set the internal variable that determines whether\n\
b055fc077224 allow jit compiler to be enabled at run-time John W. Eaton <jwe@octave.org> parents: 15245 diff changeset	2290 debugging/tracing is enabled for Octave's JIT compiler.\n\
15539 4d6e5fa37899 doc: Update docstrings for enable_jit_debugging and enable_jit_compiler. Rik <rik@octave.org> parents: 15495 diff changeset	2291 \n\
4d6e5fa37899 doc: Update docstrings for enable_jit_debugging and enable_jit_compiler. Rik <rik@octave.org> parents: 15495 diff changeset	2292 When called from inside a function with the \"local\" option, the variable is\n\
4d6e5fa37899 doc: Update docstrings for enable_jit_debugging and enable_jit_compiler. Rik <rik@octave.org> parents: 15495 diff changeset	2293 changed locally for the function and any subroutines it calls. The original\n\
4d6e5fa37899 doc: Update docstrings for enable_jit_debugging and enable_jit_compiler. Rik <rik@octave.org> parents: 15495 diff changeset	2294 variable value is restored when exiting the function.\n\
4d6e5fa37899 doc: Update docstrings for enable_jit_debugging and enable_jit_compiler. Rik <rik@octave.org> parents: 15495 diff changeset	2295 @seealso{enable_jit_compiler}\n\
15310 b055fc077224 allow jit compiler to be enabled at run-time John W. Eaton <jwe@octave.org> parents: 15245 diff changeset	2296 @end deftypefn")
b055fc077224 allow jit compiler to be enabled at run-time John W. Eaton <jwe@octave.org> parents: 15245 diff changeset	2297 {
15346 6bdf379592d9 Remove --enable-jit-debug configure option Max Brister <max@2bass.com> parents: 15339 diff changeset	2298 #if defined (HAVE_LLVM)
15479 3f447bcc8488 set Venable_jit_debugging and Venable_jit_compiler variables directly from command line options John W. Eaton <jwe@octave.org> parents: 15385 diff changeset	2299 return SET_INTERNAL_VARIABLE (enable_jit_debugging);
15310 b055fc077224 allow jit compiler to be enabled at run-time John W. Eaton <jwe@octave.org> parents: 15245 diff changeset	2300 #else
15479 3f447bcc8488 set Venable_jit_debugging and Venable_jit_compiler variables directly from command line options John W. Eaton <jwe@octave.org> parents: 15385 diff changeset	2301 warning ("enable_jit_debugging: JIT compiling not available in this version of Octave");
15310 b055fc077224 allow jit compiler to be enabled at run-time John W. Eaton <jwe@octave.org> parents: 15245 diff changeset	2302 return octave_value ();
b055fc077224 allow jit compiler to be enabled at run-time John W. Eaton <jwe@octave.org> parents: 15245 diff changeset	2303 #endif
b055fc077224 allow jit compiler to be enabled at run-time John W. Eaton <jwe@octave.org> parents: 15245 diff changeset	2304 }
b055fc077224 allow jit compiler to be enabled at run-time John W. Eaton <jwe@octave.org> parents: 15245 diff changeset	2305
15495 29382eb90285 Fix compilation when JIT is enabled. Rik <rik@octave.org> parents: 15494 diff changeset	2306 DEFUN (enable_jit_compiler, args, nargout,
15310 b055fc077224 allow jit compiler to be enabled at run-time John W. Eaton <jwe@octave.org> parents: 15245 diff changeset	2307 "-- texinfo --\n\
15539 4d6e5fa37899 doc: Update docstrings for enable_jit_debugging and enable_jit_compiler. Rik <rik@octave.org> parents: 15495 diff changeset	2308 @deftypefn {Built-in Function} {@var{val} =} enable_jit_compiler ()\n\
4d6e5fa37899 doc: Update docstrings for enable_jit_debugging and enable_jit_compiler. Rik <rik@octave.org> parents: 15495 diff changeset	2309 @deftypefnx {Built-in Function} {@var{old_val} =} enable_jit_compiler (@var{new_val})\n\
4d6e5fa37899 doc: Update docstrings for enable_jit_debugging and enable_jit_compiler. Rik <rik@octave.org> parents: 15495 diff changeset	2310 @deftypefnx {Built-in Function} {} enable_jit_compiler (@var{new_val}, \"local\")\n\
15310 b055fc077224 allow jit compiler to be enabled at run-time John W. Eaton <jwe@octave.org> parents: 15245 diff changeset	2311 Query or set the internal variable that enables Octave's JIT compiler.\n\
15539 4d6e5fa37899 doc: Update docstrings for enable_jit_debugging and enable_jit_compiler. Rik <rik@octave.org> parents: 15495 diff changeset	2312 \n\
4d6e5fa37899 doc: Update docstrings for enable_jit_debugging and enable_jit_compiler. Rik <rik@octave.org> parents: 15495 diff changeset	2313 When called from inside a function with the \"local\" option, the variable is\n\
4d6e5fa37899 doc: Update docstrings for enable_jit_debugging and enable_jit_compiler. Rik <rik@octave.org> parents: 15495 diff changeset	2314 changed locally for the function and any subroutines it calls. The original\n\
4d6e5fa37899 doc: Update docstrings for enable_jit_debugging and enable_jit_compiler. Rik <rik@octave.org> parents: 15495 diff changeset	2315 variable value is restored when exiting the function.\n\
4d6e5fa37899 doc: Update docstrings for enable_jit_debugging and enable_jit_compiler. Rik <rik@octave.org> parents: 15495 diff changeset	2316 @seealso{enable_jit_debugging}\n\
15310 b055fc077224 allow jit compiler to be enabled at run-time John W. Eaton <jwe@octave.org> parents: 15245 diff changeset	2317 @end deftypefn")
b055fc077224 allow jit compiler to be enabled at run-time John W. Eaton <jwe@octave.org> parents: 15245 diff changeset	2318 {
b055fc077224 allow jit compiler to be enabled at run-time John W. Eaton <jwe@octave.org> parents: 15245 diff changeset	2319 #if defined (HAVE_LLVM)
b055fc077224 allow jit compiler to be enabled at run-time John W. Eaton <jwe@octave.org> parents: 15245 diff changeset	2320 return SET_INTERNAL_VARIABLE (enable_jit_compiler);
b055fc077224 allow jit compiler to be enabled at run-time John W. Eaton <jwe@octave.org> parents: 15245 diff changeset	2321 #else
b055fc077224 allow jit compiler to be enabled at run-time John W. Eaton <jwe@octave.org> parents: 15245 diff changeset	2322 warning ("enable_jit_compiler: JIT compiling not available in this version of Octave");
b055fc077224 allow jit compiler to be enabled at run-time John W. Eaton <jwe@octave.org> parents: 15245 diff changeset	2323 return octave_value ();
b055fc077224 allow jit compiler to be enabled at run-time John W. Eaton <jwe@octave.org> parents: 15245 diff changeset	2324 #endif
b055fc077224 allow jit compiler to be enabled at run-time John W. Eaton <jwe@octave.org> parents: 15245 diff changeset	2325 }
15014 094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	2326
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	2327 /*
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	2328 Test some simple cases that compile.
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	2329
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	2330 %!test
15592 6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	2331 %! for i=1:1e6
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	2332 %! if i < 5
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	2333 %! break
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	2334 %! else
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	2335 %! break
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	2336 %! endif
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	2337 %! endfor
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	2338 %! assert (i, 1);
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	2339
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	2340 %!test
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	2341 %! while 1
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	2342 %! if 1
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	2343 %! break
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	2344 %! else
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	2345 %! break
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	2346 %! endif
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	2347 %! endwhile
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	2348
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	2349 %!test
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	2350 %! for i=1:1e6
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	2351 %! if i == 100
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	2352 %! break
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	2353 %! endif
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	2354 %! endfor
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	2355 %! assert (i, 100);
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	2356
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	2357 %!test
15014 094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	2358 %! inc = 1e-5;
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	2359 %! result = 0;
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	2360 %! for ii = 0:inc:1
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	2361 %! result = result + inc * (1/3 * ii * ii);
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	2362 %! endfor
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	2363 %! assert (abs (result - 1/9) < 1e-5);
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	2364
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	2365 %!test
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	2366 %! inc = 1e-5;
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	2367 %! result = 0;
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	2368 %! for ii = 0:inc:1
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	2369 %! # the ^ operator's result is complex
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	2370 %! result = result + inc * (1/3 * ii ^ 2);
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	2371 %! endfor
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	2372 %! assert (abs (result - 1/9) < 1e-5);
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	2373
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	2374 %!test
15583 0754bdfbc8fe Correct multiplication complex multiplication with NaN in JIT Max Brister <max@2bass.com> parents: 15582 diff changeset	2375 %! temp = 1+1i;
0754bdfbc8fe Correct multiplication complex multiplication with NaN in JIT Max Brister <max@2bass.com> parents: 15582 diff changeset	2376 %! nan = NaN;
0754bdfbc8fe Correct multiplication complex multiplication with NaN in JIT Max Brister <max@2bass.com> parents: 15582 diff changeset	2377 %! while 1
0754bdfbc8fe Correct multiplication complex multiplication with NaN in JIT Max Brister <max@2bass.com> parents: 15582 diff changeset	2378 %! temp = temp - 1i;
0754bdfbc8fe Correct multiplication complex multiplication with NaN in JIT Max Brister <max@2bass.com> parents: 15582 diff changeset	2379 %! temp = temp * nan;
0754bdfbc8fe Correct multiplication complex multiplication with NaN in JIT Max Brister <max@2bass.com> parents: 15582 diff changeset	2380 %! break;
0754bdfbc8fe Correct multiplication complex multiplication with NaN in JIT Max Brister <max@2bass.com> parents: 15582 diff changeset	2381 %! endwhile
0754bdfbc8fe Correct multiplication complex multiplication with NaN in JIT Max Brister <max@2bass.com> parents: 15582 diff changeset	2382 %! assert (imag (temp), 0);
0754bdfbc8fe Correct multiplication complex multiplication with NaN in JIT Max Brister <max@2bass.com> parents: 15582 diff changeset	2383
0754bdfbc8fe Correct multiplication complex multiplication with NaN in JIT Max Brister <max@2bass.com> parents: 15582 diff changeset	2384 %!test
0754bdfbc8fe Correct multiplication complex multiplication with NaN in JIT Max Brister <max@2bass.com> parents: 15582 diff changeset	2385 %! temp = 1+1i;
0754bdfbc8fe Correct multiplication complex multiplication with NaN in JIT Max Brister <max@2bass.com> parents: 15582 diff changeset	2386 %! nan = NaN+1i;
0754bdfbc8fe Correct multiplication complex multiplication with NaN in JIT Max Brister <max@2bass.com> parents: 15582 diff changeset	2387 %! while 1
0754bdfbc8fe Correct multiplication complex multiplication with NaN in JIT Max Brister <max@2bass.com> parents: 15582 diff changeset	2388 %! nan = nan - 1i;
0754bdfbc8fe Correct multiplication complex multiplication with NaN in JIT Max Brister <max@2bass.com> parents: 15582 diff changeset	2389 %! temp = temp - 1i;
0754bdfbc8fe Correct multiplication complex multiplication with NaN in JIT Max Brister <max@2bass.com> parents: 15582 diff changeset	2390 %! temp = temp * nan;
0754bdfbc8fe Correct multiplication complex multiplication with NaN in JIT Max Brister <max@2bass.com> parents: 15582 diff changeset	2391 %! break;
0754bdfbc8fe Correct multiplication complex multiplication with NaN in JIT Max Brister <max@2bass.com> parents: 15582 diff changeset	2392 %! endwhile
0754bdfbc8fe Correct multiplication complex multiplication with NaN in JIT Max Brister <max@2bass.com> parents: 15582 diff changeset	2393 %! assert (imag (temp), 0);
0754bdfbc8fe Correct multiplication complex multiplication with NaN in JIT Max Brister <max@2bass.com> parents: 15582 diff changeset	2394
0754bdfbc8fe Correct multiplication complex multiplication with NaN in JIT Max Brister <max@2bass.com> parents: 15582 diff changeset	2395 %!test
0754bdfbc8fe Correct multiplication complex multiplication with NaN in JIT Max Brister <max@2bass.com> parents: 15582 diff changeset	2396 %! temp = 1+1i;
0754bdfbc8fe Correct multiplication complex multiplication with NaN in JIT Max Brister <max@2bass.com> parents: 15582 diff changeset	2397 %! while 1
0754bdfbc8fe Correct multiplication complex multiplication with NaN in JIT Max Brister <max@2bass.com> parents: 15582 diff changeset	2398 %! temp = temp * 5;
0754bdfbc8fe Correct multiplication complex multiplication with NaN in JIT Max Brister <max@2bass.com> parents: 15582 diff changeset	2399 %! break;
0754bdfbc8fe Correct multiplication complex multiplication with NaN in JIT Max Brister <max@2bass.com> parents: 15582 diff changeset	2400 %! endwhile
0754bdfbc8fe Correct multiplication complex multiplication with NaN in JIT Max Brister <max@2bass.com> parents: 15582 diff changeset	2401 %! assert (temp, 5+5i);
0754bdfbc8fe Correct multiplication complex multiplication with NaN in JIT Max Brister <max@2bass.com> parents: 15582 diff changeset	2402
0754bdfbc8fe Correct multiplication complex multiplication with NaN in JIT Max Brister <max@2bass.com> parents: 15582 diff changeset	2403 %!test
15014 094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	2404 %! nr = 1001;
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	2405 %! mat = zeros (1, nr);
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	2406 %! for i = 1:nr
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	2407 %! mat(i) = i;
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	2408 %! endfor
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	2409 %! assert (mat == 1:nr);
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	2410
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	2411 %!test
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	2412 %! nr = 1001;
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	2413 %! mat = 1:nr;
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	2414 %! mat(end) = 0; # force mat to a matrix
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	2415 %! total = 0;
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	2416 %! for i = 1:nr
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	2417 %! total = mat(i) + total;
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	2418 %! endfor
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	2419 %! assert (sum (mat) == total);
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	2420
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	2421 %!test
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	2422 %! nr = 1001;
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	2423 %! mat = [3 1 5];
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	2424 %! try
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	2425 %! for i = 1:nr
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	2426 %! if i > 500
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	2427 %! result = mat(100);
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	2428 %! else
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	2429 %! result = i;
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	2430 %! endif
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	2431 %! endfor
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	2432 %! catch
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	2433 %! end
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	2434 %! assert (result == 500);
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	2435
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	2436 %!function result = gen_test (n)
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	2437 %! result = double (rand (1, n) > .01);
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	2438 %!endfunction
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	2439
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	2440 %!function z = vectorized (A, K)
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	2441 %! temp = ones (1, K);
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	2442 %! z = conv (A, temp);
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	2443 %! z = z > K-1;
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	2444 %! z = conv (z, temp);
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	2445 %! z = z(K:end-K+1);
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	2446 %! z = z >= 1;
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	2447 %!endfunction
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	2448
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	2449 %!function z = loopy (A, K)
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	2450 %! z = A;
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	2451 %! n = numel (A);
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	2452 %! counter = 0;
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	2453 %! for ii=1:n
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	2454 %! if z(ii)
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	2455 %! counter = counter + 1;
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	2456 %! else
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	2457 %! if counter > 0 && counter < K
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	2458 %! z(ii-counter:ii-1) = 0;
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	2459 %! endif
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	2460 %! counter = 0;
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	2461 %! endif
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	2462 %! endfor
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	2463 %!
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	2464 %! if counter > 0 && counter < K
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	2465 %! z(end-counter+1:end) = 0;
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	2466 %! endif
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	2467 %!endfunction
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	2468
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	2469 %!test
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	2470 %! test_set = gen_test (10000);
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	2471 %! 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	2472
15023 75d1bc2fd6d2 Compile top level while loops in JIT. Max Brister <max@2bass.com> parents: 15016 diff changeset	2473 %!test
75d1bc2fd6d2 Compile top level while loops in JIT. Max Brister <max@2bass.com> parents: 15016 diff changeset	2474 %! niter = 1001;
75d1bc2fd6d2 Compile top level while loops in JIT. Max Brister <max@2bass.com> parents: 15016 diff changeset	2475 %! i = 0;
75d1bc2fd6d2 Compile top level while loops in JIT. Max Brister <max@2bass.com> parents: 15016 diff changeset	2476 %! while (i < niter)
75d1bc2fd6d2 Compile top level while loops in JIT. Max Brister <max@2bass.com> parents: 15016 diff changeset	2477 %! i = i + 1;
75d1bc2fd6d2 Compile top level while loops in JIT. Max Brister <max@2bass.com> parents: 15016 diff changeset	2478 %! endwhile
75d1bc2fd6d2 Compile top level while loops in JIT. Max Brister <max@2bass.com> parents: 15016 diff changeset	2479 %! assert (i == niter);
75d1bc2fd6d2 Compile top level while loops in JIT. Max Brister <max@2bass.com> parents: 15016 diff changeset	2480
15056 bc32288f4a42 Support the end keyword for one dimentional indexing in JIT. Max Brister <max@2bass.com> parents: 15030 diff changeset	2481 %!test
bc32288f4a42 Support the end keyword for one dimentional indexing in JIT. Max Brister <max@2bass.com> parents: 15030 diff changeset	2482 %! niter = 1001;
bc32288f4a42 Support the end keyword for one dimentional indexing in JIT. Max Brister <max@2bass.com> parents: 15030 diff changeset	2483 %! result = 0;
bc32288f4a42 Support the end keyword for one dimentional indexing in JIT. Max Brister <max@2bass.com> parents: 15030 diff changeset	2484 %! m = [5 10];
bc32288f4a42 Support the end keyword for one dimentional indexing in JIT. Max Brister <max@2bass.com> parents: 15030 diff changeset	2485 %! for i=1:niter
bc32288f4a42 Support the end keyword for one dimentional indexing in JIT. Max Brister <max@2bass.com> parents: 15030 diff changeset	2486 %! result = result + m(end);
bc32288f4a42 Support the end keyword for one dimentional indexing in JIT. Max Brister <max@2bass.com> parents: 15030 diff changeset	2487 %! endfor
bc32288f4a42 Support the end keyword for one dimentional indexing in JIT. Max Brister <max@2bass.com> parents: 15030 diff changeset	2488 %! 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	2489
15067 df4538e3b50b ND scalar indexing in JIT. Max Brister <max@2bass.com> parents: 15056 diff changeset	2490 %!test
df4538e3b50b ND scalar indexing in JIT. Max Brister <max@2bass.com> parents: 15056 diff changeset	2491 %! ndim = 100;
df4538e3b50b ND scalar indexing in JIT. Max Brister <max@2bass.com> parents: 15056 diff changeset	2492 %! result = 0;
df4538e3b50b ND scalar indexing in JIT. Max Brister <max@2bass.com> parents: 15056 diff changeset	2493 %! m = zeros (ndim);
df4538e3b50b ND scalar indexing in JIT. Max Brister <max@2bass.com> parents: 15056 diff changeset	2494 %! m(:) = 1:ndim^2;
df4538e3b50b ND scalar indexing in JIT. Max Brister <max@2bass.com> parents: 15056 diff changeset	2495 %! i = 1;
df4538e3b50b ND scalar indexing in JIT. Max Brister <max@2bass.com> parents: 15056 diff changeset	2496 %! while (i <= ndim)
df4538e3b50b ND scalar indexing in JIT. Max Brister <max@2bass.com> parents: 15056 diff changeset	2497 %! for j = 1:ndim
df4538e3b50b ND scalar indexing in JIT. Max Brister <max@2bass.com> parents: 15056 diff changeset	2498 %! result = result + m(i, j);
df4538e3b50b ND scalar indexing in JIT. Max Brister <max@2bass.com> parents: 15056 diff changeset	2499 %! endfor
df4538e3b50b ND scalar indexing in JIT. Max Brister <max@2bass.com> parents: 15056 diff changeset	2500 %! i = i + 1;
df4538e3b50b ND scalar indexing in JIT. Max Brister <max@2bass.com> parents: 15056 diff changeset	2501 %! endwhile
df4538e3b50b ND scalar indexing in JIT. Max Brister <max@2bass.com> parents: 15056 diff changeset	2502 %! 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	2503
f57d7578c1a6 Support ND matrix indexing with scalar assignment in JIT. Max Brister <max@2bass.com> parents: 15067 diff changeset	2504 %!test
f57d7578c1a6 Support ND matrix indexing with scalar assignment in JIT. Max Brister <max@2bass.com> parents: 15067 diff changeset	2505 %! ndim = 100;
f57d7578c1a6 Support ND matrix indexing with scalar assignment in JIT. Max Brister <max@2bass.com> parents: 15067 diff changeset	2506 %! m = zeros (ndim);
f57d7578c1a6 Support ND matrix indexing with scalar assignment in JIT. Max Brister <max@2bass.com> parents: 15067 diff changeset	2507 %! i = 1;
f57d7578c1a6 Support ND matrix indexing with scalar assignment in JIT. Max Brister <max@2bass.com> parents: 15067 diff changeset	2508 %! while (i <= ndim)
f57d7578c1a6 Support ND matrix indexing with scalar assignment in JIT. Max Brister <max@2bass.com> parents: 15067 diff changeset	2509 %! for j = 1:ndim
f57d7578c1a6 Support ND matrix indexing with scalar assignment in JIT. Max Brister <max@2bass.com> parents: 15067 diff changeset	2510 %! 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	2511 %! endfor
f57d7578c1a6 Support ND matrix indexing with scalar assignment in JIT. Max Brister <max@2bass.com> parents: 15067 diff changeset	2512 %! i = i + 1;
f57d7578c1a6 Support ND matrix indexing with scalar assignment in JIT. Max Brister <max@2bass.com> parents: 15067 diff changeset	2513 %! endwhile
f57d7578c1a6 Support ND matrix indexing with scalar assignment in JIT. Max Brister <max@2bass.com> parents: 15067 diff changeset	2514 %! m2 = zeros (ndim);
f57d7578c1a6 Support ND matrix indexing with scalar assignment in JIT. Max Brister <max@2bass.com> parents: 15067 diff changeset	2515 %! m2(:) = 1:(ndim^2);
f57d7578c1a6 Support ND matrix indexing with scalar assignment in JIT. Max Brister <max@2bass.com> parents: 15067 diff changeset	2516 %! assert (all (m == m2));
f57d7578c1a6 Support ND matrix indexing with scalar assignment in JIT. Max Brister <max@2bass.com> parents: 15067 diff changeset	2517
15078 fe4752f772e2 Generate ND indexing functions on demand in JIT. Max Brister <max@2bass.com> parents: 15068 diff changeset	2518 %!test
fe4752f772e2 Generate ND indexing functions on demand in JIT. Max Brister <max@2bass.com> parents: 15068 diff changeset	2519 %! ndim = 2;
fe4752f772e2 Generate ND indexing functions on demand in JIT. Max Brister <max@2bass.com> parents: 15068 diff changeset	2520 %! m = zeros (ndim, ndim, ndim, ndim);
fe4752f772e2 Generate ND indexing functions on demand in JIT. Max Brister <max@2bass.com> parents: 15068 diff changeset	2521 %! result = 0;
fe4752f772e2 Generate ND indexing functions on demand in JIT. Max Brister <max@2bass.com> parents: 15068 diff changeset	2522 %! i0 = 1;
fe4752f772e2 Generate ND indexing functions on demand in JIT. Max Brister <max@2bass.com> parents: 15068 diff changeset	2523 %! while (i0 <= ndim)
fe4752f772e2 Generate ND indexing functions on demand in JIT. Max Brister <max@2bass.com> parents: 15068 diff changeset	2524 %! for i1 = 1:ndim
fe4752f772e2 Generate ND indexing functions on demand in JIT. Max Brister <max@2bass.com> parents: 15068 diff changeset	2525 %! for i2 = 1:ndim
fe4752f772e2 Generate ND indexing functions on demand in JIT. Max Brister <max@2bass.com> parents: 15068 diff changeset	2526 %! for i3 = 1:ndim
fe4752f772e2 Generate ND indexing functions on demand in JIT. Max Brister <max@2bass.com> parents: 15068 diff changeset	2527 %! m(i0, i1, i2, i3) = 1;
fe4752f772e2 Generate ND indexing functions on demand in JIT. Max Brister <max@2bass.com> parents: 15068 diff changeset	2528 %! 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	2529 %! 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	2530 %! endfor
fe4752f772e2 Generate ND indexing functions on demand in JIT. Max Brister <max@2bass.com> parents: 15068 diff changeset	2531 %! endfor
fe4752f772e2 Generate ND indexing functions on demand in JIT. Max Brister <max@2bass.com> parents: 15068 diff changeset	2532 %! endfor
fe4752f772e2 Generate ND indexing functions on demand in JIT. Max Brister <max@2bass.com> parents: 15068 diff changeset	2533 %! i0 = i0 + 1;
fe4752f772e2 Generate ND indexing functions on demand in JIT. Max Brister <max@2bass.com> parents: 15068 diff changeset	2534 %! endwhile
fe4752f772e2 Generate ND indexing functions on demand in JIT. Max Brister <max@2bass.com> parents: 15068 diff changeset	2535 %! expected = ones (ndim, ndim, ndim, ndim);
fe4752f772e2 Generate ND indexing functions on demand in JIT. Max Brister <max@2bass.com> parents: 15068 diff changeset	2536 %! assert (all (m == expected));
fe4752f772e2 Generate ND indexing functions on demand in JIT. Max Brister <max@2bass.com> parents: 15068 diff changeset	2537 %! assert (result == sum (expected (:)));
fe4752f772e2 Generate ND indexing functions on demand in JIT. Max Brister <max@2bass.com> parents: 15068 diff changeset	2538
15095 9df70a18aa27 Correct division by zero check in JIT Max Brister <max@2bass.com> parents: 15078 diff changeset	2539 %!function test_divide ()
9df70a18aa27 Correct division by zero check in JIT Max Brister <max@2bass.com> parents: 15078 diff changeset	2540 %! 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	2541 %! unwind_protect
9df70a18aa27 Correct division by zero check in JIT Max Brister <max@2bass.com> parents: 15078 diff changeset	2542 %! warning ("error", "Octave:divide-by-zero");
9df70a18aa27 Correct division by zero check in JIT Max Brister <max@2bass.com> parents: 15078 diff changeset	2543 %! for i=1:1e5
9df70a18aa27 Correct division by zero check in JIT Max Brister <max@2bass.com> parents: 15078 diff changeset	2544 %! a = 1;
9df70a18aa27 Correct division by zero check in JIT Max Brister <max@2bass.com> parents: 15078 diff changeset	2545 %! a / 0;
9df70a18aa27 Correct division by zero check in JIT Max Brister <max@2bass.com> parents: 15078 diff changeset	2546 %! endfor
9df70a18aa27 Correct division by zero check in JIT Max Brister <max@2bass.com> parents: 15078 diff changeset	2547 %! unwind_protect_cleanup
9df70a18aa27 Correct division by zero check in JIT Max Brister <max@2bass.com> parents: 15078 diff changeset	2548 %! warning (state, "Octave:divide-by-zero");
9df70a18aa27 Correct division by zero check in JIT Max Brister <max@2bass.com> parents: 15078 diff changeset	2549 %! end_unwind_protect
9df70a18aa27 Correct division by zero check in JIT Max Brister <max@2bass.com> parents: 15078 diff changeset	2550 %!endfunction
9df70a18aa27 Correct division by zero check in JIT Max Brister <max@2bass.com> parents: 15078 diff changeset	2551
9df70a18aa27 Correct division by zero check in JIT Max Brister <max@2bass.com> parents: 15078 diff changeset	2552 %!error <division by zero> test_divide ()
9df70a18aa27 Correct division by zero check in JIT Max Brister <max@2bass.com> parents: 15078 diff changeset	2553
9df70a18aa27 Correct division by zero check in JIT Max Brister <max@2bass.com> parents: 15078 diff changeset	2554 %!test
9df70a18aa27 Correct division by zero check in JIT Max Brister <max@2bass.com> parents: 15078 diff changeset	2555 %! while 1
9df70a18aa27 Correct division by zero check in JIT Max Brister <max@2bass.com> parents: 15078 diff changeset	2556 %! a = 0;
9df70a18aa27 Correct division by zero check in JIT Max Brister <max@2bass.com> parents: 15078 diff changeset	2557 %! result = a / 1;
9df70a18aa27 Correct division by zero check in JIT Max Brister <max@2bass.com> parents: 15078 diff changeset	2558 %! break;
9df70a18aa27 Correct division by zero check in JIT Max Brister <max@2bass.com> parents: 15078 diff changeset	2559 %! endwhile
9df70a18aa27 Correct division by zero check in JIT Max Brister <max@2bass.com> parents: 15078 diff changeset	2560 %! assert (result, 0);
9df70a18aa27 Correct division by zero check in JIT Max Brister <max@2bass.com> parents: 15078 diff changeset	2561
15102 d29f2583cf7b Support end in multi indexing in JIT Max Brister <max@2bass.com> parents: 15096 diff changeset	2562 %!test
d29f2583cf7b Support end in multi indexing in JIT Max Brister <max@2bass.com> parents: 15096 diff changeset	2563 %! m = zeros (2, 1001);
d29f2583cf7b Support end in multi indexing in JIT Max Brister <max@2bass.com> parents: 15096 diff changeset	2564 %! for i=1:1001
d29f2583cf7b Support end in multi indexing in JIT Max Brister <max@2bass.com> parents: 15096 diff changeset	2565 %! m(end, i) = i;
d29f2583cf7b Support end in multi indexing in JIT Max Brister <max@2bass.com> parents: 15096 diff changeset	2566 %! m(end - 1, end - i + 1) = i;
d29f2583cf7b Support end in multi indexing in JIT Max Brister <max@2bass.com> parents: 15096 diff changeset	2567 %! endfor
d29f2583cf7b Support end in multi indexing in JIT Max Brister <max@2bass.com> parents: 15096 diff changeset	2568 %! m2 = zeros (2, 1001);
d29f2583cf7b Support end in multi indexing in JIT Max Brister <max@2bass.com> parents: 15096 diff changeset	2569 %! m2(1, :) = fliplr (1:1001);
d29f2583cf7b Support end in multi indexing in JIT Max Brister <max@2bass.com> parents: 15096 diff changeset	2570 %! m2(2, :) = 1:1001;
d29f2583cf7b Support end in multi indexing in JIT Max Brister <max@2bass.com> parents: 15096 diff changeset	2571 %! assert (m, m2);
d29f2583cf7b Support end in multi indexing in JIT Max Brister <max@2bass.com> parents: 15096 diff changeset	2572
15135 bd6bb87e2bea Support sin, cos, and exp with matrix arguments in JIT Max Brister <max@2bass.com> parents: 15102 diff changeset	2573 %!test
bd6bb87e2bea Support sin, cos, and exp with matrix arguments in JIT Max Brister <max@2bass.com> parents: 15102 diff changeset	2574 %! m = [1 2 3];
bd6bb87e2bea Support sin, cos, and exp with matrix arguments in JIT Max Brister <max@2bass.com> parents: 15102 diff changeset	2575 %! for i=1:1001
bd6bb87e2bea Support sin, cos, and exp with matrix arguments in JIT Max Brister <max@2bass.com> parents: 15102 diff changeset	2576 %! m = sin (m);
bd6bb87e2bea Support sin, cos, and exp with matrix arguments in JIT Max Brister <max@2bass.com> parents: 15102 diff changeset	2577 %! break;
bd6bb87e2bea Support sin, cos, and exp with matrix arguments in JIT Max Brister <max@2bass.com> parents: 15102 diff changeset	2578 %! endfor
bd6bb87e2bea Support sin, cos, and exp with matrix arguments in JIT Max Brister <max@2bass.com> parents: 15102 diff changeset	2579 %! 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	2580
15140 6ea86e1d0f5f Support +=, -=, =, ect. in JIT Max Brister <max@2bass.com>* parents: 15135 diff changeset	2581 %!test
6ea86e1d0f5f Support +=, -=, =, ect. in JIT Max Brister <max@2bass.com>* parents: 15135 diff changeset	2582 %! i = 0;
6ea86e1d0f5f Support +=, -=, =, ect. in JIT Max Brister <max@2bass.com>* parents: 15135 diff changeset	2583 %! while i < 10
6ea86e1d0f5f Support +=, -=, =, ect. in JIT Max Brister <max@2bass.com>* parents: 15135 diff changeset	2584 %! i += 1;
6ea86e1d0f5f Support +=, -=, =, ect. in JIT Max Brister <max@2bass.com>* parents: 15135 diff changeset	2585 %! endwhile
6ea86e1d0f5f Support +=, -=, =, ect. in JIT Max Brister <max@2bass.com>* parents: 15135 diff changeset	2586 %! assert (i == 10);
6ea86e1d0f5f Support +=, -=, =, ect. in JIT Max Brister <max@2bass.com>* parents: 15135 diff changeset	2587
15146 709e8928e68c Scalar unary operation support in JIT Max Brister <max@2bass.com> parents: 15140 diff changeset	2588 %!test
709e8928e68c Scalar unary operation support in JIT Max Brister <max@2bass.com> parents: 15140 diff changeset	2589 %! i = 0;
709e8928e68c Scalar unary operation support in JIT Max Brister <max@2bass.com> parents: 15140 diff changeset	2590 %! while i < 10
709e8928e68c Scalar unary operation support in JIT Max Brister <max@2bass.com> parents: 15140 diff changeset	2591 %! a = ++i;
709e8928e68c Scalar unary operation support in JIT Max Brister <max@2bass.com> parents: 15140 diff changeset	2592 %! endwhile
709e8928e68c Scalar unary operation support in JIT Max Brister <max@2bass.com> parents: 15140 diff changeset	2593 %! assert (i == 10);
709e8928e68c Scalar unary operation support in JIT Max Brister <max@2bass.com> parents: 15140 diff changeset	2594 %! assert (a == 10);
15148 1b2fbc30e4e7 Postfix increment and decrement operations in JIT Max Brister <max@2bass.com> parents: 15147 diff changeset	2595 %!test
1b2fbc30e4e7 Postfix increment and decrement operations in JIT Max Brister <max@2bass.com> parents: 15147 diff changeset	2596 %! i = 0;
1b2fbc30e4e7 Postfix increment and decrement operations in JIT Max Brister <max@2bass.com> parents: 15147 diff changeset	2597 %! while i < 10
1b2fbc30e4e7 Postfix increment and decrement operations in JIT Max Brister <max@2bass.com> parents: 15147 diff changeset	2598 %! a = i++;
1b2fbc30e4e7 Postfix increment and decrement operations in JIT Max Brister <max@2bass.com> parents: 15147 diff changeset	2599 %! endwhile
1b2fbc30e4e7 Postfix increment and decrement operations in JIT Max Brister <max@2bass.com> parents: 15147 diff changeset	2600 %! assert (i == 10);
1b2fbc30e4e7 Postfix increment and decrement operations in JIT Max Brister <max@2bass.com> parents: 15147 diff changeset	2601 %! assert (a == 9);
15146 709e8928e68c Scalar unary operation support in JIT Max Brister <max@2bass.com> parents: 15140 diff changeset	2602
15169 6242904370bd Support balance, cond, det, norm, rand, magic, eye, and mod in JIT Max Brister <max@2bass.com> parents: 15148 diff changeset	2603 %!test
6242904370bd Support balance, cond, det, norm, rand, magic, eye, and mod in JIT Max Brister <max@2bass.com> parents: 15148 diff changeset	2604 %! num = 2;
6242904370bd Support balance, cond, det, norm, rand, magic, eye, and mod in JIT Max Brister <max@2bass.com> parents: 15148 diff changeset	2605 %! 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	2606 %! i = 1;
6242904370bd Support balance, cond, det, norm, rand, magic, eye, and mod in JIT Max Brister <max@2bass.com> parents: 15148 diff changeset	2607 %! 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	2608 %! 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	2609 %! ++i;
6242904370bd Support balance, cond, det, norm, rand, magic, eye, and mod in JIT Max Brister <max@2bass.com> parents: 15148 diff changeset	2610 %! endwhile
6242904370bd Support balance, cond, det, norm, rand, magic, eye, and mod in JIT Max Brister <max@2bass.com> parents: 15148 diff changeset	2611 %! 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	2612
15171 7a19e8275d41 Do not simplify the CFG during type inference Max Brister <max@2bass.com> parents: 15169 diff changeset	2613 %!function test_compute_idom ()
7a19e8275d41 Do not simplify the CFG during type inference Max Brister <max@2bass.com> parents: 15169 diff changeset	2614 %! 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	2615 %! if (l1 (li) < s1 (si))
7a19e8275d41 Do not simplify the CFG during type inference Max Brister <max@2bass.com> parents: 15169 diff changeset	2616 %! if (li == si)
7a19e8275d41 Do not simplify the CFG during type inference Max Brister <max@2bass.com> parents: 15169 diff changeset	2617 %! break;
7a19e8275d41 Do not simplify the CFG during type inference Max Brister <max@2bass.com> parents: 15169 diff changeset	2618 %! endif;
7a19e8275d41 Do not simplify the CFG during type inference Max Brister <max@2bass.com> parents: 15169 diff changeset	2619 %! li++;
7a19e8275d41 Do not simplify the CFG during type inference Max Brister <max@2bass.com> parents: 15169 diff changeset	2620 %! else
7a19e8275d41 Do not simplify the CFG during type inference Max Brister <max@2bass.com> parents: 15169 diff changeset	2621 %! si++;
7a19e8275d41 Do not simplify the CFG during type inference Max Brister <max@2bass.com> parents: 15169 diff changeset	2622 %! endif;
7a19e8275d41 Do not simplify the CFG during type inference Max Brister <max@2bass.com> parents: 15169 diff changeset	2623 %! endwhile
7a19e8275d41 Do not simplify the CFG during type inference Max Brister <max@2bass.com> parents: 15169 diff changeset	2624
7a19e8275d41 Do not simplify the CFG during type inference Max Brister <max@2bass.com> parents: 15169 diff changeset	2625 %!error test_compute_idom ()
7a19e8275d41 Do not simplify the CFG during type inference Max Brister <max@2bass.com> parents: 15169 diff changeset	2626
15230 b0c08e995950 pt-jit.cc (jit_convert::get_variable): Add type bound Max Brister <max@2bass.com> parents: 15195 diff changeset	2627 %!function x = test_overload (a)
b0c08e995950 pt-jit.cc (jit_convert::get_variable): Add type bound Max Brister <max@2bass.com> parents: 15195 diff changeset	2628 %! while 1
b0c08e995950 pt-jit.cc (jit_convert::get_variable): Add type bound Max Brister <max@2bass.com> parents: 15195 diff changeset	2629 %! x = a;
b0c08e995950 pt-jit.cc (jit_convert::get_variable): Add type bound Max Brister <max@2bass.com> parents: 15195 diff changeset	2630 %! break;
b0c08e995950 pt-jit.cc (jit_convert::get_variable): Add type bound Max Brister <max@2bass.com> parents: 15195 diff changeset	2631 %! endwhile
b0c08e995950 pt-jit.cc (jit_convert::get_variable): Add type bound Max Brister <max@2bass.com> parents: 15195 diff changeset	2632 %!endfunction
b0c08e995950 pt-jit.cc (jit_convert::get_variable): Add type bound Max Brister <max@2bass.com> parents: 15195 diff changeset	2633
b0c08e995950 pt-jit.cc (jit_convert::get_variable): Add type bound Max Brister <max@2bass.com> parents: 15195 diff changeset	2634 %!assert (test_overload (1), 1);
b0c08e995950 pt-jit.cc (jit_convert::get_variable): Add type bound Max Brister <max@2bass.com> parents: 15195 diff changeset	2635 %!assert (test_overload ([1 2]), [1 2]);
b0c08e995950 pt-jit.cc (jit_convert::get_variable): Add type bound Max Brister <max@2bass.com> parents: 15195 diff changeset	2636
15233 c27a1e131b16 pt-jit.cc (jit_convert::visit_simple_for_command): Fix block order Max Brister <max@2bass.com> parents: 15230 diff changeset	2637 %!function a = bubble (a = [3 2 1])
c27a1e131b16 pt-jit.cc (jit_convert::visit_simple_for_command): Fix block order Max Brister <max@2bass.com> parents: 15230 diff changeset	2638 %! swapped = 1;
c27a1e131b16 pt-jit.cc (jit_convert::visit_simple_for_command): Fix block order Max Brister <max@2bass.com> parents: 15230 diff changeset	2639 %! n = length (a);
c27a1e131b16 pt-jit.cc (jit_convert::visit_simple_for_command): Fix block order Max Brister <max@2bass.com> parents: 15230 diff changeset	2640 %! while (swapped)
c27a1e131b16 pt-jit.cc (jit_convert::visit_simple_for_command): Fix block order Max Brister <max@2bass.com> parents: 15230 diff changeset	2641 %! swapped = 0;
c27a1e131b16 pt-jit.cc (jit_convert::visit_simple_for_command): Fix block order Max Brister <max@2bass.com> parents: 15230 diff changeset	2642 %! for i = 1:n-1
c27a1e131b16 pt-jit.cc (jit_convert::visit_simple_for_command): Fix block order Max Brister <max@2bass.com> parents: 15230 diff changeset	2643 %! if a(i) > a(i + 1)
c27a1e131b16 pt-jit.cc (jit_convert::visit_simple_for_command): Fix block order Max Brister <max@2bass.com> parents: 15230 diff changeset	2644 %! swapped = 1;
c27a1e131b16 pt-jit.cc (jit_convert::visit_simple_for_command): Fix block order Max Brister <max@2bass.com> parents: 15230 diff changeset	2645 %! temp = a(i);
c27a1e131b16 pt-jit.cc (jit_convert::visit_simple_for_command): Fix block order Max Brister <max@2bass.com> parents: 15230 diff changeset	2646 %! a(i) = a(i + 1);
c27a1e131b16 pt-jit.cc (jit_convert::visit_simple_for_command): Fix block order Max Brister <max@2bass.com> parents: 15230 diff changeset	2647 %! a(i + 1) = temp;
c27a1e131b16 pt-jit.cc (jit_convert::visit_simple_for_command): Fix block order Max Brister <max@2bass.com> parents: 15230 diff changeset	2648 %! endif
c27a1e131b16 pt-jit.cc (jit_convert::visit_simple_for_command): Fix block order Max Brister <max@2bass.com> parents: 15230 diff changeset	2649 %! endfor
c27a1e131b16 pt-jit.cc (jit_convert::visit_simple_for_command): Fix block order Max Brister <max@2bass.com> parents: 15230 diff changeset	2650 %! endwhile
c27a1e131b16 pt-jit.cc (jit_convert::visit_simple_for_command): Fix block order Max Brister <max@2bass.com> parents: 15230 diff changeset	2651 %!endfunction
c27a1e131b16 pt-jit.cc (jit_convert::visit_simple_for_command): Fix block order Max Brister <max@2bass.com> parents: 15230 diff changeset	2652
c27a1e131b16 pt-jit.cc (jit_convert::visit_simple_for_command): Fix block order Max Brister <max@2bass.com> parents: 15230 diff changeset	2653 %!assert (bubble (), [1 2 3]);
c27a1e131b16 pt-jit.cc (jit_convert::visit_simple_for_command): Fix block order Max Brister <max@2bass.com> parents: 15230 diff changeset	2654
15245 4c0cef65c55f pt-jit.cc (jit_infer::do_construct_ir): Correct extraious phi removal Max Brister <max@2bass.com> parents: 15234 diff changeset	2655 %!test
4c0cef65c55f pt-jit.cc (jit_infer::do_construct_ir): Correct extraious phi removal Max Brister <max@2bass.com> parents: 15234 diff changeset	2656 %! a = 0;
4c0cef65c55f pt-jit.cc (jit_infer::do_construct_ir): Correct extraious phi removal Max Brister <max@2bass.com> parents: 15234 diff changeset	2657 %! b = 1;
4c0cef65c55f pt-jit.cc (jit_infer::do_construct_ir): Correct extraious phi removal Max Brister <max@2bass.com> parents: 15234 diff changeset	2658 %! for i=1:1e3
4c0cef65c55f pt-jit.cc (jit_infer::do_construct_ir): Correct extraious phi removal Max Brister <max@2bass.com> parents: 15234 diff changeset	2659 %! for j=1:2
4c0cef65c55f pt-jit.cc (jit_infer::do_construct_ir): Correct extraious phi removal Max Brister <max@2bass.com> parents: 15234 diff changeset	2660 %! a = a + b;
4c0cef65c55f pt-jit.cc (jit_infer::do_construct_ir): Correct extraious phi removal Max Brister <max@2bass.com> parents: 15234 diff changeset	2661 %! endfor
4c0cef65c55f pt-jit.cc (jit_infer::do_construct_ir): Correct extraious phi removal Max Brister <max@2bass.com> parents: 15234 diff changeset	2662 %! endfor
4c0cef65c55f pt-jit.cc (jit_infer::do_construct_ir): Correct extraious phi removal Max Brister <max@2bass.com> parents: 15234 diff changeset	2663 %! assert (a, 2000);
4c0cef65c55f pt-jit.cc (jit_infer::do_construct_ir): Correct extraious phi removal Max Brister <max@2bass.com> parents: 15234 diff changeset	2664 %! assert (b, 1);
4c0cef65c55f pt-jit.cc (jit_infer::do_construct_ir): Correct extraious phi removal Max Brister <max@2bass.com> parents: 15234 diff changeset	2665
15311 de9bfcf637df Fix error when compiling with complex matrix (bug #37247) Max Brister <max@2bass.com> parents: 15310 diff changeset	2666 %!test
de9bfcf637df Fix error when compiling with complex matrix (bug #37247) Max Brister <max@2bass.com> parents: 15310 diff changeset	2667 %! a = [1+1i 1+2i];
de9bfcf637df Fix error when compiling with complex matrix (bug #37247) Max Brister <max@2bass.com> parents: 15310 diff changeset	2668 %! b = 0;
de9bfcf637df Fix error when compiling with complex matrix (bug #37247) Max Brister <max@2bass.com> parents: 15310 diff changeset	2669 %! while 1
de9bfcf637df Fix error when compiling with complex matrix (bug #37247) Max Brister <max@2bass.com> parents: 15310 diff changeset	2670 %! b = a(1);
de9bfcf637df Fix error when compiling with complex matrix (bug #37247) Max Brister <max@2bass.com> parents: 15310 diff changeset	2671 %! break;
de9bfcf637df Fix error when compiling with complex matrix (bug #37247) Max Brister <max@2bass.com> parents: 15310 diff changeset	2672 %! endwhile
de9bfcf637df Fix error when compiling with complex matrix (bug #37247) Max Brister <max@2bass.com> parents: 15310 diff changeset	2673 %! assert (b, a(1));
de9bfcf637df Fix error when compiling with complex matrix (bug #37247) Max Brister <max@2bass.com> parents: 15310 diff changeset	2674
15334 8125773322d4 Error on undefined an unused variables in JIT Max Brister <max@2bass.com> parents: 15311 diff changeset	2675 %!function test_undef ()
8125773322d4 Error on undefined an unused variables in JIT Max Brister <max@2bass.com> parents: 15311 diff changeset	2676 %! for i=1:1e7
8125773322d4 Error on undefined an unused variables in JIT Max Brister <max@2bass.com> parents: 15311 diff changeset	2677 %! XXX;
8125773322d4 Error on undefined an unused variables in JIT Max Brister <max@2bass.com> parents: 15311 diff changeset	2678 %! endfor
8125773322d4 Error on undefined an unused variables in JIT Max Brister <max@2bass.com> parents: 15311 diff changeset	2679 %!endfunction
8125773322d4 Error on undefined an unused variables in JIT Max Brister <max@2bass.com> parents: 15311 diff changeset	2680
8125773322d4 Error on undefined an unused variables in JIT Max Brister <max@2bass.com> parents: 15311 diff changeset	2681 %!error <undefined near> (test_undef);
8125773322d4 Error on undefined an unused variables in JIT Max Brister <max@2bass.com> parents: 15311 diff changeset	2682
15337 3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2683 %!shared id
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2684 %! id = @(x) x;
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2685
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2686 %!assert (id (1), 1);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2687 %!assert (id (1+1i), 1+1i)
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2688 %!assert (id (1, 2), 1)
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2689 %!error <undefined> (id ())
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2690
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2691
15014 094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	2692 */

Mercurial > octave-nkf

annotate libinterp/interp-core/pt-jit.cc @ 15603:44272909d926