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

annotate src/pt-jit.h @ 14926:aebd296a15c4

Prevent double release of input arguments in JIT

author	Max Brister <max@2bass.com>
date	Tue, 29 May 2012 13:51:02 -0500
parents	8697e3e9d77a
children	39d52aa37a08

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
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	26 #include <list>
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	27 #include <map>
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	28 #include <set>
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	29 #include <stdexcept>
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	30 #include <vector>
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	31
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	32 #include "Array.h"
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	33 #include "Range.h"
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	34 #include "pt-walk.h"
14913 c7071907a641 Use symbol_record_ref instead of names in JIT Max Brister <max@2bass.com> parents: 14911 diff changeset	35 #include "symtab.h"
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	36
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	37 // -------------------- Current status --------------------
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	38 // Simple binary operations (+-*/) on octave_scalar's (doubles) are optimized.
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	39 // 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	40 // a = 5;
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	41 // b = a * 5 + a;
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	42 //
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	43 // 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	44 // example,
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	45 // a = [1 2 3]
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	46 // b = a + a;
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	47 // will compile to do_binary_op (a, a).
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	48 //
14923 168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	49 // For loops are compiled again!
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	50 // if, elseif, and else statements compile again!
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	51 // Additionally, make check passes using jit.
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	52 //
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	53 // 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	54 // 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	55 // c = call binary+ (a, b)
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	56 // 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	57 // 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	58 //
14915 cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	59 //
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	60 // TODO:
14923 168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	61 // 1. Support error cases
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	62 // 2. Support break/continue
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	63 // 3. Fix memory leaks in JIT
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	64 // 4. Cleanup/documentation
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	65 // 5. ...
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	66 // ---------------------------------------------------------
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	67
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	68
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	69 // 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	70 // and __STDC_CONSTANT_MACROS be defined in the entire compilation unit
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	71 namespace llvm
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	72 {
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	73 class Value;
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	74 class Module;
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	75 class FunctionPassManager;
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	76 class PassManager;
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	77 class ExecutionEngine;
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	78 class Function;
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	79 class BasicBlock;
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	80 class LLVMContext;
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	81 class Type;
14915 cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	82 class Twine;
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	83 }
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	84
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	85 class octave_base_value;
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	86 class octave_value;
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	87 class tree;
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	88
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	89 // jit_range is compatable with the llvm range structure
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	90 struct
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	91 jit_range
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	92 {
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	93 jit_range (void) {}
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	94
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	95 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	96 inc (from.inc ()), nelem (from.nelem ())
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	97 {}
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	98
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	99 operator Range () const
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	100 {
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	101 return Range (base, limit, inc);
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	102 }
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	103
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	104 double base;
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	105 double limit;
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	106 double inc;
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	107 octave_idx_type nelem;
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	108 };
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	109
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	110 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	111
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	112 // 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	113 // hierarchical type system which includes both concrete and abstract types.
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	114 //
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	115 // 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	116 // 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	117 // code even for the case of poor type inference.
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	118 class
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	119 jit_type
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	120 {
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	121 public:
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	122 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	123 int aid) :
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	124 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	125 mdepth (aparent ? aparent->mdepth + 1 : 0)
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	126 {}
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	127
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	128 // a user readable type name
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	129 const std::string& name (void) const { return mname; }
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	130
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	131 // 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	132 int type_id (void) const { return mid; }
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	133
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	134 // 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	135 jit_type *parent (void) const { return mparent; }
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	136
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	137 // convert to an llvm type
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	138 llvm::Type *to_llvm (void) const { return llvm_type; }
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	139
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	140 // how this type gets passed as a function argument
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	141 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	142
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	143 size_t depth (void) const { return mdepth; }
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	144 private:
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	145 std::string mname;
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	146 jit_type *mparent;
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	147 llvm::Type *llvm_type;
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	148 int mid;
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	149 size_t mdepth;
14903 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
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	152 // seperate print function to allow easy printing if type is null
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	153 static std::ostream& jit_print (std::ostream& os, jit_type *atype)
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	154 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	155 if (! atype)
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	156 return os << "null";
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	157 return os << atype->name ();
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	158 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	159
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	160 // 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	161 // and code generation.
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	162 class
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	163 jit_function
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	164 {
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	165 public:
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	166 struct overload
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	167 {
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	168 overload (void) : function (0), can_error (true), result (0) {}
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	169
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	170 overload (llvm::Function f, bool e, jit_type r, jit_type *arg0) :
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	171 function (f), can_error (e), result (r), arguments (1)
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	172 {
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	173 arguments[0] = arg0;
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	174 }
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	175
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	176 overload (llvm::Function f, bool e, jit_type r, jit_type *arg0,
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	177 jit_type *arg1) : function (f), can_error (e), result (r),
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	178 arguments (2)
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 arguments[1] = arg1;
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	182 }
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	183
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	184 llvm::Function *function;
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	185 bool can_error;
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	186 jit_type *result;
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	187 std::vector<jit_type*> arguments;
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	188 };
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 void add_overload (const overload& func)
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	191 {
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	192 add_overload (func, func.arguments);
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	193 }
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	194
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	195 void add_overload (llvm::Function f, bool e, jit_type r, jit_type *arg0)
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	196 {
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	197 overload ol (f, e, r, arg0);
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	198 add_overload (ol);
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	199 }
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	200
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	201 void add_overload (llvm::Function f, bool e, jit_type r, jit_type *arg0,
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	202 jit_type *arg1)
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	203 {
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	204 overload ol (f, e, r, arg0, arg1);
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	205 add_overload (ol);
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	206 }
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 void add_overload (const overload& func,
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	209 const std::vector<jit_type*>& args);
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	210
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	211 const overload& get_overload (const std::vector<jit_type *>& types) const;
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	212
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	213 const overload& get_overload (jit_type *arg0) const
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	214 {
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	215 std::vector<jit_type *> types (1);
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	216 types[0] = arg0;
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	217 return get_overload (types);
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	218 }
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	219
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	220 const overload& get_overload (jit_type arg0, jit_type arg1) const
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	221 {
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	222 std::vector<jit_type *> types (2);
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	223 types[0] = arg0;
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	224 types[1] = arg1;
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	225 return get_overload (types);
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	226 }
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	227
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	228 jit_type get_result (const std::vector<jit_type >& types) const
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	229 {
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	230 const overload& temp = get_overload (types);
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	231 return temp.result;
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	232 }
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 jit_type get_result (jit_type arg0, jit_type *arg1) 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& temp = get_overload (arg0, arg1);
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	237 return temp.result;
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	238 }
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	239
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	240 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	241
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	242 void stash_name (const std::string& aname) { mname = aname; }
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	243 private:
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	244 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	245
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	246 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	247
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	248 std::string mname;
14903 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 // Get information and manipulate jit types.
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	252 class
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	253 jit_typeinfo
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	254 {
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	255 public:
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	256 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	257
14922 2e6f83b2f2b9 Cleanup of some type inference functions Max Brister <max@2bass.com> parents: 14920 diff changeset	258 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	259 {
14922 2e6f83b2f2b9 Cleanup of some type inference functions Max Brister <max@2bass.com> parents: 14920 diff changeset	260 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	261 }
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 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	264
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	265 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	266
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	267 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	268
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	269 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	270
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	271 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	272
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	273 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	274
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	275 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	276
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	277 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	278
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	279 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	280 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	281 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	282 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	283
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	284 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	285 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	286 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	287 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	288
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	289 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	290
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	291 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	292 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	293 return instance->release_fn;
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	294 }
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 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	297 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	298 return instance->print_fn;
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	299 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	300
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	301 static const jit_function& for_init (void)
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	302 {
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	303 return instance->for_init_fn;
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	304 }
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	305
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	306 static const jit_function& for_check (void)
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	307 {
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	308 return instance->for_check_fn;
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	309 }
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	310
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	311 static const jit_function& for_index (void)
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	312 {
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	313 return instance->for_index_fn;
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	314 }
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	315
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	316 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	317 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	318 return instance->do_cast (result);
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	319 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	320
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	321 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	322 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	323 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	324 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	325 private:
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	326 jit_typeinfo (llvm::Module m, llvm::ExecutionEngine e);
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	327
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	328 // 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	329 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	330 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	331 // empty case
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	332 if (! lhs)
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	333 return rhs;
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	334
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	335 if (! rhs)
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	336 return lhs;
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	337
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	338 // check for a shared parent
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	339 while (lhs != rhs)
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	340 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	341 if (lhs->depth () > rhs->depth ())
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	342 lhs = lhs->parent ();
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	343 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	344 rhs = rhs->parent ();
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	345 else
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	346 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	347 // 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	348 do
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	349 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	350 lhs = lhs->parent ();
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	351 rhs = rhs->parent ();
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	352 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	353 while (lhs != rhs);
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	354 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	355 }
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	356
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	357 return lhs;
14915 cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	358 }
cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	359
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	360 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	361 {
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	362 // 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	363 return lhs;
14915 cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	364 }
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	365
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	366 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	367
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	368 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	369 {
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	370 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	371 return binary_ops[op];
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	372 }
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	373
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	374 const jit_function& do_cast (jit_type *to)
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	375 {
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	376 static jit_function null_function;
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	377 if (! to)
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	378 return null_function;
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	379
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	380 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	381 if (id >= casts.size ())
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	382 return null_function;
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	383 return casts[id];
14915 cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	384 }
cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	385
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	386 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	387 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	388 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	389 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	390
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	391 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	392 llvm::Type *llvm_type);
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	393
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	394
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	395 void add_print (jit_type ty, void call);
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	396
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	397 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	398
14915 cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	399 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	400
cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	401 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	402
cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	403 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	404 llvm::Type *arg0)
cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	405 {
cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	406 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	407 return create_function (name, ret, args);
cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	408 }
cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	409
cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	410 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	411 jit_type *arg0)
cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	412 {
cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	413 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	414 }
cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	415
cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	416 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	417 llvm::Type arg0, llvm::Type arg1)
cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	418 {
cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	419 std::vector<llvm::Type *> args (2);
cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	420 args[0] = arg0;
cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	421 args[1] = arg1;
cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	422 return create_function (name, ret, args);
cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	423 }
cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	424
cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	425 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	426 jit_type arg0, jit_type arg1)
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 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	429 arg1->to_llvm ());
cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	430 }
cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	431
cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	432 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	433 llvm::Type arg0, llvm::Type arg1,
cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	434 llvm::Type *arg2)
cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	435 {
cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	436 std::vector<llvm::Type *> args (3);
cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	437 args[0] = arg0;
cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	438 args[1] = arg1;
cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	439 args[2] = arg2;
cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	440 return create_function (name, ret, args);
cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	441 }
cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	442
cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	443 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	444 jit_type arg0, jit_type arg1,
cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	445 jit_type *arg2)
cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	446 {
cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	447 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	448 arg1->to_llvm (), arg2->to_llvm ());
cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	449 }
cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	450
cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	451 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	452 const std::vector<llvm::Type *>& args);
cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	453
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	454 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	455
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	456 static jit_typeinfo *instance;
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	457
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	458 llvm::Module *module;
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	459 llvm::ExecutionEngine *engine;
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	460 int next_id;
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	461
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	462 llvm::Type *ov_t;
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	463
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	464 std::vector<jit_type*> id_to_type;
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	465 jit_type *any;
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	466 jit_type *scalar;
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	467 jit_type *range;
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	468 jit_type *string;
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	469 jit_type *boolean;
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	470 jit_type *index;
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	471
54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	472 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	473 jit_function grab_fn;
cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	474 jit_function release_fn;
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	475 jit_function print_fn;
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	476 jit_function for_init_fn;
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	477 jit_function for_check_fn;
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	478 jit_function for_index_fn;
14915 cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	479 jit_function logically_true;
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	480
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	481 // 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	482 std::vector<jit_function> casts;
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	483
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	484 // type id -> identity function
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	485 std::vector<llvm::Function *> identities;
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	486 };
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	487
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	488 // 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	489 // 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	490 // 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	491
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	492 #define JIT_VISIT_IR_NOTEMPLATE \
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	493 JIT_METH(block); \
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	494 JIT_METH(break); \
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	495 JIT_METH(cond_break); \
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	496 JIT_METH(call); \
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	497 JIT_METH(extract_argument); \
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	498 JIT_METH(store_argument); \
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	499 JIT_METH(phi)
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	500
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	501 #define JIT_VISIT_IR_CLASSES \
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	502 JIT_VISIT_IR_NOTEMPLATE; \
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	503 JIT_VISIT_IR_CONST
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	504
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	505
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	506 class jit_ir_walker;
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	507 class jit_use;
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	508
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	509 class
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	510 jit_value
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	511 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	512 friend class jit_use;
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	513 public:
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	514 jit_value (void) : llvm_value (0), ty (0), use_head (0), myuse_count (0) {}
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	515
14925 8697e3e9d77a Properly cleanup the low level IR Max Brister <max@2bass.com> parents: 14923 diff changeset	516 virtual ~jit_value (void);
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	517
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	518 jit_type *type (void) const { return ty; }
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	519
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	520 llvm::Type *type_llvm (void) const
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	521 {
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	522 return ty ? ty->to_llvm () : 0;
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	523 }
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	524
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	525 const std::string& type_name (void) const
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	526 {
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	527 return ty->name ();
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	528 }
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	529
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	530 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	531
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	532 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	533
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	534 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	535
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	536 std::string print_string (void)
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	537 {
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	538 std::stringstream ss;
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	539 print (ss);
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	540 return ss.str ();
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	541 }
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	542
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	543 virtual std::ostream& print (std::ostream& os, size_t indent = 0) = 0;
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	544
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	545 virtual std::ostream& short_print (std::ostream& os)
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	546 { return print (os); }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	547
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	548 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	549
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	550 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	551 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	552 return llvm_value;
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	553 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	554
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	555 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	556 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	557 llvm_value = compiled;
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	558 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	559 protected:
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	560 std::ostream& print_indent (std::ostream& os, size_t indent)
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	561 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	562 for (size_t i = 0; i < indent; ++i)
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	563 os << "\t";
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	564 return os;
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	565 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	566
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	567 llvm::Value *llvm_value;
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	568 private:
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	569 jit_type *ty;
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	570 jit_use *use_head;
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	571 size_t myuse_count;
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	572 };
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	573
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	574 // defnie accept methods for subclasses
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	575 #define JIT_VALUE_ACCEPT(clname) \
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	576 virtual void accept (jit_ir_walker& walker);
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	577
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	578 template <typename T, jit_type (EXTRACT_T)(void), typename PASS_T = T,
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	579 bool QUOTE=false>
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	580 class
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	581 jit_const : public jit_value
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	582 {
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	583 public:
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	584 typedef PASS_T pass_t;
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	585
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	586 jit_const (PASS_T avalue) : mvalue (avalue)
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	587 {
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	588 stash_type (EXTRACT_T ());
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	589 }
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 PASS_T 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	592
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	593 virtual std::ostream& print (std::ostream& os, size_t indent)
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	594 {
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	595 print_indent (os, indent) << type_name () << ": ";
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	596 if (QUOTE)
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	597 os << "\"";
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	598 os << mvalue;
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	599 if (QUOTE)
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	600 os << "\"";
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	601 return os;
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	602 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	603
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	604 JIT_VALUE_ACCEPT (jit_const);
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	605 private:
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	606 T mvalue;
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	607 };
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	608
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	609 typedef jit_const<double, jit_typeinfo::get_scalar> jit_const_scalar;
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	610 typedef jit_const<octave_idx_type, jit_typeinfo::get_index> jit_const_index;
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	611
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	612 typedef jit_const<std::string, jit_typeinfo::get_string, const std::string&, true>
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	613 jit_const_string;
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	614 typedef jit_const<jit_range, jit_typeinfo::get_range, const jit_range&>
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	615 jit_const_range;
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	616
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	617 #define JIT_VISIT_IR_CONST \
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	618 JIT_METH(const_scalar); \
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	619 JIT_METH(const_index); \
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	620 JIT_METH(const_string); \
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	621 JIT_METH(const_range)
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	622
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	623 class jit_instruction;
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	624 class jit_block;
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	625
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	626 class
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	627 jit_use
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	628 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	629 public:
14923 168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	630 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	631
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	632 // 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	633 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	634 mindex (0)
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	635 {
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	636 *this = use;
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	637 }
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	638
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	639 ~jit_use (void) { remove (); }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	640
14923 168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	641 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	642 {
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	643 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	644 return *this;
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	645 }
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	646
14923 168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	647 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	648
14923 168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	649 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	650
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	651 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	652
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	653 jit_block *user_parent (void) const;
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	654
14923 168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	655 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	656 size_t aindex = -1)
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	657 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	658 remove ();
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	659
14923 168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	660 mvalue = avalue;
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	661
14923 168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	662 if (mvalue)
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	663 {
14923 168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	664 if (mvalue->use_head)
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	665 {
14923 168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	666 mvalue->use_head->mprev = this;
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	667 mnext = mvalue->use_head;
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	668 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	669
14923 168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	670 mvalue->use_head = this;
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	671 ++mvalue->myuse_count;
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	672 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	673
14923 168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	674 mindex = aindex;
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	675 muser = auser;
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	676 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	677
14923 168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	678 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	679
14923 168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	680 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	681 private:
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	682 void remove (void)
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	683 {
14923 168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	684 if (mvalue)
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	685 {
14923 168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	686 if (this == mvalue->use_head)
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	687 mvalue->use_head = mnext;
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	688
14923 168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	689 if (mprev)
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	690 mprev->mnext = mnext;
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	691
14923 168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	692 if (mnext)
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	693 mnext->mprev = mprev;
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	694
14923 168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	695 mnext = mprev = 0;
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	696 --mvalue->myuse_count;
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	697 mvalue = 0;
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	698 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	699 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	700
14923 168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	701 jit_value *mvalue;
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	702 jit_use *mnext;
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	703 jit_use *mprev;
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	704 jit_instruction *muser;
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	705 size_t mindex;
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	706 };
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	707
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	708 class
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	709 jit_instruction : public jit_value
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	710 {
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	711 public:
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	712 // FIXME: this code could be so much pretier with varadic templates...
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	713 jit_instruction (void) : id (next_id ()), mparent (0)
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	714 {}
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 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	717 : already_infered (nargs, reinterpret_cast<jit_type *>(0)), arguments (nargs),
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	718 id (next_id ()), mparent (0)
14923 168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	719 {
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	720 if (adefault)
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	721 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	722 stash_argument (i, adefault);
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	723 }
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	724
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	725 jit_instruction (jit_value *arg0)
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	726 : already_infered (1, reinterpret_cast<jit_type *>(0)), arguments (1),
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	727 id (next_id ()), mparent (0)
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	728 {
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	729 stash_argument (0, arg0);
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	730 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	731
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	732 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	733 : already_infered (2, reinterpret_cast<jit_type *>(0)), arguments (2),
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	734 id (next_id ()), mparent (0)
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	735 {
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	736 stash_argument (0, arg0);
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	737 stash_argument (1, arg1);
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	738 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	739
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	740 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	741 : already_infered (3, reinterpret_cast<jit_type *>(0)), arguments (3),
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	742 id (next_id ()), mparent (0)
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	743 {
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	744 stash_argument (0, arg0);
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	745 stash_argument (1, arg1);
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	746 stash_argument (2, arg2);
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
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	749 static void reset_ids (void)
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	750 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	751 next_id (true);
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	752 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	753
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	754 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	755 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	756 return arguments[i].value ();
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	757 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	758
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	759 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	760 {
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	761 assert (argument (i));
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	762 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	763 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	764
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	765 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	766 {
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	767 assert (argument (i));
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	768 return argument (i)->type ();
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	769 }
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	770
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	771 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	772 {
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	773 assert (argument (i));
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	774 return argument_type (i)->to_llvm ();
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	775 }
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	776
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	777 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	778 {
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	779 if (argument (i))
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	780 return argument (i)->short_print (os);
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	781 else
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	782 return os << "NULL";
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	783 }
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	784
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	785 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	786 {
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	787 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	788 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	789
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	790 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	791 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	792 return arguments.size ();
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	793 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	794
14923 168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	795 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	796 {
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	797 size_t old = arguments.size ();
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	798 arguments.resize (acount);
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	799
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	800 if (adefault)
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	801 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	802 stash_argument (i, adefault);
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	803 }
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	804
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	805 // 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	806 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	807 { return already_infered; }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	808
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	809 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	810
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	811 virtual std::ostream& short_print (std::ostream& os)
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 if (mtag.empty ())
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	814 jit_print (os, type ()) << ": #" << id;
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	815 else
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	816 jit_print (os, type ()) << ": " << mtag << "." << id;
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	817
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	818 return os;
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	819 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	820
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	821 const std::string& tag (void) const { return mtag; }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	822
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	823 void stash_tag (const std::string& atag) { mtag = atag; }
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	824
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	825 jit_block *parent (void) const { return mparent; }
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	826
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	827 llvm::BasicBlock *parent_llvm (void) const;
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	828
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	829 void stash_parent (jit_block *aparent)
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	830 {
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	831 assert (! mparent);
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	832 mparent = aparent;
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	833 }
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	834 protected:
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	835 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	836 private:
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	837 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	838 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	839 static size_t ret = 0;
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	840 if (reset)
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	841 return ret = 0;
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 return ret++;
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	844 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	845
14923 168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	846 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	847
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	848 std::string mtag;
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	849 size_t id;
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	850 jit_block *mparent;
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	851 };
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	852
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	853 class jit_terminator;
14923 168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	854 class jit_phi;
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	855
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	856 class
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	857 jit_block : public jit_value
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	858 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	859 public:
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	860 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	861 typedef instruction_list::iterator iterator;
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	862 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	863
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	864 jit_block (const std::string& aname) : mname (aname)
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	865 {}
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	866
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	867 const std::string& name (void) const { return mname; }
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 jit_instruction prepend (jit_instruction instr);
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 jit_instruction append (jit_instruction instr);
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	872
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	873 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	874
14923 168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	875 jit_block *pred (size_t idx) const;
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	876
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	877 jit_terminator *pred_terminator (size_t idx) const
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	878 {
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	879 return pred (idx)->terminator ();
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	880 }
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	881
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	882 llvm::Value *pred_terminator_llvm (size_t idx) const;
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	883
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	884 std::ostream& print_pred (std::ostream& os, size_t idx)
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	885 {
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	886 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	887 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	888
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	889 // 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	890 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	891 {
14923 168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	892 if (mpred_llvm.size () < pred_count ())
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	893 mpred_llvm.resize (pred_count ());
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	894
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	895 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	896 }
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	897
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	898 llvm::BasicBlock pred_llvm (jit_block apred) const
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	899 {
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	900 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	901 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	902
14923 168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	903 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	904
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	905 // create llvm phi merge blocks for all predecessors (if required)
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	906 void create_merge (llvm::Function *inside, size_t pred_idx);
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	907
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	908 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	909
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	910 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	911
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	912 iterator begin (void) { return instructions.begin (); }
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	913
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	914 const_iterator begin (void) const { return instructions.begin (); }
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	915
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	916 iterator end (void) { return instructions.end (); }
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	917
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	918 const_iterator end (void) const { return instructions.begin (); }
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	919
14923 168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	920 // search for the phi function with the given tag_name, if no function
14925 8697e3e9d77a Properly cleanup the low level IR Max Brister <max@2bass.com> parents: 14923 diff changeset	921 // exists then null is returned
8697e3e9d77a Properly cleanup the low level IR Max Brister <max@2bass.com> parents: 14923 diff changeset	922 jit_phi *search_phi (const std::string& tag_name);
14923 168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	923
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	924 virtual std::ostream& print (std::ostream& os, size_t indent)
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	925 {
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	926 print_indent (os, indent) << mname << ":\tpred = ";
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	927 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	928 {
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	929 print_pred (os, i);
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	930 if (i + 1 < pred_count ())
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	931 os << ", ";
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	932 }
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	933 os << std::endl;
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	934
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	935 for (iterator iter = begin (); iter != end (); ++iter)
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	936 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	937 jit_instruction instr = iter;
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	938 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	939 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	940 return os;
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	941 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	942
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	943 virtual std::ostream& short_print (std::ostream& os)
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	944 {
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	945 return os << mname;
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	946 }
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	947
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	948 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	949
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	950 JIT_VALUE_ACCEPT (block)
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	951 private:
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	952 std::string mname;
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	953 instruction_list instructions;
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	954 mutable std::vector<llvm::BasicBlock *> mpred_llvm;
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	955 };
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	956
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	957 class
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	958 jit_phi : public jit_instruction
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	959 {
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	960 public:
14923 168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	961 jit_phi (size_t npred, jit_value *adefault = 0)
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	962 : jit_instruction (npred, adefault)
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	963 {}
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	964
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	965 virtual bool infer (void)
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	966 {
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	967 jit_type *infered = 0;
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	968 for (size_t i = 0; i < argument_count (); ++i)
14922 2e6f83b2f2b9 Cleanup of some type inference functions Max Brister <max@2bass.com> parents: 14920 diff changeset	969 infered = jit_typeinfo::join (infered, argument_type (i));
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	970
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	971 if (infered != type ())
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	972 {
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	973 stash_type (infered);
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	974 return true;
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	975 }
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	976
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	977 return false;
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	978 }
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	979
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	980 virtual std::ostream& print (std::ostream& os, size_t indent)
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	981 {
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	982 std::stringstream ss;
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	983 print_indent (ss, indent);
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	984 short_print (ss) << " phi ";
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	985 std::string ss_str = ss.str ();
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	986 std::string indent_str (ss_str.size () + 7, ' ');
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	987 os << ss_str;
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	988
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	989 jit_block *pblock = parent ();
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	990 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	991 {
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	992 if (i > 0)
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	993 os << indent_str;
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	994 os << "\| ";
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	995
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	996 pblock->print_pred (os, i) << " -> ";
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	997 print_argument (os, i);
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	998
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	999 if (i + 1 < argument_count ())
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1000 os << std::endl;
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1001 }
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1002
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1003 return os;
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1004 }
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1005
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1006 JIT_VALUE_ACCEPT (phi);
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1007 };
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 class
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1010 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	1011 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1012 public:
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1013 jit_terminator (jit_value *arg0) : jit_instruction (arg0) {}
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1014
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1015 jit_terminator (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	1016 : jit_instruction (arg0, arg1, arg2) {}
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1017
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1018 virtual jit_block *sucessor (size_t idx = 0) const = 0;
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1019
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1020 // 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	1021 // 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	1022 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	1023 {
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1024 jit_block *succ = sucessor (idx);
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1025 llvm::BasicBlock *pllvm = parent_llvm ();
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1026 llvm::BasicBlock *spred_llvm = succ->pred_llvm (parent ());
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1027 llvm::BasicBlock *succ_llvm = succ->to_llvm ();
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1028 return pllvm == spred_llvm ? succ_llvm : spred_llvm;
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1029 }
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1030
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1031 std::ostream& print_sucessor (std::ostream& os, size_t idx = 0)
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1032 {
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1033 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	1034 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1035
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1036 virtual size_t sucessor_count (void) const = 0;
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1037 };
14913 c7071907a641 Use symbol_record_ref instead of names in JIT Max Brister <max@2bass.com> parents: 14911 diff changeset	1038
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1039 class
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1040 jit_break : public jit_terminator
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1041 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1042 public:
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1043 jit_break (jit_block *succ) : jit_terminator (succ) {}
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1044
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1045 jit_block *sucessor (size_t idx = 0) const
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1046 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1047 jit_value *arg = argument (idx);
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1048 return static_cast<jit_block *> (arg);
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1049 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1050
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1051 size_t sucessor_count (void) const { return 1; }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1052
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1053 virtual std::ostream& print (std::ostream& os, size_t indent)
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1054 {
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1055 print_indent (os, indent) << "break: ";
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1056 return print_sucessor (os);
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1057 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1058
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1059 JIT_VALUE_ACCEPT (break)
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1060 };
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 class
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1063 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	1064 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1065 public:
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1066 jit_cond_break (jit_value c, jit_block ctrue, jit_block *cfalse)
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1067 : jit_terminator (c, ctrue, cfalse) {}
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1068
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1069 jit_value *cond (void) const { return argument (0); }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1070
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1071 std::ostream& print_cond (std::ostream& os)
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1072 {
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1073 return cond ()->short_print (os);
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1074 }
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1075
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1076 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	1077 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1078 return cond ()->to_llvm ();
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1079 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1080
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1081 jit_block *sucessor (size_t idx) const
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1082 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1083 jit_value *arg = argument (idx + 1);
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1084 return static_cast<jit_block *> (arg);
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1085 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1086
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1087 size_t sucessor_count (void) const { return 2; }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1088
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1089 virtual std::ostream& print (std::ostream& os, size_t indent)
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1090 {
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1091 print_indent (os, indent) << "cond_break: ";
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1092 print_cond (os) << ", ";
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1093 print_sucessor (os, 0) << ", ";
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1094 return print_sucessor (os, 1);
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1095 }
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1096
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1097 JIT_VALUE_ACCEPT (cond_break)
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1098 };
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1099
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1100 class
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1101 jit_call : public jit_instruction
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1102 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1103 public:
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1104 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	1105 jit_value *arg0) : jit_instruction (arg0), mfunction (afunction) {}
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1106
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1107 jit_call (const jit_function& (*afunction) (void),
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1108 jit_value *arg0) : jit_instruction (arg0), mfunction (afunction ()) {}
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1109
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1110 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	1111 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	1112 mfunction (afunction) {}
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1113
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1114 jit_call (const jit_function& (*afunction) (void),
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1115 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	1116 mfunction (afunction ()) {}
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1117
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1118 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	1119
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1120 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	1121 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1122 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	1123 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1124
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1125 virtual std::ostream& print (std::ostream& os, size_t indent)
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1126 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1127 print_indent (os, indent);
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1128
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1129 if (use_count ())
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1130 short_print (os) << " = ";
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1131 os << "call " << mfunction.name () << " (";
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1132
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1133 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	1134 {
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1135 print_argument (os, i);
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1136 if (i + 1 < argument_count ())
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1137 os << ", ";
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1138 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1139 return os << ")";
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1140 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1141
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1142 virtual bool infer (void);
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1143
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1144 JIT_VALUE_ACCEPT (call)
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1145 private:
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1146 const jit_function& mfunction;
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1147 };
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1148
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1149 class
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1150 jit_extract_argument : public jit_instruction
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1151 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1152 public:
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1153 jit_extract_argument (jit_type *atype, const std::string& aname)
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1154 : jit_instruction ()
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1155 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1156 stash_type (atype);
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1157 stash_tag (aname);
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1158 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1159
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1160 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	1161 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1162 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	1163 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1164
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1165 virtual std::ostream& print (std::ostream& os, size_t indent)
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1166 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1167 print_indent (os, indent);
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1168 return short_print (os) << " = extract: " << tag ();
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1169 }
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 JIT_VALUE_ACCEPT (extract_argument)
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1172 };
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1173
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1174 class
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1175 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	1176 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1177 public:
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1178 jit_store_argument (const std::string& aname, jit_value *aresult)
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1179 : jit_instruction (aresult)
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1180 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1181 stash_tag (aname);
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1182 }
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1183
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1184 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	1185 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1186 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	1187 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1188
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1189 jit_value *result (void) const
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1190 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1191 return argument (0);
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1192 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1193
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1194 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	1195 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1196 return result ()->type ();
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1197 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1198
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1199 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	1200 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1201 return result ()->to_llvm ();
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1202 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1203
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1204 virtual std::ostream& print (std::ostream& os, size_t indent)
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1205 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1206 jit_value *res = result ();
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1207 print_indent (os, indent) << tag () << " <- ";
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1208 return res->short_print (os);
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1209 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1210
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1211 JIT_VALUE_ACCEPT (store_argument)
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1212 };
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1213
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1214 class
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1215 jit_ir_walker
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1216 {
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1217 public:
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1218 virtual ~jit_ir_walker () {}
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1219
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1220 #define JIT_METH(clname) \
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1221 virtual void visit (jit_ ## clname&) = 0
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1222
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1223 JIT_VISIT_IR_CLASSES;
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1224
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1225 #undef JIT_METH
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1226 };
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1227
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1228 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	1229 void
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1230 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	1231 {
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1232 walker.visit (*this);
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1233 }
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1234
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1235 // convert between IRs
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1236 // 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	1237 // cleaned up.
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1238 class
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1239 jit_convert : public tree_walker
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1240 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1241 public:
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1242 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	1243 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	1244
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1245 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	1246
14925 8697e3e9d77a Properly cleanup the low level IR Max Brister <max@2bass.com> parents: 14923 diff changeset	1247 ~jit_convert (void);
8697e3e9d77a Properly cleanup the low level IR Max Brister <max@2bass.com> parents: 14923 diff changeset	1248
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1249 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	1250
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1251 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	1252 { return arguments; }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1253
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1254 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	1255
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1256 void visit_anon_fcn_handle (tree_anon_fcn_handle&);
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1257
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1258 void visit_argument_list (tree_argument_list&);
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1259
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1260 void visit_binary_expression (tree_binary_expression&);
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1261
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1262 void visit_break_command (tree_break_command&);
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1263
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1264 void visit_colon_expression (tree_colon_expression&);
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1265
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1266 void visit_continue_command (tree_continue_command&);
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1267
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1268 void visit_global_command (tree_global_command&);
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1269
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1270 void visit_persistent_command (tree_persistent_command&);
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1271
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1272 void visit_decl_elt (tree_decl_elt&);
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1273
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1274 void visit_decl_init_list (tree_decl_init_list&);
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1275
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1276 void visit_simple_for_command (tree_simple_for_command&);
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1277
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1278 void visit_complex_for_command (tree_complex_for_command&);
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1279
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1280 void visit_octave_user_script (octave_user_script&);
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1281
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1282 void visit_octave_user_function (octave_user_function&);
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1283
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1284 void visit_octave_user_function_header (octave_user_function&);
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1285
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1286 void visit_octave_user_function_trailer (octave_user_function&);
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1287
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1288 void visit_function_def (tree_function_def&);
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1289
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1290 void visit_identifier (tree_identifier&);
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1291
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1292 void visit_if_clause (tree_if_clause&);
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1293
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1294 void visit_if_command (tree_if_command&);
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1295
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1296 void visit_if_command_list (tree_if_command_list&);
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1297
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1298 void visit_index_expression (tree_index_expression&);
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1299
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1300 void visit_matrix (tree_matrix&);
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1301
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1302 void visit_cell (tree_cell&);
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1303
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1304 void visit_multi_assignment (tree_multi_assignment&);
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1305
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1306 void visit_no_op_command (tree_no_op_command&);
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1307
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1308 void visit_constant (tree_constant&);
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1309
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1310 void visit_fcn_handle (tree_fcn_handle&);
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1311
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1312 void visit_parameter_list (tree_parameter_list&);
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1313
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1314 void visit_postfix_expression (tree_postfix_expression&);
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1315
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1316 void visit_prefix_expression (tree_prefix_expression&);
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1317
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1318 void visit_return_command (tree_return_command&);
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1319
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1320 void visit_return_list (tree_return_list&);
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1321
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1322 void visit_simple_assignment (tree_simple_assignment&);
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1323
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1324 void visit_statement (tree_statement&);
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1325
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1326 void visit_statement_list (tree_statement_list&);
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1327
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1328 void visit_switch_case (tree_switch_case&);
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1329
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1330 void visit_switch_case_list (tree_switch_case_list&);
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1331
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1332 void visit_switch_command (tree_switch_command&);
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1333
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1334 void visit_try_catch_command (tree_try_catch_command&);
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1335
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1336 void visit_unwind_protect_command (tree_unwind_protect_command&);
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1337
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1338 void visit_while_command (tree_while_command&);
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1339
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1340 void visit_do_until_command (tree_do_until_command&);
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1341 private:
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1342 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	1343 type_bound_vector bounds;
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1344
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1345 class
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1346 variable_map
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1347 {
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1348 // internal variable map
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1349 typedef std::map<std::string, jit_value *> ivar_map;
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1350 public:
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1351 typedef ivar_map::iterator iterator;
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1352 typedef ivar_map::const_iterator const_iterator;
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1353
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1354 variable_map (variable_map aparent, jit_block ablock) : mparent (aparent),
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1355 mblock (ablock)
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1356 {}
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1357
14923 168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	1358 virtual ~variable_map () {}
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	1359
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1360 variable_map *parent (void) const { return mparent; }
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1361
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1362 jit_block *block (void) const { return mblock; }
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1363
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1364 jit_value *get (const std::string& name)
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1365 {
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1366 ivar_map::iterator iter = vars.find (name);
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1367 if (iter != vars.end ())
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1368 return iter->second;
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1369
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1370 if (mparent)
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1371 {
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1372 jit_value *pval = mparent->get (name);
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1373 return insert (name, pval);
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1374 }
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1375
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1376 return insert (name, 0);
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1377 }
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1378
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1379 jit_value set (const std::string& name, jit_value val)
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1380 {
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1381 get (name); // force insertion
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1382 return vars[name] = val;
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1383 }
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1384
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1385 iterator begin (void) { return vars.begin (); }
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1386 const_iterator begin (void) const { return vars.begin (); }
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1387
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1388 iterator end (void) { return vars.end (); }
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1389 const_iterator end (void) const { return vars.end (); }
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1390
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1391 size_t size (void) const { return vars.size (); }
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1392 protected:
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1393 virtual jit_value insert (const std::string& name, jit_value pval) = 0;
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1394
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1395 ivar_map vars;
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1396 private:
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1397 variable_map *mparent;
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1398 jit_block *mblock;
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1399 };
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1400
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1401 class
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1402 toplevel_map : public variable_map
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 public:
14925 8697e3e9d77a Properly cleanup the low level IR Max Brister <max@2bass.com> parents: 14923 diff changeset	1405 toplevel_map (jit_convert& aconvert, jit_block *aentry)
8697e3e9d77a Properly cleanup the low level IR Max Brister <max@2bass.com> parents: 14923 diff changeset	1406 : variable_map (0, aentry), convert (aconvert) {}
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1407 protected:
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1408 virtual jit_value insert (const std::string& name, jit_value pval);
14925 8697e3e9d77a Properly cleanup the low level IR Max Brister <max@2bass.com> parents: 14923 diff changeset	1409 private:
8697e3e9d77a Properly cleanup the low level IR Max Brister <max@2bass.com> parents: 14923 diff changeset	1410 jit_convert& convert;
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1411 };
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1412
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1413 class
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1414 for_map : public variable_map
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 public:
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1417 typedef variable_map::iterator iterator;
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1418 typedef variable_map::const_iterator const_iterator;
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1419
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1420 for_map (variable_map aparent, jit_block ablock)
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1421 : variable_map (aparent, ablock)
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 // force insertion of all phi nodes
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1424 for (iterator iter = aparent->begin (); iter != aparent->end (); ++iter)
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1425 get (iter->first);
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1426 }
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1427
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1428 void finish_phi (variable_map& from)
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 jit_block *for_body = block ();
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1431 for (jit_block::iterator iter = for_body->begin ();
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1432 iter != for_body->end () && dynamic_cast<jit_phi > (iter); ++iter)
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1433 {
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1434 jit_instruction node = iter;
14923 168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	1435 if (! node->argument (1))
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	1436 node->stash_argument (1, from.get (node->tag ()));
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1437 }
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 protected:
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1440 virtual jit_value insert (const std::string& name, jit_value pval)
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1441 {
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1442 jit_phi *ret = new jit_phi (2);
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1443 ret->stash_tag (name);
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1444 block ()->prepend (ret);
14923 168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	1445 ret->stash_argument (0, pval);
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1446 return vars[name] = ret;
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1447 }
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1448 };
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1449
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1450 class
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1451 compound_map : public variable_map
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 public:
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1454 compound_map (variable_map *aparent) : variable_map (aparent, 0)
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1455 {}
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1456 protected:
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1457 virtual jit_value insert (const std::string&, jit_value pval)
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1458 {
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1459 return pval;
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1460 }
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1461 };
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1462
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1463
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1464 variable_map *variables;
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1465
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1466 // used instead of return values from visit_* functions
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1467 jit_value *result;
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1468
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1469 jit_block *block;
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1470 jit_block *final_block;
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1471
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1472 llvm::Function *function;
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1473
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1474 std::list<jit_block *> blocks;
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1475
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1476 std::list<jit_instruction *> worklist;
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1477
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1478 std::list<jit_value *> constants;
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1479
14925 8697e3e9d77a Properly cleanup the low level IR Max Brister <max@2bass.com> parents: 14923 diff changeset	1480 std::list<jit_value *> all_values;
8697e3e9d77a Properly cleanup the low level IR Max Brister <max@2bass.com> parents: 14923 diff changeset	1481
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1482 void do_assign (const std::string& lhs, jit_value *rhs, bool print);
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1483
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1484 jit_value visit (tree tee) { return visit (*tee); }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1485
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1486 jit_value *visit (tree& tee);
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1487
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1488 void append_users (jit_value *v)
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1489 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1490 for (jit_use *use = v->first_use (); use; use = use->next ())
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1491 worklist.push_back (use->user ());
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1492 }
14915 cba58541954c Add if support and fix leak with any Max Brister <max@2bass.com> parents: 14914 diff changeset	1493
14925 8697e3e9d77a Properly cleanup the low level IR Max Brister <max@2bass.com> parents: 14923 diff changeset	1494 // this would be easier with variadic templates
8697e3e9d77a Properly cleanup the low level IR Max Brister <max@2bass.com> parents: 14923 diff changeset	1495 template <typename T>
8697e3e9d77a Properly cleanup the low level IR Max Brister <max@2bass.com> parents: 14923 diff changeset	1496 T *create (void)
8697e3e9d77a Properly cleanup the low level IR Max Brister <max@2bass.com> parents: 14923 diff changeset	1497 {
8697e3e9d77a Properly cleanup the low level IR Max Brister <max@2bass.com> parents: 14923 diff changeset	1498 T *ret = new T();
8697e3e9d77a Properly cleanup the low level IR Max Brister <max@2bass.com> parents: 14923 diff changeset	1499 track_value (ret);
8697e3e9d77a Properly cleanup the low level IR Max Brister <max@2bass.com> parents: 14923 diff changeset	1500 return ret;
8697e3e9d77a Properly cleanup the low level IR Max Brister <max@2bass.com> parents: 14923 diff changeset	1501 }
8697e3e9d77a Properly cleanup the low level IR Max Brister <max@2bass.com> parents: 14923 diff changeset	1502
8697e3e9d77a Properly cleanup the low level IR Max Brister <max@2bass.com> parents: 14923 diff changeset	1503 template <typename T, typename ARG0>
8697e3e9d77a Properly cleanup the low level IR Max Brister <max@2bass.com> parents: 14923 diff changeset	1504 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	1505 {
14925 8697e3e9d77a Properly cleanup the low level IR Max Brister <max@2bass.com> parents: 14923 diff changeset	1506 T *ret = new T(arg0);
8697e3e9d77a Properly cleanup the low level IR Max Brister <max@2bass.com> parents: 14923 diff changeset	1507 track_value (ret);
8697e3e9d77a Properly cleanup the low level IR Max Brister <max@2bass.com> parents: 14923 diff changeset	1508 return ret;
8697e3e9d77a Properly cleanup the low level IR Max Brister <max@2bass.com> parents: 14923 diff changeset	1509 }
8697e3e9d77a Properly cleanup the low level IR Max Brister <max@2bass.com> parents: 14923 diff changeset	1510
8697e3e9d77a Properly cleanup the low level IR Max Brister <max@2bass.com> parents: 14923 diff changeset	1511 template <typename T, typename ARG0, typename ARG1>
8697e3e9d77a Properly cleanup the low level IR Max Brister <max@2bass.com> parents: 14923 diff changeset	1512 T *create (const ARG0& arg0, const ARG1& arg1)
8697e3e9d77a Properly cleanup the low level IR Max Brister <max@2bass.com> parents: 14923 diff changeset	1513 {
8697e3e9d77a Properly cleanup the low level IR Max Brister <max@2bass.com> parents: 14923 diff changeset	1514 T *ret = new T(arg0, arg1);
8697e3e9d77a Properly cleanup the low level IR Max Brister <max@2bass.com> parents: 14923 diff changeset	1515 track_value (ret);
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1516 return ret;
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1517 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1518
14925 8697e3e9d77a Properly cleanup the low level IR Max Brister <max@2bass.com> parents: 14923 diff changeset	1519 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	1520 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	1521 {
8697e3e9d77a Properly cleanup the low level IR Max Brister <max@2bass.com> parents: 14923 diff changeset	1522 T *ret = new T(arg0, arg1, arg2);
8697e3e9d77a Properly cleanup the low level IR Max Brister <max@2bass.com> parents: 14923 diff changeset	1523 track_value (ret);
8697e3e9d77a Properly cleanup the low level IR Max Brister <max@2bass.com> parents: 14923 diff changeset	1524 return ret;
8697e3e9d77a Properly cleanup the low level IR Max Brister <max@2bass.com> parents: 14923 diff changeset	1525 }
8697e3e9d77a Properly cleanup the low level IR Max Brister <max@2bass.com> parents: 14923 diff changeset	1526
8697e3e9d77a Properly cleanup the low level IR Max Brister <max@2bass.com> parents: 14923 diff changeset	1527 void track_value (jit_value *value)
8697e3e9d77a Properly cleanup the low level IR Max Brister <max@2bass.com> parents: 14923 diff changeset	1528 {
14926 aebd296a15c4 Prevent double release of input arguments in JIT Max Brister <max@2bass.com> parents: 14925 diff changeset	1529 if (value->type () && ! dynamic_cast<jit_instruction *>(value))
14925 8697e3e9d77a Properly cleanup the low level IR Max Brister <max@2bass.com> parents: 14923 diff changeset	1530 constants.push_back (value);
8697e3e9d77a Properly cleanup the low level IR Max Brister <max@2bass.com> parents: 14923 diff changeset	1531 all_values.push_back (value);
8697e3e9d77a Properly cleanup the low level IR Max Brister <max@2bass.com> parents: 14923 diff changeset	1532 }
8697e3e9d77a Properly cleanup the low level IR Max Brister <max@2bass.com> parents: 14923 diff changeset	1533
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1534 // place phi nodes in the current block to merge ref with variables
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1535 // we assume the same number of deffinitions
14923 168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	1536 void merge (jit_block *merge_block, variable_map& merge_vars,
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	1537 jit_block *incomming_block,
168cb10bb9c5 If, ifelse, and else statements JIT compile now Max Brister <max@2bass.com> parents: 14922 diff changeset	1538 const variable_map& incomming_vars);
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1539
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1540 // 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	1541 class
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1542 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	1543 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1544 public:
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1545 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	1546 const std::vector<std::pair<std::string, bool> >& args,
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1547 const std::list<jit_block *>& blocks,
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1548 const std::list<jit_value *>& constants);
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1549
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1550 #define JIT_METH(clname) \
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1551 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	1552
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1553 JIT_VISIT_IR_CLASSES;
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1554
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1555 #undef JIT_METH
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1556 private:
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1557 // name -> llvm argument
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1558 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	1559
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1560
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1561 void visit (jit_value *jvalue)
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1562 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1563 return visit (*jvalue);
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1564 }
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1565
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1566 void visit (jit_value &jvalue)
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1567 {
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1568 jvalue.accept (*this);
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1569 }
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1570 private:
51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1571 llvm::Function *function;
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1572 };
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1573 };
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1574
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1575 class jit_info;
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	1576
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	1577 class
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	1578 tree_jit
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	1579 {
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	1580 public:
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	1581 tree_jit (void);
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	1582
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	1583 ~tree_jit (void);
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	1584
14920 51d4b1018efb For loops compile with new IR Max Brister <max@2bass.com> parents: 14918 diff changeset	1585 bool execute (tree_simple_for_command& cmd);
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	1586
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1587 llvm::ExecutionEngine *get_engine (void) const { return engine; }
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	1588
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1589 llvm::Module *get_module (void) const { return module; }
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	1590
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1591 void optimize (llvm::Function *fn);
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1592 private:
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1593 bool initialize (void);
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	1594
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1595 // FIXME: Temorary hack to test
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1596 typedef std::map<tree , jit_info > compiled_map;
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	1597 llvm::Module *module;
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	1598 llvm::PassManager *module_pass_manager;
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	1599 llvm::FunctionPassManager *pass_manager;
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	1600 llvm::ExecutionEngine *engine;
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1601 };
14903 54ea692b8ab5 Reworking JIT implementation Max Brister <max@2bass.com> parents: 14901 diff changeset	1602
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1603 class
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1604 jit_info
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1605 {
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1606 public:
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1607 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	1608
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1609 bool execute (void) const;
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1610
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1611 bool match (void) const;
3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1612 private:
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1613 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	1614 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	1615 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	1616
14906 3f81e8b42955 JIT for loops over ranges Max Brister <max@2bass.com> parents: 14903 diff changeset	1617 llvm::ExecutionEngine *engine;
14917 232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1618 jited_function function;
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1619
232d8ab07932 Rewrite pt-jit.* adding new low level octave IR Max Brister <max@2bass.com> parents: 14915 diff changeset	1620 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	1621 type_bound_vector bounds;
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	1622 };
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	1623
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: diff changeset	1624 #endif

Mercurial > hg > octave-nkf

annotate src/pt-jit.h @ 14926:aebd296a15c4