octave-nkf: src/pt-jit.h annotate

annotate src/pt-jit.h @ 14946:3564bb141396

Only add items to worklist in type inferece if not already there

author	Max Brister <max@2bass.com>
date	Sat, 09 Jun 2012 10:23:28 -0500
parents	591aeec5c520
children	006570a76b90

rev	line source
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	1 /*
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	2
14901 516b4a15b775 doc: Copyright fix in pt-jit.h and pt-jit.cc Max Brister <max@2bass.com> parents: 14899 diff changeset	3 Copyright (C) 2012 Max Brister <max@2bass.com>
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	4
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	5 This file is part of Octave.
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	6
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	7 Octave is free software; you can redistribute it and/or modify it
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	8 under the terms of the GNU General Public License as published by the
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	9 Free Software Foundation; either version 3 of the License, or (at your
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	10 option) any later version.
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	11
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	12 Octave is distributed in the hope that it will be useful, but WITHOUT
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	13 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	15 for more details.
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	16
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	17 You should have received a copy of the GNU General Public License
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	18 along with Octave; see the file COPYING. If not, see
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	19 <http://www.gnu.org/licenses/>.
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	20
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	21 */
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	22
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	23 #if !defined (octave_tree_jit_h)
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	24 #define octave_tree_jit_h 1
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	25
14932 1f914446157d Locate and link with LLVM properly Max Brister <max@2bass.com> parents: 14928 diff changeset	26 #ifdef HAVE_LLVM
1f914446157d Locate and link with LLVM properly Max Brister <max@2bass.com> parents: 14928 diff changeset	27
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	28 #include <list>
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	29 #include <map>
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	30 #include <set>
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	31 #include <stdexcept>
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	32 #include <vector>
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	33 #include <stack>
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	34
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	35 #include "Array.h"
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	36 #include "Range.h"
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	37 #include "pt-walk.h"
14913 c7071907a641 Use symbol_record_ref instead of names in JIT Max Brister <max@2bass.com> parents: 14911 diff changeset	38 #include "symtab.h"
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	39
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	40 // -------------------- Current status --------------------
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	41 // Simple binary operations (+-*/) on octave_scalar's (doubles) are optimized.
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	42 // However, there is no warning emitted on divide by 0. For example,
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	43 // a = 5;
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	44 // b = a * 5 + a;
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	45 //
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	46 // For other types all binary operations are compiled but not optimized. For
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	47 // example,
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	48 // a = [1 2 3]
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	49 // b = a + a;
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	50 // will compile to do_binary_op (a, a).
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	51 //
14923 168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	52 // For loops are compiled again!
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	53 // if, elseif, and else statements compile again!
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	54 // break and continue now work!
14923 168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	55 // Additionally, make check passes using jit.
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	56 //
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	57 // The octave low level IR is a linear IR, it works by converting everything to
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	58 // calls to jit_functions. This turns expressions like c = a + b into
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	59 // c = call binary+ (a, b)
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	60 // The jit_functions contain information about overloads for differnt types. For
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	61 // example, if we know a and b are scalars, then c must also be a scalar.
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	62 //
14915 cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	63 //
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	64 // TODO:
14937 78e1457c5bf5 Remove some macros from pt-jit.h and pt-jit.cc Max Brister <max@2bass.com> parents: 14936 diff changeset	65 // 1. Support error cases
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	66 // 2. Support some simple matrix case (and cleanup Octave low level IR)
14937 78e1457c5bf5 Remove some macros from pt-jit.h and pt-jit.cc Max Brister <max@2bass.com> parents: 14936 diff changeset	67 // 3. Fix memory leaks in JIT
78e1457c5bf5 Remove some macros from pt-jit.h and pt-jit.cc Max Brister <max@2bass.com> parents: 14936 diff changeset	68 // 4. Cleanup/documentation
78e1457c5bf5 Remove some macros from pt-jit.h and pt-jit.cc Max Brister <max@2bass.com> parents: 14936 diff changeset	69 // 5. ...
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	70 // ---------------------------------------------------------
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	71
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	72
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	73 // we don't want to include llvm headers here, as they require __STDC_LIMIT_MACROS
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	74 // and __STDC_CONSTANT_MACROS be defined in the entire compilation unit
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	75 namespace llvm
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	76 {
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	77 class Value;
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	78 class Module;
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	79 class FunctionPassManager;
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	80 class PassManager;
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	81 class ExecutionEngine;
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	82 class Function;
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	83 class BasicBlock;
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	84 class LLVMContext;
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	85 class Type;
14915 cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	86 class Twine;
14938 bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	87 class GlobalVariable;
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	88 }
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	89
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	90 class octave_base_value;
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	91 class octave_value;
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	92 class tree;
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	93
14937 78e1457c5bf5 Remove some macros from pt-jit.h and pt-jit.cc Max Brister <max@2bass.com> parents: 14936 diff changeset	94 // Use like: isa<jit_phi> (value)
78e1457c5bf5 Remove some macros from pt-jit.h and pt-jit.cc Max Brister <max@2bass.com> parents: 14936 diff changeset	95 // basically just a short cut type typing dyanmic_cast.
78e1457c5bf5 Remove some macros from pt-jit.h and pt-jit.cc Max Brister <max@2bass.com> parents: 14936 diff changeset	96 template <typename T, typename U>
78e1457c5bf5 Remove some macros from pt-jit.h and pt-jit.cc Max Brister <max@2bass.com> parents: 14936 diff changeset	97 bool isa (U *value)
78e1457c5bf5 Remove some macros from pt-jit.h and pt-jit.cc Max Brister <max@2bass.com> parents: 14936 diff changeset	98 {
78e1457c5bf5 Remove some macros from pt-jit.h and pt-jit.cc Max Brister <max@2bass.com> parents: 14936 diff changeset	99 return dynamic_cast<T *> (value);
78e1457c5bf5 Remove some macros from pt-jit.h and pt-jit.cc Max Brister <max@2bass.com> parents: 14936 diff changeset	100 }
78e1457c5bf5 Remove some macros from pt-jit.h and pt-jit.cc Max Brister <max@2bass.com> parents: 14936 diff changeset	101
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	102 // jit_range is compatable with the llvm range structure
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	103 struct
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	104 jit_range
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	105 {
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	106 jit_range (const Range& from) : base (from.base ()), limit (from.limit ()),
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	107 inc (from.inc ()), nelem (from.nelem ())
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	108 {}
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	109
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	110 operator Range () const
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	111 {
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	112 return Range (base, limit, inc);
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	113 }
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	114
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	115 double base;
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	116 double limit;
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	117 double inc;
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	118 octave_idx_type nelem;
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	119 };
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	120
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	121 std::ostream& operator<< (std::ostream& os, const jit_range& rng);
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	122
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	123 // Used to keep track of estimated (infered) types during JIT. This is a
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	124 // hierarchical type system which includes both concrete and abstract types.
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	125 //
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	126 // Current, we only support any and scalar types. If we can't figure out what
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	127 // type a variable is, we assign it the any type. This allows us to generate
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	128 // code even for the case of poor type inference.
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	129 class
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	130 jit_type
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	131 {
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	132 public:
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	133 jit_type (const std::string& aname, jit_type aparent, llvm::Type allvm_type,
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	134 int aid) :
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	135 mname (aname), mparent (aparent), llvm_type (allvm_type), mid (aid),
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	136 mdepth (aparent ? aparent->mdepth + 1 : 0)
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	137 {}
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	138
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	139 // a user readable type name
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	140 const std::string& name (void) const { return mname; }
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	141
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	142 // a unique id for the type
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	143 int type_id (void) const { return mid; }
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	144
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	145 // An abstract base type, may be null
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	146 jit_type *parent (void) const { return mparent; }
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	147
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	148 // convert to an llvm type
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	149 llvm::Type *to_llvm (void) const { return llvm_type; }
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	150
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	151 // how this type gets passed as a function argument
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	152 llvm::Type *to_llvm_arg (void) const;
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	153
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	154 size_t depth (void) const { return mdepth; }
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	155 private:
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	156 std::string mname;
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	157 jit_type *mparent;
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	158 llvm::Type *llvm_type;
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	159 int mid;
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	160 size_t mdepth;
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	161 };
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	162
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	163 // seperate print function to allow easy printing if type is null
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	164 std::ostream& jit_print (std::ostream& os, jit_type *atype);
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	165
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	166 // Keeps track of overloads for a builtin function. Used for both type inference
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	167 // and code generation.
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	168 class
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	169 jit_function
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	170 {
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	171 public:
14935 5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	172 struct
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	173 overload
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	174 {
14945 591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	175 overload (void) : function (0), can_error (false), result (0) {}
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	176
14945 591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	177 overload (llvm::Function f, bool e, jit_type r, jit_type *arg0) :
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	178 function (f), can_error (e), result (r), arguments (1)
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	179 {
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	180 arguments[0] = arg0;
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	181 }
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	182
14945 591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	183 overload (llvm::Function f, bool e, jit_type r, jit_type *arg0,
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	184 jit_type *arg1) : function (f), can_error (e),
14935 5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	185 result (r), arguments (2)
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	186 {
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	187 arguments[0] = arg0;
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	188 arguments[1] = arg1;
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	189 }
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	190
14945 591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	191 overload (llvm::Function f, bool e, jit_type r, jit_type *arg0,
14936 32deb562ae77 Allow for construction of ranges during jit Max Brister <max@2bass.com> parents: 14935 diff changeset	192 jit_type arg1, jit_type arg2) : function (f), can_error (e),
14945 591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	193 result (r), arguments (3)
14936 32deb562ae77 Allow for construction of ranges during jit Max Brister <max@2bass.com> parents: 14935 diff changeset	194 {
32deb562ae77 Allow for construction of ranges during jit Max Brister <max@2bass.com> parents: 14935 diff changeset	195 arguments[0] = arg0;
32deb562ae77 Allow for construction of ranges during jit Max Brister <max@2bass.com> parents: 14935 diff changeset	196 arguments[1] = arg1;
32deb562ae77 Allow for construction of ranges during jit Max Brister <max@2bass.com> parents: 14935 diff changeset	197 arguments[2] = arg2;
32deb562ae77 Allow for construction of ranges during jit Max Brister <max@2bass.com> parents: 14935 diff changeset	198 }
32deb562ae77 Allow for construction of ranges during jit Max Brister <max@2bass.com> parents: 14935 diff changeset	199
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	200 llvm::Function *function;
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	201 bool can_error;
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	202 jit_type *result;
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	203 std::vector<jit_type*> arguments;
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	204 };
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	205
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	206 void add_overload (const overload& func)
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	207 {
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	208 add_overload (func, func.arguments);
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	209 }
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	210
14945 591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	211 void add_overload (llvm::Function f, bool e, jit_type r, jit_type *arg0)
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	212 {
14945 591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	213 overload ol (f, e, r, arg0);
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	214 add_overload (ol);
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	215 }
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	216
14945 591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	217 void add_overload (llvm::Function f, bool e, jit_type r, jit_type *arg0,
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	218 jit_type *arg1)
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	219 {
14945 591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	220 overload ol (f, e, r, arg0, arg1);
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	221 add_overload (ol);
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	222 }
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	223
14945 591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	224 void add_overload (llvm::Function f, bool e, jit_type r, jit_type *arg0,
14936 32deb562ae77 Allow for construction of ranges during jit Max Brister <max@2bass.com> parents: 14935 diff changeset	225 jit_type arg1, jit_type arg2)
32deb562ae77 Allow for construction of ranges during jit Max Brister <max@2bass.com> parents: 14935 diff changeset	226 {
14945 591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	227 overload ol (f, e, r, arg0, arg1, arg2);
14936 32deb562ae77 Allow for construction of ranges during jit Max Brister <max@2bass.com> parents: 14935 diff changeset	228 add_overload (ol);
32deb562ae77 Allow for construction of ranges during jit Max Brister <max@2bass.com> parents: 14935 diff changeset	229 }
32deb562ae77 Allow for construction of ranges during jit Max Brister <max@2bass.com> parents: 14935 diff changeset	230
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	231 void add_overload (const overload& func,
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	232 const std::vector<jit_type*>& args);
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	233
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	234 const overload& get_overload (const std::vector<jit_type *>& types) const;
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	235
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	236 const overload& get_overload (jit_type *arg0) const
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	237 {
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	238 std::vector<jit_type *> types (1);
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	239 types[0] = arg0;
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	240 return get_overload (types);
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	241 }
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	242
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	243 const overload& get_overload (jit_type arg0, jit_type arg1) const
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	244 {
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	245 std::vector<jit_type *> types (2);
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	246 types[0] = arg0;
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	247 types[1] = arg1;
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	248 return get_overload (types);
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	249 }
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 jit_type get_result (const std::vector<jit_type >& types) const
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	252 {
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	253 const overload& temp = get_overload (types);
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	254 return temp.result;
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	255 }
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 jit_type get_result (jit_type arg0, jit_type *arg1) const
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	258 {
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	259 const overload& temp = get_overload (arg0, arg1);
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	260 return temp.result;
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	261 }
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	262
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	263 const std::string& name (void) const { return mname; }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	264
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	265 void stash_name (const std::string& aname) { mname = aname; }
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	266 private:
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	267 Array<octave_idx_type> to_idx (const std::vector<jit_type*>& types) const;
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	268
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	269 std::vector<Array<overload> > overloads;
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	270
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	271 std::string mname;
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	272 };
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	273
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	274 // Get information and manipulate jit types.
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	275 class
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	276 jit_typeinfo
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	277 {
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	278 public:
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	279 static void initialize (llvm::Module m, llvm::ExecutionEngine e);
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	280
14922 2e6f83b2f2b9 Cleanup of some type inference functions Max Brister <max@2bass.com> parents: 14920 diff changeset	281 static jit_type join (jit_type lhs, jit_type *rhs)
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	282 {
14922 2e6f83b2f2b9 Cleanup of some type inference functions Max Brister <max@2bass.com> parents: 14920 diff changeset	283 return instance->do_join (lhs, rhs);
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	284 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	285
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	286 static jit_type *get_any (void) { return instance->any; }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	287
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	288 static jit_type *get_scalar (void) { return instance->scalar; }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	289
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	290 static llvm::Type *get_scalar_llvm (void) { return instance->scalar->to_llvm (); }
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	291
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	292 static jit_type *get_range (void) { return instance->range; }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	293
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	294 static jit_type *get_string (void) { return instance->string; }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	295
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	296 static jit_type *get_bool (void) { return instance->boolean; }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	297
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	298 static jit_type *get_index (void) { return instance->index; }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	299
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	300 static llvm::Type *get_index_llvm (void) { return instance->index->to_llvm (); }
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	301
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	302 static jit_type *type_of (const octave_value& ov)
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	303 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	304 return instance->do_type_of (ov);
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	305 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	306
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	307 static const jit_function& binary_op (int op)
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	308 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	309 return instance->do_binary_op (op);
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	310 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	311
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	312 static const jit_function& grab (void) { return instance->grab_fn; }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	313
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	314 static const jit_function& release (void)
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	315 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	316 return instance->release_fn;
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	317 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	318
14935 5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	319 static const jit_function::overload& get_release (jit_type *type)
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	320 {
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	321 return instance->release_fn.get_overload (type);
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	322 }
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	323
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	324 static const jit_function& print_value (void)
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	325 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	326 return instance->print_fn;
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	327 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	328
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	329 static const jit_function& for_init (void)
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	330 {
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	331 return instance->for_init_fn;
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	332 }
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	333
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	334 static const jit_function& for_check (void)
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	335 {
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	336 return instance->for_check_fn;
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	337 }
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	338
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	339 static const jit_function& for_index (void)
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	340 {
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	341 return instance->for_index_fn;
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	342 }
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	343
14936 32deb562ae77 Allow for construction of ranges during jit Max Brister <max@2bass.com> parents: 14935 diff changeset	344 static const jit_function& make_range (void)
32deb562ae77 Allow for construction of ranges during jit Max Brister <max@2bass.com> parents: 14935 diff changeset	345 {
32deb562ae77 Allow for construction of ranges during jit Max Brister <max@2bass.com> parents: 14935 diff changeset	346 return instance->make_range_fn;
32deb562ae77 Allow for construction of ranges during jit Max Brister <max@2bass.com> parents: 14935 diff changeset	347 }
32deb562ae77 Allow for construction of ranges during jit Max Brister <max@2bass.com> parents: 14935 diff changeset	348
14943 8efcaf5aa233 Prevent crash when using scalars as conditionals Max Brister <max@2bass.com> parents: 14942 diff changeset	349 static const jit_function& logically_true (void)
8efcaf5aa233 Prevent crash when using scalars as conditionals Max Brister <max@2bass.com> parents: 14942 diff changeset	350 {
8efcaf5aa233 Prevent crash when using scalars as conditionals Max Brister <max@2bass.com> parents: 14942 diff changeset	351 return instance->logically_true_fn;
8efcaf5aa233 Prevent crash when using scalars as conditionals Max Brister <max@2bass.com> parents: 14942 diff changeset	352 }
8efcaf5aa233 Prevent crash when using scalars as conditionals Max Brister <max@2bass.com> parents: 14942 diff changeset	353
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	354 static const jit_function& cast (jit_type *result)
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	355 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	356 return instance->do_cast (result);
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	357 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	358
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	359 static const jit_function::overload& cast (jit_type to, jit_type from)
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	360 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	361 return instance->do_cast (to, from);
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	362 }
14938 bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	363
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	364 static llvm::Value *insert_error_check (void)
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	365 {
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	366 return instance->do_insert_error_check ();
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	367 }
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	368 private:
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	369 jit_typeinfo (llvm::Module m, llvm::ExecutionEngine e);
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	370
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	371 // FIXME: Do these methods really need to be in jit_typeinfo?
14922 2e6f83b2f2b9 Cleanup of some type inference functions Max Brister <max@2bass.com> parents: 14920 diff changeset	372 jit_type do_join (jit_type lhs, jit_type *rhs)
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	373 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	374 // empty case
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	375 if (! lhs)
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	376 return rhs;
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	377
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	378 if (! rhs)
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	379 return lhs;
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	380
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	381 // check for a shared parent
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	382 while (lhs != rhs)
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	383 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	384 if (lhs->depth () > rhs->depth ())
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	385 lhs = lhs->parent ();
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	386 else if (lhs->depth () < rhs->depth ())
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	387 rhs = rhs->parent ();
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	388 else
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	389 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	390 // we MUST have depth > 0 as any is the base type of everything
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	391 do
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	392 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	393 lhs = lhs->parent ();
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	394 rhs = rhs->parent ();
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	395 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	396 while (lhs != rhs);
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	397 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	398 }
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	399
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	400 return lhs;
14915 cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	401 }
cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	402
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	403 jit_type do_difference (jit_type lhs, jit_type *)
14915 cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	404 {
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	405 // FIXME: Maybe we can do something smarter?
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	406 return lhs;
14915 cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	407 }
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	408
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	409 jit_type *do_type_of (const octave_value &ov) const;
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	410
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	411 const jit_function& do_binary_op (int op) const
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	412 {
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	413 assert (static_cast<size_t>(op) < binary_ops.size ());
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	414 return binary_ops[op];
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	415 }
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	416
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	417 const jit_function& do_cast (jit_type *to)
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	418 {
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	419 static jit_function null_function;
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	420 if (! to)
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	421 return null_function;
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	422
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	423 size_t id = to->type_id ();
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	424 if (id >= casts.size ())
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	425 return null_function;
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	426 return casts[id];
14915 cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	427 }
cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	428
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	429 const jit_function::overload& do_cast (jit_type to, jit_type from)
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	430 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	431 return do_cast (to).get_overload (from);
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	432 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	433
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	434 jit_type new_type (const std::string& name, jit_type parent,
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	435 llvm::Type *llvm_type);
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	436
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	437
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	438 void add_print (jit_type ty, void call);
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	439
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	440 void add_binary_op (jit_type *ty, int op, int llvm_op);
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	441
14915 cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	442 void add_binary_icmp (jit_type *ty, int op, int llvm_op);
cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	443
cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	444 void add_binary_fcmp (jit_type *ty, int op, int llvm_op);
cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	445
14941 1e3d0366ac8b warn on divide by zero Max Brister <max@2bass.com> parents: 14939 diff changeset	446 llvm::Function create_function (const llvm::Twine& name, llvm::Type ret)
1e3d0366ac8b warn on divide by zero Max Brister <max@2bass.com> parents: 14939 diff changeset	447 {
1e3d0366ac8b warn on divide by zero Max Brister <max@2bass.com> parents: 14939 diff changeset	448 std::vector<llvm::Type *> args;
1e3d0366ac8b warn on divide by zero Max Brister <max@2bass.com> parents: 14939 diff changeset	449 return create_function (name, ret, args);
1e3d0366ac8b warn on divide by zero Max Brister <max@2bass.com> parents: 14939 diff changeset	450 }
1e3d0366ac8b warn on divide by zero Max Brister <max@2bass.com> parents: 14939 diff changeset	451
14915 cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	452 llvm::Function create_function (const llvm::Twine& name, llvm::Type ret,
cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	453 llvm::Type *arg0)
cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	454 {
cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	455 std::vector<llvm::Type *> args (1, arg0);
cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	456 return create_function (name, ret, args);
cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	457 }
cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	458
cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	459 llvm::Function create_function (const llvm::Twine& name, jit_type ret,
cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	460 jit_type *arg0)
cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	461 {
cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	462 return create_function (name, ret->to_llvm (), arg0->to_llvm ());
cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	463 }
cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	464
cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	465 llvm::Function create_function (const llvm::Twine& name, llvm::Type ret,
cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	466 llvm::Type arg0, llvm::Type arg1)
cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	467 {
cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	468 std::vector<llvm::Type *> args (2);
cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	469 args[0] = arg0;
cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	470 args[1] = arg1;
cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	471 return create_function (name, ret, args);
cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	472 }
cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	473
cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	474 llvm::Function create_function (const llvm::Twine& name, jit_type ret,
cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	475 jit_type arg0, jit_type arg1)
cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	476 {
cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	477 return create_function (name, ret->to_llvm (), arg0->to_llvm (),
cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	478 arg1->to_llvm ());
cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	479 }
cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	480
cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	481 llvm::Function create_function (const llvm::Twine& name, llvm::Type ret,
cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	482 llvm::Type arg0, llvm::Type arg1,
cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	483 llvm::Type *arg2)
cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	484 {
cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	485 std::vector<llvm::Type *> args (3);
cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	486 args[0] = arg0;
cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	487 args[1] = arg1;
cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	488 args[2] = arg2;
cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	489 return create_function (name, ret, args);
cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	490 }
cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	491
cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	492 llvm::Function create_function (const llvm::Twine& name, jit_type ret,
cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	493 jit_type arg0, jit_type arg1,
cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	494 jit_type *arg2)
cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	495 {
cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	496 return create_function (name, ret->to_llvm (), arg0->to_llvm (),
cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	497 arg1->to_llvm (), arg2->to_llvm ());
cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	498 }
cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	499
cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	500 llvm::Function create_function (const llvm::Twine& name, llvm::Type ret,
cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	501 const std::vector<llvm::Type *>& args);
cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	502
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	503 llvm::Function create_identity (jit_type type);
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	504
14938 bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	505 llvm::Value *do_insert_error_check (void);
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	506
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	507 static jit_typeinfo *instance;
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	508
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	509 llvm::Module *module;
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	510 llvm::ExecutionEngine *engine;
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	511 int next_id;
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	512
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	513 llvm::Type *ov_t;
14938 bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	514 llvm::GlobalVariable *lerror_state;
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	515
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	516 std::vector<jit_type*> id_to_type;
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	517 jit_type *any;
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	518 jit_type *scalar;
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	519 jit_type *range;
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	520 jit_type *string;
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	521 jit_type *boolean;
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	522 jit_type *index;
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	523
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	524 std::vector<jit_function> binary_ops;
14915 cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	525 jit_function grab_fn;
cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	526 jit_function release_fn;
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	527 jit_function print_fn;
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	528 jit_function for_init_fn;
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	529 jit_function for_check_fn;
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	530 jit_function for_index_fn;
14943 8efcaf5aa233 Prevent crash when using scalars as conditionals Max Brister <max@2bass.com> parents: 14942 diff changeset	531 jit_function logically_true_fn;
14936 32deb562ae77 Allow for construction of ranges during jit Max Brister <max@2bass.com> parents: 14935 diff changeset	532 jit_function make_range_fn;
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	533
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	534 // type id -> cast function TO that type
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	535 std::vector<jit_function> casts;
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	536
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	537 // type id -> identity function
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	538 std::vector<llvm::Function *> identities;
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	539 };
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	540
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	541 // The low level octave jit ir
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	542 // this ir is close to llvm, but contains information for doing type inference.
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	543 // We convert the octave parse tree to this IR directly.
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	544
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	545 #define JIT_VISIT_IR_NOTEMPLATE \
14938 bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	546 JIT_METH(block); \
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	547 JIT_METH(break); \
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	548 JIT_METH(cond_break); \
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	549 JIT_METH(call); \
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	550 JIT_METH(extract_argument); \
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	551 JIT_METH(store_argument); \
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	552 JIT_METH(phi); \
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	553 JIT_METH(variable); \
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	554 JIT_METH(check_error); \
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	555 JIT_METH(assign)
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	556
14935 5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	557 #define JIT_VISIT_IR_CONST \
14938 bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	558 JIT_METH(const_scalar); \
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	559 JIT_METH(const_index); \
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	560 JIT_METH(const_string); \
14935 5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	561 JIT_METH(const_range)
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	562
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	563 #define JIT_VISIT_IR_CLASSES \
14935 5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	564 JIT_VISIT_IR_NOTEMPLATE \
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	565 JIT_VISIT_IR_CONST
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	566
14935 5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	567 // forward declare all ir classes
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	568 #define JIT_METH(cname) \
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	569 class jit_ ## cname;
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	570
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	571 JIT_VISIT_IR_NOTEMPLATE
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	572
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	573 #undef JIT_METH
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	574
14937 78e1457c5bf5 Remove some macros from pt-jit.h and pt-jit.cc Max Brister <max@2bass.com> parents: 14936 diff changeset	575 // ABCs which aren't included in JIT_VISIT_IR_ALL
78e1457c5bf5 Remove some macros from pt-jit.h and pt-jit.cc Max Brister <max@2bass.com> parents: 14936 diff changeset	576 class jit_instruction;
78e1457c5bf5 Remove some macros from pt-jit.h and pt-jit.cc Max Brister <max@2bass.com> parents: 14936 diff changeset	577 class jit_terminator;
78e1457c5bf5 Remove some macros from pt-jit.h and pt-jit.cc Max Brister <max@2bass.com> parents: 14936 diff changeset	578
14935 5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	579 template <typename T, jit_type (EXTRACT_T)(void), typename PASS_T = T,
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	580 bool QUOTE=false>
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	581 class jit_const;
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	582
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	583 typedef jit_const<double, jit_typeinfo::get_scalar> jit_const_scalar;
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	584 typedef jit_const<octave_idx_type, jit_typeinfo::get_index> jit_const_index;
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	585
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	586 typedef jit_const<std::string, jit_typeinfo::get_string, const std::string&, true>
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	587 jit_const_string;
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	588 typedef jit_const<jit_range, jit_typeinfo::get_range, const jit_range&>
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	589 jit_const_range;
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	590
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	591 class jit_ir_walker;
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	592 class jit_use;
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	593
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	594 class
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	595 jit_value
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	596 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	597 friend class jit_use;
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	598 public:
14945 591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	599 jit_value (void) : llvm_value (0), ty (0), use_head (0), use_tail (0),
14946 3564bb141396 Only add items to worklist in type inferece if not already there Max Brister <max@2bass.com> parents: 14945 diff changeset	600 myuse_count (0), mlast_use (0),
3564bb141396 Only add items to worklist in type inferece if not already there Max Brister <max@2bass.com> parents: 14945 diff changeset	601 min_worklist (false) {}
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	602
14925 8697e3e9d77a Properly cleanup the low level IR Max Brister <max@2bass.com> parents: 14923 diff changeset	603 virtual ~jit_value (void);
14946 3564bb141396 Only add items to worklist in type inferece if not already there Max Brister <max@2bass.com> parents: 14945 diff changeset	604
3564bb141396 Only add items to worklist in type inferece if not already there Max Brister <max@2bass.com> parents: 14945 diff changeset	605 bool in_worklist (void) const
3564bb141396 Only add items to worklist in type inferece if not already there Max Brister <max@2bass.com> parents: 14945 diff changeset	606 {
3564bb141396 Only add items to worklist in type inferece if not already there Max Brister <max@2bass.com> parents: 14945 diff changeset	607 return min_worklist;
3564bb141396 Only add items to worklist in type inferece if not already there Max Brister <max@2bass.com> parents: 14945 diff changeset	608 }
3564bb141396 Only add items to worklist in type inferece if not already there Max Brister <max@2bass.com> parents: 14945 diff changeset	609
3564bb141396 Only add items to worklist in type inferece if not already there Max Brister <max@2bass.com> parents: 14945 diff changeset	610 void stash_in_worklist (bool ain_worklist)
3564bb141396 Only add items to worklist in type inferece if not already there Max Brister <max@2bass.com> parents: 14945 diff changeset	611 {
3564bb141396 Only add items to worklist in type inferece if not already there Max Brister <max@2bass.com> parents: 14945 diff changeset	612 min_worklist = ain_worklist;
3564bb141396 Only add items to worklist in type inferece if not already there Max Brister <max@2bass.com> parents: 14945 diff changeset	613 }
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	614
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	615 // replace all uses with
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	616 void replace_with (jit_value *value);
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	617
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	618 jit_type *type (void) const { return ty; }
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	619
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	620 llvm::Type *type_llvm (void) const
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	621 {
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	622 return ty ? ty->to_llvm () : 0;
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	623 }
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	624
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	625 const std::string& type_name (void) const
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	626 {
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	627 return ty->name ();
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	628 }
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	629
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	630 void stash_type (jit_type *new_ty) { ty = new_ty; }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	631
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	632 jit_use *first_use (void) const { return use_head; }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	633
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	634 size_t use_count (void) const { return myuse_count; }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	635
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	636 std::string print_string (void)
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	637 {
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	638 std::stringstream ss;
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	639 print (ss);
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	640 return ss.str ();
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	641 }
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	642
14938 bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	643 jit_instruction *last_use (void) const { return mlast_use; }
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	644
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	645 void stash_last_use (jit_instruction *alast_use)
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	646 {
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	647 mlast_use = alast_use;
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	648 }
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	649
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	650 virtual std::ostream& print (std::ostream& os, size_t indent = 0) const = 0;
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	651
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	652 virtual std::ostream& short_print (std::ostream& os) const
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	653 { return print (os); }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	654
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	655 virtual void accept (jit_ir_walker& walker) = 0;
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	656
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	657 bool has_llvm (void) const
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	658 {
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	659 return llvm_value;
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	660 }
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	661
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	662 llvm::Value *to_llvm (void) const
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	663 {
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	664 assert (llvm_value);
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	665 return llvm_value;
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	666 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	667
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	668 void stash_llvm (llvm::Value *compiled)
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	669 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	670 llvm_value = compiled;
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	671 }
14935 5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	672
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	673 protected:
14945 591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	674 std::ostream& print_indent (std::ostream& os, size_t indent = 0) const
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	675 {
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	676 for (size_t i = 0; i < indent * 8; ++i)
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	677 os << " ";
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	678 return os;
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	679 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	680
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	681 llvm::Value *llvm_value;
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	682 private:
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	683 jit_type *ty;
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	684 jit_use *use_head;
14945 591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	685 jit_use *use_tail;
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	686 size_t myuse_count;
14938 bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	687 jit_instruction *mlast_use;
14946 3564bb141396 Only add items to worklist in type inferece if not already there Max Brister <max@2bass.com> parents: 14945 diff changeset	688 bool min_worklist;
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	689 };
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	690
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	691 std::ostream& operator<< (std::ostream& os, const jit_value& value);
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	692
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	693 class
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	694 jit_use
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	695 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	696 public:
14923 168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	697 jit_use (void) : mvalue (0), mnext (0), mprev (0), muser (0), mindex (0) {}
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	698
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	699 // we should really have a move operator, but not until c++11 :(
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	700 jit_use (const jit_use& use) : mvalue (0), mnext (0), mprev (0), muser (0),
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	701 mindex (0)
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	702 {
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	703 *this = use;
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	704 }
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	705
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	706 ~jit_use (void) { remove (); }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	707
14923 168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	708 jit_use& operator= (const jit_use& use)
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	709 {
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	710 stash_value (use.value (), use.user (), use.index ());
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	711 return *this;
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	712 }
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	713
14923 168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	714 jit_value *value (void) const { return mvalue; }
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	715
14923 168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	716 size_t index (void) const { return mindex; }
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	717
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	718 jit_instruction *user (void) const { return muser; }
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	719
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	720 jit_block *user_parent (void) const;
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	721
14935 5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	722 std::list<jit_block *> user_parent_location (void) const;
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	723
14923 168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	724 void stash_value (jit_value avalue, jit_instruction auser = 0,
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	725 size_t aindex = -1)
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	726 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	727 remove ();
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	728
14923 168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	729 mvalue = avalue;
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	730
14923 168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	731 if (mvalue)
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	732 {
14923 168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	733 if (mvalue->use_head)
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	734 {
14945 591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	735 mvalue->use_tail->mnext = this;
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	736 mprev = mvalue->use_tail;
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	737 }
14945 591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	738 else
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	739 mvalue->use_head = this;
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	740
14945 591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	741 mvalue->use_tail = this;
14923 168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	742 ++mvalue->myuse_count;
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	743 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	744
14923 168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	745 mindex = aindex;
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	746 muser = auser;
14917 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
14923 168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	749 jit_use *next (void) const { return mnext; }
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	750
14923 168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	751 jit_use *prev (void) const { return mprev; }
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	752 private:
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	753 void remove (void)
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	754 {
14923 168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	755 if (mvalue)
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	756 {
14923 168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	757 if (this == mvalue->use_head)
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	758 mvalue->use_head = mnext;
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	759
14945 591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	760 if (this == mvalue->use_tail)
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	761 mvalue->use_tail = mprev;
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	762
14923 168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	763 if (mprev)
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	764 mprev->mnext = mnext;
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	765
14923 168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	766 if (mnext)
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	767 mnext->mprev = mprev;
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	768
14923 168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	769 mnext = mprev = 0;
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	770 --mvalue->myuse_count;
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	771 mvalue = 0;
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	772 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	773 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	774
14923 168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	775 jit_value *mvalue;
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	776 jit_use *mnext;
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	777 jit_use *mprev;
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	778 jit_instruction *muser;
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	779 size_t mindex;
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	780 };
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	781
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	782 class
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	783 jit_instruction : public jit_value
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	784 {
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	785 public:
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	786 // FIXME: this code could be so much pretier with varadic templates...
14938 bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	787 jit_instruction (void) : mid (next_id ()), mparent (0)
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	788 {}
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	789
14923 168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	790 jit_instruction (size_t nargs, jit_value *adefault = 0)
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	791 : already_infered (nargs, reinterpret_cast<jit_type *>(0)), arguments (nargs),
14938 bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	792 mid (next_id ()), mparent (0)
14923 168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	793 {
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	794 if (adefault)
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	795 for (size_t i = 0; i < nargs; ++i)
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	796 stash_argument (i, adefault);
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	797 }
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	798
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	799 jit_instruction (jit_value *arg0)
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	800 : already_infered (1, reinterpret_cast<jit_type *>(0)), arguments (1),
14938 bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	801 mid (next_id ()), mparent (0)
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	802 {
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	803 stash_argument (0, arg0);
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	804 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	805
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	806 jit_instruction (jit_value arg0, jit_value arg1)
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	807 : already_infered (2, reinterpret_cast<jit_type *>(0)), arguments (2),
14938 bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	808 mid (next_id ()), mparent (0)
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	809 {
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	810 stash_argument (0, arg0);
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	811 stash_argument (1, arg1);
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	812 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	813
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	814 jit_instruction (jit_value arg0, jit_value arg1, jit_value *arg2)
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	815 : already_infered (3, reinterpret_cast<jit_type *>(0)), arguments (3),
14938 bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	816 mid (next_id ()), mparent (0)
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	817 {
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	818 stash_argument (0, arg0);
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	819 stash_argument (1, arg1);
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	820 stash_argument (2, arg2);
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	821 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	822
14936 32deb562ae77 Allow for construction of ranges during jit Max Brister <max@2bass.com> parents: 14935 diff changeset	823 jit_instruction (jit_value arg0, jit_value arg1, jit_value *arg2,
32deb562ae77 Allow for construction of ranges during jit Max Brister <max@2bass.com> parents: 14935 diff changeset	824 jit_value *arg3)
32deb562ae77 Allow for construction of ranges during jit Max Brister <max@2bass.com> parents: 14935 diff changeset	825 : already_infered (3, reinterpret_cast<jit_type *>(0)), arguments (4),
14938 bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	826 mid (next_id ()), mparent (0)
14936 32deb562ae77 Allow for construction of ranges during jit Max Brister <max@2bass.com> parents: 14935 diff changeset	827 {
32deb562ae77 Allow for construction of ranges during jit Max Brister <max@2bass.com> parents: 14935 diff changeset	828 stash_argument (0, arg0);
32deb562ae77 Allow for construction of ranges during jit Max Brister <max@2bass.com> parents: 14935 diff changeset	829 stash_argument (1, arg1);
32deb562ae77 Allow for construction of ranges during jit Max Brister <max@2bass.com> parents: 14935 diff changeset	830 stash_argument (2, arg2);
32deb562ae77 Allow for construction of ranges during jit Max Brister <max@2bass.com> parents: 14935 diff changeset	831 stash_argument (3, arg3);
32deb562ae77 Allow for construction of ranges during jit Max Brister <max@2bass.com> parents: 14935 diff changeset	832 }
32deb562ae77 Allow for construction of ranges during jit Max Brister <max@2bass.com> parents: 14935 diff changeset	833
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	834 static void reset_ids (void)
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	835 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	836 next_id (true);
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	837 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	838
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	839 jit_value *argument (size_t i) const
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	840 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	841 return arguments[i].value ();
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	842 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	843
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	844 llvm::Value *argument_llvm (size_t i) const
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	845 {
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	846 assert (argument (i));
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	847 return argument (i)->to_llvm ();
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	848 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	849
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	850 jit_type *argument_type (size_t i) const
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	851 {
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	852 return argument (i)->type ();
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	853 }
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	854
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	855 llvm::Type *argument_type_llvm (size_t i) const
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	856 {
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	857 assert (argument (i));
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	858 return argument_type (i)->to_llvm ();
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	859 }
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	860
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	861 std::ostream& print_argument (std::ostream& os, size_t i) const
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	862 {
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	863 if (argument (i))
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	864 return argument (i)->short_print (os);
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	865 else
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	866 return os << "NULL";
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	867 }
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	868
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	869 void stash_argument (size_t i, jit_value *arg)
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	870 {
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	871 arguments[i].stash_value (arg, this, i);
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	872 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	873
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	874 size_t argument_count (void) const
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	875 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	876 return arguments.size ();
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	877 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	878
14923 168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	879 void resize_arguments (size_t acount, jit_value *adefault = 0)
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	880 {
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	881 size_t old = arguments.size ();
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	882 arguments.resize (acount);
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	883
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	884 if (adefault)
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	885 for (size_t i = old; i < acount; ++i)
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	886 stash_argument (i, adefault);
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	887 }
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	888
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	889 // argument types which have been infered already
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	890 const std::vector<jit_type *>& argument_types (void) const
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	891 { return already_infered; }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	892
14938 bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	893 virtual void push_variable (void) {}
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	894
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	895 virtual void pop_variable (void) {}
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	896
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	897 virtual bool infer (void) { return false; }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	898
14935 5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	899 void remove (void);
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	900
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	901 virtual std::ostream& short_print (std::ostream& os) const;
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	902
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	903 jit_block *parent (void) const { return mparent; }
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	904
14935 5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	905 std::list<jit_instruction *>::iterator location (void) const
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	906 {
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	907 return mlocation;
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	908 }
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	909
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	910 llvm::BasicBlock *parent_llvm (void) const;
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	911
14935 5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	912 void stash_parent (jit_block *aparent,
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	913 std::list<jit_instruction *>::iterator alocation)
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	914 {
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	915 mparent = aparent;
14935 5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	916 mlocation = alocation;
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	917 }
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	918
14938 bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	919 size_t id (void) const { return mid; }
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	920 protected:
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	921 std::vector<jit_type *> already_infered;
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	922 private:
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	923 static size_t next_id (bool reset = false)
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	924 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	925 static size_t ret = 0;
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	926 if (reset)
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	927 return ret = 0;
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	928
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	929 return ret++;
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	930 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	931
14923 168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	932 std::vector<jit_use> arguments;
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	933
14938 bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	934 size_t mid;
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	935 jit_block *mparent;
14935 5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	936 std::list<jit_instruction *>::iterator mlocation;
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	937 };
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	938
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	939 // defnie accept methods for subclasses
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	940 #define JIT_VALUE_ACCEPT(clname) \
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	941 virtual void accept (jit_ir_walker& walker);
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	942
14935 5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	943 template <typename T, jit_type (EXTRACT_T)(void), typename PASS_T,
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	944 bool QUOTE>
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	945 class
14944 c0a5ab3b9278 jit_const no longer inherits from jit_instruction Max Brister <max@2bass.com> parents: 14943 diff changeset	946 jit_const : public jit_value
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	947 {
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	948 public:
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	949 typedef PASS_T pass_t;
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	950
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	951 jit_const (PASS_T avalue) : mvalue (avalue)
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	952 {
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	953 stash_type (EXTRACT_T ());
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	954 }
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	955
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	956 PASS_T value (void) const { return mvalue; }
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	957
14945 591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	958 virtual std::ostream& print (std::ostream& os, size_t indent = 0) const
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	959 {
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	960 print_indent (os, indent);
14944 c0a5ab3b9278 jit_const no longer inherits from jit_instruction Max Brister <max@2bass.com> parents: 14943 diff changeset	961 jit_print (os, type ()) << ": ";
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	962 if (QUOTE)
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	963 os << "\"";
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	964 os << mvalue;
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	965 if (QUOTE)
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	966 os << "\"";
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	967 return os;
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	968 }
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	969
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	970 JIT_VALUE_ACCEPT (jit_const);
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	971 private:
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	972 T mvalue;
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	973 };
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	974
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	975 class
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	976 jit_block : public jit_value
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	977 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	978 public:
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	979 typedef std::list<jit_instruction *> instruction_list;
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	980 typedef instruction_list::iterator iterator;
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	981 typedef instruction_list::const_iterator const_iterator;
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	982
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	983 typedef std::set<jit_block *> df_set;
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	984 typedef df_set::const_iterator df_iterator;
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	985
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	986 jit_block (const std::string& aname) : mvisit_count (0), mid (NO_ID), idom (0),
14945 591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	987 mname (aname), mdead (false),
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	988 malive (false)
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	989 {}
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	990
14945 591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	991 // if a block is alive, then it might be visited during execution
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	992 bool alive (void) const { return malive; }
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	993
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	994 void mark_alive (void) { malive = true; }
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	995
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	996 // dead blocks have already been removed from the CFG
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	997 bool dead (void) const { return mdead; }
14939 4488022820c9 No longer segfault when compiling nested for loops Max Brister <max@2bass.com> parents: 14938 diff changeset	998
4488022820c9 No longer segfault when compiling nested for loops Max Brister <max@2bass.com> parents: 14938 diff changeset	999 void mark_dead (void) { mdead = true; }
4488022820c9 No longer segfault when compiling nested for loops Max Brister <max@2bass.com> parents: 14938 diff changeset	1000
4488022820c9 No longer segfault when compiling nested for loops Max Brister <max@2bass.com> parents: 14938 diff changeset	1001 // If we can merge with a sucessor, do so and return the now empty block
4488022820c9 No longer segfault when compiling nested for loops Max Brister <max@2bass.com> parents: 14938 diff changeset	1002 jit_block *maybe_merge ();
4488022820c9 No longer segfault when compiling nested for loops Max Brister <max@2bass.com> parents: 14938 diff changeset	1003
4488022820c9 No longer segfault when compiling nested for loops Max Brister <max@2bass.com> parents: 14938 diff changeset	1004 // merge another block into this block, leaving the merge block empty
4488022820c9 No longer segfault when compiling nested for loops Max Brister <max@2bass.com> parents: 14938 diff changeset	1005 void merge (jit_block& merge);
4488022820c9 No longer segfault when compiling nested for loops Max Brister <max@2bass.com> parents: 14938 diff changeset	1006
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1007 const std::string& name (void) const { return mname; }
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1008
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1009 jit_instruction prepend (jit_instruction instr);
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1010
14935 5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1011 jit_instruction prepend_after_phi (jit_instruction instr);
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1012
14945 591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1013 template <typename T>
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1014 T append (T instr)
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1015 {
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1016 internal_append (instr);
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1017 return instr;
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1018 }
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1019
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1020 jit_instruction insert_before (iterator loc, jit_instruction instr);
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1021
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1022 jit_instruction insert_after (iterator loc, jit_instruction instr);
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1023
14938 bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1024 iterator remove (iterator iter)
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1025 {
14935 5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1026 jit_instruction instr = iter;
14938 bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1027 iter = instructions.erase (iter);
14935 5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1028 instr->stash_parent (0, instructions.end ());
14938 bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1029 return iter;
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1030 }
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1031
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1032 jit_terminator *terminator (void) const;
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1033
14923 168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	1034 jit_block *pred (size_t idx) const;
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1035
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1036 jit_terminator *pred_terminator (size_t idx) const
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1037 {
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1038 return pred (idx)->terminator ();
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1039 }
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1040
14945 591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1041 // is the jump from pred alive?
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1042 bool branch_alive (jit_block *asucc) const;
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1043
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1044 std::ostream& print_pred (std::ostream& os, size_t idx) const
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1045 {
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1046 return pred (idx)->short_print (os);
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1047 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1048
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1049 // takes into account for the addition of phi merges
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1050 llvm::BasicBlock *pred_llvm (size_t idx) const
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1051 {
14923 168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	1052 if (mpred_llvm.size () < pred_count ())
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1053 mpred_llvm.resize (pred_count ());
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1054
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1055 return mpred_llvm[idx] ? mpred_llvm[idx] : pred (idx)->to_llvm ();
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1056 }
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1057
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1058 llvm::BasicBlock pred_llvm (jit_block apred) const
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1059 {
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1060 return pred_llvm (pred_index (apred));
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1061 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1062
14923 168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	1063 size_t pred_index (jit_block *apred) const;
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1064
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1065 // create llvm phi merge blocks for all predecessors (if required)
14945 591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1066 void create_merge (llvm::Function inside, jit_block apred);
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1067
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1068 size_t pred_count (void) const { return use_count (); }
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1069
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1070 jit_block *succ (size_t i) const;
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1071
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1072 size_t succ_count (void) const;
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1073
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1074 iterator begin (void) { return instructions.begin (); }
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1075
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1076 const_iterator begin (void) const { return instructions.begin (); }
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1077
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1078 iterator end (void) { return instructions.end (); }
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1079
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1080 const_iterator end (void) const { return instructions.end (); }
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1081
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1082 iterator phi_begin (void);
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1083
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1084 iterator phi_end (void);
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1085
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1086 iterator nonphi_begin (void);
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1087
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1088 // must label before id is valid
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1089 size_t id (void) const { return mid; }
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1090
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1091 // dominance frontier
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1092 const df_set& df (void) const { return mdf; }
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1093
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1094 df_iterator df_begin (void) const { return mdf.begin (); }
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1095
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1096 df_iterator df_end (void) const { return mdf.end (); }
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1097
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1098 // label with a RPO walk
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1099 void label (void)
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1100 {
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1101 size_t number = 0;
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1102 label (mvisit_count, number);
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1103 }
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1104
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1105 void label (size_t visit_count, size_t& number)
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1106 {
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1107 if (mvisit_count > visit_count)
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1108 return;
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1109 ++mvisit_count;
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1110
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1111 for (size_t i = 0; i < pred_count (); ++i)
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1112 pred (i)->label (visit_count, number);
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1113
14938 bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1114 mid = number++;
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1115 }
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1116
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1117 // See for idom computation algorithm
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1118 // Cooper, Keith D.; Harvey, Timothy J; and Kennedy, Ken (2001).
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1119 // "A Simple, Fast Dominance Algorithm"
14939 4488022820c9 No longer segfault when compiling nested for loops Max Brister <max@2bass.com> parents: 14938 diff changeset	1120 void compute_idom (jit_block *entry_block)
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1121 {
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1122 bool changed;
14939 4488022820c9 No longer segfault when compiling nested for loops Max Brister <max@2bass.com> parents: 14938 diff changeset	1123 entry_block->idom = entry_block;
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1124 do
14939 4488022820c9 No longer segfault when compiling nested for loops Max Brister <max@2bass.com> parents: 14938 diff changeset	1125 changed = update_idom (mvisit_count);
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1126 while (changed);
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1127 }
14923 168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	1128
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1129 // compute dominance frontier
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1130 void compute_df (void)
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1131 {
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1132 compute_df (mvisit_count);
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1133 }
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1134
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1135 void create_dom_tree (void)
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1136 {
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1137 create_dom_tree (mvisit_count);
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1138 }
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1139
14935 5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1140 // visit blocks in the order of the dominator tree
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1141 // inorder - Run on the root first, then children
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1142 // postorder - Run on children first, then the root
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1143 template <typename func_type0, typename func_type1>
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1144 void visit_dom (func_type0 inorder, func_type1 postorder)
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1145 {
14935 5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1146 do_visit_dom (mvisit_count, inorder, postorder);
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1147 }
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1148
14935 5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1149 // call pop_varaible on all instructions
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1150 void pop_all (void);
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1151
14945 591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1152 virtual std::ostream& print (std::ostream& os, size_t indent = 0) const
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1153 {
14939 4488022820c9 No longer segfault when compiling nested for loops Max Brister <max@2bass.com> parents: 14938 diff changeset	1154 print_indent (os, indent);
4488022820c9 No longer segfault when compiling nested for loops Max Brister <max@2bass.com> parents: 14938 diff changeset	1155 short_print (os) << ": %pred = ";
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1156 for (size_t i = 0; i < pred_count (); ++i)
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1157 {
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1158 print_pred (os, i);
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1159 if (i + 1 < pred_count ())
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1160 os << ", ";
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1161 }
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1162 os << std::endl;
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1163
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1164 for (const_iterator iter = begin (); iter != end (); ++iter)
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1165 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1166 jit_instruction instr = iter;
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1167 instr->print (os, indent + 1) << std::endl;
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1168 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1169 return os;
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1170 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1171
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1172 // print dominator infomration
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1173 std::ostream& print_dom (std::ostream& os) const;
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1174
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1175 virtual std::ostream& short_print (std::ostream& os) const
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1176 {
14939 4488022820c9 No longer segfault when compiling nested for loops Max Brister <max@2bass.com> parents: 14938 diff changeset	1177 os << mname;
4488022820c9 No longer segfault when compiling nested for loops Max Brister <max@2bass.com> parents: 14938 diff changeset	1178 if (mid != NO_ID)
4488022820c9 No longer segfault when compiling nested for loops Max Brister <max@2bass.com> parents: 14938 diff changeset	1179 os << mid;
4488022820c9 No longer segfault when compiling nested for loops Max Brister <max@2bass.com> parents: 14938 diff changeset	1180 return os;
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1181 }
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1182
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1183 llvm::BasicBlock *to_llvm (void) const;
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1184
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1185 JIT_VALUE_ACCEPT (block)
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1186 private:
14945 591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1187 void internal_append (jit_instruction *instr);
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1188
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1189 void compute_df (size_t visit_count);
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1190
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1191 bool update_idom (size_t visit_count);
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1192
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1193 void create_dom_tree (size_t visit_count);
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1194
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1195 jit_block idom_intersect (jit_block b);
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1196
14935 5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1197 template <typename func_type0, typename func_type1>
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1198 void do_visit_dom (size_t visit_count, func_type0 inorder, func_type1 postorder);
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1199
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1200 static const size_t NO_ID = static_cast<size_t> (-1);
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1201 size_t mvisit_count;
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1202 size_t mid;
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1203 jit_block *idom;
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1204 df_set mdf;
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1205 std::vector<jit_block *> dom_succ;
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1206 std::string mname;
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1207 instruction_list instructions;
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1208 mutable std::vector<llvm::BasicBlock *> mpred_llvm;
14939 4488022820c9 No longer segfault when compiling nested for loops Max Brister <max@2bass.com> parents: 14938 diff changeset	1209 bool mdead;
14945 591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1210 bool malive;
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1211 };
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1212
14935 5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1213 // allow regular function pointers as well as pointers to members
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1214 template <typename func_type>
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1215 class jit_block_callback
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1216 {
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1217 public:
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1218 jit_block_callback (func_type afunction) : function (afunction) {}
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1219
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1220 void operator() (jit_block& block)
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1221 {
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1222 function (block);
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1223 }
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1224 private:
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1225 func_type function;
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1226 };
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1227
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1228 template <>
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1229 class jit_block_callback<void (jit_block::*)(void)>
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1230 {
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1231 public:
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1232 typedef void (jit_block::*func_type)(void);
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1233
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1234 jit_block_callback (func_type afunction) : function (afunction) {}
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1235
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1236 void operator() (jit_block& ablock)
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1237 {
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1238 (ablock.*function) ();
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1239 }
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1240 private:
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1241 func_type function;
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1242 };
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1243
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1244 template <typename func_type0, typename func_type1>
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1245 void
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1246 jit_block::do_visit_dom (size_t visit_count, func_type0 inorder, func_type1 postorder)
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1247 {
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1248 if (mvisit_count > visit_count)
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1249 return;
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1250 mvisit_count = visit_count + 1;
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1251
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1252 jit_block_callback<func_type0> inorder_cb (inorder);
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1253 inorder_cb (*this);
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1254
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1255 for (size_t i = 0; i < dom_succ.size (); ++i)
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1256 dom_succ[i]->do_visit_dom (visit_count, inorder, postorder);
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1257
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1258 jit_block_callback<func_type1> postorder_cb (postorder);
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1259 postorder_cb (*this);
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1260 }
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1261
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1262
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1263 // A non-ssa variable
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1264 class
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1265 jit_variable : public jit_value
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1266 {
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1267 public:
14935 5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1268 jit_variable (const std::string& aname) : mname (aname), mlast_use (0) {}
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1269
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1270 const std::string &name (void) const { return mname; }
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1271
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1272 // manipulate the value_stack, for use during SSA construction. The top of the
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1273 // value stack represents the current value for this variable
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1274 bool has_top (void) const
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1275 {
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1276 return ! value_stack.empty ();
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1277 }
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1278
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1279 jit_value *top (void) const
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1280 {
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1281 return value_stack.top ();
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1282 }
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1283
14935 5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1284 void push (jit_instruction *v)
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1285 {
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1286 value_stack.push (v);
14935 5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1287 mlast_use = v;
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1288 }
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1289
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1290 void pop (void)
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1291 {
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1292 value_stack.pop ();
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1293 }
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1294
14935 5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1295 jit_instruction *last_use (void) const
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1296 {
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1297 return mlast_use;
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1298 }
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1299
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1300 void stash_last_use (jit_instruction *instr)
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1301 {
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1302 mlast_use = instr;
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1303 }
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1304
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1305 // blocks in which we are used
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1306 void use_blocks (jit_block::df_set& result)
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1307 {
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1308 jit_use *use = first_use ();
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1309 while (use)
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1310 {
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1311 result.insert (use->user_parent ());
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1312 use = use->next ();
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1313 }
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1314 }
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1315
14945 591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1316 virtual std::ostream& print (std::ostream& os, size_t indent = 0) const
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1317 {
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1318 return print_indent (os, indent) << mname;
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1319 }
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1320
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1321 JIT_VALUE_ACCEPT (variable)
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1322 private:
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1323 std::string mname;
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1324 std::stack<jit_value *> value_stack;
14935 5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1325 jit_instruction *mlast_use;
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1326 };
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1327
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1328 class
14938 bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1329 jit_assign_base : public jit_instruction
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1330 {
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1331 public:
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1332 jit_assign_base (jit_variable *adest) : jit_instruction (), mdest (adest) {}
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1333
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1334 jit_assign_base (jit_variable *adest, size_t npred) : jit_instruction (npred),
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1335 mdest (adest) {}
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1336
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1337 jit_assign_base (jit_variable adest, jit_value arg0, jit_value *arg1)
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1338 : jit_instruction (arg0, arg1), mdest (adest) {}
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1339
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1340 jit_variable *dest (void) const { return mdest; }
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1341
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1342 virtual void push_variable (void)
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1343 {
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1344 mdest->push (this);
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1345 }
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1346
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1347 virtual void pop_variable (void)
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1348 {
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1349 mdest->pop ();
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1350 }
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1351 private:
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1352 jit_variable *mdest;
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1353 };
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1354
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1355 class
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1356 jit_assign : public jit_assign_base
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1357 {
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1358 public:
14944 c0a5ab3b9278 jit_const no longer inherits from jit_instruction Max Brister <max@2bass.com> parents: 14943 diff changeset	1359 jit_assign (jit_variable adest, jit_value asrc)
14938 bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1360 : jit_assign_base (adest, adest, asrc) {}
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1361
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1362 jit_instruction *src (void) const
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1363 {
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1364 return static_cast<jit_instruction *> (argument (1));
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1365 }
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1366
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1367 virtual void push_variable (void)
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1368 {
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1369 dest ()->push (src ());
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1370 }
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1371
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1372 virtual std::ostream& print (std::ostream& os, size_t indent = 0) const
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1373 {
14938 bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1374 return print_indent (os, indent) << dest () << " = " << src ();
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1375 }
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1376
14938 bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1377 JIT_VALUE_ACCEPT (assign);
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1378 private:
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1379 jit_variable *mdest;
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1380 };
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1381
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1382 class
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1383 jit_phi : public jit_assign_base
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1384 {
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1385 public:
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1386 jit_phi (jit_variable *adest, size_t npred) : jit_assign_base (adest, npred)
14935 5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1387 {
14945 591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1388 mincomming.reserve (npred);
14935 5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1389 }
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1390
14945 591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1391 // removes arguments form dead incomming jumps
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1392 bool prune (void);
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1393
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1394 void add_incomming (jit_block from, jit_value value)
14935 5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1395 {
14945 591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1396 stash_argument (mincomming.size (), value);
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1397 mincomming.push_back (from);
14935 5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1398 }
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1399
14945 591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1400 jit_block *incomming (size_t i) const
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1401 {
14945 591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1402 return mincomming[i];
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1403 }
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1404
14945 591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1405 llvm::BasicBlock *incomming_llvm (size_t i) const
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1406 {
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1407 jit_block *inc = incomming (i);
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1408 jit_block *p = parent ();
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1409 return p->pred_llvm (inc);
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1410 }
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1411
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1412 virtual bool infer (void);
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1413
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1414 virtual std::ostream& print (std::ostream& os, size_t indent = 0) const
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1415 {
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1416 std::stringstream ss;
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1417 print_indent (ss, indent);
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1418 short_print (ss) << " phi ";
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1419 std::string ss_str = ss.str ();
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1420 std::string indent_str (ss_str.size (), ' ');
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1421 os << ss_str;
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1422
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1423 jit_block *pblock = parent ();
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1424 for (size_t i = 0; i < argument_count (); ++i)
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1425 {
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1426 if (i > 0)
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1427 os << indent_str;
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1428 os << "\| ";
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1429
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1430 pblock->print_pred (os, i) << " -> ";
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1431 print_argument (os, i);
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1432
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1433 if (i + 1 < argument_count ())
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1434 os << std::endl;
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1435 }
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1436
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1437 return os;
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1438 }
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1439
14938 bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1440 virtual std::ostream& short_print (std::ostream& os) const
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1441 {
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1442 if (type ())
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1443 jit_print (os, type ()) << ": ";
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1444
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1445 dest ()->short_print (os);
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1446 return os << "#" << id ();
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1447 }
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1448
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1449 JIT_VALUE_ACCEPT (phi);
14945 591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1450 private:
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1451 std::vector<jit_block *> mincomming;
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1452 };
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1453
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1454 class
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1455 jit_terminator : public jit_instruction
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1456 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1457 public:
14945 591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1458 jit_terminator (size_t asucessor_count, jit_value *arg0)
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1459 : jit_instruction (arg0), malive (asucessor_count, false) {}
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1460
14945 591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1461 jit_terminator (size_t asucessor_count, jit_value arg0, jit_value arg1)
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1462 : jit_instruction (arg0, arg1), malive (asucessor_count, false) {}
14938 bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1463
14945 591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1464 jit_terminator (size_t asucessor_count, jit_value arg0, jit_value arg1,
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1465 jit_value *arg2)
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1466 : jit_instruction (arg0, arg1, arg2), malive (asucessor_count, false) {}
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1467
14945 591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1468 jit_block *sucessor (size_t idx = 0) const
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1469 {
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1470 return static_cast<jit_block *> (argument (idx));
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1471 }
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1472
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1473 // return either our sucessors block directly, or the phi merge block
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1474 // between us and our sucessor
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1475 llvm::BasicBlock *sucessor_llvm (size_t idx = 0) const
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1476 {
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1477 jit_block *succ = sucessor (idx);
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1478 llvm::BasicBlock *pllvm = parent_llvm ();
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1479 llvm::BasicBlock *spred_llvm = succ->pred_llvm (parent ());
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1480 llvm::BasicBlock *succ_llvm = succ->to_llvm ();
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1481 return pllvm == spred_llvm ? succ_llvm : spred_llvm;
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1482 }
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1483
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1484 std::ostream& print_sucessor (std::ostream& os, size_t idx = 0) const
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1485 {
14945 591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1486 if (alive (idx))
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1487 os << "[live] ";
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1488 else
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1489 os << "[dead] ";
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1490
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1491 return sucessor (idx)->short_print (os);
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1492 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1493
14945 591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1494 // Check if the jump to sucessor is live
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1495 bool alive (const jit_block *asucessor) const;
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1496 bool alive (size_t idx) const { return malive[idx]; }
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1497
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1498 size_t sucessor_count (void) const { return malive.size (); }
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1499
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1500 virtual bool infer (void);
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1501 protected:
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1502 virtual bool check_alive (size_t) const { return true; }
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1503 private:
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1504 std::vector<bool> malive;
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1505 };
14913 c7071907a641 Use symbol_record_ref instead of names in JIT Max Brister <max@2bass.com> parents: 14911 diff changeset	1506
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1507 class
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1508 jit_break : public jit_terminator
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1509 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1510 public:
14945 591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1511 jit_break (jit_block *succ) : jit_terminator (1, succ) {}
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1512
14945 591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1513 virtual size_t sucessor_count (void) const { return 1; }
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1514
14945 591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1515 virtual std::ostream& print (std::ostream& os, size_t indent = 0) const
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1516 {
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1517 print_indent (os, indent) << "break: ";
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1518 return print_sucessor (os);
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1519 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1520
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1521 JIT_VALUE_ACCEPT (break)
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1522 };
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1523
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1524 class
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1525 jit_cond_break : public jit_terminator
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1526 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1527 public:
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1528 jit_cond_break (jit_value c, jit_block ctrue, jit_block *cfalse)
14945 591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1529 : jit_terminator (2, ctrue, cfalse, c) {}
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1530
14945 591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1531 jit_value *cond (void) const { return argument (2); }
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1532
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1533 std::ostream& print_cond (std::ostream& os) const
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1534 {
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1535 return cond ()->short_print (os);
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1536 }
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1537
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1538 llvm::Value *cond_llvm (void) const
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1539 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1540 return cond ()->to_llvm ();
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1541 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1542
14945 591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1543 virtual size_t sucessor_count (void) const { return 2; }
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1544
14945 591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1545 virtual std::ostream& print (std::ostream& os, size_t indent = 0) const
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1546 {
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1547 print_indent (os, indent) << "cond_break: ";
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1548 print_cond (os) << ", ";
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1549 print_sucessor (os, 0) << ", ";
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1550 return print_sucessor (os, 1);
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1551 }
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1552
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1553 JIT_VALUE_ACCEPT (cond_break)
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1554 };
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1555
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1556 class
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1557 jit_call : public jit_instruction
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1558 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1559 public:
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1560 jit_call (const jit_function& afunction,
14945 591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1561 jit_value *arg0) : jit_instruction (arg0), mfunction (afunction)
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1562 {}
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1563
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1564 jit_call (const jit_function& (*afunction) (void),
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1565 jit_value *arg0) : jit_instruction (arg0), mfunction (afunction ()) {}
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1566
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1567 jit_call (const jit_function& afunction,
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1568 jit_value arg0, jit_value arg1) : jit_instruction (arg0, arg1),
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1569 mfunction (afunction) {}
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1570
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1571 jit_call (const jit_function& (*afunction) (void),
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1572 jit_value arg0, jit_value arg1) : jit_instruction (arg0, arg1),
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1573 mfunction (afunction ()) {}
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1574
14936 32deb562ae77 Allow for construction of ranges during jit Max Brister <max@2bass.com> parents: 14935 diff changeset	1575 jit_call (const jit_function& (*afunction) (void),
32deb562ae77 Allow for construction of ranges during jit Max Brister <max@2bass.com> parents: 14935 diff changeset	1576 jit_value arg0, jit_value arg1, jit_value *arg2)
32deb562ae77 Allow for construction of ranges during jit Max Brister <max@2bass.com> parents: 14935 diff changeset	1577 : jit_instruction (arg0, arg1, arg2), mfunction (afunction ()) {}
32deb562ae77 Allow for construction of ranges during jit Max Brister <max@2bass.com> parents: 14935 diff changeset	1578
32deb562ae77 Allow for construction of ranges during jit Max Brister <max@2bass.com> parents: 14935 diff changeset	1579 jit_call (const jit_function& (*afunction) (void),
32deb562ae77 Allow for construction of ranges during jit Max Brister <max@2bass.com> parents: 14935 diff changeset	1580 jit_value arg0, jit_value arg1, jit_value arg2, jit_value arg3)
32deb562ae77 Allow for construction of ranges during jit Max Brister <max@2bass.com> parents: 14935 diff changeset	1581 : jit_instruction (arg0, arg1, arg2, arg3), mfunction (afunction ()) {}
32deb562ae77 Allow for construction of ranges during jit Max Brister <max@2bass.com> parents: 14935 diff changeset	1582
32deb562ae77 Allow for construction of ranges during jit Max Brister <max@2bass.com> parents: 14935 diff changeset	1583
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1584 const jit_function& function (void) const { return mfunction; }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1585
14945 591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1586 bool can_error (void) const
14935 5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1587 {
14945 591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1588 return overload ().can_error;
14935 5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1589 }
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1590
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1591 const jit_function::overload& overload (void) const
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1592 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1593 return mfunction.get_overload (argument_types ());
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1594 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1595
14945 591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1596 virtual std::ostream& print (std::ostream& os, size_t indent = 0) const
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1597 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1598 print_indent (os, indent);
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1599
14938 bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1600 if (use_count ())
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1601 short_print (os) << " = ";
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1602 os << "call " << mfunction.name () << " (";
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1603
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1604 for (size_t i = 0; i < argument_count (); ++i)
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1605 {
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1606 print_argument (os, i);
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1607 if (i + 1 < argument_count ())
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1608 os << ", ";
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1609 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1610 return os << ")";
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1611 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1612
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1613 virtual bool infer (void);
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1614
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1615 JIT_VALUE_ACCEPT (call)
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1616 private:
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1617 const jit_function& mfunction;
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1618 };
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1619
14938 bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1620 // FIXME: This is just ugly...
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1621 // checks error_state, if error_state is false then goto the normal branche,
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1622 // otherwise goto the error branch
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1623 class
14938 bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1624 jit_check_error : public jit_terminator
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1625 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1626 public:
14945 591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1627 jit_check_error (jit_call acheck_for, jit_block normal, jit_block *error)
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1628 : jit_terminator (2, normal, error, acheck_for) {}
14938 bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1629
14945 591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1630 jit_call *check_for (void) const
14938 bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1631 {
14945 591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1632 return static_cast<jit_call *> (argument (2));
14938 bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1633 }
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1634
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1635 virtual std::ostream& print (std::ostream& os, size_t indent = 0) const
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1636 {
14945 591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1637 print_indent (os, indent) << "error_check " << *check_for () << ", ";
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1638 print_sucessor (os, 0) << ", ";
14938 bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1639 return print_sucessor (os, 1);
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1640 }
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1641
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1642 JIT_VALUE_ACCEPT (jit_check_error)
14945 591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1643 protected:
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1644 virtual bool check_alive (size_t idx) const
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1645 {
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1646 return idx == 0 ? true : check_for ()->can_error ();
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1647 }
14938 bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1648 };
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1649
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1650 class
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1651 jit_extract_argument : public jit_assign_base
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1652 {
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1653 public:
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1654 jit_extract_argument (jit_type atype, jit_variable adest)
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1655 : jit_assign_base (adest)
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1656 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1657 stash_type (atype);
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1658 }
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1659
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1660 const std::string& name (void) const
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1661 {
14938 bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1662 return dest ()->name ();
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1663 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1664
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1665 const jit_function::overload& overload (void) const
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1666 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1667 return jit_typeinfo::cast (type (), jit_typeinfo::get_any ());
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1668 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1669
14945 591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1670 virtual std::ostream& print (std::ostream& os, size_t indent = 0) const
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1671 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1672 print_indent (os, indent);
14942 e8487d98561c Improve printing of jit_extract_argument Max Brister <max@2bass.com> parents: 14941 diff changeset	1673
e8487d98561c Improve printing of jit_extract_argument Max Brister <max@2bass.com> parents: 14941 diff changeset	1674 return short_print (os) << " = extract " << name ();
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1675 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1676
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1677 JIT_VALUE_ACCEPT (extract_argument)
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1678 };
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1679
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1680 class
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1681 jit_store_argument : public jit_instruction
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1682 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1683 public:
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1684 jit_store_argument (jit_variable *var)
14938 bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1685 : jit_instruction (var), dest (var)
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1686 {}
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1687
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1688 const std::string& name (void) const
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1689 {
14938 bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1690 return dest->name ();
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1691 }
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1692
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1693 const jit_function::overload& overload (void) const
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1694 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1695 return jit_typeinfo::cast (jit_typeinfo::get_any (), result_type ());
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1696 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1697
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1698 jit_value *result (void) const
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1699 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1700 return argument (0);
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1701 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1702
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1703 jit_type *result_type (void) const
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1704 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1705 return result ()->type ();
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1706 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1707
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1708 llvm::Value *result_llvm (void) const
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1709 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1710 return result ()->to_llvm ();
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1711 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1712
14945 591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1713 virtual std::ostream& print (std::ostream& os, size_t indent = 0) const
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1714 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1715 jit_value *res = result ();
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1716 print_indent (os, indent) << "store ";
14938 bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1717 dest->short_print (os);
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1718
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1719 if (! isa<jit_variable> (res))
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1720 {
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1721 os << " = ";
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1722 res->short_print (os);
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1723 }
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1724
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1725 return os;
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1726 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1727
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1728 JIT_VALUE_ACCEPT (store_argument)
14938 bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1729 private:
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1730 jit_variable *dest;
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1731 };
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1732
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1733 class
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1734 jit_ir_walker
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1735 {
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1736 public:
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1737 virtual ~jit_ir_walker () {}
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1738
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1739 #define JIT_METH(clname) \
14935 5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1740 virtual void visit (jit_ ## clname&) = 0;
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1741
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1742 JIT_VISIT_IR_CLASSES;
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1743
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1744 #undef JIT_METH
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1745 };
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1746
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1747 template <typename T, jit_type (EXTRACT_T)(void), typename PASS_T, bool QUOTE>
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1748 void
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1749 jit_const<T, EXTRACT_T, PASS_T, QUOTE>::accept (jit_ir_walker& walker)
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1750 {
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1751 walker.visit (*this);
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1752 }
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1753
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1754 // convert between IRs
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1755 // FIXME: Class relationships are messy from here on down. They need to be
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1756 // cleaned up.
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1757 class
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1758 jit_convert : public tree_walker
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1759 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1760 public:
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1761 typedef std::pair<jit_type *, std::string> type_bound;
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1762 typedef std::vector<type_bound> type_bound_vector;
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1763
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1764 jit_convert (llvm::Module *module, tree &tee);
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1765
14925 8697e3e9d77a Properly cleanup the low level IR Max Brister <max@2bass.com> parents: 14923 diff changeset	1766 ~jit_convert (void);
8697e3e9d77a Properly cleanup the low level IR Max Brister <max@2bass.com> parents: 14923 diff changeset	1767
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1768 llvm::Function *get_function (void) const { return function; }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1769
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1770 const std::vector<std::pair<std::string, bool> >& get_arguments(void) const
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1771 { return arguments; }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1772
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1773 const type_bound_vector& get_bounds (void) const { return bounds; }
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1774
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1775 void visit_anon_fcn_handle (tree_anon_fcn_handle&);
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1776
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1777 void visit_argument_list (tree_argument_list&);
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1778
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1779 void visit_binary_expression (tree_binary_expression&);
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1780
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1781 void visit_break_command (tree_break_command&);
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1782
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1783 void visit_colon_expression (tree_colon_expression&);
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1784
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1785 void visit_continue_command (tree_continue_command&);
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1786
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1787 void visit_global_command (tree_global_command&);
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1788
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1789 void visit_persistent_command (tree_persistent_command&);
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1790
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1791 void visit_decl_elt (tree_decl_elt&);
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1792
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1793 void visit_decl_init_list (tree_decl_init_list&);
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1794
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1795 void visit_simple_for_command (tree_simple_for_command&);
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1796
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1797 void visit_complex_for_command (tree_complex_for_command&);
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1798
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1799 void visit_octave_user_script (octave_user_script&);
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1800
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1801 void visit_octave_user_function (octave_user_function&);
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1802
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1803 void visit_octave_user_function_header (octave_user_function&);
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1804
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1805 void visit_octave_user_function_trailer (octave_user_function&);
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1806
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1807 void visit_function_def (tree_function_def&);
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1808
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1809 void visit_identifier (tree_identifier&);
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1810
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1811 void visit_if_clause (tree_if_clause&);
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1812
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1813 void visit_if_command (tree_if_command&);
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1814
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1815 void visit_if_command_list (tree_if_command_list&);
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1816
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1817 void visit_index_expression (tree_index_expression&);
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1818
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1819 void visit_matrix (tree_matrix&);
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1820
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1821 void visit_cell (tree_cell&);
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1822
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1823 void visit_multi_assignment (tree_multi_assignment&);
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1824
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1825 void visit_no_op_command (tree_no_op_command&);
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1826
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1827 void visit_constant (tree_constant&);
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1828
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1829 void visit_fcn_handle (tree_fcn_handle&);
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1830
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1831 void visit_parameter_list (tree_parameter_list&);
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1832
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1833 void visit_postfix_expression (tree_postfix_expression&);
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1834
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1835 void visit_prefix_expression (tree_prefix_expression&);
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1836
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1837 void visit_return_command (tree_return_command&);
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1838
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1839 void visit_return_list (tree_return_list&);
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1840
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1841 void visit_simple_assignment (tree_simple_assignment&);
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1842
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1843 void visit_statement (tree_statement&);
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1844
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1845 void visit_statement_list (tree_statement_list&);
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1846
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1847 void visit_switch_case (tree_switch_case&);
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1848
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1849 void visit_switch_case_list (tree_switch_case_list&);
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1850
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1851 void visit_switch_command (tree_switch_command&);
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1852
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1853 void visit_try_catch_command (tree_try_catch_command&);
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1854
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1855 void visit_unwind_protect_command (tree_unwind_protect_command&);
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1856
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1857 void visit_while_command (tree_while_command&);
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1858
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1859 void visit_do_until_command (tree_do_until_command&);
14915 cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	1860
14925 8697e3e9d77a Properly cleanup the low level IR Max Brister <max@2bass.com> parents: 14923 diff changeset	1861 // this would be easier with variadic templates
8697e3e9d77a Properly cleanup the low level IR Max Brister <max@2bass.com> parents: 14923 diff changeset	1862 template <typename T>
8697e3e9d77a Properly cleanup the low level IR Max Brister <max@2bass.com> parents: 14923 diff changeset	1863 T *create (void)
8697e3e9d77a Properly cleanup the low level IR Max Brister <max@2bass.com> parents: 14923 diff changeset	1864 {
8697e3e9d77a Properly cleanup the low level IR Max Brister <max@2bass.com> parents: 14923 diff changeset	1865 T *ret = new T();
8697e3e9d77a Properly cleanup the low level IR Max Brister <max@2bass.com> parents: 14923 diff changeset	1866 track_value (ret);
8697e3e9d77a Properly cleanup the low level IR Max Brister <max@2bass.com> parents: 14923 diff changeset	1867 return ret;
8697e3e9d77a Properly cleanup the low level IR Max Brister <max@2bass.com> parents: 14923 diff changeset	1868 }
8697e3e9d77a Properly cleanup the low level IR Max Brister <max@2bass.com> parents: 14923 diff changeset	1869
8697e3e9d77a Properly cleanup the low level IR Max Brister <max@2bass.com> parents: 14923 diff changeset	1870 template <typename T, typename ARG0>
8697e3e9d77a Properly cleanup the low level IR Max Brister <max@2bass.com> parents: 14923 diff changeset	1871 T *create (const ARG0& arg0)
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1872 {
14925 8697e3e9d77a Properly cleanup the low level IR Max Brister <max@2bass.com> parents: 14923 diff changeset	1873 T *ret = new T(arg0);
8697e3e9d77a Properly cleanup the low level IR Max Brister <max@2bass.com> parents: 14923 diff changeset	1874 track_value (ret);
8697e3e9d77a Properly cleanup the low level IR Max Brister <max@2bass.com> parents: 14923 diff changeset	1875 return ret;
8697e3e9d77a Properly cleanup the low level IR Max Brister <max@2bass.com> parents: 14923 diff changeset	1876 }
8697e3e9d77a Properly cleanup the low level IR Max Brister <max@2bass.com> parents: 14923 diff changeset	1877
8697e3e9d77a Properly cleanup the low level IR Max Brister <max@2bass.com> parents: 14923 diff changeset	1878 template <typename T, typename ARG0, typename ARG1>
8697e3e9d77a Properly cleanup the low level IR Max Brister <max@2bass.com> parents: 14923 diff changeset	1879 T *create (const ARG0& arg0, const ARG1& arg1)
8697e3e9d77a Properly cleanup the low level IR Max Brister <max@2bass.com> parents: 14923 diff changeset	1880 {
8697e3e9d77a Properly cleanup the low level IR Max Brister <max@2bass.com> parents: 14923 diff changeset	1881 T *ret = new T(arg0, arg1);
8697e3e9d77a Properly cleanup the low level IR Max Brister <max@2bass.com> parents: 14923 diff changeset	1882 track_value (ret);
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1883 return ret;
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1884 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1885
14925 8697e3e9d77a Properly cleanup the low level IR Max Brister <max@2bass.com> parents: 14923 diff changeset	1886 template <typename T, typename ARG0, typename ARG1, typename ARG2>
8697e3e9d77a Properly cleanup the low level IR Max Brister <max@2bass.com> parents: 14923 diff changeset	1887 T *create (const ARG0& arg0, const ARG1& arg1, const ARG2& arg2)
8697e3e9d77a Properly cleanup the low level IR Max Brister <max@2bass.com> parents: 14923 diff changeset	1888 {
8697e3e9d77a Properly cleanup the low level IR Max Brister <max@2bass.com> parents: 14923 diff changeset	1889 T *ret = new T(arg0, arg1, arg2);
8697e3e9d77a Properly cleanup the low level IR Max Brister <max@2bass.com> parents: 14923 diff changeset	1890 track_value (ret);
8697e3e9d77a Properly cleanup the low level IR Max Brister <max@2bass.com> parents: 14923 diff changeset	1891 return ret;
8697e3e9d77a Properly cleanup the low level IR Max Brister <max@2bass.com> parents: 14923 diff changeset	1892 }
14936 32deb562ae77 Allow for construction of ranges during jit Max Brister <max@2bass.com> parents: 14935 diff changeset	1893
32deb562ae77 Allow for construction of ranges during jit Max Brister <max@2bass.com> parents: 14935 diff changeset	1894 template <typename T, typename ARG0, typename ARG1, typename ARG2,
32deb562ae77 Allow for construction of ranges during jit Max Brister <max@2bass.com> parents: 14935 diff changeset	1895 typename ARG3>
32deb562ae77 Allow for construction of ranges during jit Max Brister <max@2bass.com> parents: 14935 diff changeset	1896 T *create (const ARG0& arg0, const ARG1& arg1, const ARG2& arg2,
32deb562ae77 Allow for construction of ranges during jit Max Brister <max@2bass.com> parents: 14935 diff changeset	1897 const ARG3& arg3)
32deb562ae77 Allow for construction of ranges during jit Max Brister <max@2bass.com> parents: 14935 diff changeset	1898 {
32deb562ae77 Allow for construction of ranges during jit Max Brister <max@2bass.com> parents: 14935 diff changeset	1899 T *ret = new T(arg0, arg1, arg2, arg3);
32deb562ae77 Allow for construction of ranges during jit Max Brister <max@2bass.com> parents: 14935 diff changeset	1900 track_value (ret);
32deb562ae77 Allow for construction of ranges during jit Max Brister <max@2bass.com> parents: 14935 diff changeset	1901 return ret;
32deb562ae77 Allow for construction of ranges during jit Max Brister <max@2bass.com> parents: 14935 diff changeset	1902 }
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1903 private:
14935 5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1904 typedef std::list<jit_block *> block_list;
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1905 typedef block_list::iterator block_iterator;
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1906
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1907 std::vector<std::pair<std::string, bool> > arguments;
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1908 type_bound_vector bounds;
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1909
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1910 // used instead of return values from visit_* functions
14944 c0a5ab3b9278 jit_const no longer inherits from jit_instruction Max Brister <max@2bass.com> parents: 14943 diff changeset	1911 jit_value *result;
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1912
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1913 jit_block *entry_block;
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1914
14938 bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1915 jit_block *final_block;
bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1916
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1917 jit_block *block;
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1918
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1919 llvm::Function *function;
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1920
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1921 std::list<jit_block *> blocks;
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1922
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1923 std::list<jit_instruction *> worklist;
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1924
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1925 std::list<jit_value *> constants;
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1926
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1927 std::list<jit_value *> all_values;
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1928
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1929 size_t iterator_count;
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1930
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1931 typedef std::map<std::string, jit_variable *> vmap_t;
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1932 vmap_t vmap;
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1933
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1934 jit_variable *get_variable (const std::string& vname);
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1935
14944 c0a5ab3b9278 jit_const no longer inherits from jit_instruction Max Brister <max@2bass.com> parents: 14943 diff changeset	1936 jit_value do_assign (const std::string& lhs, jit_value rhs, bool print);
c0a5ab3b9278 jit_const no longer inherits from jit_instruction Max Brister <max@2bass.com> parents: 14943 diff changeset	1937
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1938
14944 c0a5ab3b9278 jit_const no longer inherits from jit_instruction Max Brister <max@2bass.com> parents: 14943 diff changeset	1939 jit_value visit (tree tee) { return visit (*tee); }
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1940
14944 c0a5ab3b9278 jit_const no longer inherits from jit_instruction Max Brister <max@2bass.com> parents: 14943 diff changeset	1941 jit_value *visit (tree& tee);
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1942
14946 3564bb141396 Only add items to worklist in type inferece if not already there Max Brister <max@2bass.com> parents: 14945 diff changeset	1943 void push_worklist (jit_instruction *instr)
3564bb141396 Only add items to worklist in type inferece if not already there Max Brister <max@2bass.com> parents: 14945 diff changeset	1944 {
3564bb141396 Only add items to worklist in type inferece if not already there Max Brister <max@2bass.com> parents: 14945 diff changeset	1945 if (! instr->in_worklist ())
3564bb141396 Only add items to worklist in type inferece if not already there Max Brister <max@2bass.com> parents: 14945 diff changeset	1946 {
3564bb141396 Only add items to worklist in type inferece if not already there Max Brister <max@2bass.com> parents: 14945 diff changeset	1947 instr->stash_in_worklist (true);
3564bb141396 Only add items to worklist in type inferece if not already there Max Brister <max@2bass.com> parents: 14945 diff changeset	1948 worklist.push_back (instr);
3564bb141396 Only add items to worklist in type inferece if not already there Max Brister <max@2bass.com> parents: 14945 diff changeset	1949 }
3564bb141396 Only add items to worklist in type inferece if not already there Max Brister <max@2bass.com> parents: 14945 diff changeset	1950 }
3564bb141396 Only add items to worklist in type inferece if not already there Max Brister <max@2bass.com> parents: 14945 diff changeset	1951
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1952 void append_users (jit_value *v)
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1953 {
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1954 for (jit_use *use = v->first_use (); use; use = use->next ())
14946 3564bb141396 Only add items to worklist in type inferece if not already there Max Brister <max@2bass.com> parents: 14945 diff changeset	1955 push_worklist (use->user ());
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1956 }
14925 8697e3e9d77a Properly cleanup the low level IR Max Brister <max@2bass.com> parents: 14923 diff changeset	1957
14945 591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1958 void append_users_term (jit_terminator *term);
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1959
14925 8697e3e9d77a Properly cleanup the low level IR Max Brister <max@2bass.com> parents: 14923 diff changeset	1960 void track_value (jit_value *value)
8697e3e9d77a Properly cleanup the low level IR Max Brister <max@2bass.com> parents: 14923 diff changeset	1961 {
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1962 if (value->type ())
14925 8697e3e9d77a Properly cleanup the low level IR Max Brister <max@2bass.com> parents: 14923 diff changeset	1963 constants.push_back (value);
8697e3e9d77a Properly cleanup the low level IR Max Brister <max@2bass.com> parents: 14923 diff changeset	1964 all_values.push_back (value);
8697e3e9d77a Properly cleanup the low level IR Max Brister <max@2bass.com> parents: 14923 diff changeset	1965 }
8697e3e9d77a Properly cleanup the low level IR Max Brister <max@2bass.com> parents: 14923 diff changeset	1966
14939 4488022820c9 No longer segfault when compiling nested for loops Max Brister <max@2bass.com> parents: 14938 diff changeset	1967 void merge_blocks (void);
4488022820c9 No longer segfault when compiling nested for loops Max Brister <max@2bass.com> parents: 14938 diff changeset	1968
14938 bab44e3ee291 Adding basic error support to JIT Max Brister <max@2bass.com> parents: 14937 diff changeset	1969 void construct_ssa (void);
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1970
14935 5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1971 static void do_construct_ssa (jit_block& block);
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1972
14945 591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1973 void remove_dead ();
591aeec5c520 Remove uneeded error checks Max Brister <max@2bass.com> parents: 14944 diff changeset	1974
14935 5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1975 void place_releases (void);
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	1976
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1977 void print_blocks (const std::string& header)
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1978 {
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1979 std::cout << "-------------------- " << header << " --------------------\n";
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1980 for (std::list<jit_block *>::iterator iter = blocks.begin ();
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1981 iter != blocks.end (); ++iter)
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1982 {
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1983 assert (*iter);
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1984 (*iter)->print (std::cout, 0);
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1985 }
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1986 std::cout << std::endl;
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1987 }
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1988
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1989 void print_dom (void)
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1990 {
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1991 std::cout << "-------------------- dom info --------------------\n";
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1992 for (std::list<jit_block *>::iterator iter = blocks.begin ();
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1993 iter != blocks.end (); ++iter)
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1994 {
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1995 assert (*iter);
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1996 (*iter)->print_dom (std::cout);
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1997 }
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1998 std::cout << std::endl;
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	1999 }
39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	2000
14935 5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	2001 bool breaking; // true if we are breaking OR continuing
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	2002 block_list breaks;
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	2003 block_list continues;
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	2004
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	2005 void finish_breaks (jit_block *dest, const block_list& lst);
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	2006
14935 5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	2007 struct release_placer
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	2008 {
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	2009 release_placer (jit_convert& aconvert) : convert (aconvert) {}
14928 39d52aa37a08 Use standard SSA construction algorithm, and support break/continue Max Brister <max@2bass.com> parents: 14926 diff changeset	2010
14935 5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	2011 jit_convert& convert;
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 operator() (jit_block& block);
5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	2014 };
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	2015
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	2016 // this case is much simpler, just convert from the jit ir to llvm
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	2017 class
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	2018 convert_llvm : public jit_ir_walker
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	2019 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	2020 public:
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	2021 llvm::Function convert (llvm::Module module,
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	2022 const std::vector<std::pair<std::string, bool> >& args,
14944 c0a5ab3b9278 jit_const no longer inherits from jit_instruction Max Brister <max@2bass.com> parents: 14943 diff changeset	2023 const std::list<jit_block *>& blocks,
c0a5ab3b9278 jit_const no longer inherits from jit_instruction Max Brister <max@2bass.com> parents: 14943 diff changeset	2024 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	2025
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	2026 #define JIT_METH(clname) \
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	2027 virtual void visit (jit_ ## clname&);
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	2028
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	2029 JIT_VISIT_IR_CLASSES;
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	2030
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	2031 #undef JIT_METH
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	2032 private:
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	2033 // name -> llvm argument
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	2034 std::map<std::string, llvm::Value *> arguments;
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	2035
14935 5801e031a3b5 Place releases after last use and generalize dom visiting Max Brister <max@2bass.com> parents: 14932 diff changeset	2036 void finish_phi (jit_instruction *phi);
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	2037
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	2038 void visit (jit_value *jvalue)
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	2039 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	2040 return visit (*jvalue);
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	2041 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	2042
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	2043 void visit (jit_value &jvalue)
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 jvalue.accept (*this);
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	2046 }
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	2047 private:
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	2048 llvm::Function *function;
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	2049 };
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	2050 };
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	2051
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	2052 class jit_info;
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	2053
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	2054 class
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	2055 tree_jit
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	2056 {
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	2057 public:
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	2058 tree_jit (void);
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	2059
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	2060 ~tree_jit (void);
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	2061
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	2062 bool execute (tree_simple_for_command& cmd);
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	2063
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	2064 llvm::ExecutionEngine *get_engine (void) const { return engine; }
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	2065
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	2066 llvm::Module *get_module (void) const { return module; }
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	2067
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	2068 void optimize (llvm::Function *fn);
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	2069 private:
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	2070 bool initialize (void);
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	2071
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	2072 // FIXME: Temorary hack to test
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	2073 typedef std::map<tree , jit_info > compiled_map;
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	2074 llvm::Module *module;
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	2075 llvm::PassManager *module_pass_manager;
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	2076 llvm::FunctionPassManager *pass_manager;
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	2077 llvm::ExecutionEngine *engine;
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	2078 };
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	2079
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	2080 class
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	2081 jit_info
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	2082 {
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	2083 public:
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	2084 jit_info (tree_jit& tjit, tree& tee);
14913 c7071907a641 Use symbol_record_ref instead of names in JIT Max Brister <max@2bass.com> parents: 14911 diff changeset	2085
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	2086 bool execute (void) const;
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	2087
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	2088 bool match (void) const;
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	2089 private:
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	2090 typedef jit_convert::type_bound type_bound;
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	2091 typedef jit_convert::type_bound_vector type_bound_vector;
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	2092 typedef void (jited_function)(octave_base_value*);
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	2093
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	2094 llvm::ExecutionEngine *engine;
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	2095 jited_function function;
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	2096
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	2097 std::vector<std::pair<std::string, bool> > arguments;
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	2098 type_bound_vector bounds;
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	2099 };
14937 78e1457c5bf5 Remove some macros from pt-jit.h and pt-jit.cc Max Brister <max@2bass.com> parents: 14936 diff changeset	2100
78e1457c5bf5 Remove some macros from pt-jit.h and pt-jit.cc Max Brister <max@2bass.com> parents: 14936 diff changeset	2101 // some #defines we use in the header, but not the cc file
78e1457c5bf5 Remove some macros from pt-jit.h and pt-jit.cc Max Brister <max@2bass.com> parents: 14936 diff changeset	2102 #undef JIT_VISIT_IR_CLASSES
78e1457c5bf5 Remove some macros from pt-jit.h and pt-jit.cc Max Brister <max@2bass.com> parents: 14936 diff changeset	2103 #undef JIT_VISIT_IR_CONST
78e1457c5bf5 Remove some macros from pt-jit.h and pt-jit.cc Max Brister <max@2bass.com> parents: 14936 diff changeset	2104 #undef JIT_VALUE_ACCEPT
78e1457c5bf5 Remove some macros from pt-jit.h and pt-jit.cc Max Brister <max@2bass.com> parents: 14936 diff changeset	2105
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	2106 #endif
14932 1f914446157d Locate and link with LLVM properly Max Brister <max@2bass.com> parents: 14928 diff changeset	2107 #endif

Mercurial > hg > octave-nkf

annotate src/pt-jit.h @ 14946:3564bb141396