|
14899
|
1 /* |
|
|
2 |
|
|
3 Copyright (C) 2009-2012 John W. Eaton |
|
|
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 |
|
|
23 #define __STDC_LIMIT_MACROS |
|
|
24 #define __STDC_CONSTANT_MACROS |
|
|
25 |
|
|
26 #ifdef HAVE_CONFIG_H |
|
|
27 #include <config.h> |
|
|
28 #endif |
|
|
29 |
|
|
30 #include "pt-jit.h" |
|
|
31 |
|
|
32 #include <typeinfo> |
|
|
33 |
|
|
34 #include <llvm/LLVMContext.h> |
|
|
35 #include <llvm/Module.h> |
|
|
36 #include <llvm/Function.h> |
|
|
37 #include <llvm/BasicBlock.h> |
|
|
38 #include <llvm/Support/IRBuilder.h> |
|
|
39 #include <llvm/ExecutionEngine/ExecutionEngine.h> |
|
|
40 #include <llvm/ExecutionEngine/JIT.h> |
|
|
41 #include <llvm/PassManager.h> |
|
|
42 #include <llvm/Analysis/Verifier.h> |
|
|
43 #include <llvm/Analysis/Passes.h> |
|
|
44 #include <llvm/Target/TargetData.h> |
|
|
45 #include <llvm/Transforms/Scalar.h> |
|
|
46 #include <llvm/Support/TargetSelect.h> |
|
|
47 #include <llvm/Support/raw_os_ostream.h> |
|
|
48 |
|
|
49 #include "ov-fcn-handle.h" |
|
|
50 #include "ov-usr-fcn.h" |
|
|
51 #include "pt-all.h" |
|
|
52 |
|
|
53 using namespace llvm; |
|
|
54 |
|
|
55 //FIXME: Move into tree_jit |
|
|
56 static IRBuilder<> builder (getGlobalContext ()); |
|
|
57 |
|
|
58 extern "C" void |
|
|
59 octave_print_double (const char *name, double value) |
|
|
60 { |
|
|
61 // FIXME: We should avoid allocating a new octave_scalar each time |
|
|
62 octave_value ov (value); |
|
|
63 ov.print_with_name (octave_stdout, name); |
|
|
64 } |
|
|
65 |
|
|
66 tree_jit::tree_jit (void) : context (getGlobalContext ()), engine (0) |
|
|
67 { |
|
|
68 InitializeNativeTarget (); |
|
|
69 InitializeNativeTargetAsmPrinter (); |
|
|
70 module = new Module ("octave", context); |
|
|
71 } |
|
|
72 |
|
|
73 tree_jit::~tree_jit (void) |
|
|
74 { |
|
|
75 delete module; |
|
|
76 } |
|
|
77 |
|
|
78 bool |
|
|
79 tree_jit::execute (tree& tee) |
|
|
80 { |
|
|
81 if (!engine) |
|
|
82 { |
|
|
83 engine = ExecutionEngine::createJIT (module); |
|
|
84 |
|
|
85 // initialize pass manager |
|
|
86 pass_manager = new FunctionPassManager (module); |
|
|
87 pass_manager->add (new TargetData(*engine->getTargetData ())); |
|
|
88 pass_manager->add (createBasicAliasAnalysisPass ()); |
|
|
89 pass_manager->add (createPromoteMemoryToRegisterPass ()); |
|
|
90 pass_manager->add (createInstructionCombiningPass ()); |
|
|
91 pass_manager->add (createReassociatePass ()); |
|
|
92 pass_manager->add (createGVNPass ()); |
|
|
93 pass_manager->add (createCFGSimplificationPass ()); |
|
|
94 pass_manager->doInitialization (); |
|
|
95 |
|
|
96 // create external functions |
|
|
97 Type *vtype = Type::getVoidTy (context); |
|
|
98 std::vector<Type*> pd_args (2); |
|
|
99 pd_args[0] = Type::getInt8PtrTy (context); |
|
|
100 pd_args[1] = Type::getDoubleTy (context); |
|
|
101 FunctionType *print_double_ty = FunctionType::get (vtype, pd_args, false); |
|
|
102 print_double = Function::Create (print_double_ty, |
|
|
103 Function::ExternalLinkage, |
|
|
104 "octave_print_double", module); |
|
|
105 engine->addGlobalMapping (print_double, |
|
|
106 reinterpret_cast<void*>(&octave_print_double)); |
|
|
107 } |
|
|
108 |
|
|
109 if (!engine) |
|
|
110 // sometimes this fails during early initialization |
|
|
111 return false; |
|
|
112 |
|
|
113 // find function |
|
|
114 function_info *finfo; |
|
|
115 finfo_map_iterator iter = compiled_functions.find (&tee); |
|
|
116 |
|
|
117 if (iter == compiled_functions.end ()) |
|
|
118 finfo = compile (tee); |
|
|
119 else |
|
|
120 finfo = iter->second; |
|
|
121 |
|
|
122 return finfo->execute (); |
|
|
123 } |
|
|
124 |
|
|
125 tree_jit::function_info* |
|
|
126 tree_jit::compile (tree& tee) |
|
|
127 { |
|
|
128 value_stack.clear (); |
|
|
129 variables.clear (); |
|
|
130 |
|
|
131 // setup function |
|
|
132 std::vector<Type*> args (2); |
|
|
133 args[0] = Type::getInt1PtrTy (context); |
|
|
134 args[1] = Type::getDoublePtrTy (context); |
|
|
135 FunctionType *ft = FunctionType::get (Type::getVoidTy (context), args, false); |
|
|
136 Function *compiling = Function::Create (ft, Function::ExternalLinkage, |
|
|
137 "test_fn", module); |
|
|
138 |
|
|
139 entry_block = BasicBlock::Create (context, "entry", compiling); |
|
|
140 BasicBlock *body = BasicBlock::Create (context, "body", |
|
|
141 compiling); |
|
|
142 builder.SetInsertPoint (body); |
|
|
143 |
|
|
144 // convert tree to LLVM IR |
|
|
145 try |
|
|
146 { |
|
|
147 tee.accept (*this); |
|
|
148 } |
|
|
149 catch (const jit_fail_exception&) |
|
|
150 { |
|
|
151 //FIXME: cleanup |
|
|
152 return compiled_functions[&tee] = new function_info (); |
|
|
153 } |
|
|
154 |
|
|
155 // copy input arguments |
|
|
156 builder.SetInsertPoint (entry_block); |
|
|
157 |
|
|
158 Function::arg_iterator arg_iter = compiling->arg_begin (); |
|
|
159 Value *arg_defined = arg_iter; |
|
|
160 Value *arg_value = ++arg_iter; |
|
|
161 |
|
|
162 arg_defined->setName ("arg_defined"); |
|
|
163 arg_value->setName ("arg_value"); |
|
|
164 |
|
|
165 size_t idx = 0; |
|
|
166 std::vector<std::string> arg_names; |
|
|
167 std::vector<bool> arg_used; |
|
|
168 for (var_map_iterator iter = variables.begin (); iter != variables.end (); |
|
|
169 ++iter, ++idx) |
|
|
170 { |
|
|
171 arg_names.push_back (iter->first); |
|
|
172 arg_used.push_back (iter->second.use); |
|
|
173 |
|
|
174 Value *gep_defined = builder.CreateConstInBoundsGEP1_32 (arg_defined, idx); |
|
|
175 Value *defined = builder.CreateLoad (gep_defined); |
|
|
176 builder.CreateStore (defined, iter->second.defined); |
|
|
177 |
|
|
178 Value *gep_value = builder.CreateConstInBoundsGEP1_32 (arg_value, idx); |
|
|
179 Value *value = builder.CreateLoad (gep_value); |
|
|
180 builder.CreateStore (value, iter->second.value); |
|
|
181 } |
|
|
182 builder.CreateBr (body); |
|
|
183 |
|
|
184 // copy output arguments |
|
|
185 BasicBlock *cleanup = BasicBlock::Create (context, "cleanup", compiling); |
|
|
186 builder.SetInsertPoint (body); |
|
|
187 builder.CreateBr (cleanup); |
|
|
188 builder.SetInsertPoint (cleanup); |
|
|
189 |
|
|
190 idx = 0; |
|
|
191 for (var_map_iterator iter = variables.begin (); iter != variables.end (); |
|
|
192 ++iter, ++idx) |
|
|
193 { |
|
|
194 Value *gep_defined = builder.CreateConstInBoundsGEP1_32 (arg_defined, idx); |
|
|
195 Value *defined = builder.CreateLoad (iter->second.defined); |
|
|
196 builder.CreateStore (defined, gep_defined); |
|
|
197 |
|
|
198 Value *gep_value = builder.CreateConstInBoundsGEP1_32 (arg_value, idx); |
|
|
199 Value *value = builder.CreateLoad (iter->second.value, iter->first); |
|
|
200 builder.CreateStore (value, gep_value); |
|
|
201 } |
|
|
202 |
|
|
203 builder.CreateRetVoid (); |
|
|
204 |
|
|
205 // print what we compiled (for debugging) |
|
|
206 // we leave this in for now, as other people might want to view the ir created |
|
|
207 // should be removed eventually though |
|
|
208 const bool debug_print_ir = false; |
|
|
209 if (debug_print_ir) |
|
|
210 { |
|
|
211 raw_os_ostream os (std::cout); |
|
|
212 std::cout << "Compiling --------------------\n"; |
|
|
213 tree_print_code tpc (std::cout); |
|
|
214 std::cout << typeid (tee).name () << std::endl; |
|
|
215 tee.accept (tpc); |
|
|
216 std::cout << "\n--------------------\n"; |
|
|
217 |
|
|
218 std::cout << "llvm_ir\n"; |
|
|
219 compiling->print (os); |
|
|
220 std::cout << "--------------------\n"; |
|
|
221 } |
|
|
222 |
|
|
223 // compile code |
|
|
224 verifyFunction (*compiling); |
|
|
225 pass_manager->run (*compiling); |
|
|
226 |
|
|
227 if (debug_print_ir) |
|
|
228 { |
|
|
229 raw_os_ostream os (std::cout); |
|
|
230 std::cout << "optimized llvm_ir\n"; |
|
|
231 compiling->print (os); |
|
|
232 std::cout << "--------------------\n"; |
|
|
233 } |
|
|
234 |
|
|
235 jit_function fun = |
|
|
236 reinterpret_cast<jit_function> (engine->getPointerToFunction (compiling)); |
|
|
237 |
|
|
238 return compiled_functions[&tee] = new function_info (fun, arg_names, arg_used); |
|
|
239 } |
|
|
240 |
|
|
241 tree_jit::variable_info |
|
|
242 tree_jit::find (const std::string &name, bool use) |
|
|
243 { |
|
|
244 var_map_iterator iter = variables.find (name); |
|
|
245 if (iter == variables.end ()) |
|
|
246 { |
|
|
247 // we currently just assume everything is a double |
|
|
248 Type *dbl = Type::getDoubleTy (context); |
|
|
249 Type *bol = Type::getInt1Ty (context); |
|
|
250 IRBuilder<> tmpB (entry_block, entry_block->begin ()); |
|
|
251 |
|
|
252 variable_info vinfo; |
|
|
253 vinfo.defined = tmpB.CreateAlloca (bol, 0); |
|
|
254 vinfo.value = tmpB.CreateAlloca (dbl, 0, name); |
|
|
255 vinfo.use = use; |
|
|
256 variables[name] = vinfo; |
|
|
257 return vinfo; |
|
|
258 } |
|
|
259 else |
|
|
260 { |
|
|
261 iter->second.use = iter->second.use || use; |
|
|
262 return iter->second; |
|
|
263 } |
|
|
264 } |
|
|
265 |
|
|
266 void |
|
|
267 tree_jit::do_assign (variable_info vinfo, llvm::Value *value) |
|
|
268 { |
|
|
269 // create assign expression |
|
|
270 Value *result = builder.CreateStore (value, vinfo.value); |
|
|
271 value_stack.push_back (result); |
|
|
272 |
|
|
273 // update defined for lhs |
|
|
274 Type *btype = Type::getInt1Ty (context); |
|
|
275 Value *btrue = ConstantInt::get (btype, APInt (1, 1)); |
|
|
276 builder.CreateStore (btrue, vinfo.defined); |
|
|
277 } |
|
|
278 |
|
|
279 void |
|
|
280 tree_jit::emit_print (const std::string& vname, llvm::Value *value) |
|
|
281 { |
|
|
282 Value *pname = builder.CreateGlobalStringPtr (vname); |
|
|
283 builder.CreateCall2 (print_double, pname, value); |
|
|
284 } |
|
|
285 |
|
|
286 void |
|
|
287 tree_jit::visit_anon_fcn_handle (tree_anon_fcn_handle&) |
|
|
288 { |
|
|
289 fail (); |
|
|
290 } |
|
|
291 |
|
|
292 void |
|
|
293 tree_jit::visit_argument_list (tree_argument_list&) |
|
|
294 { |
|
|
295 fail (); |
|
|
296 } |
|
|
297 |
|
|
298 void |
|
|
299 tree_jit::visit_binary_expression (tree_binary_expression& be) |
|
|
300 { |
|
|
301 tree_expression *lhs = be.lhs (); |
|
|
302 tree_expression *rhs = be.rhs (); |
|
|
303 if (lhs && rhs) |
|
|
304 { |
|
|
305 lhs->accept (*this); |
|
|
306 rhs->accept (*this); |
|
|
307 |
|
|
308 Value *lhsv = value_stack.back (); |
|
|
309 value_stack.pop_back (); |
|
|
310 |
|
|
311 Value *rhsv = value_stack.back (); |
|
|
312 value_stack.pop_back (); |
|
|
313 |
|
|
314 Value *result; |
|
|
315 switch (be.op_type ()) |
|
|
316 { |
|
|
317 case octave_value::op_add: |
|
|
318 result = builder.CreateFAdd (lhsv, rhsv); |
|
|
319 break; |
|
|
320 case octave_value::op_sub: |
|
|
321 result = builder.CreateFSub (lhsv, rhsv); |
|
|
322 break; |
|
|
323 case octave_value::op_mul: |
|
|
324 result = builder.CreateFMul (lhsv, rhsv); |
|
|
325 break; |
|
|
326 case octave_value::op_div: |
|
|
327 result = builder.CreateFDiv (lhsv, rhsv); |
|
|
328 break; |
|
|
329 default: |
|
|
330 fail (); |
|
|
331 } |
|
|
332 |
|
|
333 value_stack.push_back (result); |
|
|
334 } |
|
|
335 else |
|
|
336 fail (); |
|
|
337 } |
|
|
338 |
|
|
339 void |
|
|
340 tree_jit::visit_break_command (tree_break_command&) |
|
|
341 { |
|
|
342 fail (); |
|
|
343 } |
|
|
344 |
|
|
345 void |
|
|
346 tree_jit::visit_colon_expression (tree_colon_expression&) |
|
|
347 { |
|
|
348 fail (); |
|
|
349 } |
|
|
350 |
|
|
351 void |
|
|
352 tree_jit::visit_continue_command (tree_continue_command&) |
|
|
353 { |
|
|
354 fail (); |
|
|
355 } |
|
|
356 |
|
|
357 void |
|
|
358 tree_jit::visit_global_command (tree_global_command&) |
|
|
359 { |
|
|
360 fail (); |
|
|
361 } |
|
|
362 |
|
|
363 void |
|
|
364 tree_jit::visit_persistent_command (tree_persistent_command&) |
|
|
365 { |
|
|
366 fail (); |
|
|
367 } |
|
|
368 |
|
|
369 void |
|
|
370 tree_jit::visit_decl_elt (tree_decl_elt&) |
|
|
371 { |
|
|
372 fail (); |
|
|
373 } |
|
|
374 |
|
|
375 void |
|
|
376 tree_jit::visit_decl_init_list (tree_decl_init_list&) |
|
|
377 { |
|
|
378 fail (); |
|
|
379 } |
|
|
380 |
|
|
381 void |
|
|
382 tree_jit::visit_simple_for_command (tree_simple_for_command&) |
|
|
383 { |
|
|
384 fail (); |
|
|
385 } |
|
|
386 |
|
|
387 void |
|
|
388 tree_jit::visit_complex_for_command (tree_complex_for_command&) |
|
|
389 { |
|
|
390 fail (); |
|
|
391 } |
|
|
392 |
|
|
393 void |
|
|
394 tree_jit::visit_octave_user_script (octave_user_script&) |
|
|
395 { |
|
|
396 fail (); |
|
|
397 } |
|
|
398 |
|
|
399 void |
|
|
400 tree_jit::visit_octave_user_function (octave_user_function&) |
|
|
401 { |
|
|
402 fail (); |
|
|
403 } |
|
|
404 |
|
|
405 void |
|
|
406 tree_jit::visit_octave_user_function_header (octave_user_function&) |
|
|
407 { |
|
|
408 fail (); |
|
|
409 } |
|
|
410 |
|
|
411 void |
|
|
412 tree_jit::visit_octave_user_function_trailer (octave_user_function&) |
|
|
413 { |
|
|
414 fail (); |
|
|
415 } |
|
|
416 |
|
|
417 void |
|
|
418 tree_jit::visit_function_def (tree_function_def&) |
|
|
419 { |
|
|
420 fail (); |
|
|
421 } |
|
|
422 |
|
|
423 void |
|
|
424 tree_jit::visit_identifier (tree_identifier& ti) |
|
|
425 { |
|
|
426 octave_value ov = ti.do_lookup (); |
|
|
427 if (ov.is_function ()) |
|
|
428 fail (); |
|
|
429 |
|
|
430 std::string name = ti.name (); |
|
|
431 variable_info vinfo = find (ti.name (), true); |
|
|
432 |
|
|
433 // TODO check defined |
|
|
434 |
|
|
435 Value *load_value = builder.CreateLoad (vinfo.value, name); |
|
|
436 value_stack.push_back (load_value); |
|
|
437 } |
|
|
438 |
|
|
439 void |
|
|
440 tree_jit::visit_if_clause (tree_if_clause&) |
|
|
441 { |
|
|
442 fail (); |
|
|
443 } |
|
|
444 |
|
|
445 void |
|
|
446 tree_jit::visit_if_command (tree_if_command&) |
|
|
447 { |
|
|
448 fail (); |
|
|
449 } |
|
|
450 |
|
|
451 void |
|
|
452 tree_jit::visit_if_command_list (tree_if_command_list&) |
|
|
453 { |
|
|
454 fail (); |
|
|
455 } |
|
|
456 |
|
|
457 void |
|
|
458 tree_jit::visit_index_expression (tree_index_expression&) |
|
|
459 { |
|
|
460 fail (); |
|
|
461 } |
|
|
462 |
|
|
463 void |
|
|
464 tree_jit::visit_matrix (tree_matrix&) |
|
|
465 { |
|
|
466 fail (); |
|
|
467 } |
|
|
468 |
|
|
469 void |
|
|
470 tree_jit::visit_cell (tree_cell&) |
|
|
471 { |
|
|
472 fail (); |
|
|
473 } |
|
|
474 |
|
|
475 void |
|
|
476 tree_jit::visit_multi_assignment (tree_multi_assignment&) |
|
|
477 { |
|
|
478 fail (); |
|
|
479 } |
|
|
480 |
|
|
481 void |
|
|
482 tree_jit::visit_no_op_command (tree_no_op_command&) |
|
|
483 { |
|
|
484 fail (); |
|
|
485 } |
|
|
486 |
|
|
487 void |
|
|
488 tree_jit::visit_constant (tree_constant& tc) |
|
|
489 { |
|
|
490 octave_value v = tc.rvalue1 (); |
|
|
491 if (v.is_real_scalar () && v.is_double_type ()) |
|
|
492 { |
|
|
493 double dv = v.double_value (); |
|
|
494 Value *lv = ConstantFP::get (context, APFloat (dv)); |
|
|
495 value_stack.push_back (lv); |
|
|
496 } |
|
|
497 else |
|
|
498 fail (); |
|
|
499 } |
|
|
500 |
|
|
501 void |
|
|
502 tree_jit::visit_fcn_handle (tree_fcn_handle&) |
|
|
503 { |
|
|
504 fail (); |
|
|
505 } |
|
|
506 |
|
|
507 void |
|
|
508 tree_jit::visit_parameter_list (tree_parameter_list&) |
|
|
509 { |
|
|
510 fail (); |
|
|
511 } |
|
|
512 |
|
|
513 void |
|
|
514 tree_jit::visit_postfix_expression (tree_postfix_expression&) |
|
|
515 { |
|
|
516 fail (); |
|
|
517 } |
|
|
518 |
|
|
519 void |
|
|
520 tree_jit::visit_prefix_expression (tree_prefix_expression&) |
|
|
521 { |
|
|
522 fail (); |
|
|
523 } |
|
|
524 |
|
|
525 void |
|
|
526 tree_jit::visit_return_command (tree_return_command&) |
|
|
527 { |
|
|
528 fail (); |
|
|
529 } |
|
|
530 |
|
|
531 void |
|
|
532 tree_jit::visit_return_list (tree_return_list&) |
|
|
533 { |
|
|
534 fail (); |
|
|
535 } |
|
|
536 |
|
|
537 void |
|
|
538 tree_jit::visit_simple_assignment (tree_simple_assignment& tsa) |
|
|
539 { |
|
|
540 // only support an identifier as lhs |
|
|
541 tree_identifier *lhs = dynamic_cast<tree_identifier*> (tsa.left_hand_side ()); |
|
|
542 if (!lhs) |
|
|
543 fail (); |
|
|
544 |
|
|
545 variable_info lhsv = find (lhs->name (), false); |
|
|
546 |
|
|
547 // resolve rhs as normal |
|
|
548 tree_expression *rhs = tsa.right_hand_side (); |
|
|
549 rhs->accept (*this); |
|
|
550 |
|
|
551 Value *rhsv = value_stack.back (); |
|
|
552 value_stack.pop_back (); |
|
|
553 |
|
|
554 do_assign (lhsv, rhsv); |
|
|
555 |
|
|
556 if (tsa.print_result ()) |
|
|
557 emit_print (lhs->name (), rhsv); |
|
|
558 } |
|
|
559 |
|
|
560 void |
|
|
561 tree_jit::visit_statement (tree_statement& stmt) |
|
|
562 { |
|
|
563 tree_command *cmd = stmt.command (); |
|
|
564 tree_expression *expr = stmt.expression (); |
|
|
565 |
|
|
566 if (cmd) |
|
|
567 cmd->accept (*this); |
|
|
568 else |
|
|
569 { |
|
|
570 // TODO deal with printing |
|
|
571 |
|
|
572 // stolen from tree_evaluator::visit_statement |
|
|
573 bool do_bind_ans = false; |
|
|
574 |
|
|
575 if (expr->is_identifier ()) |
|
|
576 { |
|
|
577 tree_identifier *id = dynamic_cast<tree_identifier *> (expr); |
|
|
578 |
|
|
579 do_bind_ans = (! id->is_variable ()); |
|
|
580 } |
|
|
581 else |
|
|
582 do_bind_ans = (! expr->is_assignment_expression ()); |
|
|
583 |
|
|
584 expr->accept (*this); |
|
|
585 |
|
|
586 if (do_bind_ans) |
|
|
587 { |
|
|
588 Value *rhs = value_stack.back (); |
|
|
589 value_stack.pop_back (); |
|
|
590 |
|
|
591 variable_info ans = find ("ans", false); |
|
|
592 do_assign (ans, rhs); |
|
|
593 } |
|
|
594 else if (expr->is_identifier () && expr->print_result ()) |
|
|
595 { |
|
|
596 // FIXME: ugly hack, we need to come up with a way to pass |
|
|
597 // nargout to visit_identifier |
|
|
598 emit_print (expr->name (), value_stack.back ()); |
|
|
599 } |
|
|
600 |
|
|
601 |
|
|
602 value_stack.pop_back (); |
|
|
603 } |
|
|
604 } |
|
|
605 |
|
|
606 void |
|
|
607 tree_jit::visit_statement_list (tree_statement_list&) |
|
|
608 { |
|
|
609 fail (); |
|
|
610 } |
|
|
611 |
|
|
612 void |
|
|
613 tree_jit::visit_switch_case (tree_switch_case&) |
|
|
614 { |
|
|
615 fail (); |
|
|
616 } |
|
|
617 |
|
|
618 void |
|
|
619 tree_jit::visit_switch_case_list (tree_switch_case_list&) |
|
|
620 { |
|
|
621 fail (); |
|
|
622 } |
|
|
623 |
|
|
624 void |
|
|
625 tree_jit::visit_switch_command (tree_switch_command&) |
|
|
626 { |
|
|
627 fail (); |
|
|
628 } |
|
|
629 |
|
|
630 void |
|
|
631 tree_jit::visit_try_catch_command (tree_try_catch_command&) |
|
|
632 { |
|
|
633 fail (); |
|
|
634 } |
|
|
635 |
|
|
636 void |
|
|
637 tree_jit::visit_unwind_protect_command (tree_unwind_protect_command&) |
|
|
638 { |
|
|
639 fail (); |
|
|
640 } |
|
|
641 |
|
|
642 void |
|
|
643 tree_jit::visit_while_command (tree_while_command&) |
|
|
644 { |
|
|
645 fail (); |
|
|
646 } |
|
|
647 |
|
|
648 void |
|
|
649 tree_jit::visit_do_until_command (tree_do_until_command&) |
|
|
650 { |
|
|
651 fail (); |
|
|
652 } |
|
|
653 |
|
|
654 void |
|
|
655 tree_jit::fail (void) |
|
|
656 { |
|
|
657 throw jit_fail_exception (); |
|
|
658 } |
|
|
659 |
|
|
660 tree_jit::function_info::function_info (void) : function (0) |
|
|
661 {} |
|
|
662 |
|
|
663 tree_jit::function_info::function_info (jit_function fun, |
|
|
664 const std::vector<std::string>& args, |
|
|
665 const std::vector<bool>& arg_used) : |
|
|
666 function (fun), arguments (args), argument_used (arg_used) |
|
|
667 {} |
|
|
668 |
|
|
669 bool tree_jit::function_info::execute () |
|
|
670 { |
|
|
671 if (! function) |
|
|
672 return false; |
|
|
673 |
|
|
674 // FIXME: we are doing hash lookups every time, this has got to be slow |
|
|
675 unwind_protect up; |
|
|
676 bool *args_defined = new bool[arguments.size ()]; // vector<bool> sucks |
|
|
677 up.add_delete (args_defined); |
|
|
678 |
|
|
679 std::vector<double> args_values (arguments.size ()); |
|
|
680 for (size_t i = 0; i < arguments.size (); ++i) |
|
|
681 { |
|
|
682 octave_value ov = symbol_table::varval (arguments[i]); |
|
|
683 |
|
|
684 if (argument_used[i]) |
|
|
685 { |
|
|
686 if (! (ov.is_double_type () && ov.is_real_scalar ())) |
|
|
687 return false; |
|
|
688 |
|
|
689 args_defined[i] = ov.is_defined (); |
|
|
690 args_values[i] = ov.double_value (); |
|
|
691 } |
|
|
692 else |
|
|
693 args_defined[i] = false; |
|
|
694 } |
|
|
695 |
|
|
696 function (args_defined, &args_values[0]); |
|
|
697 |
|
|
698 for (size_t i = 0; i < arguments.size (); ++i) |
|
|
699 if (args_defined[i]) |
|
|
700 symbol_table::varref (arguments[i]) = octave_value (args_values[i]); |
|
|
701 |
|
|
702 return true; |
|
|
703 } |
