octave-nkf: libinterp/corefcn/pt-jit.cc annotate

annotate libinterp/corefcn/pt-jit.cc @ 20654:b65888ec820e draft default tip gccjit

dmalcom gcc jit import

author	Stefan Mahr <dac922@gmx.de>
date	Fri, 27 Feb 2015 16:59:36 +0100
parents	d35201e5ce5d
children

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
19731 4197fc428c7d maint: Update copyright notices for 2015. John W. Eaton <jwe@octave.org> parents: 19685 diff changeset	3 Copyright (C) 2012-2015 Max Brister
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
16768 e2de3c8882be copyright notice fixes John W. Eaton <jwe@octave.org> parents: 16442 diff changeset	23 // Author: Max Brister <max@2bass.com>
e2de3c8882be copyright notice fixes John W. Eaton <jwe@octave.org> parents: 16442 diff changeset	24
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	25 #define __STDC_LIMIT_MACROS
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	26 #define __STDC_CONSTANT_MACROS
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	27
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	28 #ifdef HAVE_CONFIG_H
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	29 #include <config.h>
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	30 #endif
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	31
15582 52df2e7baabe Disable JIT when breakpoints are present Max Brister <max@2bass.com> parents: 15539 diff changeset	32 #include "debug.h"
15310 b055fc077224 allow jit compiler to be enabled at run-time John W. Eaton <jwe@octave.org> parents: 15245 diff changeset	33 #include "defun.h"
b055fc077224 allow jit compiler to be enabled at run-time John W. Eaton <jwe@octave.org> parents: 15245 diff changeset	34 #include "ov.h"
b055fc077224 allow jit compiler to be enabled at run-time John W. Eaton <jwe@octave.org> parents: 15245 diff changeset	35 #include "pt-all.h"
b055fc077224 allow jit compiler to be enabled at run-time John W. Eaton <jwe@octave.org> parents: 15245 diff changeset	36 #include "pt-jit.h"
15595 6e780fb15c14 Make Vdebug_on_interrupt not be static Max Brister <max@2bass.com> parents: 15593 diff changeset	37 #include "sighandlers.h"
15310 b055fc077224 allow jit compiler to be enabled at run-time John W. Eaton <jwe@octave.org> parents: 15245 diff changeset	38 #include "symtab.h"
b055fc077224 allow jit compiler to be enabled at run-time John W. Eaton <jwe@octave.org> parents: 15245 diff changeset	39 #include "variables.h"
14932 1f914446157d Locate and link with LLVM properly Max Brister <max@2bass.com> parents: 14928 diff changeset	40
20654 b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	41 #ifdef HAVE_JIT
16131 e125db98263f build: Eliminate 2 unused variable warnings when not compiling with JIT. Rik <rik@octave.org> parents: 15893 diff changeset	42
16877 5482cd26311a Rename enable_jit_compiler to jit_enable, enable_jit_debugging to debug_jit. Rik <rik@octave.org> parents: 16768 diff changeset	43 static bool Vdebug_jit = false;
5482cd26311a Rename enable_jit_compiler to jit_enable, enable_jit_debugging to debug_jit. Rik <rik@octave.org> parents: 16768 diff changeset	44
17792 26e9312e6928 Build JIT compiler by default, but do not enable it by default. Rik <rik@octave.org> parents: 17787 diff changeset	45 static bool Vjit_enable = false;
15310 b055fc077224 allow jit compiler to be enabled at run-time John W. Eaton <jwe@octave.org> parents: 15245 diff changeset	46
16941 e6ddaa65a777 Add new function jit_startcnt to control JIT acceleration. Rik <rik@octave.org> parents: 16930 diff changeset	47 static int Vjit_startcnt = 1000;
e6ddaa65a777 Add new function jit_startcnt to control JIT acceleration. Rik <rik@octave.org> parents: 16930 diff changeset	48
19870 9cf91ecdc6f7 Rename jit_failure_count() to jit_failcnt(). Rik <rik@octave.org> parents: 19731 diff changeset	49 static int Vjit_failcnt = 0;
18321 efa4572997ba jit compiler: Add counter of jit_fail_exceptions to check if jit compilation fails Stefan Mahr <dac922@gmx.de> parents: 17856 diff changeset	50
20654 b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	51 #ifdef HAVE_LLVM
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	52 #include <llvm/Analysis/CallGraph.h>
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	53 #include <llvm/Analysis/Passes.h>
18840 4a4edf0f2077 fix LLVM 3.4 build (bug #41061) Stefan Mahr <dac922@gmx.de> parents: 18726 diff changeset	54
4a4edf0f2077 fix LLVM 3.4 build (bug #41061) Stefan Mahr <dac922@gmx.de> parents: 18726 diff changeset	55 #ifdef HAVE_LLVM_IR_VERIFIER_H
4a4edf0f2077 fix LLVM 3.4 build (bug #41061) Stefan Mahr <dac922@gmx.de> parents: 18726 diff changeset	56 #include <llvm/IR/Verifier.h>
4a4edf0f2077 fix LLVM 3.4 build (bug #41061) Stefan Mahr <dac922@gmx.de> parents: 18726 diff changeset	57 #else
15016 005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	58 #include <llvm/Analysis/Verifier.h>
18840 4a4edf0f2077 fix LLVM 3.4 build (bug #41061) Stefan Mahr <dac922@gmx.de> parents: 18726 diff changeset	59 #endif
4a4edf0f2077 fix LLVM 3.4 build (bug #41061) Stefan Mahr <dac922@gmx.de> parents: 18726 diff changeset	60
15346 6bdf379592d9 Remove --enable-jit-debug configure option Max Brister <max@2bass.com> parents: 15339 diff changeset	61 #include <llvm/Bitcode/ReaderWriter.h>
15016 005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	62 #include <llvm/ExecutionEngine/ExecutionEngine.h>
005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	63 #include <llvm/ExecutionEngine/JIT.h>
18840 4a4edf0f2077 fix LLVM 3.4 build (bug #41061) Stefan Mahr <dac922@gmx.de> parents: 18726 diff changeset	64
4a4edf0f2077 fix LLVM 3.4 build (bug #41061) Stefan Mahr <dac922@gmx.de> parents: 18726 diff changeset	65 #ifdef LEGACY_PASSMANAGER
4a4edf0f2077 fix LLVM 3.4 build (bug #41061) Stefan Mahr <dac922@gmx.de> parents: 18726 diff changeset	66 #include <llvm/IR/LegacyPassManager.h>
4a4edf0f2077 fix LLVM 3.4 build (bug #41061) Stefan Mahr <dac922@gmx.de> parents: 18726 diff changeset	67 #else
17164 36fd98b9ce48 Add support for llvm 3.3 Max Brister <max@2bass.com> parents: 17031 diff changeset	68 #include <llvm/PassManager.h>
18840 4a4edf0f2077 fix LLVM 3.4 build (bug #41061) Stefan Mahr <dac922@gmx.de> parents: 18726 diff changeset	69 #endif
17164 36fd98b9ce48 Add support for llvm 3.3 Max Brister <max@2bass.com> parents: 17031 diff changeset	70
36fd98b9ce48 Add support for llvm 3.3 Max Brister <max@2bass.com> parents: 17031 diff changeset	71 #ifdef HAVE_LLVM_IR_FUNCTION_H
36fd98b9ce48 Add support for llvm 3.3 Max Brister <max@2bass.com> parents: 17031 diff changeset	72 #include <llvm/IR/LLVMContext.h>
36fd98b9ce48 Add support for llvm 3.3 Max Brister <max@2bass.com> parents: 17031 diff changeset	73 #include <llvm/IR/Module.h>
36fd98b9ce48 Add support for llvm 3.3 Max Brister <max@2bass.com> parents: 17031 diff changeset	74 #else
36fd98b9ce48 Add support for llvm 3.3 Max Brister <max@2bass.com> parents: 17031 diff changeset	75 #include <llvm/LLVMContext.h>
15016 005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	76 #include <llvm/Module.h>
17164 36fd98b9ce48 Add support for llvm 3.3 Max Brister <max@2bass.com> parents: 17031 diff changeset	77 #endif
36fd98b9ce48 Add support for llvm 3.3 Max Brister <max@2bass.com> parents: 17031 diff changeset	78
36fd98b9ce48 Add support for llvm 3.3 Max Brister <max@2bass.com> parents: 17031 diff changeset	79 #ifdef HAVE_LLVM_SUPPORT_IRBUILDER_H
15016 005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	80 #include <llvm/Support/IRBuilder.h>
17164 36fd98b9ce48 Add support for llvm 3.3 Max Brister <max@2bass.com> parents: 17031 diff changeset	81 #elif defined(HAVE_LLVM_IR_IRBUILDER_H)
36fd98b9ce48 Add support for llvm 3.3 Max Brister <max@2bass.com> parents: 17031 diff changeset	82 #include <llvm/IR/IRBuilder.h>
17031 38bcfd413db0 Handle LLVM API incoherence. Octave now works with LLVM 3.0, 3.1, and 3.2 LYH <lyh.kernel@gmail.com> parents: 16941 diff changeset	83 #else
38bcfd413db0 Handle LLVM API incoherence. Octave now works with LLVM 3.0, 3.1, and 3.2 LYH <lyh.kernel@gmail.com> parents: 16941 diff changeset	84 #include <llvm/IRBuilder.h>
38bcfd413db0 Handle LLVM API incoherence. Octave now works with LLVM 3.0, 3.1, and 3.2 LYH <lyh.kernel@gmail.com> parents: 16941 diff changeset	85 #endif
17164 36fd98b9ce48 Add support for llvm 3.3 Max Brister <max@2bass.com> parents: 17031 diff changeset	86
15016 005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	87 #include <llvm/Support/raw_os_ostream.h>
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	88 #include <llvm/Support/TargetSelect.h>
17164 36fd98b9ce48 Add support for llvm 3.3 Max Brister <max@2bass.com> parents: 17031 diff changeset	89
36fd98b9ce48 Add support for llvm 3.3 Max Brister <max@2bass.com> parents: 17031 diff changeset	90 #ifdef HAVE_LLVM_IR_DATALAYOUT_H
36fd98b9ce48 Add support for llvm 3.3 Max Brister <max@2bass.com> parents: 17031 diff changeset	91 #include <llvm/IR/DataLayout.h>
36fd98b9ce48 Add support for llvm 3.3 Max Brister <max@2bass.com> parents: 17031 diff changeset	92 #elif defined(HAVE_LLVM_DATALAYOUT_H)
17031 38bcfd413db0 Handle LLVM API incoherence. Octave now works with LLVM 3.0, 3.1, and 3.2 LYH <lyh.kernel@gmail.com> parents: 16941 diff changeset	93 #include <llvm/DataLayout.h>
38bcfd413db0 Handle LLVM API incoherence. Octave now works with LLVM 3.0, 3.1, and 3.2 LYH <lyh.kernel@gmail.com> parents: 16941 diff changeset	94 #else
15016 005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	95 #include <llvm/Target/TargetData.h>
17031 38bcfd413db0 Handle LLVM API incoherence. Octave now works with LLVM 3.0, 3.1, and 3.2 LYH <lyh.kernel@gmail.com> parents: 16941 diff changeset	96 #endif
17164 36fd98b9ce48 Add support for llvm 3.3 Max Brister <max@2bass.com> parents: 17031 diff changeset	97
15016 005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	98 #include <llvm/Transforms/IPO.h>
005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	99 #include <llvm/Transforms/Scalar.h>
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	100
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	101 static llvm::IRBuilder<> builder (llvm::getGlobalContext ());
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	102
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	103 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	104
20654 b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	105 #endif /* ifdef HAVE_LLVM */
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	106
15592 6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	107 // -------------------- jit_break_exception --------------------
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	108
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	109 // 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	110 // 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	111 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	112
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	113 // -------------------- jit_convert --------------------
15191 ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	114 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	115 : converting_function (false)
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	116 {
15337 3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	117 initialize (symbol_table::current_scope ());
15027 741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	118
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	119 if (for_bounds)
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	120 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	121
15592 6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	122 try
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	123 {
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	124 visit (tee);
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	125 }
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	126 catch (const jit_break_exception&)
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	127 { }
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	128
15337 3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	129 // 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	130 assert (breaks.empty ());
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	131 assert (continues.empty ());
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	132
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	133 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	134 blocks.push_back (final_block);
14959 12fd4a62d633 Fix whitespace issues and update documentation Max Brister <max@2bass.com> parents: 14958 diff changeset	135
15191 ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	136 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	137 {
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	138 jit_variable *var = iter->second;
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	139 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	140 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	141 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	142 }
15337 3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	143
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	144 final_block->append (factory.create<jit_return> ());
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	145 }
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	146
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	147 jit_convert::jit_convert (octave_user_function& fcn,
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	148 const std::vector<jit_type *>& args)
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	149 : converting_function (true)
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	150 {
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	151 initialize (fcn.scope ());
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	152
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	153 tree_parameter_list *plist = fcn.parameter_list ();
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	154 tree_parameter_list *rlist = fcn.return_list ();
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	155 if (plist && plist->takes_varargs ())
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	156 throw jit_fail_exception ("varags not supported");
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	157
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	158 if (rlist && (rlist->size () > 1 \|\| rlist->takes_varargs ()))
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	159 throw jit_fail_exception ("multiple returns not supported");
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	160
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	161 if (plist)
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	162 {
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	163 tree_parameter_list::iterator piter = plist->begin ();
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	164 for (size_t i = 0; i < args.size (); ++i, ++piter)
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	165 {
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	166 if (piter == plist->end ())
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	167 throw jit_fail_exception ("Too many parameter to function");
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	168
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	169 tree_decl_elt elt = piter;
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	170 std::string name = elt->name ();
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	171 create_variable (name, args[i]);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	172 }
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	173 }
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	174
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	175 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	176 bool all_breaking = false;
15337 3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	177 if (fcn.is_special_expr ())
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 tree_expression *expr = fcn.special_expr ();
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	180 if (expr)
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	181 {
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	182 jit_variable *retvar = get_variable ("#return");
18322 8b22a9215ec2 jit compiler: Fix uninitialized variable warning Stefan Mahr <dac922@gmx.de> parents: 18321 diff changeset	183 jit_value *retval = 0;
15592 6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	184 try
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	185 {
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	186 retval = visit (expr);
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	187 }
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	188 catch (const jit_break_exception&)
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	189 { }
15592 6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	190
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	191 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	192 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	193 "anonymous functions");
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	194
15337 3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	195 block->append (factory.create<jit_assign> (retvar, retval));
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	196 return_value = retvar;
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 }
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	199 else
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	200 {
15592 6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	201 try
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	202 {
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	203 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	204 }
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	205 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	206 {
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	207 all_breaking = true;
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	208 }
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	209
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	210 // 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	211 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	212 finish_breaks (final_block, breaks);
15337 3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	213 }
15592 6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	214
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	215 if (! all_breaking)
15337 3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	216 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	217
15337 3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	218 blocks.push_back (final_block);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	219 block = final_block;
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	220
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	221 if (! return_value && rlist && rlist->size () == 1)
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	222 {
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	223 tree_decl_elt *elt = rlist->front ();
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	224 return_value = get_variable (elt->name ());
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	225 }
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	226
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	227 // 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	228 // 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	229 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	230 {
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	231 if (iter->second != return_value)
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	232 {
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	233 jit_call *call;
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	234 call = factory.create<jit_call> (&jit_typeinfo::destroy,
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	235 iter->second);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	236 final_block->append (call);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	237 }
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	238 }
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	239
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	240 if (return_value)
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	241 final_block->append (factory.create<jit_return> (return_value));
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	242 else
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	243 final_block->append (factory.create<jit_return> ());
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	244 }
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	245
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	246 void
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	247 jit_convert::visit_anon_fcn_handle (tree_anon_fcn_handle&)
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	248 {
18324 7e425ca58e9c jit compiler: Add fail reason to jit_fail_exceptions LYH <lyh.kernel@gmail.com> parents: 18322 diff changeset	249 throw jit_fail_exception ("No visit_anon_fcn_handle implementation");
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	250 }
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	251
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	252 void
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	253 jit_convert::visit_argument_list (tree_argument_list&)
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	254 {
18324 7e425ca58e9c jit compiler: Add fail reason to jit_fail_exceptions LYH <lyh.kernel@gmail.com> parents: 18322 diff changeset	255 throw jit_fail_exception ("No visit_argument_list implementation");
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	256 }
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	257
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	258 void
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	259 jit_convert::visit_binary_expression (tree_binary_expression& be)
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	260 {
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	261 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	262 {
f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	263 tree_boolean_expression *boole;
f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	264 boole = dynamic_cast<tree_boolean_expression *> (&be);
f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	265 assert (boole);
f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	266 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	267
15027 741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	268 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	269 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	270 vmap[short_name] = short_result;
f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	271
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	272 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	273 tree_expression *lhs = be.lhs ();
f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	274 jit_value *lhsv = visit (lhs);
f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	275 lhsv = create_checked (&jit_typeinfo::logically_true, lhsv);
f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	276
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	277 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	278 blocks.push_back (short_early);
14978 f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	279
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	280 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	281
f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	282 if (is_and)
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	283 block->append (factory.create<jit_cond_branch> (lhsv, short_cont,
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	284 short_early));
14978 f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	285 else
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	286 block->append (factory.create<jit_cond_branch> (lhsv, short_early,
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	287 short_cont));
14978 f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	288
f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	289 block = short_early;
f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	290
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	291 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	292 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	293 block->append (factory.create<jit_branch> (done));
14978 f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	294
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	295 blocks.push_back (short_cont);
14978 f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	296 block = short_cont;
f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	297
f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	298 tree_expression *rhs = be.rhs ();
f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	299 jit_value *rhsv = visit (rhs);
f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	300 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	301 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	302 block->append (factory.create<jit_branch> (done));
14978 f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	303
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	304 blocks.push_back (done);
14978 f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	305 block = done;
f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	306 result = short_result;
f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	307 }
f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	308 else
f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	309 {
f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	310 tree_expression *lhs = be.lhs ();
f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	311 jit_value *lhsv = visit (lhs);
f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	312
f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	313 tree_expression *rhs = be.rhs ();
f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	314 jit_value *rhsv = visit (rhs);
f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	315
14983 a5f75de0dab1 Rename jit_function to jit_operation Max Brister <max@2bass.com> parents: 14978 diff changeset	316 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	317 result = create_checked (fn, lhsv, rhsv);
f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	318 }
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_break_command (tree_break_command&)
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	323 {
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	324 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	325 throw jit_break_exception ();
14903 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
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	328 void
14936 32deb562ae77 Allow for construction of ranges during jit Max Brister <max@2bass.com> parents: 14935 diff changeset	329 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	330 {
14936 32deb562ae77 Allow for construction of ranges during jit Max Brister <max@2bass.com> parents: 14935 diff changeset	331 // 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	332 jit_value *base = visit (expr.base ());
c0a5ab3b9278 jit_const no longer inherits from jit_instruction Max Brister <max@2bass.com> parents: 14943 diff changeset	333 jit_value *limit = visit (expr.limit ());
c0a5ab3b9278 jit_const no longer inherits from jit_instruction Max Brister <max@2bass.com> parents: 14943 diff changeset	334 jit_value *increment;
14936 32deb562ae77 Allow for construction of ranges during jit Max Brister <max@2bass.com> parents: 14935 diff changeset	335 tree_expression *tinc = expr.increment ();
32deb562ae77 Allow for construction of ranges during jit Max Brister <max@2bass.com> parents: 14935 diff changeset	336
32deb562ae77 Allow for construction of ranges during jit Max Brister <max@2bass.com> parents: 14935 diff changeset	337 if (tinc)
32deb562ae77 Allow for construction of ranges during jit Max Brister <max@2bass.com> parents: 14935 diff changeset	338 increment = visit (tinc);
32deb562ae77 Allow for construction of ranges during jit Max Brister <max@2bass.com> parents: 14935 diff changeset	339 else
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	340 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	341
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	342 result = block->append (factory.create<jit_call> (jit_typeinfo::make_range,
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	343 base, limit, increment));
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	344 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	345
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	346 void
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	347 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	348 {
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	349 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	350 throw jit_break_exception ();
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	351 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	352
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	353 void
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	354 jit_convert::visit_global_command (tree_global_command&)
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	355 {
18324 7e425ca58e9c jit compiler: Add fail reason to jit_fail_exceptions LYH <lyh.kernel@gmail.com> parents: 18322 diff changeset	356 throw jit_fail_exception ("No visit_global_command implemenation");
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	357 }
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	358
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	359 void
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	360 jit_convert::visit_persistent_command (tree_persistent_command&)
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	361 {
18324 7e425ca58e9c jit compiler: Add fail reason to jit_fail_exceptions LYH <lyh.kernel@gmail.com> parents: 18322 diff changeset	362 throw jit_fail_exception ("No visit_persistent_command implementation");
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	363 }
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	364
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	365 void
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	366 jit_convert::visit_decl_elt (tree_decl_elt&)
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	367 {
18324 7e425ca58e9c jit compiler: Add fail reason to jit_fail_exceptions LYH <lyh.kernel@gmail.com> parents: 18322 diff changeset	368 throw jit_fail_exception ("No visit_decl_elt implementation");
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	369 }
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	370
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	371 void
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	372 jit_convert::visit_decl_init_list (tree_decl_init_list&)
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	373 {
18324 7e425ca58e9c jit compiler: Add fail reason to jit_fail_exceptions LYH <lyh.kernel@gmail.com> parents: 18322 diff changeset	374 throw jit_fail_exception ("No visit_decl_init_list implementation");
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	375 }
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	376
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	377 void
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	378 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	379 {
14938 bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	380 // 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	381 // 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	382 // 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	383
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	384 // 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	385 unwind_protect prot;
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	386 prot.protect_var (breaks);
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	387 prot.protect_var (continues);
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	388 breaks.clear ();
14989 dfaa8da46364 Support while loops in JIT Max Brister <max@2bass.com> parents: 14988 diff changeset	389 continues.clear ();
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	390
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	391 // 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	392 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	393 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	394 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	395 vmap[iter_name] = iterator;
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	396
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	397 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	398 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	399
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	400 // 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	401 // 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	402 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	403 if (! control)
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	404 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	405 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	406 control);
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	407 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	408 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	409
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	410 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	411 iterator);
a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	412 block->append (check);
a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	413 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	414
c27a1e131b16 pt-jit.cc (jit_convert::visit_simple_for_command): Fix block order Max Brister <max@2bass.com> parents: 15230 diff changeset	415 blocks.push_back (body);
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	416 block = body;
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	417
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	418 // 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	419 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	420 control, iterator);
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	421 block->append (idx_rhs);
14969 bbeef7b8ea2e Add support for matrix indexed assignment to JIT Max Brister <max@2bass.com> parents: 14968 diff changeset	422 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	423
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	424 // do loop
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	425 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	426 bool all_breaking = false;
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	427 try
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	428 {
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	429 pt_body->accept (*this);
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	430 }
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	431 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	432 {
15592 6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	433 if (continues.empty ())
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	434 {
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	435 // 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	436 // 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	437 finish_breaks (tail, breaks);
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	438 blocks.push_back (tail);
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	439 block = tail;
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	440 return;
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	441 }
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	442
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	443 all_breaking = true;
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	444 }
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	445
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	446 // 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	447 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	448 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	449
15603 44272909d926 Stop JIT on interrupt Max Brister <max@2bass.com> parents: 15602 diff changeset	450 jit_block *interrupt_check = factory.create<jit_block> ("for_interrupt");
44272909d926 Stop JIT on interrupt Max Brister <max@2bass.com> parents: 15602 diff changeset	451 blocks.push_back (interrupt_check);
44272909d926 Stop JIT on interrupt Max Brister <max@2bass.com> parents: 15602 diff changeset	452
15592 6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	453 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	454 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	455 finish_breaks (check_block, continues);
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	456
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	457 block = check_block;
14983 a5f75de0dab1 Rename jit_function to jit_operation Max Brister <max@2bass.com> parents: 14978 diff changeset	458 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	459 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	460 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	461 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	462 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	463 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	464 control, iterator));
15603 44272909d926 Stop JIT on interrupt Max Brister <max@2bass.com> parents: 15602 diff changeset	465 block->append (factory.create<jit_cond_branch> (check, interrupt_check,
44272909d926 Stop JIT on interrupt Max Brister <max@2bass.com> parents: 15602 diff changeset	466 tail));
44272909d926 Stop JIT on interrupt Max Brister <max@2bass.com> parents: 15602 diff changeset	467
44272909d926 Stop JIT on interrupt Max Brister <max@2bass.com> parents: 15602 diff changeset	468 block = interrupt_check;
44272909d926 Stop JIT on interrupt Max Brister <max@2bass.com> parents: 15602 diff changeset	469 jit_error_check *ec
44272909d926 Stop JIT on interrupt Max Brister <max@2bass.com> parents: 15602 diff changeset	470 = factory.create<jit_error_check> (jit_error_check::var_interrupt,
44272909d926 Stop JIT on interrupt Max Brister <max@2bass.com> parents: 15602 diff changeset	471 body, final_block);
44272909d926 Stop JIT on interrupt Max Brister <max@2bass.com> parents: 15602 diff changeset	472 block->append (ec);
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	473
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	474 // 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	475 blocks.push_back (tail);
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	476 finish_breaks (tail, breaks);
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	477 block = tail;
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	478 }
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	479
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	480 void
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	481 jit_convert::visit_complex_for_command (tree_complex_for_command&)
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	482 {
18324 7e425ca58e9c jit compiler: Add fail reason to jit_fail_exceptions LYH <lyh.kernel@gmail.com> parents: 18322 diff changeset	483 throw jit_fail_exception ("No visit_complex_for_command implementation");
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	484 }
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	485
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	486 void
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	487 jit_convert::visit_octave_user_script (octave_user_script&)
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	488 {
18324 7e425ca58e9c jit compiler: Add fail reason to jit_fail_exceptions LYH <lyh.kernel@gmail.com> parents: 18322 diff changeset	489 throw jit_fail_exception ("No visit_octave_user_script implementation");
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	490 }
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	491
14915 cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14913 diff changeset	492 void
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	493 jit_convert::visit_octave_user_function (octave_user_function&)
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	494 {
18324 7e425ca58e9c jit compiler: Add fail reason to jit_fail_exceptions LYH <lyh.kernel@gmail.com> parents: 18322 diff changeset	495 throw jit_fail_exception ("No visit_octave_user_function implementation");
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	496 }
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	497
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	498 void
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	499 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	500 {
18324 7e425ca58e9c jit compiler: Add fail reason to jit_fail_exceptions LYH <lyh.kernel@gmail.com> parents: 18322 diff changeset	501 throw jit_fail_exception ("No visit_octave_user_function_header implementation");
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	502 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	503
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	504 void
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	505 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	506 {
18324 7e425ca58e9c jit compiler: Add fail reason to jit_fail_exceptions LYH <lyh.kernel@gmail.com> parents: 18322 diff changeset	507 throw jit_fail_exception ("No visit_octave_user_function_trailer implementation");
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	508 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	509
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	510 void
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	511 jit_convert::visit_function_def (tree_function_def&)
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	512 {
18324 7e425ca58e9c jit compiler: Add fail reason to jit_fail_exceptions LYH <lyh.kernel@gmail.com> parents: 18322 diff changeset	513 throw jit_fail_exception ("No visit_function_def implementation");
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	514 }
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	515
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	516 void
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	517 jit_convert::visit_identifier (tree_identifier& ti)
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	518 {
15056 bc32288f4a42 Support the end keyword for one dimentional indexing in JIT. Max Brister <max@2bass.com> parents: 15030 diff changeset	519 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	520 {
bc32288f4a42 Support the end keyword for one dimentional indexing in JIT. Max Brister <max@2bass.com> parents: 15030 diff changeset	521 if (!end_context.size ())
bc32288f4a42 Support the end keyword for one dimentional indexing in JIT. Max Brister <max@2bass.com> parents: 15030 diff changeset	522 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	523 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	524 }
bc32288f4a42 Support the end keyword for one dimentional indexing in JIT. Max Brister <max@2bass.com> parents: 15030 diff changeset	525 else
15334 8125773322d4 Error on undefined an unused variables in JIT Max Brister <max@2bass.com> parents: 15311 diff changeset	526 {
8125773322d4 Error on undefined an unused variables in JIT Max Brister <max@2bass.com> parents: 15311 diff changeset	527 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	528 jit_instruction *instr;
8125773322d4 Error on undefined an unused variables in JIT Max Brister <max@2bass.com> parents: 15311 diff changeset	529 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	530 result = block->append (instr);
8125773322d4 Error on undefined an unused variables in JIT Max Brister <max@2bass.com> parents: 15311 diff changeset	531 }
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	532 }
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	533
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	534 void
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	535 jit_convert::visit_if_clause (tree_if_clause&)
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	536 {
18324 7e425ca58e9c jit compiler: Add fail reason to jit_fail_exceptions LYH <lyh.kernel@gmail.com> parents: 18322 diff changeset	537 throw jit_fail_exception ("No visit_if_clause implementation");
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	538 }
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	539
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	540 void
14923 168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	541 jit_convert::visit_if_command (tree_if_command& cmd)
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	542 {
14923 168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	543 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	544 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	545 lst->accept (*this);
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	546 }
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	547
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	548 void
14923 168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	549 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	550 {
14923 168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	551 tree_if_clause *last = lst.back ();
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	552 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	553
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	554 // 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	555 // 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	556 // 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	557 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	558 entry_blocks[0] = block;
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	559
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	560 // 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	561 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	562 ++iter;
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	563 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	564 {
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	565 tree_if_clause tic = iter;
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	566 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	567 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	568 else
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	569 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	570 }
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	571
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	572 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	573 if (! last_else)
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	574 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	575
15592 6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	576
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	577 // 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	578 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	579 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	580 breaks.clear ();
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	581 continues.clear ();
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	582
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	583 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	584 iter = lst.begin ();
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	585 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	586 {
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	587 tree_if_clause tic = iter;
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	588 block = entry_blocks[i];
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	589 assert (block);
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	590
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	591 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	592 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	593
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	594 if (! tic->is_else_clause ())
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	595 {
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	596 tree_expression *expr = tic->condition ();
14944 c0a5ab3b9278 jit_const no longer inherits from jit_instruction Max Brister <max@2bass.com> parents: 14943 diff changeset	597 jit_value *cond = visit (expr);
14961 903a5ee2cdde Simplify the creation of error checks in jit Max Brister <max@2bass.com> parents: 14960 diff changeset	598 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	599 cond);
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	600 jit_block *body = factory.create<jit_block> (i == 0 ? "if_body"
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	601 : "ifelse_body");
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	602 blocks.push_back (body);
14923 168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	603
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	604 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	605 entry_blocks[i + 1]);
14923 168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	606 block->append (br);
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	607 block = body;
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	608 }
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	609
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	610 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	611 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	612
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	613 try
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	614 {
15592 6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	615 stmt_lst->accept (*this);
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	616 ++num_incomming;
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	617 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	618 }
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	619 catch (const jit_break_exception&)
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	620 { }
15592 6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	621
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	622 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	623 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	624 }
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	625
15592 6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	626 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	627 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	628
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	629 if (num_incomming \|\| ! last_else)
14923 168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	630 {
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	631 blocks.push_back (tail);
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	632 block = tail;
14923 168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	633 }
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	634 else
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	635 // 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	636 throw jit_break_exception ();
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	637 }
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	638
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	639 void
14951 4c9fd3e31436 Start of jit support for double matricies Max Brister <max@2bass.com> parents: 14949 diff changeset	640 jit_convert::visit_index_expression (tree_index_expression& exp)
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	641 {
15334 8125773322d4 Error on undefined an unused variables in JIT Max Brister <max@2bass.com> parents: 15311 diff changeset	642 result = resolve (exp);
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	643 }
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	644
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	645 void
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	646 jit_convert::visit_matrix (tree_matrix&)
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	647 {
18324 7e425ca58e9c jit compiler: Add fail reason to jit_fail_exceptions LYH <lyh.kernel@gmail.com> parents: 18322 diff changeset	648 throw jit_fail_exception ("No visit_matrix implementation");
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	649 }
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	650
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	651 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_cell (tree_cell&)
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	653 {
18324 7e425ca58e9c jit compiler: Add fail reason to jit_fail_exceptions LYH <lyh.kernel@gmail.com> parents: 18322 diff changeset	654 throw jit_fail_exception ("No visit_cell implementation");
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	655 }
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	656
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 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_multi_assignment (tree_multi_assignment&)
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	659 {
18324 7e425ca58e9c jit compiler: Add fail reason to jit_fail_exceptions LYH <lyh.kernel@gmail.com> parents: 18322 diff changeset	660 throw jit_fail_exception ("No visit_multi_assignment implementation");
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	661 }
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	662
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	663 void
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	664 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	665 {
18324 7e425ca58e9c jit compiler: Add fail reason to jit_fail_exceptions LYH <lyh.kernel@gmail.com> parents: 18322 diff changeset	666 throw jit_fail_exception ("No visit_no_op_command implementation");
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	667 }
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	668
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	669 void
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	670 jit_convert::visit_constant (tree_constant& tc)
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	671 {
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	672 octave_value v = tc.rvalue1 ();
15583 0754bdfbc8fe Correct multiplication complex multiplication with NaN in JIT Max Brister <max@2bass.com> parents: 15582 diff changeset	673 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	674
0754bdfbc8fe Correct multiplication complex multiplication with NaN in JIT Max Brister <max@2bass.com> parents: 15582 diff changeset	675 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	676 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	677 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	678 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	679 }
15583 0754bdfbc8fe Correct multiplication complex multiplication with NaN in JIT Max Brister <max@2bass.com> parents: 15582 diff changeset	680 else if (ty == jit_typeinfo::get_range ())
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	681 {
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	682 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	683 result = factory.create<jit_const_range> (rv);
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	684 }
15583 0754bdfbc8fe Correct multiplication complex multiplication with NaN in JIT Max Brister <max@2bass.com> parents: 15582 diff changeset	685 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	686 {
561aad6a9e4b Initial support for complex numbers in JIT Max Brister <max@2bass.com> parents: 14983 diff changeset	687 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	688 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	689 }
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	690 else
15016 005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	691 throw jit_fail_exception ("Unknown constant");
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	692 }
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	693
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	694 void
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	695 jit_convert::visit_fcn_handle (tree_fcn_handle&)
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	696 {
18324 7e425ca58e9c jit compiler: Add fail reason to jit_fail_exceptions LYH <lyh.kernel@gmail.com> parents: 18322 diff changeset	697 throw jit_fail_exception ("No visit_fcn_handle implementation");
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	698 }
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	699
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	700 void
15842 896cf5769537 Add visit_funcall method to JIT tree walker. Michael Goffioul <michael.goffioul@gmail.com> parents: 15603 diff changeset	701 jit_convert::visit_funcall (tree_funcall&)
896cf5769537 Add visit_funcall method to JIT tree walker. Michael Goffioul <michael.goffioul@gmail.com> parents: 15603 diff changeset	702 {
896cf5769537 Add visit_funcall method to JIT tree walker. Michael Goffioul <michael.goffioul@gmail.com> parents: 15603 diff changeset	703 throw jit_fail_exception ();
896cf5769537 Add visit_funcall method to JIT tree walker. Michael Goffioul <michael.goffioul@gmail.com> parents: 15603 diff changeset	704 }
896cf5769537 Add visit_funcall method to JIT tree walker. Michael Goffioul <michael.goffioul@gmail.com> parents: 15603 diff changeset	705
896cf5769537 Add visit_funcall method to JIT tree walker. Michael Goffioul <michael.goffioul@gmail.com> parents: 15603 diff changeset	706 void
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	707 jit_convert::visit_parameter_list (tree_parameter_list&)
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	708 {
18324 7e425ca58e9c jit compiler: Add fail reason to jit_fail_exceptions LYH <lyh.kernel@gmail.com> parents: 18322 diff changeset	709 throw jit_fail_exception ("No visit_parameter_list implementation");
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	710 }
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	711
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	712 void
15146 709e8928e68c Scalar unary operation support in JIT Max Brister <max@2bass.com> parents: 15140 diff changeset	713 jit_convert::visit_postfix_expression (tree_postfix_expression& tpe)
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	714 {
15146 709e8928e68c Scalar unary operation support in JIT Max Brister <max@2bass.com> parents: 15140 diff changeset	715 octave_value::unary_op etype = tpe.op_type ();
709e8928e68c Scalar unary operation support in JIT Max Brister <max@2bass.com> parents: 15140 diff changeset	716 tree_expression *operand = tpe.operand ();
709e8928e68c Scalar unary operation support in JIT Max Brister <max@2bass.com> parents: 15140 diff changeset	717 jit_value *operandv = visit (operand);
709e8928e68c Scalar unary operation support in JIT Max Brister <max@2bass.com> parents: 15140 diff changeset	718
709e8928e68c Scalar unary operation support in JIT Max Brister <max@2bass.com> parents: 15140 diff changeset	719 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	720 result = create_checked (fn, operandv);
709e8928e68c Scalar unary operation support in JIT Max Brister <max@2bass.com> parents: 15140 diff changeset	721
709e8928e68c Scalar unary operation support in JIT Max Brister <max@2bass.com> parents: 15140 diff changeset	722 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	723 {
15334 8125773322d4 Error on undefined an unused variables in JIT Max Brister <max@2bass.com> parents: 15311 diff changeset	724 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	725 do_assign (operand, result);
1b2fbc30e4e7 Postfix increment and decrement operations in JIT Max Brister <max@2bass.com> parents: 15147 diff changeset	726 result = ret;
15146 709e8928e68c Scalar unary operation support in JIT Max Brister <max@2bass.com> parents: 15140 diff changeset	727 }
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	728 }
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	729
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	730 void
15146 709e8928e68c Scalar unary operation support in JIT Max Brister <max@2bass.com> parents: 15140 diff changeset	731 jit_convert::visit_prefix_expression (tree_prefix_expression& tpe)
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	732 {
15146 709e8928e68c Scalar unary operation support in JIT Max Brister <max@2bass.com> parents: 15140 diff changeset	733 octave_value::unary_op etype = tpe.op_type ();
709e8928e68c Scalar unary operation support in JIT Max Brister <max@2bass.com> parents: 15140 diff changeset	734 tree_expression *operand = tpe.operand ();
709e8928e68c Scalar unary operation support in JIT Max Brister <max@2bass.com> parents: 15140 diff changeset	735 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	736 result = create_checked (fn, visit (operand));
709e8928e68c Scalar unary operation support in JIT Max Brister <max@2bass.com> parents: 15140 diff changeset	737
709e8928e68c Scalar unary operation support in JIT Max Brister <max@2bass.com> parents: 15140 diff changeset	738 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	739 do_assign (operand, result);
14899 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
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	742 void
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	743 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	744 {
18324 7e425ca58e9c jit compiler: Add fail reason to jit_fail_exceptions LYH <lyh.kernel@gmail.com> parents: 18322 diff changeset	745 throw jit_fail_exception ("No visit_return_command implementation");
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	746 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	747
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	748 void
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	749 jit_convert::visit_return_list (tree_return_list&)
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	750 {
18324 7e425ca58e9c jit compiler: Add fail reason to jit_fail_exceptions LYH <lyh.kernel@gmail.com> parents: 18322 diff changeset	751 throw jit_fail_exception ("No visit_return_list implementation");
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	752 }
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 void
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	755 jit_convert::visit_simple_assignment (tree_simple_assignment& tsa)
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	756 {
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	757 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	758 jit_value *rhsv = visit (rhs);
15140 6ea86e1d0f5f Support +=, -=, =, ect. in JIT Max Brister <max@2bass.com>* parents: 15135 diff changeset	759 octave_value::assign_op op = tsa.op_type ();
6ea86e1d0f5f Support +=, -=, =, ect. in JIT Max Brister <max@2bass.com>* parents: 15135 diff changeset	760
6ea86e1d0f5f Support +=, -=, =, ect. in JIT Max Brister <max@2bass.com>* parents: 15135 diff changeset	761 if (op != octave_value::op_asn_eq)
6ea86e1d0f5f Support +=, -=, =, ect. in JIT Max Brister <max@2bass.com>* parents: 15135 diff changeset	762 {
6ea86e1d0f5f Support +=, -=, =, ect. in JIT Max Brister <max@2bass.com>* parents: 15135 diff changeset	763 // 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	764 // but isn't always optimal.
6ea86e1d0f5f Support +=, -=, =, ect. in JIT Max Brister <max@2bass.com>* parents: 15135 diff changeset	765 tree_expression *lhs = tsa.left_hand_side ();
6ea86e1d0f5f Support +=, -=, =, ect. in JIT Max Brister <max@2bass.com>* parents: 15135 diff changeset	766 jit_value *lhsv = visit (lhs);
6ea86e1d0f5f Support +=, -=, =, ect. in JIT Max Brister <max@2bass.com>* parents: 15135 diff changeset	767 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	768 const jit_operation& fn = jit_typeinfo::binary_op (bop);
6ea86e1d0f5f Support +=, -=, =, ect. in JIT Max Brister <max@2bass.com>* parents: 15135 diff changeset	769 rhsv = create_checked (fn, lhsv, rhsv);
6ea86e1d0f5f Support +=, -=, =, ect. in JIT Max Brister <max@2bass.com>* parents: 15135 diff changeset	770 }
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	771
14978 f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	772 result = do_assign (tsa.left_hand_side (), rhsv);
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	773 }
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	774
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	775 void
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	776 jit_convert::visit_statement (tree_statement& stmt)
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	777 {
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	778 tree_command *cmd = stmt.command ();
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	779 tree_expression *expr = stmt.expression ();
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	780
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	781 if (cmd)
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	782 visit (cmd);
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	783 else
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	784 {
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	785 // stolen from tree_evaluator::visit_statement
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	786 bool do_bind_ans = false;
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 if (expr->is_identifier ())
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	789 {
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	790 tree_identifier id = dynamic_cast<tree_identifier > (expr);
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	791
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	792 do_bind_ans = (! id->is_variable ());
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	793 }
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	794 else
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	795 do_bind_ans = (! expr->is_assignment_expression ());
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	796
14944 c0a5ab3b9278 jit_const no longer inherits from jit_instruction Max Brister <max@2bass.com> parents: 14943 diff changeset	797 jit_value *expr_result = visit (expr);
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 if (do_bind_ans)
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	800 do_assign ("ans", expr_result, expr->print_result ());
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	801 else if (expr->is_identifier () && expr->print_result ())
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	802 {
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	803 // 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	804 // nargout to visit_identifier
14983 a5f75de0dab1 Rename jit_function to jit_operation Max Brister <max@2bass.com> parents: 14978 diff changeset	805 const jit_operation& fn = jit_typeinfo::print_value ();
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	806 jit_const_string *name = factory.create<jit_const_string>
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	807 (expr->name ());
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	808 block->append (factory.create<jit_call> (fn, name, expr_result));
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	809 }
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	810 }
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	811 }
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	812
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	813 void
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	814 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	815 {
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	816 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	817 ++iter)
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	818 {
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	819 tree_statement elt = iter;
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	820 // jwe: Can this ever be null?
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	821 assert (elt);
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	822 elt->accept (*this);
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	823 }
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	824 }
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	825
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	826 void
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	827 jit_convert::visit_switch_case (tree_switch_case&)
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	828 {
18324 7e425ca58e9c jit compiler: Add fail reason to jit_fail_exceptions LYH <lyh.kernel@gmail.com> parents: 18322 diff changeset	829 throw jit_fail_exception ("No visit_switch_case implementation");
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	830 }
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	831
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	832 void
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	833 jit_convert::visit_switch_case_list (tree_switch_case_list&)
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	834 {
18324 7e425ca58e9c jit compiler: Add fail reason to jit_fail_exceptions LYH <lyh.kernel@gmail.com> parents: 18322 diff changeset	835 throw jit_fail_exception ("No visit_switch_case_list implementation");
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	836 }
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	837
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	838 void
18326 421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	839 jit_convert::visit_switch_command (tree_switch_command& cmd)
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	840 {
18326 421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	841 tree_switch_case_list *lst = cmd.case_list ();
421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	842
421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	843 // always visit switch expression
421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	844 tree_expression *expr = cmd.switch_value ();
421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	845 assert (expr && "Switch value can not be null");
421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	846 jit_value *value = visit (expr);
421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	847 assert (value);
421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	848
421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	849 size_t case_blocks_num = lst->size ();
421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	850
421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	851 if (! case_blocks_num) // there's nothing to do
421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	852 return;
421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	853
421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	854 // check for otherwise, it's interpreted as last 'else' condition
421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	855 size_t has_otherwise = 0;
421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	856 tree_switch_case *last = lst->back ();
421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	857 if (last->is_default_case ())
421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	858 has_otherwise = 1;
421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	859
421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	860 std::vector<jit_block *> entry_blocks (case_blocks_num + 1 - has_otherwise);
421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	861
421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	862 // the first entry point is always the actual block. afterward new blocks
421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	863 // are created for every case and the otherwise branch
421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	864 entry_blocks[0] = block;
421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	865 for (size_t i = 1; i < case_blocks_num; ++i)
421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	866 entry_blocks[i] = factory.create<jit_block> ("case_cond");
421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	867
421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	868 jit_block *tail = factory.create<jit_block> ("switch_tail");
421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	869
421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	870 // if there's no otherwise branch, the the 'else' of the last branch
421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	871 // has to point to the tail
421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	872 if (! has_otherwise)
421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	873 entry_blocks[entry_blocks.size()-1] = tail;
421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	874
421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	875 // each branch in the case statement will have different breaks/continues
421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	876 block_list current_breaks = breaks;
421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	877 block_list current_continues = continues;
421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	878 breaks.clear ();
421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	879 continues.clear ();
421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	880
421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	881 size_t num_incomming = 0; // number of incomming blocks to our tail
421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	882
421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	883 tree_switch_case_list::iterator iter = lst->begin ();
421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	884 for (size_t i = 0; i < case_blocks_num; ++iter, ++i)
421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	885 {
421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	886 tree_switch_case twc = iter;
421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	887 block = entry_blocks[i]; // case_cond
421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	888 assert (block);
421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	889
421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	890 if (i)
421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	891 blocks.push_back (entry_blocks[i]); // first block already pushed
421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	892
421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	893 if (! twc->is_default_case ())
421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	894 {
18726 fe0e34be5576 maint: untabify recently added code files. Rik <rik@octave.org> parents: 18327 diff changeset	895 // compare result of switch expression with actual case label
18326 421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	896 tree_expression *te = twc->case_label ();
421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	897 jit_value *label = visit (te);
421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	898 assert(label);
421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	899
421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	900 const jit_operation& fn = jit_typeinfo::binary_op (octave_value::op_eq);
421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	901 jit_value *cond = create_checked (fn, value, label);
421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	902 assert(cond);
421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	903
421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	904 jit_call *check = create_checked (&jit_typeinfo::logically_true,
421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	905 cond);
421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	906
421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	907 jit_block *body = factory.create<jit_block> ("case_body");
421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	908 blocks.push_back (body);
421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	909
421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	910 block->append (factory.create<jit_cond_branch> (check, body,
421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	911 entry_blocks[i+1]));
421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	912 block = body; // case_body
421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	913 }
421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	914
421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	915 tree_statement_list *stmt_lst = twc->commands ();
421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	916 assert(stmt_lst);
421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	917
421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	918 try
421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	919 {
421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	920 stmt_lst->accept (*this);
421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	921 num_incomming++;
421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	922 block->append (factory.create<jit_branch> (tail));
421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	923 }
421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	924 catch (const jit_break_exception&)
421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	925 { }
421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	926
421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	927 // each branch in the case statement will have different breaks/continues
421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	928 current_breaks.splice (current_breaks.end (), breaks);
421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	929 current_continues.splice (current_continues.end (), continues);
421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	930 }
421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	931
421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	932 // each branch in the case statement will have different breaks/continues
421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	933 breaks.splice (breaks.end (), current_breaks);
421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	934 continues.splice (continues.end (), current_continues);
421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	935
421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	936 if (num_incomming \|\| ! has_otherwise)
421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	937 {
421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	938 blocks.push_back (tail);
421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	939 block = tail; // switch_tail
421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	940 }
421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	941 else
421bed6994f0 jit compiler: Add support for switch statement Stefan Mahr <dac922@gmx.de> parents: 18325 diff changeset	942 throw jit_break_exception (); // every branch broke
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	943 }
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	944
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	945 void
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	946 jit_convert::visit_try_catch_command (tree_try_catch_command&)
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	947 {
18324 7e425ca58e9c jit compiler: Add fail reason to jit_fail_exceptions LYH <lyh.kernel@gmail.com> parents: 18322 diff changeset	948 throw jit_fail_exception ("No visit_try_catch_command implementation");
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	949 }
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	950
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	951 void
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	952 jit_convert::visit_unwind_protect_command (tree_unwind_protect_command&)
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	953 {
18324 7e425ca58e9c jit compiler: Add fail reason to jit_fail_exceptions LYH <lyh.kernel@gmail.com> parents: 18322 diff changeset	954 throw jit_fail_exception ("No visit_unwind_protect_command implementation");
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	955 }
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	956
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	957 void
14989 dfaa8da46364 Support while loops in JIT Max Brister <max@2bass.com> parents: 14988 diff changeset	958 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	959 {
14989 dfaa8da46364 Support while loops in JIT Max Brister <max@2bass.com> parents: 14988 diff changeset	960 unwind_protect prot;
dfaa8da46364 Support while loops in JIT Max Brister <max@2bass.com> parents: 14988 diff changeset	961 prot.protect_var (breaks);
dfaa8da46364 Support while loops in JIT Max Brister <max@2bass.com> parents: 14988 diff changeset	962 prot.protect_var (continues);
dfaa8da46364 Support while loops in JIT Max Brister <max@2bass.com> parents: 14988 diff changeset	963 breaks.clear ();
dfaa8da46364 Support while loops in JIT Max Brister <max@2bass.com> parents: 14988 diff changeset	964 continues.clear ();
dfaa8da46364 Support while loops in JIT Max Brister <max@2bass.com> parents: 14988 diff changeset	965
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	966 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	967 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	968 blocks.push_back (cond_check);
14989 dfaa8da46364 Support while loops in JIT Max Brister <max@2bass.com> parents: 14988 diff changeset	969 block = cond_check;
dfaa8da46364 Support while loops in JIT Max Brister <max@2bass.com> parents: 14988 diff changeset	970
dfaa8da46364 Support while loops in JIT Max Brister <max@2bass.com> parents: 14988 diff changeset	971 tree_expression *expr = wc.condition ();
dfaa8da46364 Support while loops in JIT Max Brister <max@2bass.com> parents: 14988 diff changeset	972 assert (expr && "While expression can not be null");
dfaa8da46364 Support while loops in JIT Max Brister <max@2bass.com> parents: 14988 diff changeset	973 jit_value *check = visit (expr);
dfaa8da46364 Support while loops in JIT Max Brister <max@2bass.com> parents: 14988 diff changeset	974 check = create_checked (&jit_typeinfo::logically_true, check);
dfaa8da46364 Support while loops in JIT Max Brister <max@2bass.com> parents: 14988 diff changeset	975
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	976 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	977 blocks.push_back (body);
14989 dfaa8da46364 Support while loops in JIT Max Brister <max@2bass.com> parents: 14988 diff changeset	978
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	979 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	980 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	981 block = body;
dfaa8da46364 Support while loops in JIT Max Brister <max@2bass.com> parents: 14988 diff changeset	982
dfaa8da46364 Support while loops in JIT Max Brister <max@2bass.com> parents: 14988 diff changeset	983 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	984 bool all_breaking = false;
14989 dfaa8da46364 Support while loops in JIT Max Brister <max@2bass.com> parents: 14988 diff changeset	985 if (loop_body)
15592 6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	986 {
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	987 try
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	988 {
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	989 loop_body->accept (*this);
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	990 }
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	991 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	992 {
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	993 all_breaking = true;
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	994 }
6fc163b59746 Correctly handle break/continue for some corner cases in JIT Max Brister <max@2bass.com> parents: 15583 diff changeset	995 }
14989 dfaa8da46364 Support while loops in JIT Max Brister <max@2bass.com> parents: 14988 diff changeset	996
dfaa8da46364 Support while loops in JIT Max Brister <max@2bass.com> parents: 14988 diff changeset	997 finish_breaks (tail, breaks);
15603 44272909d926 Stop JIT on interrupt Max Brister <max@2bass.com> parents: 15602 diff changeset	998
44272909d926 Stop JIT on interrupt Max Brister <max@2bass.com> parents: 15602 diff changeset	999 if (! all_breaking \|\| continues.size ())
44272909d926 Stop JIT on interrupt Max Brister <max@2bass.com> parents: 15602 diff changeset	1000 {
44272909d926 Stop JIT on interrupt Max Brister <max@2bass.com> parents: 15602 diff changeset	1001 jit_block *interrupt_check
44272909d926 Stop JIT on interrupt Max Brister <max@2bass.com> parents: 15602 diff changeset	1002 = factory.create<jit_block> ("interrupt_check");
44272909d926 Stop JIT on interrupt Max Brister <max@2bass.com> parents: 15602 diff changeset	1003 blocks.push_back (interrupt_check);
44272909d926 Stop JIT on interrupt Max Brister <max@2bass.com> parents: 15602 diff changeset	1004 finish_breaks (interrupt_check, continues);
44272909d926 Stop JIT on interrupt Max Brister <max@2bass.com> parents: 15602 diff changeset	1005 if (! all_breaking)
44272909d926 Stop JIT on interrupt Max Brister <max@2bass.com> parents: 15602 diff changeset	1006 block->append (factory.create<jit_branch> (interrupt_check));
44272909d926 Stop JIT on interrupt Max Brister <max@2bass.com> parents: 15602 diff changeset	1007
44272909d926 Stop JIT on interrupt Max Brister <max@2bass.com> parents: 15602 diff changeset	1008 block = interrupt_check;
44272909d926 Stop JIT on interrupt Max Brister <max@2bass.com> parents: 15602 diff changeset	1009 jit_error_check *ec
44272909d926 Stop JIT on interrupt Max Brister <max@2bass.com> parents: 15602 diff changeset	1010 = factory.create<jit_error_check> (jit_error_check::var_interrupt,
44272909d926 Stop JIT on interrupt Max Brister <max@2bass.com> parents: 15602 diff changeset	1011 cond_check, final_block);
44272909d926 Stop JIT on interrupt Max Brister <max@2bass.com> parents: 15602 diff changeset	1012 block->append (ec);
44272909d926 Stop JIT on interrupt Max Brister <max@2bass.com> parents: 15602 diff changeset	1013 }
14989 dfaa8da46364 Support while loops in JIT Max Brister <max@2bass.com> parents: 14988 diff changeset	1014
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	1015 blocks.push_back (tail);
14989 dfaa8da46364 Support while loops in JIT Max Brister <max@2bass.com> parents: 14988 diff changeset	1016 block = tail;
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1017 }
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1018
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1019 void
18325 2a8243d8327a jit compiler: Add support for the do_until statement LYH <lyh.kernel@gmail.com> parents: 18324 diff changeset	1020 jit_convert::visit_do_until_command (tree_do_until_command& duc)
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	1021 {
18325 2a8243d8327a jit compiler: Add support for the do_until statement LYH <lyh.kernel@gmail.com> parents: 18324 diff changeset	1022 unwind_protect prot;
2a8243d8327a jit compiler: Add support for the do_until statement LYH <lyh.kernel@gmail.com> parents: 18324 diff changeset	1023 prot.protect_var (breaks);
2a8243d8327a jit compiler: Add support for the do_until statement LYH <lyh.kernel@gmail.com> parents: 18324 diff changeset	1024 prot.protect_var (continues);
2a8243d8327a jit compiler: Add support for the do_until statement LYH <lyh.kernel@gmail.com> parents: 18324 diff changeset	1025 breaks.clear ();
2a8243d8327a jit compiler: Add support for the do_until statement LYH <lyh.kernel@gmail.com> parents: 18324 diff changeset	1026 continues.clear ();
2a8243d8327a jit compiler: Add support for the do_until statement LYH <lyh.kernel@gmail.com> parents: 18324 diff changeset	1027
2a8243d8327a jit compiler: Add support for the do_until statement LYH <lyh.kernel@gmail.com> parents: 18324 diff changeset	1028 jit_block *body = factory.create<jit_block> ("do_until_body");
2a8243d8327a jit compiler: Add support for the do_until statement LYH <lyh.kernel@gmail.com> parents: 18324 diff changeset	1029 jit_block *cond_check = factory.create<jit_block> ("do_until_cond_check");
2a8243d8327a jit compiler: Add support for the do_until statement LYH <lyh.kernel@gmail.com> parents: 18324 diff changeset	1030 jit_block *tail = factory.create<jit_block> ("do_until_tail");
2a8243d8327a jit compiler: Add support for the do_until statement LYH <lyh.kernel@gmail.com> parents: 18324 diff changeset	1031
2a8243d8327a jit compiler: Add support for the do_until statement LYH <lyh.kernel@gmail.com> parents: 18324 diff changeset	1032 block->append (factory.create<jit_branch> (body));
2a8243d8327a jit compiler: Add support for the do_until statement LYH <lyh.kernel@gmail.com> parents: 18324 diff changeset	1033 blocks.push_back (body);
2a8243d8327a jit compiler: Add support for the do_until statement LYH <lyh.kernel@gmail.com> parents: 18324 diff changeset	1034 block = body;
2a8243d8327a jit compiler: Add support for the do_until statement LYH <lyh.kernel@gmail.com> parents: 18324 diff changeset	1035
2a8243d8327a jit compiler: Add support for the do_until statement LYH <lyh.kernel@gmail.com> parents: 18324 diff changeset	1036 tree_statement_list *loop_body = duc.body ();
2a8243d8327a jit compiler: Add support for the do_until statement LYH <lyh.kernel@gmail.com> parents: 18324 diff changeset	1037 bool all_breaking = false;
2a8243d8327a jit compiler: Add support for the do_until statement LYH <lyh.kernel@gmail.com> parents: 18324 diff changeset	1038 if (loop_body)
2a8243d8327a jit compiler: Add support for the do_until statement LYH <lyh.kernel@gmail.com> parents: 18324 diff changeset	1039 {
2a8243d8327a jit compiler: Add support for the do_until statement LYH <lyh.kernel@gmail.com> parents: 18324 diff changeset	1040 try
2a8243d8327a jit compiler: Add support for the do_until statement LYH <lyh.kernel@gmail.com> parents: 18324 diff changeset	1041 {
2a8243d8327a jit compiler: Add support for the do_until statement LYH <lyh.kernel@gmail.com> parents: 18324 diff changeset	1042 loop_body->accept (*this);
2a8243d8327a jit compiler: Add support for the do_until statement LYH <lyh.kernel@gmail.com> parents: 18324 diff changeset	1043 }
2a8243d8327a jit compiler: Add support for the do_until statement LYH <lyh.kernel@gmail.com> parents: 18324 diff changeset	1044 catch (const jit_break_exception&)
2a8243d8327a jit compiler: Add support for the do_until statement LYH <lyh.kernel@gmail.com> parents: 18324 diff changeset	1045 {
2a8243d8327a jit compiler: Add support for the do_until statement LYH <lyh.kernel@gmail.com> parents: 18324 diff changeset	1046 all_breaking = true;
2a8243d8327a jit compiler: Add support for the do_until statement LYH <lyh.kernel@gmail.com> parents: 18324 diff changeset	1047 }
2a8243d8327a jit compiler: Add support for the do_until statement LYH <lyh.kernel@gmail.com> parents: 18324 diff changeset	1048 }
2a8243d8327a jit compiler: Add support for the do_until statement LYH <lyh.kernel@gmail.com> parents: 18324 diff changeset	1049
2a8243d8327a jit compiler: Add support for the do_until statement LYH <lyh.kernel@gmail.com> parents: 18324 diff changeset	1050 finish_breaks (tail, breaks);
2a8243d8327a jit compiler: Add support for the do_until statement LYH <lyh.kernel@gmail.com> parents: 18324 diff changeset	1051
2a8243d8327a jit compiler: Add support for the do_until statement LYH <lyh.kernel@gmail.com> parents: 18324 diff changeset	1052 if (! all_breaking \|\| continues.size ())
2a8243d8327a jit compiler: Add support for the do_until statement LYH <lyh.kernel@gmail.com> parents: 18324 diff changeset	1053 {
2a8243d8327a jit compiler: Add support for the do_until statement LYH <lyh.kernel@gmail.com> parents: 18324 diff changeset	1054 jit_block *interrupt_check
2a8243d8327a jit compiler: Add support for the do_until statement LYH <lyh.kernel@gmail.com> parents: 18324 diff changeset	1055 = factory.create<jit_block> ("interrupt_check");
2a8243d8327a jit compiler: Add support for the do_until statement LYH <lyh.kernel@gmail.com> parents: 18324 diff changeset	1056 blocks.push_back (interrupt_check);
2a8243d8327a jit compiler: Add support for the do_until statement LYH <lyh.kernel@gmail.com> parents: 18324 diff changeset	1057 finish_breaks (interrupt_check, continues);
2a8243d8327a jit compiler: Add support for the do_until statement LYH <lyh.kernel@gmail.com> parents: 18324 diff changeset	1058 if (! all_breaking)
2a8243d8327a jit compiler: Add support for the do_until statement LYH <lyh.kernel@gmail.com> parents: 18324 diff changeset	1059 block->append (factory.create<jit_branch> (interrupt_check));
2a8243d8327a jit compiler: Add support for the do_until statement LYH <lyh.kernel@gmail.com> parents: 18324 diff changeset	1060
2a8243d8327a jit compiler: Add support for the do_until statement LYH <lyh.kernel@gmail.com> parents: 18324 diff changeset	1061 block = interrupt_check;
2a8243d8327a jit compiler: Add support for the do_until statement LYH <lyh.kernel@gmail.com> parents: 18324 diff changeset	1062 jit_error_check *ec
2a8243d8327a jit compiler: Add support for the do_until statement LYH <lyh.kernel@gmail.com> parents: 18324 diff changeset	1063 = factory.create<jit_error_check> (jit_error_check::var_interrupt,
2a8243d8327a jit compiler: Add support for the do_until statement LYH <lyh.kernel@gmail.com> parents: 18324 diff changeset	1064 cond_check, final_block);
2a8243d8327a jit compiler: Add support for the do_until statement LYH <lyh.kernel@gmail.com> parents: 18324 diff changeset	1065 block->append (ec);
2a8243d8327a jit compiler: Add support for the do_until statement LYH <lyh.kernel@gmail.com> parents: 18324 diff changeset	1066
2a8243d8327a jit compiler: Add support for the do_until statement LYH <lyh.kernel@gmail.com> parents: 18324 diff changeset	1067 blocks.push_back (cond_check);
2a8243d8327a jit compiler: Add support for the do_until statement LYH <lyh.kernel@gmail.com> parents: 18324 diff changeset	1068 block = cond_check;
2a8243d8327a jit compiler: Add support for the do_until statement LYH <lyh.kernel@gmail.com> parents: 18324 diff changeset	1069
2a8243d8327a jit compiler: Add support for the do_until statement LYH <lyh.kernel@gmail.com> parents: 18324 diff changeset	1070 tree_expression *expr = duc.condition ();
2a8243d8327a jit compiler: Add support for the do_until statement LYH <lyh.kernel@gmail.com> parents: 18324 diff changeset	1071 assert (expr && "Do-Until expression can not be null");
2a8243d8327a jit compiler: Add support for the do_until statement LYH <lyh.kernel@gmail.com> parents: 18324 diff changeset	1072 jit_value *check = visit (expr);
2a8243d8327a jit compiler: Add support for the do_until statement LYH <lyh.kernel@gmail.com> parents: 18324 diff changeset	1073 check = create_checked (&jit_typeinfo::logically_true, check);
2a8243d8327a jit compiler: Add support for the do_until statement LYH <lyh.kernel@gmail.com> parents: 18324 diff changeset	1074
2a8243d8327a jit compiler: Add support for the do_until statement LYH <lyh.kernel@gmail.com> parents: 18324 diff changeset	1075 block->append (factory.create<jit_cond_branch> (check, tail, body));
2a8243d8327a jit compiler: Add support for the do_until statement LYH <lyh.kernel@gmail.com> parents: 18324 diff changeset	1076 }
2a8243d8327a jit compiler: Add support for the do_until statement LYH <lyh.kernel@gmail.com> parents: 18324 diff changeset	1077
2a8243d8327a jit compiler: Add support for the do_until statement LYH <lyh.kernel@gmail.com> parents: 18324 diff changeset	1078 blocks.push_back (tail);
2a8243d8327a jit compiler: Add support for the do_until statement LYH <lyh.kernel@gmail.com> parents: 18324 diff changeset	1079 block = tail;
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	1080 }
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	1081
15337 3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1082 void
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1083 jit_convert::initialize (symbol_table::scope_id s)
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1084 {
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1085 scope = s;
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1086 iterator_count = 0;
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1087 for_bounds_count = 0;
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1088 short_count = 0;
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1089 jit_instruction::reset_ids ();
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1090
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1091 entry_block = factory.create<jit_block> ("body");
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1092 final_block = factory.create<jit_block> ("final");
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1093 blocks.push_back (entry_block);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1094 entry_block->mark_alive ();
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1095 block = entry_block;
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1096 }
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1097
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	1098 jit_call *
a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	1099 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	1100 {
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	1101 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	1102
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	1103 jit_block *normal = factory.create<jit_block> (block->name ());
15603 44272909d926 Stop JIT on interrupt Max Brister <max@2bass.com> parents: 15602 diff changeset	1104 jit_error_check *check
44272909d926 Stop JIT on interrupt Max Brister <max@2bass.com> parents: 15602 diff changeset	1105 = 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	1106 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	1107 block->append (check);
a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	1108 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	1109 block = normal;
a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	1110
a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	1111 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	1112 }
709f50069722 Change algorithm for placing releases and simplify PHIs in low level Octave IR Max Brister <max@2bass.com> parents: 14962 diff changeset	1113
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	1114 jit_variable *
15027 741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1115 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	1116 {
15191 ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1117 variable_map::const_iterator iter;
15027 741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1118 iter = vmap.find (vname);
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1119 return iter != vmap.end () ? iter->second : 0;
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1120 }
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1121
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1122 jit_variable *
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	1123 jit_convert::get_variable (const std::string& vname)
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	1124 {
15027 741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1125 jit_variable *ret = find_variable (vname);
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1126 if (ret)
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1127 return ret;
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	1128
15337 3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1129 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	1130 if (record.is_persistent () \|\| record.is_global ())
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1131 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	1132
15337 3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1133 if (converting_function)
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1134 return create_variable (vname, jit_typeinfo::get_any (), false);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1135 else
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1136 {
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1137 octave_value val = record.varval ();
19685 885d38747cd5 Fix failing JIT tests (bug #41312). Stefan Mahr <dac922@gmx.de> parents: 19631 diff changeset	1138 if (val.is_undefined ())
885d38747cd5 Fix failing JIT tests (bug #41312). Stefan Mahr <dac922@gmx.de> parents: 19631 diff changeset	1139 val = symbol_table::find_function (vname);
885d38747cd5 Fix failing JIT tests (bug #41312). Stefan Mahr <dac922@gmx.de> parents: 19631 diff changeset	1140
15337 3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1141 jit_type *type = jit_typeinfo::type_of (val);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1142 bounds.push_back (type_bound (type, vname));
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1143
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1144 return create_variable (vname, type);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1145 }
15027 741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1146 }
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1147
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1148 jit_variable *
15337 3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1149 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	1150 bool isarg)
15027 741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1151 {
15182 a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	1152 jit_variable *var = factory.create<jit_variable> (vname);
15337 3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1153
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1154 if (isarg)
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1155 {
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1156 jit_extract_argument *extract;
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1157 extract = factory.create<jit_extract_argument> (type, var);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1158 entry_block->prepend (extract);
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 else
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1161 {
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1162 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	1163 jit_assign *assign = factory.create<jit_assign> (var, init);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1164 entry_block->prepend (assign);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1165 entry_block->prepend (init);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1166 }
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1167
15027 741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1168 return vmap[vname] = var;
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1169 }
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	1170
15027 741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1171 std::string
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1172 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	1173 {
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1174 std::stringstream ss;
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1175 ss << prefix << count;
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1176 if (inc)
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1177 ++count;
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	1178 return ss.str ();
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	1179 }
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	1180
15067 df4538e3b50b ND scalar indexing in JIT. Max Brister <max@2bass.com> parents: 15056 diff changeset	1181 jit_instruction *
15334 8125773322d4 Error on undefined an unused variables in JIT Max Brister <max@2bass.com> parents: 15311 diff changeset	1182 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	1183 bool lhs)
14969 bbeef7b8ea2e Add support for matrix indexed assignment to JIT Max Brister <max@2bass.com> parents: 14968 diff changeset	1184 {
bbeef7b8ea2e Add support for matrix indexed assignment to JIT Max Brister <max@2bass.com> parents: 14968 diff changeset	1185 std::string type = exp.type_tags ();
bbeef7b8ea2e Add support for matrix indexed assignment to JIT Max Brister <max@2bass.com> parents: 14968 diff changeset	1186 if (! (type.size () == 1 && type[0] == '('))
15016 005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	1187 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	1188
bbeef7b8ea2e Add support for matrix indexed assignment to JIT Max Brister <max@2bass.com> parents: 14968 diff changeset	1189 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	1190 if (args.size () != 1)
15334 8125773322d4 Error on undefined an unused variables in JIT Max Brister <max@2bass.com> parents: 15311 diff changeset	1191 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	1192 "tree_index_expression");
14969 bbeef7b8ea2e Add support for matrix indexed assignment to JIT Max Brister <max@2bass.com> parents: 14968 diff changeset	1193
bbeef7b8ea2e Add support for matrix indexed assignment to JIT Max Brister <max@2bass.com> parents: 14968 diff changeset	1194 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	1195 if (! arg_list)
15016 005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	1196 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	1197
15067 df4538e3b50b ND scalar indexing in JIT. Max Brister <max@2bass.com> parents: 15056 diff changeset	1198 if (arg_list->size () < 1)
df4538e3b50b ND scalar indexing in JIT. Max Brister <max@2bass.com> parents: 15056 diff changeset	1199 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	1200
bbeef7b8ea2e Add support for matrix indexed assignment to JIT Max Brister <max@2bass.com> parents: 14968 diff changeset	1201 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	1202 jit_value *object;
8125773322d4 Error on undefined an unused variables in JIT Max Brister <max@2bass.com> parents: 15311 diff changeset	1203 if (lhs)
8125773322d4 Error on undefined an unused variables in JIT Max Brister <max@2bass.com> parents: 15311 diff changeset	1204 {
8125773322d4 Error on undefined an unused variables in JIT Max Brister <max@2bass.com> parents: 15311 diff changeset	1205 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	1206 if (! id)
8125773322d4 Error on undefined an unused variables in JIT Max Brister <max@2bass.com> parents: 15311 diff changeset	1207 throw jit_fail_exception ("expected identifier");
8125773322d4 Error on undefined an unused variables in JIT Max Brister <max@2bass.com> parents: 15311 diff changeset	1208 object = get_variable (id->name ());
8125773322d4 Error on undefined an unused variables in JIT Max Brister <max@2bass.com> parents: 15311 diff changeset	1209 }
8125773322d4 Error on undefined an unused variables in JIT Max Brister <max@2bass.com> parents: 15311 diff changeset	1210 else
8125773322d4 Error on undefined an unused variables in JIT Max Brister <max@2bass.com> parents: 15311 diff changeset	1211 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	1212
15067 df4538e3b50b ND scalar indexing in JIT. Max Brister <max@2bass.com> parents: 15056 diff changeset	1213 size_t narg = arg_list->size ();
df4538e3b50b ND scalar indexing in JIT. Max Brister <max@2bass.com> parents: 15056 diff changeset	1214 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	1215 bool have_extra = extra_arg;
f57d7578c1a6 Support ND matrix indexing with scalar assignment in JIT. Max Brister <max@2bass.com> parents: 15067 diff changeset	1216 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	1217 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	1218
15067 df4538e3b50b ND scalar indexing in JIT. Max Brister <max@2bass.com> parents: 15056 diff changeset	1219 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	1220 {
df4538e3b50b ND scalar indexing in JIT. Max Brister <max@2bass.com> parents: 15056 diff changeset	1221 unwind_protect prot;
df4538e3b50b ND scalar indexing in JIT. Max Brister <max@2bass.com> parents: 15056 diff changeset	1222 prot.add_method (&end_context,
df4538e3b50b ND scalar indexing in JIT. Max Brister <max@2bass.com> parents: 15056 diff changeset	1223 &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	1224
a7a56b436de2 Factor out jit_block_list and jit_factory from jit_convert Max Brister <max@2bass.com> parents: 15181 diff changeset	1225 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	1226 end_context.push_back (ctx);
15067 df4538e3b50b ND scalar indexing in JIT. Max Brister <max@2bass.com> parents: 15056 diff changeset	1227 call_args[idx + 1] = visit (*iter);
df4538e3b50b ND scalar indexing in JIT. Max Brister <max@2bass.com> parents: 15056 diff changeset	1228 }
14969 bbeef7b8ea2e Add support for matrix indexed assignment to JIT Max Brister <max@2bass.com> parents: 14968 diff changeset	1229
15068 f57d7578c1a6 Support ND matrix indexing with scalar assignment in JIT. Max Brister <max@2bass.com> parents: 15067 diff changeset	1230 if (extra_arg)
f57d7578c1a6 Support ND matrix indexing with scalar assignment in JIT. Max Brister <max@2bass.com> parents: 15067 diff changeset	1231 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	1232
15334 8125773322d4 Error on undefined an unused variables in JIT Max Brister <max@2bass.com> parents: 15311 diff changeset	1233 const jit_operation& fres = lhs ? jit_typeinfo::paren_subsasgn ()
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1234 : jit_typeinfo::paren_subsref ();
15334 8125773322d4 Error on undefined an unused variables in JIT Max Brister <max@2bass.com> parents: 15311 diff changeset	1235
15067 df4538e3b50b ND scalar indexing in JIT. Max Brister <max@2bass.com> parents: 15056 diff changeset	1236 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	1237 }
bbeef7b8ea2e Add support for matrix indexed assignment to JIT Max Brister <max@2bass.com> parents: 14968 diff changeset	1238
bbeef7b8ea2e Add support for matrix indexed assignment to JIT Max Brister <max@2bass.com> parents: 14968 diff changeset	1239 jit_value *
bbeef7b8ea2e Add support for matrix indexed assignment to JIT Max Brister <max@2bass.com> parents: 14968 diff changeset	1240 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	1241 {
bbeef7b8ea2e Add support for matrix indexed assignment to JIT Max Brister <max@2bass.com> parents: 14968 diff changeset	1242 if (! exp)
15016 005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	1243 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	1244
bbeef7b8ea2e Add support for matrix indexed assignment to JIT Max Brister <max@2bass.com> parents: 14968 diff changeset	1245 if (isa<tree_identifier> (exp))
bbeef7b8ea2e Add support for matrix indexed assignment to JIT Max Brister <max@2bass.com> parents: 14968 diff changeset	1246 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	1247 else if (tree_index_expression *idx
bbeef7b8ea2e Add support for matrix indexed assignment to JIT Max Brister <max@2bass.com> parents: 14968 diff changeset	1248 = dynamic_cast<tree_index_expression *> (exp))
bbeef7b8ea2e Add support for matrix indexed assignment to JIT Max Brister <max@2bass.com> parents: 14968 diff changeset	1249 {
15334 8125773322d4 Error on undefined an unused variables in JIT Max Brister <max@2bass.com> parents: 15311 diff changeset	1250 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	1251 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	1252
bbeef7b8ea2e Add support for matrix indexed assignment to JIT Max Brister <max@2bass.com> parents: 14968 diff changeset	1253 // 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	1254 return rhs;
bbeef7b8ea2e Add support for matrix indexed assignment to JIT Max Brister <max@2bass.com> parents: 14968 diff changeset	1255 }
bbeef7b8ea2e Add support for matrix indexed assignment to JIT Max Brister <max@2bass.com> parents: 14968 diff changeset	1256 else
15016 005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	1257 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	1258 }
bbeef7b8ea2e Add support for matrix indexed assignment to JIT Max Brister <max@2bass.com> parents: 14968 diff changeset	1259
14944 c0a5ab3b9278 jit_const no longer inherits from jit_instruction Max Brister <max@2bass.com> parents: 14943 diff changeset	1260 jit_value *
c0a5ab3b9278 jit_const no longer inherits from jit_instruction Max Brister <max@2bass.com> parents: 14943 diff changeset	1261 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	1262 bool print, bool artificial)
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	1263 {
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	1264 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	1265 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	1266
bbeef7b8ea2e Add support for matrix indexed assignment to JIT Max Brister <max@2bass.com> parents: 14968 diff changeset	1267 if (artificial)
bbeef7b8ea2e Add support for matrix indexed assignment to JIT Max Brister <max@2bass.com> parents: 14968 diff changeset	1268 assign->mark_artificial ();
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1269
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1270 if (print)
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1271 {
14983 a5f75de0dab1 Rename jit_function to jit_operation Max Brister <max@2bass.com> parents: 14978 diff changeset	1272 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	1273 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	1274 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	1275 }
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	1276
14944 c0a5ab3b9278 jit_const no longer inherits from jit_instruction Max Brister <max@2bass.com> parents: 14943 diff changeset	1277 return var;
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1278 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1279
14944 c0a5ab3b9278 jit_const no longer inherits from jit_instruction Max Brister <max@2bass.com> parents: 14943 diff changeset	1280 jit_value *
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1281 jit_convert::visit (tree& tee)
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1282 {
15146 709e8928e68c Scalar unary operation support in JIT Max Brister <max@2bass.com> parents: 15140 diff changeset	1283 unwind_protect prot;
709e8928e68c Scalar unary operation support in JIT Max Brister <max@2bass.com> parents: 15140 diff changeset	1284 prot.protect_var (result);
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1285
15146 709e8928e68c Scalar unary operation support in JIT Max Brister <max@2bass.com> parents: 15140 diff changeset	1286 tee.accept (*this);
709e8928e68c Scalar unary operation support in JIT Max Brister <max@2bass.com> parents: 15140 diff changeset	1287 return result;
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1288 }
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1289
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1290 void
14935 5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1291 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	1292 {
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1293 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	1294 ++iter)
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	1295 {
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	1296 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	1297 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	1298 }
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1299 }
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1300
20654 b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1301 // -------------------- jit_convert_gcc --------------------
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1302 #ifdef HAVE_GCCJIT
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1303 jit_convert_gcc::jit_convert_gcc ()
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1304 : m_blocks (NULL),
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1305 m_constants (NULL),
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1306 m_ctxt (jit_typeinfo::create_gccjit_child_context ()),
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1307 m_func (),
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1308 m_extracted_params (),
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1309 m_block_map (),
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1310 m_locals_for_insns (),
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1311 m_block_stack (),
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1312 m_log_visits (false)
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1313 {
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1314 // FIXME: error-handling
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1315
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1316 m_ctxt.set_int_option (GCC_JIT_INT_OPTION_OPTIMIZATION_LEVEL,
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1317 3);
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1318
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1319 // Diagnostics, debugging etc:
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1320 if (1)
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1321 {
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1322 m_ctxt.set_bool_option (GCC_JIT_BOOL_OPTION_DEBUGINFO,
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1323 1);
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1324 m_ctxt.set_bool_option (GCC_JIT_BOOL_OPTION_DUMP_INITIAL_TREE,
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1325 0);
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1326 m_ctxt.set_bool_option (GCC_JIT_BOOL_OPTION_DUMP_INITIAL_GIMPLE,
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1327 1);
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1328 m_ctxt.set_bool_option (GCC_JIT_BOOL_OPTION_DUMP_SUMMARY,
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1329 1);
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1330 m_ctxt.set_bool_option (GCC_JIT_BOOL_OPTION_DUMP_GENERATED_CODE,
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1331 0);
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1332 m_ctxt.set_bool_option (GCC_JIT_BOOL_OPTION_DUMP_EVERYTHING,
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1333 1);
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1334 m_ctxt.set_bool_option (GCC_JIT_BOOL_OPTION_SELFCHECK_GC,
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1335 0);
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1336 m_ctxt.set_bool_option (GCC_JIT_BOOL_OPTION_KEEP_INTERMEDIATES,
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1337 1);
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1338 }
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1339 }
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1340
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1341 jit_convert_gcc::~jit_convert_gcc ()
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1342 {
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1343 m_ctxt.release ();
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1344 }
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1345
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1346 gcc_jit_result *
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1347 jit_convert_gcc::convert_loop (const jit_block_list& blocks,
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1348 const std::list<jit_value *>& constants)
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1349 {
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1350 converting_function = false;
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1351
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1352 m_blocks = &blocks;
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1353 m_constants = &constants;
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1354
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1355 jit_type *any = jit_typeinfo::get_any ();
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1356 // argument is an array of octave_base_value, or octave_base_value*
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1357 gccjit::type arg_type = any->to_gccjit (); // this is octave_base_value*
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1358 arg_type = arg_type.get_pointer ();
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1359
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1360 // for now just init arguments from entry, later we will have to do something
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1361 // more interesting
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1362 jit_block *entry_block = m_blocks->front ();
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1363 for (jit_block::iterator iter = entry_block->begin ();
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1364 iter != entry_block->end (); ++iter)
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1365 if (jit_extract_argument *extract
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1366 = dynamic_cast<jit_extract_argument > (iter))
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1367 {
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1368 m_argument_index[extract->name ()] = m_argument_vec.size ();
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1369 m_argument_vec.push_back (std::make_pair (extract->name (), true));
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1370 }
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1371
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1372 /* We have a single param, confusingly named "params" (an array). */
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1373 params = m_ctxt.new_param (arg_type, "params");
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1374
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1375 std::vector<gccjit::param> params_of_fn (1, params);
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1376
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1377 m_func = m_ctxt.new_function (GCC_JIT_FUNCTION_EXPORTED,
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1378 m_ctxt.get_type (GCC_JIT_TYPE_VOID),
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1379 "loop",
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1380 params_of_fn,
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1381 0);
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1382
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1383 gccjit::block initial_block = m_func.new_block ("initial");
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1384
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1385 /* Create gccjit::blocks for each jit_block, and for each edge.
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1386
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1387 We're converting from an SSA representation back to a non-SSA
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1388 representation, hence we need to convert phi nodes into regular
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1389 assignments. To do this, introduce a gccjit::block for each edge, to
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1390 handle the phis along each edges. Jumps to blocks in the JIT-IR
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1391 will become jumps to edge-handling gccjit::blocks in our CFG; each
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1392 such "edge" block will end with a jump to the "real" gccjit::block. */
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1393 std::list<jit_block *>::const_iterator block_iter;
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1394 for (block_iter = m_blocks->begin ();
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1395 block_iter != m_blocks->end ();
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1396 ++block_iter)
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1397 {
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1398 jit_block jblock = block_iter;
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1399
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1400 // Find predecessor blocks
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1401 for (jit_use *use = jblock->first_use (); use; use = use->next ())
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1402 {
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1403 jit_block *pred = use->user_parent ();
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1404
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1405 /* Create edge-handling gccjit::block. */
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1406 m_blocks_for_edges[std::make_pair(pred, jblock)] =
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1407 m_func.new_block (std::string ("edge_from_")
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1408 + pred->name_and_id ()
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1409 + std::string ("_to_")
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1410 + jblock->name_and_id ());
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1411 }
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1412
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1413 /* The "real" gccjit::block. */
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1414 m_block_map[jblock] =
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1415 m_func.new_block (jblock->name_and_id ());
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1416 }
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1417
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1418 /* It's an SSA representation, so we have another pass here that
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1419 creates a local for every statement. */
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1420 for (block_iter = m_blocks->begin ();
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1421 block_iter != m_blocks->end ();
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1422 ++block_iter)
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1423 for (jit_block::iterator insn_iter = (*block_iter)->begin ();
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1424 insn_iter != (*block_iter)->end ();
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1425 ++insn_iter)
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1426 {
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1427 jit_instruction insn = insn_iter;
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1428
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1429 /* Some insns have NULL type e.g. conditional branches; it only
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1430 makes sense to create a local for those with actual types. */
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1431 if (insn->type ())
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1432 {
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1433 std::stringstream ss;
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1434 // FIXME: perhaps make these identifiers look less weird?
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1435 // that said, the short_print vfunc conveys more information
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1436 ss << "(";
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1437 insn->short_print (ss);
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1438 ss << ")";
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1439
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1440 m_locals_for_insns[insn] =
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1441 m_func.new_local (insn->type_gccjit (),
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1442 ss.str ().c_str ());
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1443
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1444 insn->stash_rvalue (m_locals_for_insns[insn]);
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1445 }
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1446 }
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1447
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1448 // constants aren't in the IR, we visit those first
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1449 for (std::list<jit_value *>::const_iterator iter = m_constants->begin ();
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1450 iter != m_constants->end (); ++iter)
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1451 if (! isa<jit_instruction> (*iter))
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1452 visit (*iter);
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1453
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1454 /* Prelude: extract params from the "params" array. */
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1455 if (m_with_comments)
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1456 initial_block.add_comment ("prelude");
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1457 for (int i = 0; i < m_argument_vec.size (); ++i)
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1458 {
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1459 gccjit::lvalue extracted_param =
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1460 m_func.new_local (any->to_gccjit (),
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1461 "extracted_param_" + m_argument_vec[i].first);
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1462 m_extracted_params.push_back (extracted_param);
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1463 initial_block.add_assignment (
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1464 extracted_param,
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1465 m_ctxt.new_array_access (
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1466 params,
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1467 m_ctxt.new_rvalue (m_ctxt.get_type (GCC_JIT_TYPE_INT),
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1468 i)));
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1469 }
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1470 initial_block.end_with_jump (m_block_map[*m_blocks->begin ()]);
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1471
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1472 // convert all instructions
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1473 for (block_iter = m_blocks->begin (); block_iter != m_blocks->end (); ++block_iter)
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1474 visit (**block_iter);
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1475
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1476 m_ctxt.dump_to_file ("/tmp/loop-dump.c", true);
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1477
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1478 m_func.dump_to_dot ("/tmp/loop.dot");
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1479
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1480 return m_ctxt.compile ();
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1481 }
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1482
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1483 #if 0
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1484 gccjit::lvalue
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1485 jit_convert_gcc::as_lvalue (jit_value *jval)
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1486 {
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1487 if (m_log_visits)
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1488 std::cerr << "jit_convert_gcc::as_lvalue (jit_value jval): " << jval << "\n";
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1489
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1490 if (!jval->has_lvalue ())
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1491 {
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1492 gccjit::lvalue local =
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1493 m_func.new_local (/* FIXME: */
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1494 m_ctxt.get_type (GCC_JIT_TYPE_INT),
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1495 jval->print_string ().c_str ());
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1496 jval->stash_lvalue (local);
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1497 }
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1498
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1499 return jval->as_lvalue ();
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1500 }
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1501 #endif
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1502
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1503 gccjit::rvalue
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1504 jit_convert_gcc::as_rvalue (jit_value *jval)
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1505 {
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1506 if (m_log_visits)
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1507 std::cerr << "jit_convert_gcc::as_rvalue (jit_value jval): " << jval << "\n";
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1508 //std::map<jit_value , gcc_jit_rvalue > m_rvalues;
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1509
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1510 if (jit_instruction insn = dynamic_cast<jit_instruction > (jval))
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1511 {
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1512 return m_locals_for_insns[insn];
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1513 }
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1514
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1515 // return gcc_jit_lvalue_as_rvalue (as_lvalue (jval));
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1516 return jval->as_rvalue ();
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1517 }
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1518
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1519 void
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1520 jit_convert_gcc::add_assignment_for_insn (jit_instruction &insn,
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1521 gccjit::rvalue val)
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1522 {
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1523 //insn.stash_rvalue (val);
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1524 if (insn.type ())
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1525 get_current_block ().add_assignment (m_locals_for_insns[&insn],
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1526 val);
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1527 //TODO: use location of insn
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1528 }
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1529
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1530 gccjit::block
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1531 jit_convert_gcc::get_block_for_edge (jit_block src, jit_block dest)
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1532 {
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1533 return m_blocks_for_edges[std::make_pair (src, dest)];
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1534 }
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1535
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1536 gccjit::block
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1537 jit_convert_gcc::get_current_block ()
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1538 {
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1539 assert (!m_block_stack.empty ());
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1540 return m_block_stack.top ();
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1541 }
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1542
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1543 void
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1544 jit_convert_gcc::push_block (gccjit::block block)
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1545 {
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1546 m_block_stack.push (block);
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1547 }
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1548
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1549 void
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1550 jit_convert_gcc::pop_block ()
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1551 {
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1552 m_block_stack.pop ();
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1553 }
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1554
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1555 //std::vector<gccjit::block> m_current_block_stack;
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1556
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1557
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1558 void
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1559 jit_convert_gcc::visit (jit_const_string& cs)
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1560 {
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1561 if (m_log_visits)
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1562 std::cerr << "jit_convert_gcc::visit (jit_const_string& cs): " << cs << "\n";
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1563 gccjit::rvalue rvalue = m_ctxt.new_rvalue (cs.value ());
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1564 cs.stash_rvalue (rvalue);
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1565 }
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1566
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1567 void
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1568 jit_convert_gcc::visit (jit_const_bool& cb)
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1569 {
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1570 if (m_log_visits)
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1571 std::cerr << "jit_convert_gcc::visit (jit_const_bool& cb): " << cb << "\n";
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1572 gccjit::rvalue rvalue = m_ctxt.new_rvalue (cb.type_gccjit (),
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1573 cb.value ());
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1574 cb.stash_rvalue (rvalue);
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1575 }
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1576
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1577 void
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1578 jit_convert_gcc::visit (jit_const_scalar& cs)
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1579 {
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1580 if (m_log_visits)
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1581 std::cerr << "jit_convert_gcc::visit (jit_const_scalar& cs): " << cs << "\n";
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1582 gccjit::rvalue rvalue = m_ctxt.new_rvalue (cs.type_gccjit (),
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1583 cs.value ());
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1584 cs.stash_rvalue (rvalue);
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1585 }
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1586
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1587 void
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1588 jit_convert_gcc::visit (jit_const_complex& cc)
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1589 {
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1590 if (m_log_visits)
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1591 std::cerr << "jit_convert_gcc::visit (jit_const_complex& cc): " << cc << "\n";
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1592 #if 0
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1593 gccjit::rvalue rvalue = m_ctxt.new_rvalue (cc.type_gccjit (),
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1594 cc.value ());
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1595 cc.stash_rvalue (rvalue);
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1596 #else
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1597 throw jit_fail_exception ("TODO");
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1598 #endif
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1599 }
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1600
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1601 void jit_convert_gcc::visit (jit_const_index& ci)
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1602 {
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1603 if (m_log_visits)
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1604 std::cerr << "jit_convert_gcc::visit (jit_const_index& ci): " << ci << "\n";
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1605 gccjit::rvalue rvalue = m_ctxt.new_rvalue (ci.type_gccjit (),
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1606 ci.value ());
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1607 ci.stash_rvalue (rvalue);
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1608 }
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1609
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1610 void
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1611 jit_convert_gcc::visit (jit_const_range& cr)
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1612 {
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1613 if (m_log_visits)
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1614 std::cerr << "jit_convert_gcc::visit (jit_const_range& cr): " << cr << "\n";
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1615 #if 0
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1616 gccjit::rvalue rvalue = m_ctxt.new_rvalue (cr.type_gccjit (),
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1617 cr.value ());
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1618 cr.stash_rvalue (rvalue);
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1619 #else
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1620 throw jit_fail_exception ("TODO");
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1621 #endif
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1622 }
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1623
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1624 void
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1625 jit_convert_gcc::visit (jit_block& b)
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1626 {
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1627 /* First, handle the phi nodes by populating the edge-handling blocks
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1628 with assignments that set up the phi nodes's lvalues based on the incoming
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1629 edge, then jumping to the "real" block for this block. */
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1630 for (jit_block::iterator insn_iter = b.begin ();
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1631 insn_iter != b.end ();
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1632 ++insn_iter)
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1633 if (jit_phi phi = dynamic_cast<jit_phi > (*insn_iter))
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1634 {
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1635 for (size_t i = 0; i < phi->argument_count (); ++i)
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1636 {
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1637 jit_block *pred = phi->incomming (i);
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1638 push_block (m_blocks_for_edges[std::make_pair(pred, &b)]);
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1639 if (m_with_comments)
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1640 {
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1641 std::ostringstream os;
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1642 os << "incoming edge " << i << " for: ";
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1643 phi->print (os);
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1644 get_current_block ().add_comment (os.str ());
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1645 }
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1646 get_current_block ().add_assignment (
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1647 m_locals_for_insns[phi],
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1648 m_locals_for_insns[static_cast <jit_instruction *> (phi->argument (i))]);
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1649 pop_block ();
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1650 }
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1651 }
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1652
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1653 /* Terminate the blocks for edges leading to this block. */
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1654 jit_use *use;
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1655 for (use = b.first_use (); use; use = use->next ())
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1656 {
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1657 jit_block *pred = use->user_parent ();
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1658 gccjit::block block_for_edge =
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1659 m_blocks_for_edges[std::make_pair(pred, &b)];
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1660 block_for_edge.end_with_jump (m_block_map[&b]);
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1661 }
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1662
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1663 /* Now generate a block for all of the non-phi instructions. */
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1664 push_block (m_block_map[&b]);
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1665 for (jit_block::iterator insn_iter = b.begin ();
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1666 insn_iter != b.end ();
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1667 ++insn_iter)
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1668 {
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1669 // We've handled phi nodes above; skip them:
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1670 if (dynamic_cast<jit_phi > (insn_iter))
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1671 continue;
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1672
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1673 if (m_with_comments)
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1674 get_current_block ().add_comment (std::string ("jit_instruction: ")
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1675 + (*insn_iter)->print_string ());
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1676 visit (*insn_iter);
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1677 }
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1678 pop_block ();
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1679 }
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1680
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1681 void
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1682 jit_convert_gcc::visit (jit_branch& b)
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1683 {
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1684 if (m_log_visits)
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1685 std::cerr << "jit_convert_gcc::visit (jit_branch& b): " << b << "\n";
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1686
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1687 jit_block *this_block = b.parent ();
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1688 jit_block *next = b.successor ();
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1689
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1690 get_current_block ().end_with_jump (get_block_for_edge (this_block, next));
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1691 }
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1692
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1693 void
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1694 jit_convert_gcc::visit (jit_cond_branch& cb)
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1695 {
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1696 if (m_log_visits)
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1697 std::cerr << "jit_convert_gcc::visit (jit_cond_branch& cb): " << cb << "\n";
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1698
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1699 gccjit::rvalue boolval = as_rvalue (cb.cond ());
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1700
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1701 jit_block *this_block = cb.parent ();
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1702 get_current_block ().end_with_conditional (
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1703 boolval,
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1704 get_block_for_edge (this_block, cb.successor (0)),
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1705 get_block_for_edge (this_block, cb.successor (1)));
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1706 }
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1707
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1708 void
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1709 jit_convert_gcc::visit (jit_call& call)
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1710 {
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1711 if (m_log_visits)
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1712 std::cerr << "jit_convert_gcc::visit (jit_call& call): " << call << "\n";
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1713
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1714 const jit_function& ol = call.overload ();
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1715
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1716 std::vector<jit_value *> args (call.arguments ().size ());
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1717 for (size_t i = 0; i < args.size (); ++i)
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1718 args[i] = call.argument (i);
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1719
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1720 gccjit::rvalue ret = ol.call (m_ctxt, get_current_block (), args);
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1721 add_assignment_for_insn (call, ret);
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1722 }
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1723
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1724 void
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1725 jit_convert_gcc::visit (jit_extract_argument& extract)
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1726 {
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1727 if (m_log_visits)
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1728 std::cerr << "jit_convert_gcc::visit (jit_extract_argument& extract): " << extract << "\n";
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1729
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1730 const std::string& argname = extract.name ();
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1731
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1732 // Get the stored (octave_base_value *)
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1733 gccjit::lvalue param = m_extracted_params[m_argument_index[argname]];
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1734
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1735 // Convert it to a more specialized type:
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1736 const jit_function& ol = extract.overload ();
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1737 std::vector<gccjit::rvalue> args (1, param);
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1738 gccjit::rvalue extracted = ol.call (m_ctxt, get_current_block (), args);
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1739 add_assignment_for_insn (extract,
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1740 extracted);
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1741 }
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1742
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1743 void
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1744 jit_convert_gcc::visit (jit_store_argument& store)
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1745 {
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1746 if (m_log_visits)
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1747 std::cerr << "jit_convert_gcc::visit (jit_store_argument& store): " << store << "\n";
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1748
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1749 const jit_function& ol = store.overload ();
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1750
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1751 std::vector<jit_value *> args (1);
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1752 args[0] = store.result ();
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1753
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1754 gccjit::rvalue ret = ol.call (m_ctxt, get_current_block (), args);
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1755 int index = m_argument_index[store.name ()];
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1756 get_current_block ().add_assignment (
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1757 // "params[index] = ..."
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1758 m_ctxt.new_array_access (
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1759 params,
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1760 m_ctxt.new_rvalue (m_ctxt.get_type (GCC_JIT_TYPE_INT),
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1761 index)),
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1762 // "... = ret;"
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1763 ret);
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1764 }
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1765
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1766 void
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1767 jit_convert_gcc::visit (jit_return& ret)
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1768 {
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1769 if (m_log_visits)
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1770 std::cerr << "jit_convert_gcc::visit (jit_return& ret): " << ret << "\n";
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1771 jit_value *res = ret.result ();
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1772
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1773 if (converting_function)
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1774 throw jit_fail_exception ("TODO");
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1775 else
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1776 {
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1777 if (res)
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1778 get_current_block ().end_with_return (res->as_rvalue ());
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1779 else
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1780 get_current_block ().end_with_return ();
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1781 }
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1782 }
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1783
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1784 void
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1785 jit_convert_gcc::visit (jit_phi& phi)
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1786 {
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1787 if (m_log_visits)
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1788 std::cerr << "jit_convert_gcc::visit (jit_phi& phi): " << phi << "\n";
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1789 throw jit_fail_exception ("TODO");
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1790 }
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1791
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1792 void
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1793 jit_convert_gcc::visit (jit_variable& var)
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1794 {
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1795 if (m_log_visits)
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1796 std::cerr << "jit_convert_gcc::visit (jit_variable&): " << var << "\n";
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1797 throw jit_fail_exception ("TODO");
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1798 }
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1799
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1800 void
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1801 jit_convert_gcc::visit (jit_error_check& check)
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1802 {
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1803 if (m_log_visits)
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1804 std::cerr << "jit_convert_gcc::visit (jit_error_check& check): " << check << "\n";
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1805
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1806 gccjit::rvalue cond;
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1807
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1808 switch (check.check_variable ())
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1809 {
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1810 case jit_error_check::var_error_state:
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1811 cond = jit_typeinfo::insert_error_check (m_func);
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1812 break;
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1813 case jit_error_check::var_interrupt:
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1814 cond = jit_typeinfo::insert_interrupt_check (m_func);
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1815 break;
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1816 default:
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1817 panic_impossible ();
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1818 }
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1819
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1820 jit_block *this_block = check.parent ();
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1821 get_current_block ().end_with_conditional (
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1822 cond,
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1823 get_block_for_edge (this_block, check.successor (0)),
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1824 get_block_for_edge (this_block, check.successor (1)));
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1825 }
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1826
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1827 void
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1828 jit_convert_gcc::visit (jit_assign& assign)
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1829 {
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1830 if (m_log_visits)
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1831 std::cerr << "jit_convert_gcc::visit (jit_assign& assign): " << assign << "\n";
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1832
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1833 jit_value *jsrc = assign.src ();
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1834
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1835 add_assignment_for_insn (assign,
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1836 as_rvalue (jsrc));
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1837 }
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1838
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1839 void
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1840 jit_convert_gcc::visit (jit_argument& arg)
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1841 {
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1842 if (m_log_visits)
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1843 std::cerr << "jit_convert_gcc::visit (jit_argument&): " << arg << "\n";
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1844 throw jit_fail_exception ("TODO");
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1845 }
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1846
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1847 void
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1848 jit_convert_gcc::visit (jit_magic_end& me)
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1849 {
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1850 if (m_log_visits)
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1851 std::cerr << "jit_convert_gcc::visit (jit_magic_end& me): " << me << "\n";
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1852 throw jit_fail_exception ("TODO");
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1853 }
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1854 #endif /* HAVE_GCCJIT */
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1855
15191 ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1856 // -------------------- jit_convert_llvm --------------------
20654 b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1857
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1858 #ifdef HAVE_LLVM
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1859
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1860 llvm::Function *
15337 3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1861 jit_convert_llvm::convert_loop (llvm::Module *module,
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1862 const jit_block_list& blocks,
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1863 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	1864 {
15337 3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1865 converting_function = false;
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1866
15191 ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1867 // 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	1868 // more interesting
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1869 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	1870 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	1871 iter != entry_block->end (); ++iter)
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1872 if (jit_extract_argument *extract
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1873 = 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	1874 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	1875
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	1876
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1877 jit_type *any = jit_typeinfo::get_any ();
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	1878
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1879 // 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	1880 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	1881 arg_type = arg_type->getPointerTo ();
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1882 llvm::FunctionType *ft;
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1883 ft = llvm::FunctionType::get (llvm::Type::getVoidTy (context), arg_type,
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1884 false);
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1885 function = llvm::Function::Create (ft, llvm::Function::ExternalLinkage,
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1886 "foobar", module);
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1887
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1888 try
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1889 {
14968 7f60cdfcc0e5 Do not smash stack when passing structures in JIT Max Brister <max@2bass.com> parents: 14967 diff changeset	1890 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	1891 builder.SetInsertPoint (prelude);
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1892
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1893 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	1894 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	1895 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1896 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	1897 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	1898 }
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1899
15337 3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1900 convert (blocks, constants);
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1901 }
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1902 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	1903 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1904 function->eraseFromParent ();
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1905 throw;
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1906 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1907
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1908 return function;
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	1909 }
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	1910
15337 3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1911
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1912 jit_function
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1913 jit_convert_llvm::convert_function (llvm::Module *module,
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1914 const jit_block_list& blocks,
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1915 const std::list<jit_value *>& constants,
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1916 octave_user_function& fcn,
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1917 const std::vector<jit_type *>& args)
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 converting_function = true;
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 jit_block *final_block = blocks.back ();
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1922 jit_return ret = dynamic_cast<jit_return > (final_block->back ());
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1923 assert (ret);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1924
20654 b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1925 creating = jit_function (module,
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1926 #ifdef HAVE_GCCJIT
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1927 gccjit::context (), // FIXME?
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1928 #endif
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	1929 jit_convention::internal,
15370 8355fddce815 Use sret and do not use save/restore stack (bug #37308) Max Brister <max@2bass.com> parents: 15346 diff changeset	1930 "foobar", ret->result_type (), args);
15337 3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1931 function = creating.to_llvm ();
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1932
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1933 try
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1934 {
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1935 prelude = creating.new_block ("prelude");
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1936 builder.SetInsertPoint (prelude);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1937
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1938 tree_parameter_list *plist = fcn.parameter_list ();
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1939 if (plist)
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1940 {
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1941 tree_parameter_list::iterator piter = plist->begin ();
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1942 tree_parameter_list::iterator pend = plist->end ();
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1943 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	1944 {
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1945 tree_decl_elt elt = piter;
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1946 std::string arg_name = elt->name ();
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1947 arguments[arg_name] = creating.argument (builder, i);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1948 }
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1949 }
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1950
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1951 convert (blocks, constants);
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1952 }
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1953 catch (const jit_fail_exception& e)
15337 3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1954 {
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1955 function->eraseFromParent ();
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1956 throw;
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1957 }
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1958
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1959 return creating;
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1960 }
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1961
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1962 void
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1963 jit_convert_llvm::convert (const jit_block_list& blocks,
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1964 const std::list<jit_value *>& constants)
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1965 {
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1966 std::list<jit_block *>::const_iterator biter;
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1967 for (biter = blocks.begin (); biter != blocks.end (); ++biter)
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1968 {
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1969 jit_block jblock = biter;
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1970 llvm::BasicBlock *block = llvm::BasicBlock::Create (context,
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1971 jblock->name (),
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1972 function);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1973 jblock->stash_llvm (block);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1974 }
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1975
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1976 jit_block first = blocks.begin ();
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1977 builder.CreateBr (first->to_llvm ());
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1978
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1979 // constants aren't in the IR, we visit those first
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1980 for (std::list<jit_value *>::const_iterator iter = constants.begin ();
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1981 iter != constants.end (); ++iter)
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1982 if (! isa<jit_instruction> (*iter))
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1983 visit (*iter);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1984
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1985 // convert all instructions
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1986 for (biter = blocks.begin (); biter != blocks.end (); ++biter)
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1987 visit (*biter);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1988
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1989 // now finish phi nodes
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1990 for (biter = blocks.begin (); biter != blocks.end (); ++biter)
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1991 {
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1992 jit_block& block = **biter;
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1993 for (jit_block::iterator piter = block.begin ();
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1994 piter != block.end () && isa<jit_phi> (*piter); ++piter)
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1995 {
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1996 jit_instruction phi = piter;
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1997 finish_phi (static_cast<jit_phi *> (phi));
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1998 }
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	1999 }
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2000 }
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2001
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	2002 void
15181 ed2b911a2fb3 Rename jit_convert::convert_llvm to jit_convert_llvm Max Brister <max@2bass.com> parents: 15171 diff changeset	2003 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	2004 {
14963 709f50069722 Change algorithm for placing releases and simplify PHIs in low level Octave IR Max Brister <max@2bass.com> parents: 14962 diff changeset	2005 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	2006 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	2007 {
14963 709f50069722 Change algorithm for placing releases and simplify PHIs in low level Octave IR Max Brister <max@2bass.com> parents: 14962 diff changeset	2008 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	2009 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	2010 }
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	2011 }
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	2012
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	2013 void
15181 ed2b911a2fb3 Rename jit_convert::convert_llvm to jit_convert_llvm Max Brister <max@2bass.com> parents: 15171 diff changeset	2014 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	2015 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	2016 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	2017 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	2018
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	2019 void
15181 ed2b911a2fb3 Rename jit_convert::convert_llvm to jit_convert_llvm Max Brister <max@2bass.com> parents: 15171 diff changeset	2020 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	2021 {
f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	2022 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	2023 }
f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	2024
f649b66ef1af Add short circult operators to JIT Max Brister <max@2bass.com> parents: 14977 diff changeset	2025 void
15181 ed2b911a2fb3 Rename jit_convert::convert_llvm to jit_convert_llvm Max Brister <max@2bass.com> parents: 15171 diff changeset	2026 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	2027 {
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	2028 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	2029 }
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	2030
14984 561aad6a9e4b Initial support for complex numbers in JIT Max Brister <max@2bass.com> parents: 14983 diff changeset	2031 void
15181 ed2b911a2fb3 Rename jit_convert::convert_llvm to jit_convert_llvm Max Brister <max@2bass.com> parents: 15171 diff changeset	2032 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	2033 {
561aad6a9e4b Initial support for complex numbers in JIT Max Brister <max@2bass.com> parents: 14983 diff changeset	2034 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	2035 Complex value = cc.value ();
15893 1f076c40c133 Do not use vectorized llvm commands for complex numbers Max Brister <max@2bass.com> parents: 15603 diff changeset	2036 llvm::Value *real = llvm::ConstantFP::get (scalar_t, value.real ());
1f076c40c133 Do not use vectorized llvm commands for complex numbers Max Brister <max@2bass.com> parents: 15603 diff changeset	2037 llvm::Value *imag = llvm::ConstantFP::get (scalar_t, value.imag ());
1f076c40c133 Do not use vectorized llvm commands for complex numbers Max Brister <max@2bass.com> parents: 15603 diff changeset	2038 cc.stash_llvm (jit_typeinfo::create_complex (real, imag));
14984 561aad6a9e4b Initial support for complex numbers in JIT Max Brister <max@2bass.com> parents: 14983 diff changeset	2039 }
561aad6a9e4b Initial support for complex numbers in JIT Max Brister <max@2bass.com> parents: 14983 diff changeset	2040
15181 ed2b911a2fb3 Rename jit_convert::convert_llvm to jit_convert_llvm Max Brister <max@2bass.com> parents: 15171 diff changeset	2041 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	2042 {
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	2043 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	2044 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	2045
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	2046 void
15181 ed2b911a2fb3 Rename jit_convert::convert_llvm to jit_convert_llvm Max Brister <max@2bass.com> parents: 15171 diff changeset	2047 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	2048 {
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	2049 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	2050 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	2051 llvm::Type *idx = jit_typeinfo::get_index_llvm ();
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	2052 const jit_range& rng = cr.value ();
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	2053
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	2054 llvm::Constant *constants[4];
14951 4c9fd3e31436 Start of jit support for double matricies Max Brister <max@2bass.com> parents: 14949 diff changeset	2055 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	2056 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	2057 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	2058 constants[3] = llvm::ConstantInt::get (idx, rng.nelem);
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	2059
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	2060 llvm::Value *as_llvm;
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	2061 as_llvm = llvm::ConstantStruct::get (stype,
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	2062 llvm::makeArrayRef (constants, 4));
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	2063 cr.stash_llvm (as_llvm);
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	2064 }
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	2065
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	2066 void
15181 ed2b911a2fb3 Rename jit_convert::convert_llvm to jit_convert_llvm Max Brister <max@2bass.com> parents: 15171 diff changeset	2067 jit_convert_llvm::visit (jit_block& b)
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	2068 {
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	2069 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	2070 builder.SetInsertPoint (block);
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	2071 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	2072 visit (*iter);
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	2073 }
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	2074
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	2075 void
15181 ed2b911a2fb3 Rename jit_convert::convert_llvm to jit_convert_llvm Max Brister <max@2bass.com> parents: 15171 diff changeset	2076 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	2077 {
14948 006570a76b90 Cleanup and optimization of JIT Max Brister <max@2bass.com> parents: 14946 diff changeset	2078 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	2079 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	2080
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	2081 void
15181 ed2b911a2fb3 Rename jit_convert::convert_llvm to jit_convert_llvm Max Brister <max@2bass.com> parents: 15171 diff changeset	2082 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	2083 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	2084 llvm::Value *cond = cb.cond_llvm ();
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	2085 llvm::Value *br;
14959 12fd4a62d633 Fix whitespace issues and update documentation Max Brister <max@2bass.com> parents: 14958 diff changeset	2086 br = builder.CreateCondBr (cond, cb.successor_llvm (0),
12fd4a62d633 Fix whitespace issues and update documentation Max Brister <max@2bass.com> parents: 14958 diff changeset	2087 cb.successor_llvm (1));
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	2088 cb.stash_llvm (br);
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	2089 }
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	2090
14913 c7071907a641 Use symbol_record_ref instead of names in JIT Max Brister <max@2bass.com> parents: 14911 diff changeset	2091 void
15181 ed2b911a2fb3 Rename jit_convert::convert_llvm to jit_convert_llvm Max Brister <max@2bass.com> parents: 15171 diff changeset	2092 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	2093 {
15014 094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	2094 const jit_function& ol = call.overload ();
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	2095
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	2096 std::vector<jit_value *> args (call.arguments ().size ());
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	2097 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	2098 args[i] = call.argument (i);
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	2099
15016 005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	2100 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	2101 call.stash_llvm (ret);
14913 c7071907a641 Use symbol_record_ref instead of names in JIT Max Brister <max@2bass.com> parents: 14911 diff changeset	2102 }
c7071907a641 Use symbol_record_ref instead of names in JIT Max Brister <max@2bass.com> parents: 14911 diff changeset	2103
c7071907a641 Use symbol_record_ref instead of names in JIT Max Brister <max@2bass.com> parents: 14911 diff changeset	2104 void
15181 ed2b911a2fb3 Rename jit_convert::convert_llvm to jit_convert_llvm Max Brister <max@2bass.com> parents: 15171 diff changeset	2105 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	2106 {
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	2107 llvm::Value *arg = arguments[extract.name ()];
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	2108 assert (arg);
14951 4c9fd3e31436 Start of jit support for double matricies Max Brister <max@2bass.com> parents: 14949 diff changeset	2109
15337 3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2110 if (converting_function)
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2111 extract.stash_llvm (arg);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2112 else
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 arg = builder.CreateLoad (arg);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2115
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2116 const jit_function& ol = extract.overload ();
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2117 extract.stash_llvm (ol.call (builder, arg));
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2118 }
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	2119 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	2120
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	2121 void
15181 ed2b911a2fb3 Rename jit_convert::convert_llvm to jit_convert_llvm Max Brister <max@2bass.com> parents: 15171 diff changeset	2122 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	2123 {
15014 094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	2124 const jit_function& ol = store.overload ();
15016 005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	2125 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	2126 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	2127 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	2128 }
c7071907a641 Use symbol_record_ref instead of names in JIT Max Brister <max@2bass.com> parents: 14911 diff changeset	2129
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	2130 void
15337 3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2131 jit_convert_llvm::visit (jit_return& ret)
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2132 {
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2133 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	2134
8355fddce815 Use sret and do not use save/restore stack (bug #37308) Max Brister <max@2bass.com> parents: 15346 diff changeset	2135 if (converting_function)
8355fddce815 Use sret and do not use save/restore stack (bug #37308) Max Brister <max@2bass.com> parents: 15346 diff changeset	2136 creating.do_return (builder, res->to_llvm (), false);
15337 3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2137 else
15370 8355fddce815 Use sret and do not use save/restore stack (bug #37308) Max Brister <max@2bass.com> parents: 15346 diff changeset	2138 {
8355fddce815 Use sret and do not use save/restore stack (bug #37308) Max Brister <max@2bass.com> parents: 15346 diff changeset	2139 if (res)
8355fddce815 Use sret and do not use save/restore stack (bug #37308) Max Brister <max@2bass.com> parents: 15346 diff changeset	2140 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	2141 else
8355fddce815 Use sret and do not use save/restore stack (bug #37308) Max Brister <max@2bass.com> parents: 15346 diff changeset	2142 builder.CreateRetVoid ();
8355fddce815 Use sret and do not use save/restore stack (bug #37308) Max Brister <max@2bass.com> parents: 15346 diff changeset	2143 }
15337 3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2144 }
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2145
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2146 void
15181 ed2b911a2fb3 Rename jit_convert::convert_llvm to jit_convert_llvm Max Brister <max@2bass.com> parents: 15171 diff changeset	2147 jit_convert_llvm::visit (jit_phi& phi)
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	2148 {
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	2149 // 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	2150 // set incomming branches now
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	2151 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	2152 phi.argument_count ());
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	2153 builder.Insert (node);
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	2154 phi.stash_llvm (node);
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	2155 }
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	2156
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	2157 void
15181 ed2b911a2fb3 Rename jit_convert::convert_llvm to jit_convert_llvm Max Brister <max@2bass.com> parents: 15171 diff changeset	2158 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	2159 {
15016 005cb78e1dd1 Split pt-jit into multiple files. Max Brister <max@2bass.com> parents: 15014 diff changeset	2160 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	2161 }
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14925 diff changeset	2162
14938 bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	2163 void
15181 ed2b911a2fb3 Rename jit_convert::convert_llvm to jit_convert_llvm Max Brister <max@2bass.com> parents: 15171 diff changeset	2164 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	2165 {
15603 44272909d926 Stop JIT on interrupt Max Brister <max@2bass.com> parents: 15602 diff changeset	2166 llvm::Value *cond;
44272909d926 Stop JIT on interrupt Max Brister <max@2bass.com> parents: 15602 diff changeset	2167
44272909d926 Stop JIT on interrupt Max Brister <max@2bass.com> parents: 15602 diff changeset	2168 switch (check.check_variable ())
44272909d926 Stop JIT on interrupt Max Brister <max@2bass.com> parents: 15602 diff changeset	2169 {
44272909d926 Stop JIT on interrupt Max Brister <max@2bass.com> parents: 15602 diff changeset	2170 case jit_error_check::var_error_state:
44272909d926 Stop JIT on interrupt Max Brister <max@2bass.com> parents: 15602 diff changeset	2171 cond = jit_typeinfo::insert_error_check (builder);
44272909d926 Stop JIT on interrupt Max Brister <max@2bass.com> parents: 15602 diff changeset	2172 break;
44272909d926 Stop JIT on interrupt Max Brister <max@2bass.com> parents: 15602 diff changeset	2173 case jit_error_check::var_interrupt:
44272909d926 Stop JIT on interrupt Max Brister <max@2bass.com> parents: 15602 diff changeset	2174 cond = jit_typeinfo::insert_interrupt_check (builder);
44272909d926 Stop JIT on interrupt Max Brister <max@2bass.com> parents: 15602 diff changeset	2175 break;
44272909d926 Stop JIT on interrupt Max Brister <max@2bass.com> parents: 15602 diff changeset	2176 default:
44272909d926 Stop JIT on interrupt Max Brister <max@2bass.com> parents: 15602 diff changeset	2177 panic_impossible ();
44272909d926 Stop JIT on interrupt Max Brister <max@2bass.com> parents: 15602 diff changeset	2178 }
44272909d926 Stop JIT on interrupt Max Brister <max@2bass.com> parents: 15602 diff changeset	2179
14948 006570a76b90 Cleanup and optimization of JIT Max Brister <max@2bass.com> parents: 14946 diff changeset	2180 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	2181 check.successor_llvm (1));
14938 bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	2182 check.stash_llvm (br);
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	2183 }
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	2184
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	2185 void
15181 ed2b911a2fb3 Rename jit_convert::convert_llvm to jit_convert_llvm Max Brister <max@2bass.com> parents: 15171 diff changeset	2186 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	2187 {
15014 094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	2188 jit_value *new_value = assign.src ();
094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	2189 assign.stash_llvm (new_value->to_llvm ());
14965 f2117a963c54 Place grab/release for assignments Max Brister <max@2bass.com> parents: 14964 diff changeset	2190
14969 bbeef7b8ea2e Add support for matrix indexed assignment to JIT Max Brister <max@2bass.com> parents: 14968 diff changeset	2191 if (assign.artificial ())
bbeef7b8ea2e Add support for matrix indexed assignment to JIT Max Brister <max@2bass.com> parents: 14968 diff changeset	2192 return;
bbeef7b8ea2e Add support for matrix indexed assignment to JIT Max Brister <max@2bass.com> parents: 14968 diff changeset	2193
14965 f2117a963c54 Place grab/release for assignments Max Brister <max@2bass.com> parents: 14964 diff changeset	2194 jit_value *overwrite = assign.overwrite ();
f2117a963c54 Place grab/release for assignments Max Brister <max@2bass.com> parents: 14964 diff changeset	2195 if (isa<jit_assign_base> (overwrite))
f2117a963c54 Place grab/release for assignments Max Brister <max@2bass.com> parents: 14964 diff changeset	2196 {
15014 094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	2197 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	2198 if (ol.valid ())
98a65d9e426f Remove uneeded release overloads Max Brister <max@2bass.com> parents: 15146 diff changeset	2199 ol.call (builder, overwrite);
14965 f2117a963c54 Place grab/release for assignments Max Brister <max@2bass.com> parents: 14964 diff changeset	2200 }
14962 90a7a2af2cd5 Keep track of variables after SSA construction Max Brister <max@2bass.com> parents: 14961 diff changeset	2201 }
14938 bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	2202
14951 4c9fd3e31436 Start of jit support for double matricies Max Brister <max@2bass.com> parents: 14949 diff changeset	2203 void
15181 ed2b911a2fb3 Rename jit_convert::convert_llvm to jit_convert_llvm Max Brister <max@2bass.com> parents: 15171 diff changeset	2204 jit_convert_llvm::visit (jit_argument&)
14951 4c9fd3e31436 Start of jit support for double matricies Max Brister <max@2bass.com> parents: 14949 diff changeset	2205 {}
4c9fd3e31436 Start of jit support for double matricies Max Brister <max@2bass.com> parents: 14949 diff changeset	2206
15056 bc32288f4a42 Support the end keyword for one dimentional indexing in JIT. Max Brister <max@2bass.com> parents: 15030 diff changeset	2207 void
15181 ed2b911a2fb3 Rename jit_convert::convert_llvm to jit_convert_llvm Max Brister <max@2bass.com> parents: 15171 diff changeset	2208 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	2209 {
bc32288f4a42 Support the end keyword for one dimentional indexing in JIT. Max Brister <max@2bass.com> parents: 15030 diff changeset	2210 const jit_function& ol = me.overload ();
15102 d29f2583cf7b Support end in multi indexing in JIT Max Brister <max@2bass.com> parents: 15096 diff changeset	2211
d29f2583cf7b Support end in multi indexing in JIT Max Brister <max@2bass.com> parents: 15096 diff changeset	2212 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	2213 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	2214 me.stash_llvm (ret);
bc32288f4a42 Support the end keyword for one dimentional indexing in JIT. Max Brister <max@2bass.com> parents: 15030 diff changeset	2215 }
bc32288f4a42 Support the end keyword for one dimentional indexing in JIT. Max Brister <max@2bass.com> parents: 15030 diff changeset	2216
20654 b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	2217 #endif /* ifdef HAVE_LLVM */
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	2218
15191 ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2219 // -------------------- jit_infer --------------------
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2220 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	2221 const variable_map& avmap)
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	2222 : blocks (ablocks), factory (afactory), vmap (avmap) { }
15191 ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2223
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2224 void
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2225 jit_infer::infer (void)
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2226 {
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2227 construct_ssa ();
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2228
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2229 // 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	2230 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	2231 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	2232 iter != constants.end (); ++iter)
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2233 append_users (*iter);
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2234
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2235 // 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	2236 if (entry_block ().terminator ())
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2237 push_worklist (entry_block ().terminator ());
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2238
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2239 // FIXME: Describe algorithm here
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2240 while (worklist.size ())
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 jit_instruction *next = worklist.front ();
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2243 worklist.pop_front ();
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2244 next->stash_in_worklist (false);
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2245
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2246 if (next->infer ())
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2247 {
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2248 // 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	2249 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	2250 append_users_term (term);
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2251 else
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2252 append_users (next);
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2253 }
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2254 }
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2255
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2256 remove_dead ();
15602 f3e339aee38f Fix block labeling in JIT debug output Max Brister <max@2bass.com> parents: 15595 diff changeset	2257 blocks.label ();
15191 ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2258 place_releases ();
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2259 simplify_phi ();
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2260 }
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2261
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2262 void
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2263 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	2264 {
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2265 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	2266 push_worklist (use->user ());
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2267 }
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2268
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2269 void
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2270 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	2271 {
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2272 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	2273 {
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2274 if (term->alive (i))
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2275 {
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2276 jit_block *succ = term->successor (i);
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	2277 for (jit_block::iterator iter = succ->begin ();
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	2278 iter != succ->end () && isa<jit_phi> (*iter); ++iter)
15191 ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2279 push_worklist (*iter);
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2280
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2281 jit_terminator *sterm = succ->terminator ();
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2282 if (sterm)
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2283 push_worklist (sterm);
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2284 }
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2285 }
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2286 }
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2287
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2288 void
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2289 jit_infer::construct_ssa (void)
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2290 {
15602 f3e339aee38f Fix block labeling in JIT debug output Max Brister <max@2bass.com> parents: 15595 diff changeset	2291 blocks.label ();
15191 ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2292 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	2293 entry_block ().compute_df ();
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2294 entry_block ().create_dom_tree ();
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2295
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2296 // 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	2297 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	2298 ++iter)
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2299 {
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2300 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	2301 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	2302 iter->second->use_blocks (visited);
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2303 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	2304 visited.end ());
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2305
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2306 while (ssa_worklist.size ())
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2307 {
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2308 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	2309 ssa_worklist.pop_front ();
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2310
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2311 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	2312 diter != b->df_end (); ++diter)
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2313 {
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2314 jit_block dblock = diter;
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2315 if (! added_phi.count (dblock))
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2316 {
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2317 jit_phi *phi = factory.create<jit_phi> (iter->second,
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	2318 dblock->use_count ());
15191 ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2319 dblock->prepend (phi);
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2320 added_phi.insert (dblock);
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2321 }
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2322
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2323 if (! visited.count (dblock))
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2324 {
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2325 ssa_worklist.push_back (dblock);
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2326 visited.insert (dblock);
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2327 }
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2328 }
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2329 }
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2330 }
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2331
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2332 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	2333 }
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2334
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2335 void
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2336 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	2337 {
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2338 if (ablock.visited (avisit_count))
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2339 return;
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2340
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2341 // 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	2342 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	2343 ++iter)
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2344 {
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2345 jit_instruction instr = iter;
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2346 instr->construct_ssa ();
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2347 instr->push_variable ();
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2348 }
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2349
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2350 // finish phi nodes of successors
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2351 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	2352 {
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2353 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	2354
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	2355 for (jit_block::iterator iter = finish->begin ();
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	2356 iter != finish->end () && isa<jit_phi> (*iter);)
15191 ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2357 {
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2358 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	2359 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	2360 ++iter;
4c0cef65c55f pt-jit.cc (jit_infer::do_construct_ir): Correct extraious phi removal Max Brister <max@2bass.com> parents: 15234 diff changeset	2361
15191 ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2362 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	2363 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	2364 else
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2365 {
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2366 // 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	2367 assert (! phi->use_count ());
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2368 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	2369 phi->remove ();
15191 ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2370 }
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2371 }
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2372 }
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2373
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2374 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	2375 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	2376
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2377 ablock.pop_all ();
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2378 }
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2379
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2380 void
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2381 jit_infer::place_releases (void)
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2382 {
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2383 std::set<jit_value *> temporaries;
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2384 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	2385 ++iter)
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2386 {
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2387 jit_block& ablock = **iter;
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2388 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	2389 {
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2390 release_temp (ablock, temporaries);
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2391 release_dead_phi (ablock);
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2392 }
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2393 }
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2394 }
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2395
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2396 void
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2397 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	2398 {
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2399 if (! instr->in_worklist ())
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2400 {
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2401 instr->stash_in_worklist (true);
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2402 worklist.push_back (instr);
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2403 }
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2404 }
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2405
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2406 void
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2407 jit_infer::remove_dead ()
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2408 {
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2409 jit_block_list::iterator biter;
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2410 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	2411 {
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2412 jit_block b = biter;
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2413 if (b->alive ())
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2414 {
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	2415 for (jit_block::iterator iter = b->begin ();
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	2416 iter != b->end () && isa<jit_phi> (*iter);)
15191 ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2417 {
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2418 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	2419 if (phi->prune ())
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2420 iter = b->remove (iter);
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2421 else
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2422 ++iter;
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2423 }
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2424 }
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2425 }
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2426
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2427 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	2428 {
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2429 jit_block b = biter;
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2430 if (b->alive ())
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2431 {
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2432 // 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	2433 // we will need to change!
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2434 jit_terminator *term = b->terminator ();
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2435 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	2436 {
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2437 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	2438 term->remove ();
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2439 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	2440 b->append (abreak);
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2441 abreak->infer ();
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2442 }
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2443
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2444 ++biter;
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2445 }
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2446 else
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2447 {
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2448 jit_terminator *term = b->terminator ();
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2449 if (term)
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2450 term->remove ();
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2451 biter = blocks.erase (biter);
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2452 }
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2453 }
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2454 }
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2455
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2456 void
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2457 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	2458 {
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2459 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	2460 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	2461 {
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2462 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	2463 ++iter;
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2464
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2465 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	2466 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	2467 {
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2468 // 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	2469 // 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	2470 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	2471 {
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2472 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	2473 if (! arg->needs_release ())
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2474 continue;
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2475
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2476 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	2477 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	2478 jit_terminator *term = split->terminator ();
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2479 jit_call *release
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2480 = 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	2481 release->infer ();
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2482 split->insert_before (term, release);
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2483 }
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2484
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2485 phi->replace_with (0);
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2486 phi->remove ();
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2487 }
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2488 }
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2489 }
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2490
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2491 void
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2492 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	2493 {
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2494 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	2495 ++iter)
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2496 {
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2497 jit_instruction instr = iter;
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2498
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2499 // 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	2500 // multiple blocks
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2501 if (instr->needs_release ())
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2502 {
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2503 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	2504 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	2505 temp.insert (instr);
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2506 }
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2507
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2508 if (isa<jit_call> (instr))
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2509 {
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2510 // place releases for temporary arguments
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2511 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	2512 {
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2513 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	2514 if (! arg->needs_release ())
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2515 continue;
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2516
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2517 jit_call *release
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2518 = 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	2519 release->infer ();
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2520 ablock.insert_after (iter, release);
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2521 ++iter;
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2522 temp.erase (arg);
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2523 }
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2524 }
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2525 }
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2526
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2527 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	2528 return;
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2529
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	2530 // FIXME: If we support try/catch or unwind_protect final_block
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	2531 // may not be the destination
15191 ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2532 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	2533 jit_terminator *term = split->terminator ();
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2534 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	2535 iter != temp.end (); ++iter)
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2536 {
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2537 jit_value value = iter;
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2538 jit_call *release
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2539 = 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	2540 split->insert_before (term, release);
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2541 release->infer ();
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2542 }
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2543 }
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2544
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2545 void
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2546 jit_infer::simplify_phi (void)
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2547 {
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2548 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	2549 ++biter)
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2550 {
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2551 jit_block &ablock = **biter;
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	2552 for (jit_block::iterator iter = ablock.begin ();
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	2553 iter != ablock.end () && isa<jit_phi> (*iter); ++iter)
15191 ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2554 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	2555 }
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2556 }
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2557
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2558 void
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2559 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	2560 {
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2561 jit_block& pblock = *phi.parent ();
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2562 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	2563 jit_variable *dest = phi.dest ();
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2564 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	2565 {
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2566 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	2567 if (arg->type () != phi.type ())
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2568 {
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2569 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	2570 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	2571 jit_terminator *term = split->terminator ();
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2572 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	2573 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	2574
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2575 split->insert_before (term, cast);
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2576 split->insert_before (term, assign);
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2577 cast->infer ();
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2578 assign->infer ();
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2579 phi.stash_argument (i, assign);
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2580 }
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2581 }
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2582 }
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2583
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	2584 // -------------------- tree_jit --------------------
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	2585
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	2586 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	2587 {
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	2588 }
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	2589
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	2590 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	2591 {}
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	2592
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	2593 bool
15027 741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	2594 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	2595 {
15337 3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2596 return instance ().do_execute (cmd, bounds);
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	2597 }
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	2598
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	2599 bool
15023 75d1bc2fd6d2 Compile top level while loops in JIT. Max Brister <max@2bass.com> parents: 15016 diff changeset	2600 tree_jit::execute (tree_while_command& cmd)
75d1bc2fd6d2 Compile top level while loops in JIT. Max Brister <max@2bass.com> parents: 15016 diff changeset	2601 {
15337 3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2602 return instance ().do_execute (cmd);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2603 }
15023 75d1bc2fd6d2 Compile top level while loops in JIT. Max Brister <max@2bass.com> parents: 15016 diff changeset	2604
15337 3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2605 bool
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2606 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	2607 octave_value_list& retval)
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2608 {
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2609 return instance ().do_execute (fcn, args, retval);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2610 }
15023 75d1bc2fd6d2 Compile top level while loops in JIT. Max Brister <max@2bass.com> parents: 15016 diff changeset	2611
15337 3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2612 tree_jit&
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2613 tree_jit::instance (void)
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2614 {
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2615 static tree_jit ret;
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2616 return ret;
15023 75d1bc2fd6d2 Compile top level while loops in JIT. Max Brister <max@2bass.com> parents: 15016 diff changeset	2617 }
75d1bc2fd6d2 Compile top level while loops in JIT. Max Brister <max@2bass.com> parents: 15016 diff changeset	2618
75d1bc2fd6d2 Compile top level while loops in JIT. Max Brister <max@2bass.com> parents: 15016 diff changeset	2619 bool
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	2620 tree_jit::initialize (void)
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	2621 {
20654 b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	2622 #ifdef HAVE_LLVM
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	2623 if (engine)
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	2624 return true;
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	2625
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	2626 if (! module)
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	2627 {
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	2628 llvm::InitializeNativeTarget ();
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	2629 module = new llvm::Module ("octave", context);
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	2630 }
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	2631
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	2632 // sometimes this fails pre main
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	2633 engine = llvm::ExecutionEngine::createJIT (module);
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	2634
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	2635 if (! engine)
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	2636 return false;
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	2637
18840 4a4edf0f2077 fix LLVM 3.4 build (bug #41061) Stefan Mahr <dac922@gmx.de> parents: 18726 diff changeset	2638 #ifdef LEGACY_PASSMANAGER
4a4edf0f2077 fix LLVM 3.4 build (bug #41061) Stefan Mahr <dac922@gmx.de> parents: 18726 diff changeset	2639 module_pass_manager = new llvm::legacy::PassManager ();
19631 db92e7e28e1f strip trailing whitespace from most source files John W. Eaton <jwe@octave.org> parents: 18968 diff changeset	2640 pass_manager = new llvm::legacy::FunctionPassManager (module);
18840 4a4edf0f2077 fix LLVM 3.4 build (bug #41061) Stefan Mahr <dac922@gmx.de> parents: 18726 diff changeset	2641 #else
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	2642 module_pass_manager = new llvm::PassManager ();
18840 4a4edf0f2077 fix LLVM 3.4 build (bug #41061) Stefan Mahr <dac922@gmx.de> parents: 18726 diff changeset	2643 pass_manager = new llvm::FunctionPassManager (module);
4a4edf0f2077 fix LLVM 3.4 build (bug #41061) Stefan Mahr <dac922@gmx.de> parents: 18726 diff changeset	2644 #endif
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	2645 module_pass_manager->add (llvm::createAlwaysInlinerPass ());
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	2646
17164 36fd98b9ce48 Add support for llvm 3.3 Max Brister <max@2bass.com> parents: 17031 diff changeset	2647 #ifdef HAVE_LLVM_DATALAYOUT
17031 38bcfd413db0 Handle LLVM API incoherence. Octave now works with LLVM 3.0, 3.1, and 3.2 LYH <lyh.kernel@gmail.com> parents: 16941 diff changeset	2648 pass_manager->add (new llvm::DataLayout (*engine->getDataLayout ()));
38bcfd413db0 Handle LLVM API incoherence. Octave now works with LLVM 3.0, 3.1, and 3.2 LYH <lyh.kernel@gmail.com> parents: 16941 diff changeset	2649 #else
38bcfd413db0 Handle LLVM API incoherence. Octave now works with LLVM 3.0, 3.1, and 3.2 LYH <lyh.kernel@gmail.com> parents: 16941 diff changeset	2650 pass_manager->add (new llvm::TargetData (*engine->getTargetData ()));
38bcfd413db0 Handle LLVM API incoherence. Octave now works with LLVM 3.0, 3.1, and 3.2 LYH <lyh.kernel@gmail.com> parents: 16941 diff changeset	2651 #endif
15171 7a19e8275d41 Do not simplify the CFG during type inference Max Brister <max@2bass.com> parents: 15169 diff changeset	2652 pass_manager->add (llvm::createCFGSimplificationPass ());
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	2653 pass_manager->add (llvm::createBasicAliasAnalysisPass ());
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	2654 pass_manager->add (llvm::createPromoteMemoryToRegisterPass ());
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	2655 pass_manager->add (llvm::createInstructionCombiningPass ());
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	2656 pass_manager->add (llvm::createReassociatePass ());
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	2657 pass_manager->add (llvm::createGVNPass ());
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	2658 pass_manager->add (llvm::createCFGSimplificationPass ());
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	2659 pass_manager->doInitialization ();
20654 b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	2660 #endif /* ifdef HAVE_LLVM */
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	2661
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	2662 jit_typeinfo::initialize (
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	2663 #ifdef HAVE_LLVM
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	2664 module, engine
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	2665 #endif
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	2666 );
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	2667
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	2668 return true;
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	2669 }
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	2670
15337 3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2671 bool
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2672 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	2673 {
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2674 size_t tc = trip_count (bounds);
15582 52df2e7baabe Disable JIT when breakpoints are present Max Brister <max@2bass.com> parents: 15539 diff changeset	2675 if (! tc \|\| ! initialize () \|\| ! enabled ())
15337 3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2676 return false;
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2677
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2678 jit_info::vmap extra_vars;
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2679 extra_vars["#for_bounds0"] = &bounds;
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2680
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2681 jit_info *info = cmd.get_info ();
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2682 if (! info \|\| ! info->match (extra_vars))
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2683 {
16941 e6ddaa65a777 Add new function jit_startcnt to control JIT acceleration. Rik <rik@octave.org> parents: 16930 diff changeset	2684 if (tc < static_cast<size_t> (Vjit_startcnt))
15337 3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2685 return false;
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2686
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2687 delete info;
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2688 info = new jit_info (*this, cmd, bounds);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2689 cmd.stash_info (info);
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
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2692 return info->execute (extra_vars);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2693 }
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2694
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2695 bool
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2696 tree_jit::do_execute (tree_while_command& cmd)
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2697 {
15582 52df2e7baabe Disable JIT when breakpoints are present Max Brister <max@2bass.com> parents: 15539 diff changeset	2698 if (! initialize () \|\| ! enabled ())
15337 3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2699 return false;
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2700
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2701 jit_info *info = cmd.get_info ();
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2702 if (! info \|\| ! info->match ())
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2703 {
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2704 delete info;
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2705 info = new jit_info (*this, cmd);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2706 cmd.stash_info (info);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2707 }
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2708
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2709 return info->execute ();
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2710 }
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2711
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2712 bool
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2713 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	2714 octave_value_list& retval)
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2715 {
15582 52df2e7baabe Disable JIT when breakpoints are present Max Brister <max@2bass.com> parents: 15539 diff changeset	2716 if (! initialize () \|\| ! enabled ())
15337 3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2717 return false;
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2718
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2719 jit_function_info *info = fcn.get_info ();
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	2720 if (! info \|\| ! info->match (args))
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	2721 {
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	2722 delete info;
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	2723 info = new jit_function_info (*this, fcn, args);
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	2724 fcn.stash_info (info);
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	2725 }
15337 3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2726
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	2727 return info->execute (args, retval);
15337 3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2728 }
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2729
15582 52df2e7baabe Disable JIT when breakpoints are present Max Brister <max@2bass.com> parents: 15539 diff changeset	2730 bool
52df2e7baabe Disable JIT when breakpoints are present Max Brister <max@2bass.com> parents: 15539 diff changeset	2731 tree_jit::enabled (void)
52df2e7baabe Disable JIT when breakpoints are present Max Brister <max@2bass.com> parents: 15539 diff changeset	2732 {
52df2e7baabe Disable JIT when breakpoints are present Max Brister <max@2bass.com> parents: 15539 diff changeset	2733 // 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	2734 // 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	2735 // conservatively check for the existence of any breakpoints.
16877 5482cd26311a Rename enable_jit_compiler to jit_enable, enable_jit_debugging to debug_jit. Rik <rik@octave.org> parents: 16768 diff changeset	2736 return Vjit_enable && ! bp_table::have_breakpoints ()
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	2737 && ! Vdebug_on_interrupt && ! Vdebug_on_error;
15582 52df2e7baabe Disable JIT when breakpoints are present Max Brister <max@2bass.com> parents: 15539 diff changeset	2738 }
52df2e7baabe Disable JIT when breakpoints are present Max Brister <max@2bass.com> parents: 15539 diff changeset	2739
15027 741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	2740 size_t
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	2741 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	2742 {
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	2743 if (bounds.is_range ())
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	2744 {
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	2745 Range rng = bounds.range_value ();
20649 d35201e5ce5d Fix compilation of jit broken by dd6345fd8a97 (bug #46191). Rik <rik@octave.org> parents: 20207 diff changeset	2746 return rng.numel ();
15027 741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	2747 }
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	2748
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	2749 // unsupported type
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	2750 return 0;
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	2751 }
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	2752
20654 b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	2753 #ifdef HAVE_LLVM
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	2754 void
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	2755 tree_jit::optimize (llvm::Function *fn)
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	2756 {
16877 5482cd26311a Rename enable_jit_compiler to jit_enable, enable_jit_debugging to debug_jit. Rik <rik@octave.org> parents: 16768 diff changeset	2757 if (Vdebug_jit)
15385 8ccb187b24e9 Erase partially created functions on JIT compilation failure (bug #37308) Max Brister <max@2bass.com> parents: 15370 diff changeset	2758 llvm::verifyModule (*module);
8ccb187b24e9 Erase partially created functions on JIT compilation failure (bug #37308) Max Brister <max@2bass.com> parents: 15370 diff changeset	2759
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	2760 module_pass_manager->run (*module);
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	2761 pass_manager->run (*fn);
14985 f5925478bc15 More support for complex numbers in JIT Max Brister <max@2bass.com> parents: 14984 diff changeset	2762
16877 5482cd26311a Rename enable_jit_compiler to jit_enable, enable_jit_debugging to debug_jit. Rik <rik@octave.org> parents: 16768 diff changeset	2763 if (Vdebug_jit)
15346 6bdf379592d9 Remove --enable-jit-debug configure option Max Brister <max@2bass.com> parents: 15339 diff changeset	2764 {
6bdf379592d9 Remove --enable-jit-debug configure option Max Brister <max@2bass.com> parents: 15339 diff changeset	2765 std::string error;
18840 4a4edf0f2077 fix LLVM 3.4 build (bug #41061) Stefan Mahr <dac922@gmx.de> parents: 18726 diff changeset	2766 #ifdef RAW_FD_OSTREAM_ARG_IS_LLVM_SYS_FS
4a4edf0f2077 fix LLVM 3.4 build (bug #41061) Stefan Mahr <dac922@gmx.de> parents: 18726 diff changeset	2767 llvm::raw_fd_ostream fout ("test.bc", error,
4a4edf0f2077 fix LLVM 3.4 build (bug #41061) Stefan Mahr <dac922@gmx.de> parents: 18726 diff changeset	2768 llvm::sys::fs::F_Binary);
4a4edf0f2077 fix LLVM 3.4 build (bug #41061) Stefan Mahr <dac922@gmx.de> parents: 18726 diff changeset	2769 #else
15346 6bdf379592d9 Remove --enable-jit-debug configure option Max Brister <max@2bass.com> parents: 15339 diff changeset	2770 llvm::raw_fd_ostream fout ("test.bc", error,
6bdf379592d9 Remove --enable-jit-debug configure option Max Brister <max@2bass.com> parents: 15339 diff changeset	2771 llvm::raw_fd_ostream::F_Binary);
18840 4a4edf0f2077 fix LLVM 3.4 build (bug #41061) Stefan Mahr <dac922@gmx.de> parents: 18726 diff changeset	2772 #endif
15346 6bdf379592d9 Remove --enable-jit-debug configure option Max Brister <max@2bass.com> parents: 15339 diff changeset	2773 llvm::WriteBitcodeToFile (module, fout);
6bdf379592d9 Remove --enable-jit-debug configure option Max Brister <max@2bass.com> parents: 15339 diff changeset	2774 }
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	2775 }
20654 b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	2776 #endif /* ifdef HAVE_LLVM */
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	2777
15337 3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2778 // -------------------- jit_function_info --------------------
20654 b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	2779 #ifdef HAVE_JIT
15337 3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2780 jit_function_info::jit_function_info (tree_jit& tjit,
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2781 octave_user_function& fcn,
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2782 const octave_value_list& ov_args)
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2783 : argument_types (ov_args.length ()), function (0)
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2784 {
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2785 size_t nargs = ov_args.length ();
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2786 for (size_t i = 0; i < nargs; ++i)
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2787 argument_types[i] = jit_typeinfo::type_of (ov_args(i));
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2788
15385 8ccb187b24e9 Erase partially created functions on JIT compilation failure (bug #37308) Max Brister <max@2bass.com> parents: 15370 diff changeset	2789 jit_function raw_fn;
8ccb187b24e9 Erase partially created functions on JIT compilation failure (bug #37308) Max Brister <max@2bass.com> parents: 15370 diff changeset	2790 jit_function wrapper;
8ccb187b24e9 Erase partially created functions on JIT compilation failure (bug #37308) Max Brister <max@2bass.com> parents: 15370 diff changeset	2791
15337 3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2792 try
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2793 {
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2794 jit_convert conv (fcn, argument_types);
20654 b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	2795
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	2796 if (Vdebug_jit)
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	2797 {
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	2798 jit_block_list& blocks = conv.get_blocks ();
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	2799 blocks.label ();
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	2800 std::cout << "-------------------- Compiling function ";
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	2801 std::cout << "--------------------\n";
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	2802
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	2803 tree_print_code tpc (std::cout);
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	2804 tpc.visit_octave_user_function_header (fcn);
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	2805 tpc.visit_statement_list (*fcn.body ());
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	2806 tpc.visit_octave_user_function_trailer (fcn);
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	2807 blocks.print (std::cout, "octave jit ir");
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	2808 }
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	2809
15337 3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2810 jit_infer infer (conv.get_factory (), conv.get_blocks (),
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2811 conv.get_variable_map ());
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2812 infer.infer ();
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2813
16877 5482cd26311a Rename enable_jit_compiler to jit_enable, enable_jit_debugging to debug_jit. Rik <rik@octave.org> parents: 16768 diff changeset	2814 if (Vdebug_jit)
15337 3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2815 {
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2816 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	2817 blocks.label ();
15337 3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2818 std::cout << "-------------------- Compiling function ";
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2819 std::cout << "--------------------\n";
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2820
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2821 tree_print_code tpc (std::cout);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2822 tpc.visit_octave_user_function_header (fcn);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2823 tpc.visit_statement_list (*fcn.body ());
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2824 tpc.visit_octave_user_function_trailer (fcn);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2825 blocks.print (std::cout, "octave jit ir");
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2826 }
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2827
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2828 jit_factory& factory = conv.get_factory ();
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2829 llvm::Module *module = tjit.get_module ();
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2830 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	2831 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	2832 factory.constants (), fcn,
8ccb187b24e9 Erase partially created functions on JIT compilation failure (bug #37308) Max Brister <max@2bass.com> parents: 15370 diff changeset	2833 argument_types);
15337 3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2834
16877 5482cd26311a Rename enable_jit_compiler to jit_enable, enable_jit_debugging to debug_jit. Rik <rik@octave.org> parents: 16768 diff changeset	2835 if (Vdebug_jit)
15337 3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2836 {
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2837 std::cout << "-------------------- raw function ";
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2838 std::cout << "--------------------\n";
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2839 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	2840 llvm::verifyFunction (*raw_fn.to_llvm ());
15337 3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2841 }
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2842
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2843 std::string wrapper_name = fcn.name () + "_wrapper";
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2844 jit_type *any_t = jit_typeinfo::get_any ();
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2845 std::vector<jit_type *> wrapper_args (1, jit_typeinfo::get_any_ptr ());
20654 b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	2846 wrapper = jit_function (module,
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	2847 #ifdef HAVE_GCCJIT
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	2848 gccjit::context (), // FIXME
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	2849 #endif
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	2850 jit_convention::internal, wrapper_name,
15385 8ccb187b24e9 Erase partially created functions on JIT compilation failure (bug #37308) Max Brister <max@2bass.com> parents: 15370 diff changeset	2851 any_t, wrapper_args);
8ccb187b24e9 Erase partially created functions on JIT compilation failure (bug #37308) Max Brister <max@2bass.com> parents: 15370 diff changeset	2852
15337 3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2853 llvm::BasicBlock *wrapper_body = wrapper.new_block ();
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2854 builder.SetInsertPoint (wrapper_body);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2855
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2856 llvm::Value *wrapper_arg = wrapper.argument (builder, 0);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2857 std::vector<llvm::Value *> raw_args (nargs);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2858 for (size_t i = 0; i < nargs; ++i)
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2859 {
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2860 llvm::Value *arg;
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2861 arg = builder.CreateConstInBoundsGEP1_32 (wrapper_arg, i);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2862 arg = builder.CreateLoad (arg);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2863
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2864 jit_type *arg_type = argument_types[i];
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2865 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	2866 raw_args[i] = cast.call (builder, arg);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2867 }
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2868
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2869 llvm::Value *result = raw_fn.call (builder, raw_args);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2870 if (raw_fn.result ())
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2871 {
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2872 jit_type *raw_result_t = raw_fn.result ();
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2873 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	2874 result = cast.call (builder, result);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2875 }
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2876 else
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2877 {
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2878 llvm::Value *zero = builder.getInt32 (0);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2879 result = builder.CreateBitCast (zero, any_t->to_llvm ());
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2880 }
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2881
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2882 wrapper.do_return (builder, result);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2883
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2884 llvm::Function *llvm_function = wrapper.to_llvm ();
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2885 tjit.optimize (llvm_function);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2886
16877 5482cd26311a Rename enable_jit_compiler to jit_enable, enable_jit_debugging to debug_jit. Rik <rik@octave.org> parents: 16768 diff changeset	2887 if (Vdebug_jit)
15337 3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2888 {
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2889 std::cout << "-------------------- optimized and wrapped ";
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2890 std::cout << "--------------------\n";
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2891 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	2892 llvm::verifyFunction (*llvm_function);
15337 3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2893 }
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2894
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2895 llvm::ExecutionEngine* engine = tjit.get_engine ();
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2896 void *void_fn = engine->getPointerToFunction (llvm_function);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2897 function = reinterpret_cast<jited_function> (void_fn);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2898 }
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2899 catch (const jit_fail_exception& e)
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2900 {
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2901 argument_types.clear ();
15346 6bdf379592d9 Remove --enable-jit-debug configure option Max Brister <max@2bass.com> parents: 15339 diff changeset	2902
16877 5482cd26311a Rename enable_jit_compiler to jit_enable, enable_jit_debugging to debug_jit. Rik <rik@octave.org> parents: 16768 diff changeset	2903 if (Vdebug_jit)
15337 3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2904 {
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2905 if (e.known ())
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2906 std::cout << "jit fail: " << e.what () << std::endl;
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2907 }
15385 8ccb187b24e9 Erase partially created functions on JIT compilation failure (bug #37308) Max Brister <max@2bass.com> parents: 15370 diff changeset	2908
19870 9cf91ecdc6f7 Rename jit_failure_count() to jit_failcnt(). Rik <rik@octave.org> parents: 19731 diff changeset	2909 Vjit_failcnt++;
18321 efa4572997ba jit compiler: Add counter of jit_fail_exceptions to check if jit compilation fails Stefan Mahr <dac922@gmx.de> parents: 17856 diff changeset	2910
15385 8ccb187b24e9 Erase partially created functions on JIT compilation failure (bug #37308) Max Brister <max@2bass.com> parents: 15370 diff changeset	2911 wrapper.erase ();
8ccb187b24e9 Erase partially created functions on JIT compilation failure (bug #37308) Max Brister <max@2bass.com> parents: 15370 diff changeset	2912 raw_fn.erase ();
15337 3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2913 }
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2914 }
20654 b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	2915 #endif /* ifdef HAVE_JIT */
15337 3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2916
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2917 bool
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2918 jit_function_info::execute (const octave_value_list& ov_args,
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2919 octave_value_list& retval) const
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2920 {
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2921 if (! function)
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2922 return false;
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2923
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2924 // 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	2925 size_t nargs = ov_args.length ();
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2926 std::vector<octave_base_value *> args (nargs);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2927 for (size_t i = 0; i < nargs; ++i)
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2928 {
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2929 octave_base_value *obv = ov_args(i).internal_rep ();
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2930 obv->grab ();
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2931 args[i] = obv;
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2932 }
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2933
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2934 octave_base_value *ret = function (&args[0]);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2935 if (ret)
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2936 retval(0) = octave_value (ret);
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2937
15603 44272909d926 Stop JIT on interrupt Max Brister <max@2bass.com> parents: 15602 diff changeset	2938 octave_quit ();
44272909d926 Stop JIT on interrupt Max Brister <max@2bass.com> parents: 15602 diff changeset	2939
15337 3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2940 return true;
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2941 }
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2942
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2943 bool
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2944 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	2945 {
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2946 if (! function)
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2947 return true;
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2948
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2949 size_t nargs = ov_args.length ();
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2950 if (nargs != argument_types.size ())
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2951 return false;
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2952
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2953 for (size_t i = 0; i < nargs; ++i)
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2954 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	2955 return false;
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2956
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2957 return true;
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2958 }
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	2959
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	2960 // -------------------- jit_info --------------------
20654 b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	2961 #ifdef HAVE_LLVM
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	2962 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	2963 : engine (tjit.get_engine ()), function (0), llvm_function (0)
20654 b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	2964 #ifdef HAVE_GCCJIT
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	2965 , gccjit_result (NULL)
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	2966 #endif
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	2967 {
15191 ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2968 compile (tjit, tee);
15027 741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	2969 }
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	2970
15027 741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	2971 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	2972 : engine (tjit.get_engine ()), function (0), llvm_function (0)
20654 b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	2973 #ifdef HAVE_GCCJIT
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	2974 , gccjit_result (NULL)
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	2975 #endif
15027 741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	2976 {
15191 ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	2977 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	2978 }
609dcc297db5 src/pt-jit.cc (jit_info::~jit_info): New function Max Brister <max@2bass.com> parents: 14954 diff changeset	2979
609dcc297db5 src/pt-jit.cc (jit_info::~jit_info): New function Max Brister <max@2bass.com> parents: 14954 diff changeset	2980 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	2981 {
609dcc297db5 src/pt-jit.cc (jit_info::~jit_info): New function Max Brister <max@2bass.com> parents: 14954 diff changeset	2982 if (llvm_function)
609dcc297db5 src/pt-jit.cc (jit_info::~jit_info): New function Max Brister <max@2bass.com> parents: 14954 diff changeset	2983 llvm_function->eraseFromParent ();
20654 b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	2984 #ifdef HAVE_GCCJIT
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	2985 if (gccjit_result)
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	2986 gcc_jit_result_release (gccjit_result);
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	2987 #endif
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	2988 }
20654 b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	2989 #endif
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	2990
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	2991 bool
15027 741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	2992 jit_info::execute (const vmap& extra_vars) const
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	2993 {
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	2994 if (! function)
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	2995 return false;
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	2996
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	2997 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	2998 for (size_t i = 0; i < arguments.size (); ++i)
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	2999 {
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	3000 if (arguments[i].second)
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	3001 {
15027 741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	3002 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	3003 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	3004 obv->grab ();
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	3005 real_arguments[i] = obv;
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	3006 }
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	3007 }
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	3008
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	3009 function (&real_arguments[0]);
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	3010
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	3011 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	3012 {
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	3013 const std::string& name = arguments[i].first;
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	3014
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	3015 // do not store for loop bounds temporary
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	3016 if (name.size () && name[0] != '#')
16442 302157614308 deprecate symbol_table::varref functions John W. Eaton <jwe@octave.org> parents: 16131 diff changeset	3017 symbol_table::assign (arguments[i].first, real_arguments[i]);
15027 741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	3018 }
14910 a8f1e08de8fc Simplified llvm::GenericValue creation Max Brister <max@2bass.com> parents: 14906 diff changeset	3019
15603 44272909d926 Stop JIT on interrupt Max Brister <max@2bass.com> parents: 15602 diff changeset	3020 octave_quit ();
44272909d926 Stop JIT on interrupt Max Brister <max@2bass.com> parents: 15602 diff changeset	3021
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	3022 return true;
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	3023 }
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	3024
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	3025 bool
15027 741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	3026 jit_info::match (const vmap& extra_vars) const
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	3027 {
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	3028 if (! function)
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	3029 return true;
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	3030
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	3031 for (size_t i = 0; i < bounds.size (); ++i)
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	3032 {
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	3033 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	3034 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	3035 jit_type *type = jit_typeinfo::type_of (value);
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	3036
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	3037 // 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	3038 if (type != bounds[i].first)
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	3039 return false;
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	3040 }
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	3041
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	3042 return true;
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	3043 }
15027 741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	3044
20654 b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	3045 #ifdef HAVE_LLVM
15027 741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	3046 void
15191 ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	3047 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	3048 {
15191 ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	3049 try
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	3050 {
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	3051 jit_convert conv (tee, for_bounds);
20654 b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	3052
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	3053 if (Vdebug_jit)
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	3054 {
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	3055 jit_block_list& blocks = conv.get_blocks ();
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	3056 blocks.label ();
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	3057 std::cout << "-------------------- Compiling tree --------------------\n";
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	3058 std::cout << tee.str_print_code () << std::endl;
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	3059 blocks.print (std::cout, "octave jit ir");
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	3060 }
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	3061
15191 ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	3062 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	3063 conv.get_variable_map ());
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	3064
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	3065 infer.infer ();
15346 6bdf379592d9 Remove --enable-jit-debug configure option Max Brister <max@2bass.com> parents: 15339 diff changeset	3066
16877 5482cd26311a Rename enable_jit_compiler to jit_enable, enable_jit_debugging to debug_jit. Rik <rik@octave.org> parents: 16768 diff changeset	3067 if (Vdebug_jit)
15310 b055fc077224 allow jit compiler to be enabled at run-time John W. Eaton <jwe@octave.org> parents: 15245 diff changeset	3068 {
b055fc077224 allow jit compiler to be enabled at run-time John W. Eaton <jwe@octave.org> parents: 15245 diff changeset	3069 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	3070 blocks.label ();
15310 b055fc077224 allow jit compiler to be enabled at run-time John W. Eaton <jwe@octave.org> parents: 15245 diff changeset	3071 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	3072 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	3073 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	3074 }
15191 ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	3075
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	3076 jit_factory& factory = conv.get_factory ();
20654 b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	3077
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	3078 #ifdef HAVE_GCCJIT
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	3079 jit_convert_gcc to_gcc;
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	3080 gccjit_result = to_gcc.convert_loop (infer.get_blocks (),
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	3081 factory.constants ());
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	3082 #endif
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	3083
15191 ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	3084 jit_convert_llvm to_llvm;
15337 3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	3085 llvm_function = to_llvm.convert_loop (tjit.get_module (),
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	3086 infer.get_blocks (),
3f43e9d6d86e JIT compile anonymous functions Max Brister <max@2bass.com> parents: 15334 diff changeset	3087 factory.constants ());
15191 ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	3088 arguments = to_llvm.get_arguments ();
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	3089 bounds = conv.get_bounds ();
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	3090 }
ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	3091 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	3092 {
16877 5482cd26311a Rename enable_jit_compiler to jit_enable, enable_jit_debugging to debug_jit. Rik <rik@octave.org> parents: 16768 diff changeset	3093 if (Vdebug_jit)
15310 b055fc077224 allow jit compiler to be enabled at run-time John W. Eaton <jwe@octave.org> parents: 15245 diff changeset	3094 {
b055fc077224 allow jit compiler to be enabled at run-time John W. Eaton <jwe@octave.org> parents: 15245 diff changeset	3095 if (e.known ())
b055fc077224 allow jit compiler to be enabled at run-time John W. Eaton <jwe@octave.org> parents: 15245 diff changeset	3096 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	3097 }
18321 efa4572997ba jit compiler: Add counter of jit_fail_exceptions to check if jit compilation fails Stefan Mahr <dac922@gmx.de> parents: 17856 diff changeset	3098
19870 9cf91ecdc6f7 Rename jit_failure_count() to jit_failcnt(). Rik <rik@octave.org> parents: 19731 diff changeset	3099 Vjit_failcnt++;
18321 efa4572997ba jit compiler: Add counter of jit_fail_exceptions to check if jit compilation fails Stefan Mahr <dac922@gmx.de> parents: 17856 diff changeset	3100
15191 ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	3101 }
20654 b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	3102 #ifdef HAVE_GCCJIT
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	3103 if (gccjit_result)
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	3104 {
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	3105 if (Vdebug_jit)
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	3106 {
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	3107 std::cout << "-------------------- gccjit --------------------";
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	3108 void *void_fn = gcc_jit_result_get_code (gccjit_result, "loop");
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	3109 function = reinterpret_cast<jited_function> (void_fn);
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	3110 }
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	3111 printf ("using gccjit function\n");
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	3112 }
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	3113 else
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	3114 #endif
15027 741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	3115 if (llvm_function)
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	3116 {
16877 5482cd26311a Rename enable_jit_compiler to jit_enable, enable_jit_debugging to debug_jit. Rik <rik@octave.org> parents: 16768 diff changeset	3117 if (Vdebug_jit)
15310 b055fc077224 allow jit compiler to be enabled at run-time John W. Eaton <jwe@octave.org> parents: 15245 diff changeset	3118 {
b055fc077224 allow jit compiler to be enabled at run-time John W. Eaton <jwe@octave.org> parents: 15245 diff changeset	3119 std::cout << "-------------------- llvm ir --------------------";
15346 6bdf379592d9 Remove --enable-jit-debug configure option Max Brister <max@2bass.com> parents: 15339 diff changeset	3120 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	3121 llvm::verifyFunction (*llvm_function);
b055fc077224 allow jit compiler to be enabled at run-time John W. Eaton <jwe@octave.org> parents: 15245 diff changeset	3122 }
15191 ed4f4fb78586 Move type inference from jit_convert to jit_infer Max Brister <max@2bass.com> parents: 15182 diff changeset	3123
15027 741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	3124 tjit.optimize (llvm_function);
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	3125
16877 5482cd26311a Rename enable_jit_compiler to jit_enable, enable_jit_debugging to debug_jit. Rik <rik@octave.org> parents: 16768 diff changeset	3126 if (Vdebug_jit)
15310 b055fc077224 allow jit compiler to be enabled at run-time John W. Eaton <jwe@octave.org> parents: 15245 diff changeset	3127 {
b055fc077224 allow jit compiler to be enabled at run-time John W. Eaton <jwe@octave.org> parents: 15245 diff changeset	3128 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	3129 << "--------------------\n";
15346 6bdf379592d9 Remove --enable-jit-debug configure option Max Brister <max@2bass.com> parents: 15339 diff changeset	3130 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	3131 }
15027 741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	3132
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	3133 void *void_fn = engine->getPointerToFunction (llvm_function);
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	3134 function = reinterpret_cast<jited_function> (void_fn);
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	3135 }
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	3136 }
20654 b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	3137 #endif
15027 741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	3138
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	3139 octave_value
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	3140 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	3141 {
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	3142 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	3143 return iter == extra_vars.end () ? symbol_table::varval (vname)
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	3144 : *iter->second;
15027 741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	3145 }
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	3146
20654 b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	3147 #endif /* if HAVE_JIT */
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	3148
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	3149 #if defined (HAVE_JIT)
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	3150 #define UNUSED_WITHOUT_JIT(x) x
18968 770c0d79341b avoid some unused variable warnings if LLVM is not available John W. Eaton <jwe@octave.org> parents: 18840 diff changeset	3151 #else
20654 b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	3152 #define UNUSED_WITHOUT_JIT(x) x GCC_ATTR_UNUSED
18968 770c0d79341b avoid some unused variable warnings if LLVM is not available John W. Eaton <jwe@octave.org> parents: 18840 diff changeset	3153 #endif
770c0d79341b avoid some unused variable warnings if LLVM is not available John W. Eaton <jwe@octave.org> parents: 18840 diff changeset	3154
20654 b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	3155 DEFUN (jit_failcnt, UNUSED_WITHOUT_JIT (args),
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	3156 UNUSED_WITHOUT_JIT (nargout),
18321 efa4572997ba jit compiler: Add counter of jit_fail_exceptions to check if jit compilation fails Stefan Mahr <dac922@gmx.de> parents: 17856 diff changeset	3157 "-- texinfo --\n\
19870 9cf91ecdc6f7 Rename jit_failure_count() to jit_failcnt(). Rik <rik@octave.org> parents: 19731 diff changeset	3158 @deftypefn {Built-in Function} {@var{val} =} jit_failcnt ()\n\
9cf91ecdc6f7 Rename jit_failure_count() to jit_failcnt(). Rik <rik@octave.org> parents: 19731 diff changeset	3159 @deftypefnx {Built-in Function} {@var{old_val} =} jit_failcnt (@var{new_val})\n\
9cf91ecdc6f7 Rename jit_failure_count() to jit_failcnt(). Rik <rik@octave.org> parents: 19731 diff changeset	3160 @deftypefnx {Built-in Function} {} jit_failcnt (@var{new_val}, \"local\")\n\
20207 4f45eaf83908 doc: Update more docstrings to have one sentence summary as first line. Rik <rik@octave.org> parents: 19870 diff changeset	3161 Query or set the internal variable that counts the number of JIT fail\n\
4f45eaf83908 doc: Update more docstrings to have one sentence summary as first line. Rik <rik@octave.org> parents: 19870 diff changeset	3162 exceptions for Octave's JIT compiler.\n\
18321 efa4572997ba jit compiler: Add counter of jit_fail_exceptions to check if jit compilation fails Stefan Mahr <dac922@gmx.de> parents: 17856 diff changeset	3163 \n\
efa4572997ba jit compiler: Add counter of jit_fail_exceptions to check if jit compilation fails Stefan Mahr <dac922@gmx.de> parents: 17856 diff changeset	3164 When called from inside a function with the @qcode{\"local\"} option, the\n\
20207 4f45eaf83908 doc: Update more docstrings to have one sentence summary as first line. Rik <rik@octave.org> parents: 19870 diff changeset	3165 variable is changed locally for the function and any subroutines it calls.\n\
18321 efa4572997ba jit compiler: Add counter of jit_fail_exceptions to check if jit compilation fails Stefan Mahr <dac922@gmx.de> parents: 17856 diff changeset	3166 The original variable value is restored when exiting the function.\n\
efa4572997ba jit compiler: Add counter of jit_fail_exceptions to check if jit compilation fails Stefan Mahr <dac922@gmx.de> parents: 17856 diff changeset	3167 @seealso{jit_enable, jit_startcnt, debug_jit}\n\
efa4572997ba jit compiler: Add counter of jit_fail_exceptions to check if jit compilation fails Stefan Mahr <dac922@gmx.de> parents: 17856 diff changeset	3168 @end deftypefn")
efa4572997ba jit compiler: Add counter of jit_fail_exceptions to check if jit compilation fails Stefan Mahr <dac922@gmx.de> parents: 17856 diff changeset	3169 {
20654 b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	3170 #if defined (HAVE_JIT)
19870 9cf91ecdc6f7 Rename jit_failure_count() to jit_failcnt(). Rik <rik@octave.org> parents: 19731 diff changeset	3171 return SET_INTERNAL_VARIABLE (jit_failcnt);
18321 efa4572997ba jit compiler: Add counter of jit_fail_exceptions to check if jit compilation fails Stefan Mahr <dac922@gmx.de> parents: 17856 diff changeset	3172 #else
19870 9cf91ecdc6f7 Rename jit_failure_count() to jit_failcnt(). Rik <rik@octave.org> parents: 19731 diff changeset	3173 warning ("jit_failcnt: JIT compiling not available in this version of Octave");
18321 efa4572997ba jit compiler: Add counter of jit_fail_exceptions to check if jit compilation fails Stefan Mahr <dac922@gmx.de> parents: 17856 diff changeset	3174 return octave_value ();
efa4572997ba jit compiler: Add counter of jit_fail_exceptions to check if jit compilation fails Stefan Mahr <dac922@gmx.de> parents: 17856 diff changeset	3175 #endif
efa4572997ba jit compiler: Add counter of jit_fail_exceptions to check if jit compilation fails Stefan Mahr <dac922@gmx.de> parents: 17856 diff changeset	3176 }
efa4572997ba jit compiler: Add counter of jit_fail_exceptions to check if jit compilation fails Stefan Mahr <dac922@gmx.de> parents: 17856 diff changeset	3177
20654 b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	3178 DEFUN (debug_jit, UNUSED_WITHOUT_JIT (args),
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	3179 UNUSED_WITHOUT_JIT (nargout),
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	3180 "-- texinfo --\n\
16877 5482cd26311a Rename enable_jit_compiler to jit_enable, enable_jit_debugging to debug_jit. Rik <rik@octave.org> parents: 16768 diff changeset	3181 @deftypefn {Built-in Function} {@var{val} =} debug_jit ()\n\
5482cd26311a Rename enable_jit_compiler to jit_enable, enable_jit_debugging to debug_jit. Rik <rik@octave.org> parents: 16768 diff changeset	3182 @deftypefnx {Built-in Function} {@var{old_val} =} debug_jit (@var{new_val})\n\
5482cd26311a Rename enable_jit_compiler to jit_enable, enable_jit_debugging to debug_jit. Rik <rik@octave.org> parents: 16768 diff changeset	3183 @deftypefnx {Built-in Function} {} debug_jit (@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	3184 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	3185 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	3186 \n\
17281 bc924baa2c4e doc: Add new @qcode macro for code samples which are quoted. Rik <rik@octave.org> parents: 17164 diff changeset	3187 When called from inside a function with the @qcode{\"local\"} option, the\n\
20207 4f45eaf83908 doc: Update more docstrings to have one sentence summary as first line. Rik <rik@octave.org> parents: 19870 diff changeset	3188 variable is changed locally for the function and any subroutines it calls.\n\
17281 bc924baa2c4e doc: Add new @qcode macro for code samples which are quoted. Rik <rik@octave.org> parents: 17164 diff changeset	3189 The original variable value is restored when exiting the function.\n\
16941 e6ddaa65a777 Add new function jit_startcnt to control JIT acceleration. Rik <rik@octave.org> parents: 16930 diff changeset	3190 @seealso{jit_enable, jit_startcnt}\n\
15310 b055fc077224 allow jit compiler to be enabled at run-time John W. Eaton <jwe@octave.org> parents: 15245 diff changeset	3191 @end deftypefn")
b055fc077224 allow jit compiler to be enabled at run-time John W. Eaton <jwe@octave.org> parents: 15245 diff changeset	3192 {
20654 b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	3193 #if defined (HAVE_JIT)
16877 5482cd26311a Rename enable_jit_compiler to jit_enable, enable_jit_debugging to debug_jit. Rik <rik@octave.org> parents: 16768 diff changeset	3194 return SET_INTERNAL_VARIABLE (debug_jit);
15310 b055fc077224 allow jit compiler to be enabled at run-time John W. Eaton <jwe@octave.org> parents: 15245 diff changeset	3195 #else
16877 5482cd26311a Rename enable_jit_compiler to jit_enable, enable_jit_debugging to debug_jit. Rik <rik@octave.org> parents: 16768 diff changeset	3196 warning ("debug_jit: 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	3197 return octave_value ();
b055fc077224 allow jit compiler to be enabled at run-time John W. Eaton <jwe@octave.org> parents: 15245 diff changeset	3198 #endif
b055fc077224 allow jit compiler to be enabled at run-time John W. Eaton <jwe@octave.org> parents: 15245 diff changeset	3199 }
b055fc077224 allow jit compiler to be enabled at run-time John W. Eaton <jwe@octave.org> parents: 15245 diff changeset	3200
20654 b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	3201 DEFUN (jit_enable, UNUSED_WITHOUT_JIT (args),
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	3202 UNUSED_WITHOUT_JIT (nargout),
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	3203 "-- texinfo --\n\
16877 5482cd26311a Rename enable_jit_compiler to jit_enable, enable_jit_debugging to debug_jit. Rik <rik@octave.org> parents: 16768 diff changeset	3204 @deftypefn {Built-in Function} {@var{val} =} jit_enable ()\n\
5482cd26311a Rename enable_jit_compiler to jit_enable, enable_jit_debugging to debug_jit. Rik <rik@octave.org> parents: 16768 diff changeset	3205 @deftypefnx {Built-in Function} {@var{old_val} =} jit_enable (@var{new_val})\n\
5482cd26311a Rename enable_jit_compiler to jit_enable, enable_jit_debugging to debug_jit. Rik <rik@octave.org> parents: 16768 diff changeset	3206 @deftypefnx {Built-in Function} {} jit_enable (@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	3207 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	3208 \n\
17281 bc924baa2c4e doc: Add new @qcode macro for code samples which are quoted. Rik <rik@octave.org> parents: 17164 diff changeset	3209 When called from inside a function with the @qcode{\"local\"} option, the\n\
20207 4f45eaf83908 doc: Update more docstrings to have one sentence summary as first line. Rik <rik@octave.org> parents: 19870 diff changeset	3210 variable is changed locally for the function and any subroutines it calls.\n\
17281 bc924baa2c4e doc: Add new @qcode macro for code samples which are quoted. Rik <rik@octave.org> parents: 17164 diff changeset	3211 The original variable value is restored when exiting the function.\n\
16941 e6ddaa65a777 Add new function jit_startcnt to control JIT acceleration. Rik <rik@octave.org> parents: 16930 diff changeset	3212 @seealso{jit_startcnt, debug_jit}\n\
15310 b055fc077224 allow jit compiler to be enabled at run-time John W. Eaton <jwe@octave.org> parents: 15245 diff changeset	3213 @end deftypefn")
b055fc077224 allow jit compiler to be enabled at run-time John W. Eaton <jwe@octave.org> parents: 15245 diff changeset	3214 {
20654 b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	3215 #if defined (HAVE_JIT)
16877 5482cd26311a Rename enable_jit_compiler to jit_enable, enable_jit_debugging to debug_jit. Rik <rik@octave.org> parents: 16768 diff changeset	3216 return SET_INTERNAL_VARIABLE (jit_enable);
15310 b055fc077224 allow jit compiler to be enabled at run-time John W. Eaton <jwe@octave.org> parents: 15245 diff changeset	3217 #else
16877 5482cd26311a Rename enable_jit_compiler to jit_enable, enable_jit_debugging to debug_jit. Rik <rik@octave.org> parents: 16768 diff changeset	3218 warning ("jit_enable: 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	3219 return octave_value ();
b055fc077224 allow jit compiler to be enabled at run-time John W. Eaton <jwe@octave.org> parents: 15245 diff changeset	3220 #endif
b055fc077224 allow jit compiler to be enabled at run-time John W. Eaton <jwe@octave.org> parents: 15245 diff changeset	3221 }
15014 094bc0a145a1 Take into account different calling conventions Max Brister <max@2bass.com> parents: 14992 diff changeset	3222
20654 b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	3223 DEFUN (jit_startcnt, UNUSED_WITHOUT_JIT (args),
b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	3224 UNUSED_WITHOUT_JIT (nargout),
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	3225 "-- texinfo --\n\
16941 e6ddaa65a777 Add new function jit_startcnt to control JIT acceleration. Rik <rik@octave.org> parents: 16930 diff changeset	3226 @deftypefn {Built-in Function} {@var{val} =} jit_startcnt ()\n\
e6ddaa65a777 Add new function jit_startcnt to control JIT acceleration. Rik <rik@octave.org> parents: 16930 diff changeset	3227 @deftypefnx {Built-in Function} {@var{old_val} =} jit_startcnt (@var{new_val})\n\
e6ddaa65a777 Add new function jit_startcnt to control JIT acceleration. Rik <rik@octave.org> parents: 16930 diff changeset	3228 @deftypefnx {Built-in Function} {} jit_startcnt (@var{new_val}, \"local\")\n\
e6ddaa65a777 Add new function jit_startcnt to control JIT acceleration. Rik <rik@octave.org> parents: 16930 diff changeset	3229 Query or set the internal variable that determines whether JIT compilation\n\
20207 4f45eaf83908 doc: Update more docstrings to have one sentence summary as first line. Rik <rik@octave.org> parents: 19870 diff changeset	3230 will take place for a specific loop.\n\
4f45eaf83908 doc: Update more docstrings to have one sentence summary as first line. Rik <rik@octave.org> parents: 19870 diff changeset	3231 \n\
4f45eaf83908 doc: Update more docstrings to have one sentence summary as first line. Rik <rik@octave.org> parents: 19870 diff changeset	3232 Because compilation is a costly operation it does not make sense to employ\n\
4f45eaf83908 doc: Update more docstrings to have one sentence summary as first line. Rik <rik@octave.org> parents: 19870 diff changeset	3233 JIT when the loop count is low. By default only loops with greater than\n\
4f45eaf83908 doc: Update more docstrings to have one sentence summary as first line. Rik <rik@octave.org> parents: 19870 diff changeset	3234 1000 iterations will be accelerated.\n\
16941 e6ddaa65a777 Add new function jit_startcnt to control JIT acceleration. Rik <rik@octave.org> parents: 16930 diff changeset	3235 \n\
17281 bc924baa2c4e doc: Add new @qcode macro for code samples which are quoted. Rik <rik@octave.org> parents: 17164 diff changeset	3236 When called from inside a function with the @qcode{\"local\"} option, the\n\
20207 4f45eaf83908 doc: Update more docstrings to have one sentence summary as first line. Rik <rik@octave.org> parents: 19870 diff changeset	3237 variable is changed locally for the function and any subroutines it calls.\n\
17281 bc924baa2c4e doc: Add new @qcode macro for code samples which are quoted. Rik <rik@octave.org> parents: 17164 diff changeset	3238 The original variable value is restored when exiting the function.\n\
20207 4f45eaf83908 doc: Update more docstrings to have one sentence summary as first line. Rik <rik@octave.org> parents: 19870 diff changeset	3239 @seealso{jit_enable, jit_failcnt, debug_jit}\n\
16941 e6ddaa65a777 Add new function jit_startcnt to control JIT acceleration. Rik <rik@octave.org> parents: 16930 diff changeset	3240 @end deftypefn")
e6ddaa65a777 Add new function jit_startcnt to control JIT acceleration. Rik <rik@octave.org> parents: 16930 diff changeset	3241 {
20654 b65888ec820e dmalcom gcc jit import Stefan Mahr <dac922@gmx.de> parents: 20649 diff changeset	3242 #if defined (HAVE_JIT)
16941 e6ddaa65a777 Add new function jit_startcnt to control JIT acceleration. Rik <rik@octave.org> parents: 16930 diff changeset	3243 return SET_INTERNAL_VARIABLE_WITH_LIMITS (jit_startcnt, 1,
e6ddaa65a777 Add new function jit_startcnt to control JIT acceleration. Rik <rik@octave.org> parents: 16930 diff changeset	3244 std::numeric_limits<int>::max ());
e6ddaa65a777 Add new function jit_startcnt to control JIT acceleration. Rik <rik@octave.org> parents: 16930 diff changeset	3245 #else
e6ddaa65a777 Add new function jit_startcnt to control JIT acceleration. Rik <rik@octave.org> parents: 16930 diff changeset	3246 warning ("jit_enable: JIT compiling not available in this version of Octave");
e6ddaa65a777 Add new function jit_startcnt to control JIT acceleration. Rik <rik@octave.org> parents: 16930 diff changeset	3247 return octave_value ();
e6ddaa65a777 Add new function jit_startcnt to control JIT acceleration. Rik <rik@octave.org> parents: 16930 diff changeset	3248 #endif
e6ddaa65a777 Add new function jit_startcnt to control JIT acceleration. Rik <rik@octave.org> parents: 16930 diff changeset	3249 }

Mercurial > octave-nkf

annotate libinterp/corefcn/pt-jit.cc @ 20654:b65888ec820e draft default tip gccjit