JIT: Multiplication management
[scilab.git] / scilab / modules / jit / includes / JITvisitor.hxx
1 /*
2  *  Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  *  Copyright (C) 2013 - Harris Bakiras <harris.bakiras@lip6.fr>,
4  *  Peter Senna Tschudin <peter.senna@lip6.fr>
5  *
6  *  This file must be used under the terms of the CeCILL.
7  *  This source file is licensed as described in the file COPYING, which
8  *  you should have received as part of this distribution.  The terms
9  *  are also available at
10  *  http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
11  *
12  */
13
14 #ifndef AST_JITVISITOR_HXX
15 #define AST_JITVISITOR_HXX
16
17 #include <time.h>
18 #include <string>
19 #include <iostream>
20 #include <sstream>
21 #include <cstdio>
22 #include <iostream>
23
24 #include "visitor_common.hxx"
25 #include "shortcutvisitor.hxx"
26 #include "printvisitor.hxx"
27 #include "mutevisitor.hxx"
28
29 // Needed by visitprivate(const OpExp &)
30 // Needed by visitprivate(const LogicalOpExp &)
31 #include "generic_operations.hxx"
32 #include "types_or_and.hxx"
33 #include "configvariable.hxx"
34 #include "overload.hxx"
35 #include "scilabexception.hxx"
36
37 //#include "matrix_transpose_int.hxx"
38
39 extern "C" {
40 #include "doublecomplex.h"
41 #include "matrix_transpose.h"
42 #include "os_swprintf.h"
43 #include "more.h"
44 #include "sciprint.h"
45     //#include "HandleManagement.h"
46 }
47
48 #include "timer.hxx"
49 #include "localization.h"
50
51 #include "scilabWrite.hxx"
52 #include "context.hxx"
53
54 #include "all.hxx"
55 #include "types.hxx"
56 #include "alltypes.hxx"
57
58 #undef ID
59 #undef LT
60 #undef GT
61
62 #include "llvm/IR/Constants.h"
63 #include "llvm/IR/DerivedTypes.h"
64 #include "llvm/IR/IRBuilder.h"
65 #include "llvm/IR/LLVMContext.h"
66 #include "llvm/IR/Module.h"
67 #include "llvm/IR/Type.h"
68
69 #include "llvm/Analysis/Verifier.h"
70 #include "llvm/Support/TargetSelect.h"
71 #include "llvm/ExecutionEngine/ExecutionEngine.h"
72 #include "llvm/ExecutionEngine/JIT.h"
73 #include "llvm/PassManager.h"
74 #include "llvm/IR/DataLayout.h"
75 #include "vmkit_core.h"
76
77 #undef WHITE
78 #undef Max
79
80 #include <sys/types.h>
81
82 #include "llvm/IR/Attributes.h"
83 #include "llvm/IR/Function.h"
84 #include "llvm/IR/Instructions.h"
85 #include "llvm/CodeGen/GCStrategy.h"
86 #include "llvm/CodeGen/JITCodeEmitter.h"
87 #include "llvm/CodeGen/MachineFunction.h"
88 #include "llvm/ExecutionEngine/ExecutionEngine.h"
89 #include "llvm/Support/CommandLine.h"
90 #include "llvm/Support/ManagedStatic.h"
91 //#include "llvm/Support/Debug.h"
92 //#include "llvm/Support/raw_ostream.h"
93 #include <llvm/LinkAllPasses.h>
94
95 namespace llvm
96 {
97 #include "../src/cpp/llvm-wrapper-generated.cpp"
98 }
99
100 namespace ast
101 {
102 typedef double (*jitptr_t) ();
103
104 class JITVisitor : public ConstVisitor
105 {
106 private:
107     /*
108      * Attributes
109      */
110     llvm::Value* _result;
111     bool m_bSingleResult;
112     llvm::LLVMContext *context;
113     llvm::Module *TheModule;
114     llvm::IRBuilder<> *Builder;
115     llvm::ExecutionEngine* ee;
116     llvm::FunctionPassManager* pm;
117     llvm::Type* uintptrType;
118     symbol::Context * scilabContext;
119     llvm::Function * TheFunction;
120
121     // utilisees par step, end ds la visit de ListExp
122     llvm::Value * _result2;
123     llvm::Value * _result3;
124
125     void visit (const SeqExp  &e)
126     {
127         visitprivate(e);
128     }
129
130     void visit (const IntExp &e)
131     {
132         visitprivate(e);
133     }
134
135     void visit (const FloatExp &e)
136     {
137         visitprivate(e);
138     }
139
140     void visit (const DoubleExp &e)
141     {
142         visitprivate(e);
143     }
144
145     void visit (const OpExp &e)
146     {
147         visitprivate(e);
148     }
149
150     void visit (const SimpleVar &e)
151     {
152         visitprivate(e);
153     }
154
155
156 public:
157     JITVisitor() : ConstVisitor()
158     {
159         llvm::InitializeNativeTarget();
160         context = &llvm::getGlobalContext();
161         Builder = new llvm::IRBuilder<> (*context);
162         _result = NULL;
163         m_bSingleResult = false;
164         TheModule = new llvm::Module("scilab jit", *context);
165
166         std::string err;
167         llvm::EngineBuilder engine (TheModule);
168         llvm::TargetOptions options;
169         options.NoFramePointerElim = true;
170         engine.setTargetOptions(options);
171         engine.setEngineKind(llvm::EngineKind::JIT);
172         engine.setErrorStr(&err);
173
174         ee = engine.create();
175         if (!ee)
176         {
177             fprintf(stderr, "Could not create ExecutionEngine: %s\n", err.c_str());
178             exit(1);
179         }
180         ee->DisableLazyCompilation(0);
181         ee->addModule(TheModule);
182         TheModule->setDataLayout(ee->getDataLayout()->getStringRepresentation());
183         pm = NULL; /* TODO : init */
184
185         uintptrType = TheModule->getPointerSize() == llvm::Module::Pointer32 ?
186                       llvm::Type::getInt32Ty(*context) : llvm::Type::getInt64Ty(*context);
187
188         TheModule = llvm::makeLLVMModuleContents(TheModule);
189         //TheModule->dump();
190
191         for (llvm::Module::iterator cur = TheModule->begin(), end = TheModule->end(); cur != end; cur++)
192         {
193             void* ptr = dlsym(RTLD_DEFAULT, cur->getName().data());
194             //printf("%s ---> %p\n", cur->getName().data(), ptr);
195             if (ptr)
196             {
197                 ee->updateGlobalMapping(cur, ptr);
198             }
199         }
200
201         scilabContext = symbol::Context::getInstance();
202     }
203
204     void result_set(llvm::Value* const gtVal)
205     {
206         m_bSingleResult = true;
207         _result = gtVal;
208     }
209
210     llvm::Value* result_get()
211     {
212         return  _result;
213     }
214
215     void visitprivate(const DoubleExp &e)
216     {
217         if (e.getBigDouble() == NULL)
218         {
219             Double *pdbl = new Double(e.value_get());
220             (const_cast<DoubleExp *>(&e))->setBigDouble(pdbl);
221         }
222
223         //              llvm::Value* res = llvm::ConstantFP::get(llvm::getGlobalContext(), llvm::APFloat(e.getBigDouble()));
224         llvm::Value* res = llvm::ConstantInt::get(uintptrType, (uintptr_t)e.getBigDouble());
225         res = Builder->CreateIntToPtr(res, llvm::PointerType::getUnqual(TheModule->getTypeByName("class.types::Double")));
226
227         result_set(res);
228     }
229
230     void visitprivate(const FloatExp &e)
231     {
232     }
233
234     void visitprivate(const IntExp &e)
235     {
236     }
237
238     void visitprivate(const SeqExp &e)
239     {
240
241         //T execMe;
242         std::list<Exp *>::const_iterator    itExp;
243
244         for (itExp = e.exps_get().begin (); itExp != e.exps_get().end (); ++itExp)
245         {
246             //reset default values
247             result_set(NULL);
248
249             (*itExp)->accept(*this);
250             std::cout << "coucou" << std::endl;
251             result_get()->dump();
252         }
253     }
254
255     llvm::Value* const llvm_value_one = llvm::ConstantFP::get(llvm::getGlobalContext(), llvm::APFloat(1.0));
256     llvm::Value* llvm_rec_power (llvm::Value* x, llvm::Value* n)
257     {
258         llvm::ConstantFP* ncfp = llvm::dyn_cast<llvm::ConstantFP>(n);
259
260         if (ncfp->isZero())
261         {
262             // return 1
263             return llvm_value_one;
264         }
265         if (ncfp->isNegative())
266         {
267             llvm::Value* moduloN = Builder->CreateFMul(llvm::ConstantFP::get(llvm::getGlobalContext(), llvm::APFloat(-1.0)), n);
268             // return 1 / (x * llvm_rec_power(x, (-1 * n)-1))
269             return Builder->CreateFDiv(llvm_value_one, Builder->CreateFMul(x, llvm_rec_power(x, Builder->CreateFSub(moduloN, llvm_value_one, "OpExp::minus")), "OpExp::times"), "OpExp::rdivide");
270         }
271         else
272         {
273             // return x * llvm_rec_power(x, n-1)
274             return Builder->CreateFMul(x, llvm_rec_power(x, Builder->CreateFSub(n, llvm_value_one, "OpExp::minus")), "OpExp::times");
275         }
276     }
277     void visitprivate(const OpExp &e)
278     {
279         /*
280           switch (e.kind_get())
281           {
282           case OpExp::invalid_kind :
283           {
284           std::cout << "OpExp::invalid_kind" << std::endl;
285           break;
286           }
287           case OpExp::bool_kind :
288           {
289           std::cout << "OpExp::bool_kind" << std::endl;
290           break;
291           }
292           case OpExp::string_kind :
293           {
294           std::cout << "OpExp::string_kind" << std::endl;
295           break;
296           }
297           case OpExp::integer_kind :
298           {
299           std::cout << "OpExp::integer_kind" << std::endl;
300           break;
301           }
302           case OpExp::float_kind :
303           {
304           std::cout << "OpExp::float_kind" << std::endl;
305           break;
306           }
307           case OpExp::double_kind :
308           {
309           std::cout << "OpExp::double_kind" << std::endl;
310           break;
311           }
312           case OpExp::float_complex_kind :
313           {
314           break;
315           }
316           case OpExp::double_complex_kind :
317           {
318           break;
319           }
320           case OpExp::bool_matrix_kind :
321           {
322           break;
323           }
324           case OpExp::string_matrix_kind :
325           {
326           break;
327           }
328           case OpExp::integer_matrix_kind :
329           {
330           break;
331           }
332           case OpExp::float_matrix_kind :
333           {
334           break;
335           }
336           case OpExp::double_matrix_kind :
337           {
338           break;
339           }
340           case OpExp::float_complex_matrix_kind :
341           {
342           break;
343           }
344           case OpExp::double_complex_matrix_kind :
345           {
346           break;
347           }
348           case OpExp::matrix_kind :
349           {
350           break;
351           }
352           }
353         */
354
355         /*getting what to assign*/
356         e.left_get().accept(*this);
357         llvm::Value *pITL = result_get();
358
359         /*getting what to assign*/
360         e.right_get().accept(*this);
361         llvm::Value *pITR = result_get();
362
363         llvm::Value *pResult = NULL;
364         switch (e.oper_get())
365         {
366             case OpExp::plus :
367             {
368                 //%5 = call i32 @_Z17AddDoubleToDoublePN5types6DoubleES1_PS1_(%"class.types::Double"* %3, %"class.types::Double"* %4, %"class.types::Double"** %pdbl1)
369                 //                      pResult = Builder->CreateFAdd(pITL, pITR, "OpExp::plus");
370
371                 llvm::Value * tmp = Builder->CreateAlloca(llvm::PointerType::getUnqual(TheModule->getTypeByName("class.types::Double")));
372
373                 Builder->CreateCall3(TheModule->getFunction("_Z17AddDoubleToDoublePN5types6DoubleES1_PS1_"), pITR, pITL, tmp);
374
375                 pResult = Builder->CreateLoad(tmp);
376                 break;
377             }
378             case OpExp::minus :
379             {
380                 pResult = Builder->CreateFSub(pITL, pITR, "OpExp::minus");
381                 break;
382             }
383             case OpExp::times :
384             {
385
386                 llvm::Value * tmp = Builder->CreateAlloca(llvm::PointerType::getUnqual(TheModule->getTypeByName("class.types::Double")));
387
388                 //printf("%p \n",TheModule->getFunction("_Z17AddDoubleToDoublePN5types6DoubleES1_PS1_"));
389
390                 Builder->CreateCall3(TheModule->getFunction("_Z22MultiplyDoubleByDoublePN5types6DoubleES1_PS1_"), pITR, pITL, tmp);
391
392                 pResult = Builder->CreateLoad(tmp);
393                 break;
394             }
395             case OpExp::rdivide :
396             {
397                 pResult = Builder->CreateFDiv(pITL, pITR, "OpExp::rdivide");
398                 break;
399             }
400             case OpExp::ldivide :
401             {
402                 pResult = Builder->CreateFDiv(pITR, pITL, "OpExp::ldivide");
403                 break;
404             }
405             case OpExp::power :
406             {
407                 pResult = llvm_rec_power(pITL, pITR);
408                 break;
409             }
410             case OpExp::unaryMinus :
411             {
412                 pResult = Builder->CreateFSub(pITL, pITR, "OpExp::unaryMinus");
413                 break;
414             }
415             case OpExp::eq :
416             {
417                 pResult = Builder->CreateUIToFP(Builder->CreateFCmpUEQ(pITL, pITR, "OpExp::eq"), llvm::Type::getDoubleTy(llvm::getGlobalContext()), "booltodouble");
418                 break;
419             }
420             case OpExp::ne :
421             {
422                 pResult = Builder->CreateUIToFP(Builder->CreateNot(Builder->CreateFCmpUEQ(pITL, pITR, "OpExp::eq"), "not"), llvm::Type::getDoubleTy(llvm::getGlobalContext()), "booltodouble");
423                 break;
424             }
425             case OpExp::lt :
426             {
427                 pResult = Builder->CreateUIToFP(Builder->CreateFCmpULT(pITL, pITR, "OpExp::lt"), llvm::Type::getDoubleTy(llvm::getGlobalContext()), "booltodouble");
428                 break;
429             }
430             case OpExp::le :
431             {
432                 pResult = Builder->CreateUIToFP(Builder->CreateFCmpULE(pITL, pITR, "OpExp::le"), llvm::Type::getDoubleTy(llvm::getGlobalContext()), "booltodouble");
433                 break;
434             }
435             case OpExp::gt :
436             {
437                 pResult = Builder->CreateUIToFP(Builder->CreateFCmpUGT(pITL, pITR, "OpExp::gt"), llvm::Type::getDoubleTy(llvm::getGlobalContext()), "booltodouble");
438                 break;
439             }
440             case OpExp::ge :
441             {
442                 pResult = Builder->CreateUIToFP(Builder->CreateFCmpUGE(pITL, pITR, "OpExp::ge"), llvm::Type::getDoubleTy(llvm::getGlobalContext()), "booltodouble");
443                 break;
444             }
445             default:
446             {
447                 std::cout << "Operation not supported, returning 42..." << std::endl;
448                 pResult = llvm::ConstantFP::get(llvm::getGlobalContext(), llvm::APFloat(42.0));
449                 break;
450             }
451         }
452
453         if (pResult == NULL)
454         {
455             result_set(llvm::ConstantFP::get(llvm::getGlobalContext(), llvm::APFloat(42.0)));
456         }
457         result_set(pResult);
458     }
459
460     void visitprivate (const AssignExp &e)
461     {
462         /*getting what to assign*/
463
464         const SimpleVar *pVar = dynamic_cast<const SimpleVar*>(&e.left_exp_get());
465         if (pVar)
466         {
467             // x = ?
468             /*getting what to assign*/
469             e.right_exp_get().accept(*this);
470
471             llvm::Value *pITR = result_get();
472             //reset result
473             result_set(NULL);
474
475             genLLVMPutSymbol(&pVar->name_get(), pITR);
476
477             //symbol::Context::getInstance()->put(pVar->name_get(), *pIT);
478             return;
479         }
480
481         llvm::Value *pResult = NULL;
482     }
483
484     void visitprivate (const SimpleVar &e)
485     {
486         if (e.is_verbose())
487         {
488             InternalType * pI = symbol::Context::getInstance()->get(e.name_get());
489             if (pI != NULL && pI->isCallable() == false && ConfigVariable::isPromptShow())
490             {
491                 std::wostringstream ostr;
492                 ostr << e.name_get().name_get() << L"  = " << L"(" << pI->getRef() << L")" << std::endl;
493                 ostr << std::endl;
494                 scilabWriteW(ostr.str().c_str());
495                 printScilabVar(pI);
496             }
497             else
498             {
499                 wchar_t szError[bsiz];
500                 os_swprintf(szError, bsiz, _W("Undefined variable: %ls\n"), e.name_get().name_get().c_str());
501                 throw ScilabError(szError, 999, e.location_get());
502                 //Err, SimpleVar doesn't exist in Scilab scopes.
503             }
504         }
505         else // JIT
506         {
507             //mod->getFunction("_ZNK6symbol7Context3getERKNS_6SymbolE")
508             llvm::Value * llvmScilabContext = llvm::ConstantInt::get(uintptrType, (uintptr_t)scilabContext);
509             llvmScilabContext = Builder->CreateIntToPtr(llvmScilabContext, llvm::PointerType::getUnqual(TheModule->getTypeByName("class.symbol::Context")));
510
511             llvm::Value * llvmSym = llvm::ConstantInt::get(uintptrType, (uintptr_t)&e.name_get());
512             llvmSym = Builder->CreateIntToPtr(llvmSym, llvm::PointerType::getUnqual(TheModule->getTypeByName("class.symbol::Symbol")));
513
514             llvm::Value * result = Builder->CreateCall2(TheModule->getFunction("_ZNK6symbol7Context3getERKNS_6SymbolE"), llvmScilabContext, llvmSym);
515             result_set(result);
516         }
517     }
518
519     void visitprivate(const ForExp &e)
520     {
521         e.vardec_get().accept(*this);
522         symbol::Symbol& varName = e.vardec_get().name_get();
523
524         llvm::BasicBlock * BBTest = llvm::BasicBlock::Create(llvm::getGlobalContext(), "for_test", TheFunction);
525         llvm::BasicBlock * BBBody = llvm::BasicBlock::Create(llvm::getGlobalContext(), "for_body", TheFunction);
526         llvm::BasicBlock * BBAfter = llvm::BasicBlock::Create(llvm::getGlobalContext(), "for_after", TheFunction);
527
528         llvm::Value* cur = Builder->CreateAlloca(llvm::PointerType::getUnqual(TheModule->getTypeByName("class.types::Double")));
529         llvm::Value* tmp = Builder->CreateAlloca(llvm::PointerType::getUnqual(TheModule->getTypeByName("class.types::Bool")));
530         llvm::Value* zero = llvm::ConstantInt::get(llvm::Type::getInt32Ty(*context), 0);
531
532         llvm::Value* start = _result;
533         llvm::Value* step = _result2;
534         llvm::Value* end = _result3;
535
536         Builder->CreateStore(start, cur);
537         Builder->CreateBr(BBTest);
538
539         Builder->SetInsertPoint(BBTest);
540         Builder->CreateCall3(TheModule->getFunction("_Z16DoubleLessDoublePN5types6DoubleES1_PPNS_4BoolE"), end, Builder->CreateLoad(cur), tmp);
541         tmp = Builder->CreateLoad(tmp);
542         tmp = Builder->CreateCall2(TheModule->getFunction("_ZN5types7ArrayOfIiE3getEi"), tmp, zero);
543         Builder->CreateCondBr(tmp, BBAfter, BBBody);
544
545
546         Builder->SetInsertPoint(BBBody);
547         genLLVMPutSymbol(&varName, Builder->CreateLoad(cur));
548         e.body_get().accept(*this);
549         Builder->CreateCall3(TheModule->getFunction("_Z17AddDoubleToDoublePN5types6DoubleES1_PS1_"), Builder->CreateLoad(cur), step, cur);
550         Builder->CreateBr(BBTest);
551
552         Builder->SetInsertPoint(BBAfter);
553     }
554
555     void visitprivate(const ListExp &e)
556     {
557         e.start_get().accept(*this);
558         llvm::Value * start = result_get();
559
560         e.step_get().accept(*this);
561         llvm::Value * step = result_get();
562
563         e.end_get().accept(*this);
564         llvm::Value * end = result_get();
565
566         _result = start;
567         _result2 = step;
568         _result3 = end;
569     }
570
571     void visitprivate(const VarDec &e)
572     {
573         e.init_get().accept(*this);
574     }
575
576     void visit (const BoolExp &e)
577     {
578         //            visitprivate(e);
579     }
580
581     void visit (const NilExp &e)
582     {
583         //            visitprivate(e);
584     }
585
586     void visit (const ColonVar &e)
587     {
588         //            visitprivate(e);
589     }
590
591     void visit (const DollarVar &e)
592     {
593         //            visitprivate(e);
594     }
595
596     void visit (const ArrayListVar &e)
597     {
598         //            visitprivate(e);
599     }
600
601     void visit (const FieldExp &e)
602     {
603         //            visitprivate(e);
604     }
605
606
607     void visit (const LogicalOpExp &e)
608     {
609         //            visitprivate(e);
610     }
611
612     void visit (const AssignExp &e)
613     {
614         visitprivate(e);
615     }
616
617     void visit (const CellCallExp &e)
618     {
619         //            visitprivate(e);
620     }
621
622     void visit (const CallExp &e)
623     {
624         //            visitprivate(e);
625     }
626
627     void visit (const IfExp &e)
628     {
629         //            visitprivate(e);
630     }
631
632     void visit (const TryCatchExp &e)
633     {
634         //            visitprivate(e);
635     }
636
637     void visit (const WhileExp &e)
638     {
639         //            visitprivate(e);
640     }
641
642     void visit (const ForExp &e)
643     {
644         visitprivate(e);
645     }
646
647     void visit (const BreakExp &e)
648     {
649         //            visitprivate(e);
650     }
651
652     void visit (const ContinueExp &e)
653     {
654         //            visitprivate(e);
655     }
656
657     void visit (const ReturnExp &e)
658     {
659         //            visitprivate(e);
660     }
661
662     void visit (const SelectExp &e)
663     {
664         //            visitprivate(e);
665     }
666
667     void visit (const CaseExp &e)
668     {
669         //            visitprivate(e);
670     }
671
672     void visit (const ArrayListExp &e)
673     {
674         //            visitprivate(e);
675     }
676
677     void visit (const AssignListExp &e)
678     {
679         //            visitprivate(e);
680     }
681
682     void visit (const NotExp &e)
683     {
684         //            visitprivate(e);
685     }
686
687     void visit (const TransposeExp &e)
688     {
689         //            visitprivate(e);
690     }
691
692     void visit (const VarDec &e)
693     {
694         visitprivate(e);
695     }
696
697     void visit (const FunctionDec &e)
698     {
699         //            visitprivate(e);
700     }
701
702     void visit(const ListExp &e)
703     {
704         visitprivate(e);
705     }
706     void visit (const MatrixExp &e)
707     {
708         //            visitprivate(e);
709     }
710
711     void visit (const MatrixLineExp &e)
712     {
713         //            visitprivate(e);
714     }
715
716     void visit (const CellExp &e)
717     {
718         //            visitprivate(e);
719     }
720
721     void visit (const StringExp &e)
722     {
723         //            visitprivate(e);
724     }
725
726     void visit (const CommentExp &e)
727     {
728         //            visitprivate(e);
729     }
730
731     void genLLVMInitialize()
732     {
733         llvm::FunctionType *FT = llvm::FunctionType::get(llvm::Type::getVoidTy(*context), false);
734         TheFunction = llvm::Function::Create(FT, llvm::Function::ExternalLinkage, "TheFunction", TheModule);
735         llvm::BasicBlock *BB = llvm::BasicBlock::Create(llvm::getGlobalContext(), "entry", TheFunction);
736         Builder->SetInsertPoint(BB);
737     }
738
739     void genLLVMFinalize()
740     {
741         Builder->CreateRetVoid();
742         TheFunction->dump();
743     }
744
745     void compileAndExec()
746     {
747         void* res = ee->getPointerToFunction(TheFunction);
748         jitptr_t myJit = (jitptr_t) res;
749         myJit();
750     }
751
752     void genLLVMPutSymbol(const symbol::Symbol * s, llvm::Value * v)
753     {
754         llvm::Value * llvmScilabContext = llvm::ConstantInt::get(uintptrType, (uintptr_t)scilabContext);
755         llvmScilabContext = Builder->CreateIntToPtr(llvmScilabContext, llvm::PointerType::getUnqual(TheModule->getTypeByName("class.symbol::Context")));
756
757         llvm::Value * llvmSym = llvm::ConstantInt::get(uintptrType, (uintptr_t)s);
758         llvmSym = Builder->CreateIntToPtr(llvmSym, llvm::PointerType::getUnqual(TheModule->getTypeByName("class.symbol::Symbol")));
759         //llvmSym->dump();
760
761         Builder->CreateCall3(TheModule->getFunction("_ZN6symbol7Context3putERKNS_6SymbolERN5types12InternalTypeE"), llvmScilabContext, llvmSym, v);
762     }
763
764     static void printScilabVar(types::InternalType * pIT)
765     {
766         std::wostringstream ostr;
767
768         //to manage lines information
769         int iLines = ConfigVariable::getConsoleLines();
770
771         bool bFinish = false;
772         do
773         {
774             //block by block
775             bFinish = pIT->toString(ostr);
776             scilabWriteW(ostr.str().c_str());
777             if (bFinish == false && iLines != 0)
778             {
779                 //show message on prompt
780                 bFinish = linesmore() == 1;
781             }
782             ostr.str(L"");
783         }
784         while (bFinish == false);
785
786         pIT->clearPrintState();
787     }
788
789 };
790 }
791 #endif // !AST_JITVISITOR_HXX
792
793