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