Change the way to manage the variables and operations:
[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
120
121     void visit (const SeqExp  &e)
122     {
123         visitprivate(e);
124     }
125
126     void visit (const IntExp &e)
127     {
128         visitprivate(e);
129     }
130
131     void visit (const FloatExp &e)
132     {
133         visitprivate(e);
134     }
135
136     void visit (const DoubleExp &e)
137     {
138         visitprivate(e);
139     }
140
141     void visit (const OpExp &e)
142     {
143         visitprivate(e);
144     }
145
146     void visit (const SimpleVar &e)
147     {
148         visitprivate(e);
149     }
150
151
152 public:
153     JITVisitor() : ConstVisitor()
154     {
155         llvm::InitializeNativeTarget();
156         context = &llvm::getGlobalContext();
157         Builder = new llvm::IRBuilder<> (*context);
158         _result = NULL;
159         m_bSingleResult = false;
160         TheModule = new llvm::Module("scilab jit", *context);
161
162         std::string err;
163         llvm::EngineBuilder engine (TheModule);
164         llvm::TargetOptions options;
165         options.NoFramePointerElim = true;
166         engine.setTargetOptions(options);
167         engine.setEngineKind(llvm::EngineKind::JIT);
168         engine.setErrorStr(&err);
169
170         ee = engine.create();
171         if (!ee)
172         {
173             fprintf(stderr, "Could not create ExecutionEngine: %s\n", err.c_str());
174             exit(1);
175         }
176         ee->DisableLazyCompilation(0);
177         ee->addModule(TheModule);
178         TheModule->setDataLayout(ee->getDataLayout()->getStringRepresentation());
179         pm = NULL; /* TODO : init */
180
181         uintptrType = TheModule->getPointerSize() == llvm::Module::Pointer32 ?
182                       llvm::Type::getInt32Ty(*context) : llvm::Type::getInt64Ty(*context);
183
184         TheModule = llvm::makeLLVMModuleContents(TheModule);
185         //TheModule->dump();
186
187         for (llvm::Module::iterator cur = TheModule->begin(), end = TheModule->end(); cur != end; cur++)
188         {
189             void* ptr = dlsym(RTLD_DEFAULT, cur->getName().data());
190             //printf("%s ---> %p\n", cur->getName().data(), ptr);
191             if (ptr)
192             {
193                 ee->updateGlobalMapping(cur, ptr);
194             }
195         }
196
197         scilabContext = symbol::Context::getInstance();
198     }
199
200     void result_set(llvm::Value* const gtVal)
201     {
202         m_bSingleResult = true;
203         _result = gtVal;
204     }
205
206     llvm::Value* result_get()
207     {
208         return  _result;
209     }
210
211     void visitprivate(const DoubleExp &e)
212     {
213         if (e.getBigDouble() == NULL)
214         {
215             Double *pdbl = new Double(e.value_get());
216             (const_cast<DoubleExp *>(&e))->setBigDouble(pdbl);
217         }
218
219         //              llvm::Value* res = llvm::ConstantFP::get(llvm::getGlobalContext(), llvm::APFloat(e.getBigDouble()));
220         llvm::Value* res = llvm::ConstantInt::get(uintptrType, (uintptr_t)e.getBigDouble());
221         res = Builder->CreateIntToPtr(res, llvm::PointerType::getUnqual(TheModule->getTypeByName("class.types::Double")));
222         res->dump();
223         result_set(res);
224         _result->dump();
225     }
226
227     void visitprivate(const FloatExp &e)
228     {
229     }
230
231     void visitprivate(const IntExp &e)
232     {
233     }
234
235     void visitprivate(const SeqExp &e)
236     {
237
238         //T execMe;
239         std::list<Exp *>::const_iterator    itExp;
240
241         for (itExp = e.exps_get().begin (); itExp != e.exps_get().end (); ++itExp)
242         {
243             //reset default values
244             result_set(NULL);
245             llvm::FunctionType *FT = llvm::FunctionType::get(llvm::Type::getDoubleTy(*context), false);
246             llvm::Function *TheFunction = llvm::Function::Create(FT, llvm::Function::ExternalLinkage, "TheFunction", TheModule);
247             llvm::BasicBlock *BB = llvm::BasicBlock::Create(llvm::getGlobalContext(), "entry", TheFunction);
248             Builder->SetInsertPoint(BB);
249
250             (*itExp)->accept(*this);
251
252             if (1 || result_get() != NULL)
253             {
254                 Builder->CreateRet(result_get());
255                 TheFunction->dump();
256                 void* res = ee->getPointerToFunction(TheFunction);
257                 jitptr_t myJit = (jitptr_t) res;
258                 double result = myJit();
259                 std::cout << "coucou result : " << result << std::endl;
260             }
261         }
262     }
263
264     llvm::Value* const llvm_value_one = llvm::ConstantFP::get(llvm::getGlobalContext(), llvm::APFloat(1.0));
265     llvm::Value* llvm_rec_power (llvm::Value* x, llvm::Value* n)
266     {
267         llvm::ConstantFP* ncfp = llvm::dyn_cast<llvm::ConstantFP>(n);
268
269         if (ncfp->isZero())
270         {
271             // return 1
272             return llvm_value_one;
273         }
274         if (ncfp->isNegative())
275         {
276             llvm::Value* moduloN = Builder->CreateFMul(llvm::ConstantFP::get(llvm::getGlobalContext(), llvm::APFloat(-1.0)), n);
277             // return 1 / (x * llvm_rec_power(x, (-1 * n)-1))
278             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");
279         }
280         else
281         {
282             // return x * llvm_rec_power(x, n-1)
283             return Builder->CreateFMul(x, llvm_rec_power(x, Builder->CreateFSub(n, llvm_value_one, "OpExp::minus")), "OpExp::times");
284         }
285     }
286     void visitprivate(const OpExp &e)
287     {
288         /*
289           switch (e.kind_get())
290           {
291           case OpExp::invalid_kind :
292           {
293           std::cout << "OpExp::invalid_kind" << std::endl;
294           break;
295           }
296           case OpExp::bool_kind :
297           {
298           std::cout << "OpExp::bool_kind" << std::endl;
299           break;
300           }
301           case OpExp::string_kind :
302           {
303           std::cout << "OpExp::string_kind" << std::endl;
304           break;
305           }
306           case OpExp::integer_kind :
307           {
308           std::cout << "OpExp::integer_kind" << std::endl;
309           break;
310           }
311           case OpExp::float_kind :
312           {
313           std::cout << "OpExp::float_kind" << std::endl;
314           break;
315           }
316           case OpExp::double_kind :
317           {
318           std::cout << "OpExp::double_kind" << std::endl;
319           break;
320           }
321           case OpExp::float_complex_kind :
322           {
323           break;
324           }
325           case OpExp::double_complex_kind :
326           {
327           break;
328           }
329           case OpExp::bool_matrix_kind :
330           {
331           break;
332           }
333           case OpExp::string_matrix_kind :
334           {
335           break;
336           }
337           case OpExp::integer_matrix_kind :
338           {
339           break;
340           }
341           case OpExp::float_matrix_kind :
342           {
343           break;
344           }
345           case OpExp::double_matrix_kind :
346           {
347           break;
348           }
349           case OpExp::float_complex_matrix_kind :
350           {
351           break;
352           }
353           case OpExp::double_complex_matrix_kind :
354           {
355           break;
356           }
357           case OpExp::matrix_kind :
358           {
359           break;
360           }
361           }
362         */
363
364         /*getting what to assign*/
365         e.left_get().accept(*this);
366         llvm::Value *pITL = result_get();
367
368         /*getting what to assign*/
369         e.right_get().accept(*this);
370         llvm::Value *pITR = result_get();
371
372         llvm::Value *pResult = NULL;
373         switch (e.oper_get())
374         {
375             case OpExp::plus :
376             {
377                 //%5 = call i32 @_Z17AddDoubleToDoublePN5types6DoubleES1_PS1_(%"class.types::Double"* %3, %"class.types::Double"* %4, %"class.types::Double"** %pdbl1)
378                 //                      pResult = Builder->CreateFAdd(pITL, pITR, "OpExp::plus");
379
380                 llvm::Value * tmp = Builder->CreateAlloca(llvm::PointerType::getUnqual(TheModule->getTypeByName("class.types::Double")));
381
382                 //printf("%p \n",TheModule->getFunction("_Z17AddDoubleToDoublePN5types6DoubleES1_PS1_"));
383
384                 Builder->CreateCall3(TheModule->getFunction("_Z17AddDoubleToDoublePN5types6DoubleES1_PS1_"), pITR, pITL, tmp);
385
386                 pResult = Builder->CreateLoad(tmp);
387                 break;
388             }
389             case OpExp::minus :
390             {
391                 pResult = Builder->CreateFSub(pITL, pITR, "OpExp::minus");
392                 break;
393             }
394             case OpExp::times :
395             {
396                 pResult = Builder->CreateFMul(pITL, pITR, "OpExp::times");
397                 break;
398             }
399             case OpExp::rdivide :
400             {
401                 pResult = Builder->CreateFDiv(pITL, pITR, "OpExp::rdivide");
402                 break;
403             }
404             case OpExp::ldivide :
405             {
406                 pResult = Builder->CreateFDiv(pITR, pITL, "OpExp::ldivide");
407                 break;
408             }
409             case OpExp::power :
410             {
411                 pResult = llvm_rec_power(pITL, pITR);
412                 break;
413             }
414             case OpExp::unaryMinus :
415             {
416                 pResult = Builder->CreateFSub(pITL, pITR, "OpExp::unaryMinus");
417                 break;
418             }
419             case OpExp::eq :
420             {
421                 pResult = Builder->CreateUIToFP(Builder->CreateFCmpUEQ(pITL, pITR, "OpExp::eq"), llvm::Type::getDoubleTy(llvm::getGlobalContext()), "booltodouble");
422                 break;
423             }
424             case OpExp::ne :
425             {
426                 pResult = Builder->CreateUIToFP(Builder->CreateNot(Builder->CreateFCmpUEQ(pITL, pITR, "OpExp::eq"), "not"), llvm::Type::getDoubleTy(llvm::getGlobalContext()), "booltodouble");
427                 break;
428             }
429             case OpExp::lt :
430             {
431                 pResult = Builder->CreateUIToFP(Builder->CreateFCmpULT(pITL, pITR, "OpExp::lt"), llvm::Type::getDoubleTy(llvm::getGlobalContext()), "booltodouble");
432                 break;
433             }
434             case OpExp::le :
435             {
436                 pResult = Builder->CreateUIToFP(Builder->CreateFCmpULE(pITL, pITR, "OpExp::le"), llvm::Type::getDoubleTy(llvm::getGlobalContext()), "booltodouble");
437                 break;
438             }
439             case OpExp::gt :
440             {
441                 pResult = Builder->CreateUIToFP(Builder->CreateFCmpUGT(pITL, pITR, "OpExp::gt"), llvm::Type::getDoubleTy(llvm::getGlobalContext()), "booltodouble");
442                 break;
443             }
444             case OpExp::ge :
445             {
446                 pResult = Builder->CreateUIToFP(Builder->CreateFCmpUGE(pITL, pITR, "OpExp::ge"), llvm::Type::getDoubleTy(llvm::getGlobalContext()), "booltodouble");
447                 break;
448             }
449             default:
450             {
451                 std::cout << "Operation not supported, returning 42..." << std::endl;
452                 pResult = llvm::ConstantFP::get(llvm::getGlobalContext(), llvm::APFloat(42.0));
453                 break;
454             }
455         }
456
457         if (pResult == NULL)
458         {
459             result_set(llvm::ConstantFP::get(llvm::getGlobalContext(), llvm::APFloat(42.0)));
460         }
461         result_set(pResult);
462     }
463
464     void visitprivate (const AssignExp &e)
465     {
466         /*getting what to assign*/
467
468         const SimpleVar *pVar = dynamic_cast<const SimpleVar*>(&e.left_exp_get());
469         if (pVar)
470         {
471             // x = ?
472             /*getting what to assign*/
473             e.right_exp_get().accept(*this);
474
475             llvm::Value *pITR = result_get();
476             //reset result
477             result_set(NULL);
478
479             //mod->getFunction("_ZN6symbol7Context3putERKNS_6SymbolERN5types12InternalTypeE");
480             llvm::Value * llvmScilabContext = llvm::ConstantInt::get(uintptrType, (uintptr_t)scilabContext);
481             llvmScilabContext = Builder->CreateIntToPtr(llvmScilabContext, llvm::PointerType::getUnqual(TheModule->getTypeByName("class.symbol::Context")));
482
483             llvm::Value * llvmSym = llvm::ConstantInt::get(uintptrType, (uintptr_t)&pVar->name_get());
484             llvmSym = Builder->CreateIntToPtr(llvmSym, llvm::PointerType::getUnqual(TheModule->getTypeByName("class.symbol::Symbol")));
485             llvmSym->dump();
486
487             Builder->CreateCall3(TheModule->getFunction("_ZN6symbol7Context3putERKNS_6SymbolERN5types12InternalTypeE"), llvmScilabContext, llvmSym, pITR);
488
489             //symbol::Context::getInstance()->put(pVar->name_get(), *pIT);
490             return;
491         }
492
493         llvm::Value *pResult = NULL;
494     }
495
496     void visitprivate (const SimpleVar &e)
497     {
498         /*               InternalType * pI = symbol::Context::getInstance()->get(e.name_get());
499                 result_set(pI);
500                 if (pI != NULL)
501                 {
502                     if (e.is_verbose() && pI->isCallable() == false && ConfigVariable::isPromptShow())
503                     {
504                         std::wostringstream ostr;
505                         ostr << e.name_get().name_get() << L"  = " << L"(" << pI->getRef() << L")" << std::endl;
506                         ostr << std::endl;
507                         scilabWriteW(ostr.str().c_str());
508                         VariableToString(pI);
509                     }
510             else
511             {
512
513             }
514                 }
515                 else
516                 {
517                     wchar_t szError[bsiz];
518                     os_swprintf(szError, bsiz, _W("Undefined variable: %ls\n"), e.name_get().name_get().c_str());
519                     throw ScilabError(szError, 999, e.location_get());
520                     //Err, SimpleVar doesn't exist in Scilab scopes.
521             }*/
522     }
523
524     void visit (const BoolExp &e)
525     {
526         //            visitprivate(e);
527     }
528
529     void visit (const NilExp &e)
530     {
531         //            visitprivate(e);
532     }
533
534     void visit (const ColonVar &e)
535     {
536         //            visitprivate(e);
537     }
538
539     void visit (const DollarVar &e)
540     {
541         //            visitprivate(e);
542     }
543
544     void visit (const ArrayListVar &e)
545     {
546         //            visitprivate(e);
547     }
548
549     void visit (const FieldExp &e)
550     {
551         //            visitprivate(e);
552     }
553
554
555     void visit (const LogicalOpExp &e)
556     {
557         //            visitprivate(e);
558     }
559
560     void visit (const AssignExp &e)
561     {
562         visitprivate(e);
563     }
564
565     void visit (const CellCallExp &e)
566     {
567         //            visitprivate(e);
568     }
569
570     void visit (const CallExp &e)
571     {
572         //            visitprivate(e);
573     }
574
575     void visit (const IfExp &e)
576     {
577         //            visitprivate(e);
578     }
579
580     void visit (const TryCatchExp &e)
581     {
582         //            visitprivate(e);
583     }
584
585     void visit (const WhileExp &e)
586     {
587         //            visitprivate(e);
588     }
589
590     void visit (const ForExp &e)
591     {
592         //            visitprivate(e);
593     }
594
595     void visit (const BreakExp &e)
596     {
597         //            visitprivate(e);
598     }
599
600     void visit (const ContinueExp &e)
601     {
602         //            visitprivate(e);
603     }
604
605     void visit (const ReturnExp &e)
606     {
607         //            visitprivate(e);
608     }
609
610     void visit (const SelectExp &e)
611     {
612         //            visitprivate(e);
613     }
614
615     void visit (const CaseExp &e)
616     {
617         //            visitprivate(e);
618     }
619
620     void visit (const ArrayListExp &e)
621     {
622         //            visitprivate(e);
623     }
624
625     void visit (const AssignListExp &e)
626     {
627         //            visitprivate(e);
628     }
629
630     void visit (const NotExp &e)
631     {
632         //            visitprivate(e);
633     }
634
635     void visit (const TransposeExp &e)
636     {
637         //            visitprivate(e);
638     }
639
640     void visit (const VarDec &e)
641     {
642         //            visitprivate(e);
643     }
644
645     void visit (const FunctionDec &e)
646     {
647         //            visitprivate(e);
648     }
649
650     void visit(const ListExp &e)
651     {
652         //            visitprivate(e);
653     }
654     void visit (const MatrixExp &e)
655     {
656         //            visitprivate(e);
657     }
658
659     void visit (const MatrixLineExp &e)
660     {
661         //            visitprivate(e);
662     }
663
664     void visit (const CellExp &e)
665     {
666         //            visitprivate(e);
667     }
668
669     void visit (const StringExp &e)
670     {
671         //            visitprivate(e);
672     }
673
674     void visit (const CommentExp &e)
675     {
676         //            visitprivate(e);
677     }
678 };
679 }
680 #endif // !AST_JITVISITOR_HXX
681
682