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
 365         llvm::Value * tmp = Builder->CreateAlloca(llvm::PointerType::getUnqual(TheModule->getTypeByName("class.types::Double")));
 366
 367         switch (e.oper_get())
 368         {
 369             case OpExp::plus :
 370             {
 371
 372                 Builder->CreateCall3(TheModule->getFunction("_Z17AddDoubleToDoublePN5types6DoubleES1_PS1_"), pITR, pITL, tmp);
 373
 374                 break;
 375             }
 376             case OpExp::minus :
 377             {
 378
 379                 Builder->CreateCall3(TheModule->getFunction("_Z23SubstractDoubleToDoublePN5types6DoubleES1_PS1_"), pITR, pITL, tmp);
 380
 381                 break;
 382             }
 383             case OpExp::times :
 384             {
 385
 386                 Builder->CreateCall3(TheModule->getFunction("_Z22MultiplyDoubleByDoublePN5types6DoubleES1_PS1_"), pITR, pITL, tmp);
 387
 388                 break;
 389             }
 390             case OpExp::rdivide :
 391             {
 392                 pResult = Builder->CreateFDiv(pITL, pITR, "OpExp::rdivide");
 393                 break;
 394             }
 395             case OpExp::ldivide :
 396             {
 397                 pResult = Builder->CreateFDiv(pITR, pITL, "OpExp::ldivide");
 398                 break;
 399             }
 400             case OpExp::power :
 401             {
 402                 pResult = llvm_rec_power(pITL, pITR);
 403                 break;
 404             }
 405             case OpExp::unaryMinus :
 406             {
 407                 pResult = Builder->CreateFSub(pITL, pITR, "OpExp::unaryMinus");
 408                 break;
 409             }
 410             case OpExp::eq :
 411             {
 412                 pResult = Builder->CreateUIToFP(Builder->CreateFCmpUEQ(pITL, pITR, "OpExp::eq"), llvm::Type::getDoubleTy(llvm::getGlobalContext()), "booltodouble");
 413                 break;
 414             }
 415             case OpExp::ne :
 416             {
 417                 pResult = Builder->CreateUIToFP(Builder->CreateNot(Builder->CreateFCmpUEQ(pITL, pITR, "OpExp::eq"), "not"), llvm::Type::getDoubleTy(llvm::getGlobalContext()), "booltodouble");
 418                 break;
 419             }
 420             case OpExp::lt :
 421             {
 422                 pResult = Builder->CreateUIToFP(Builder->CreateFCmpULT(pITL, pITR, "OpExp::lt"), llvm::Type::getDoubleTy(llvm::getGlobalContext()), "booltodouble");
 423                 break;
 424             }
 425             case OpExp::le :
 426             {
 427                 pResult = Builder->CreateUIToFP(Builder->CreateFCmpULE(pITL, pITR, "OpExp::le"), llvm::Type::getDoubleTy(llvm::getGlobalContext()), "booltodouble");
 428                 break;
 429             }
 430             case OpExp::gt :
 431             {
 432                 pResult = Builder->CreateUIToFP(Builder->CreateFCmpUGT(pITL, pITR, "OpExp::gt"), llvm::Type::getDoubleTy(llvm::getGlobalContext()), "booltodouble");
 433                 break;
 434             }
 435             case OpExp::ge :
 436             {
 437                 pResult = Builder->CreateUIToFP(Builder->CreateFCmpUGE(pITL, pITR, "OpExp::ge"), llvm::Type::getDoubleTy(llvm::getGlobalContext()), "booltodouble");
 438                 break;
 439             }
 440             default:
 441             {
 442                 std::cout << "Operation not supported, returning 42..." << std::endl;
 443                 pResult = llvm::ConstantFP::get(llvm::getGlobalContext(), llvm::APFloat(42.0));
 444                 break;
 445             }
 446         }
 447         pResult = Builder->CreateLoad(tmp);
 448
 449         if (pResult == NULL)
 450         {
 451             result_set(llvm::ConstantFP::get(llvm::getGlobalContext(), llvm::APFloat(42.0)));
 452         }
 453         result_set(pResult);
 454     }
 455
 456     void visitprivate (const AssignExp &e)
 457     {
 458         /*getting what to assign*/
 459
 460         const SimpleVar *pVar = dynamic_cast<const SimpleVar*>(&e.left_exp_get());
 461         if (pVar)
 462         {
 463             // x = ?
 464             /*getting what to assign*/
 465             e.right_exp_get().accept(*this);
 466
 467             llvm::Value *pITR = result_get();
 468             //reset result
 469             result_set(NULL);
 470
 471             genLLVMPutSymbol(&pVar->name_get(), pITR);
 472
 473             //symbol::Context::getInstance()->put(pVar->name_get(), *pIT);
 474             return;
 475         }
 476
 477         llvm::Value *pResult = NULL;
 478     }
 479
 480     void visitprivate (const SimpleVar &e)
 481     {
 482         if (e.is_verbose())
 483         {
 484             InternalType * pI = symbol::Context::getInstance()->get(e.name_get());
 485             if (pI != NULL && pI->isCallable() == false && ConfigVariable::isPromptShow())
 486             {
 487                 std::wostringstream ostr;
 488                 ostr << e.name_get().name_get() << L"  = " << L"(" << pI->getRef() << L")" << std::endl;
 489                 ostr << std::endl;
 490                 scilabWriteW(ostr.str().c_str());
 491                 printScilabVar(pI);
 492             }
 493             else
 494             {
 495                 wchar_t szError[bsiz];
 496                 os_swprintf(szError, bsiz, _W("Undefined variable: %ls\n"), e.name_get().name_get().c_str());
 497                 throw ScilabError(szError, 999, e.location_get());
 498                 //Err, SimpleVar doesn't exist in Scilab scopes.
 499             }
 500         }
 501         else // JIT
 502         {
 503             //mod->getFunction("_ZNK6symbol7Context3getERKNS_6SymbolE")
 504             llvm::Value * llvmScilabContext = llvm::ConstantInt::get(uintptrType, (uintptr_t)scilabContext);
 505             llvmScilabContext = Builder->CreateIntToPtr(llvmScilabContext, llvm::PointerType::getUnqual(TheModule->getTypeByName("class.symbol::Context")));
 506
 507             llvm::Value * llvmSym = llvm::ConstantInt::get(uintptrType, (uintptr_t)&e.name_get());
 508             llvmSym = Builder->CreateIntToPtr(llvmSym, llvm::PointerType::getUnqual(TheModule->getTypeByName("class.symbol::Symbol")));
 509
 510             llvm::Value * result = Builder->CreateCall2(TheModule->getFunction("_ZNK6symbol7Context3getERKNS_6SymbolE"), llvmScilabContext, llvmSym);
 511             result_set(result);
 512         }
 513     }
 514
 515     void visitprivate(const ForExp &e)
 516     {
 517         e.vardec_get().accept(*this);
 518         symbol::Symbol& varName = e.vardec_get().name_get();
 519
 520         llvm::BasicBlock * BBTest = llvm::BasicBlock::Create(llvm::getGlobalContext(), "for_test", TheFunction);
 521         llvm::BasicBlock * BBBody = llvm::BasicBlock::Create(llvm::getGlobalContext(), "for_body", TheFunction);
 522         llvm::BasicBlock * BBAfter = llvm::BasicBlock::Create(llvm::getGlobalContext(), "for_after", TheFunction);
 523
 524         llvm::Value* cur = Builder->CreateAlloca(llvm::PointerType::getUnqual(TheModule->getTypeByName("class.types::Double")));
 525         llvm::Value* tmp = Builder->CreateAlloca(llvm::PointerType::getUnqual(TheModule->getTypeByName("class.types::Bool")));
 526         llvm::Value* zero = llvm::ConstantInt::get(llvm::Type::getInt32Ty(*context), 0);
 527
 528         llvm::Value* start = _result;
 529         llvm::Value* step = _result2;
 530         llvm::Value* end = _result3;
 531
 532         Builder->CreateStore(start, cur);
 533         Builder->CreateBr(BBTest);
 534
 535         Builder->SetInsertPoint(BBTest);
 536         Builder->CreateCall3(TheModule->getFunction("_Z16DoubleLessDoublePN5types6DoubleES1_PPNS_4BoolE"), end, Builder->CreateLoad(cur), tmp);
 537         tmp = Builder->CreateLoad(tmp);
 538         tmp = Builder->CreateCall2(TheModule->getFunction("_ZN5types7ArrayOfIiE3getEi"), tmp, zero);
 539         Builder->CreateCondBr(tmp, BBAfter, BBBody);
 540
 541
 542         Builder->SetInsertPoint(BBBody);
 543         genLLVMPutSymbol(&varName, Builder->CreateLoad(cur));
 544         e.body_get().accept(*this);
 545         Builder->CreateCall3(TheModule->getFunction("_Z17AddDoubleToDoublePN5types6DoubleES1_PS1_"), Builder->CreateLoad(cur), step, cur);
 546         Builder->CreateBr(BBTest);
 547
 548         Builder->SetInsertPoint(BBAfter);
 549     }
 550
 551     void visitprivate(const ListExp &e)
 552     {
 553         e.start_get().accept(*this);
 554         llvm::Value * start = result_get();
 555
 556         e.step_get().accept(*this);
 557         llvm::Value * step = result_get();
 558
 559         e.end_get().accept(*this);
 560         llvm::Value * end = result_get();
 561
 562         _result = start;
 563         _result2 = step;
 564         _result3 = end;
 565     }
 566
 567     void visitprivate(const VarDec &e)
 568     {
 569         e.init_get().accept(*this);
 570     }
 571
 572     void visit (const BoolExp &e)
 573     {
 574         //            visitprivate(e);
 575     }
 576
 577     void visit (const NilExp &e)
 578     {
 579         //            visitprivate(e);
 580     }
 581
 582     void visit (const ColonVar &e)
 583     {
 584         //            visitprivate(e);
 585     }
 586
 587     void visit (const DollarVar &e)
 588     {
 589         //            visitprivate(e);
 590     }
 591
 592     void visit (const ArrayListVar &e)
 593     {
 594         //            visitprivate(e);
 595     }
 596
 597     void visit (const FieldExp &e)
 598     {
 599         //            visitprivate(e);
 600     }
 601
 602
 603     void visit (const LogicalOpExp &e)
 604     {
 605         //            visitprivate(e);
 606     }
 607
 608     void visit (const AssignExp &e)
 609     {
 610         visitprivate(e);
 611     }
 612
 613     void visit (const CellCallExp &e)
 614     {
 615         //            visitprivate(e);
 616     }
 617
 618     void visit (const CallExp &e)
 619     {
 620         //            visitprivate(e);
 621     }
 622
 623     void visit (const IfExp &e)
 624     {
 625         //            visitprivate(e);
 626     }
 627
 628     void visit (const TryCatchExp &e)
 629     {
 630         //            visitprivate(e);
 631     }
 632
 633     void visit (const WhileExp &e)
 634     {
 635         //            visitprivate(e);
 636     }
 637
 638     void visit (const ForExp &e)
 639     {
 640         visitprivate(e);
 641     }
 642
 643     void visit (const BreakExp &e)
 644     {
 645         //            visitprivate(e);
 646     }
 647
 648     void visit (const ContinueExp &e)
 649     {
 650         //            visitprivate(e);
 651     }
 652
 653     void visit (const ReturnExp &e)
 654     {
 655         //            visitprivate(e);
 656     }
 657
 658     void visit (const SelectExp &e)
 659     {
 660         //            visitprivate(e);
 661     }
 662
 663     void visit (const CaseExp &e)
 664     {
 665         //            visitprivate(e);
 666     }
 667
 668     void visit (const ArrayListExp &e)
 669     {
 670         //            visitprivate(e);
 671     }
 672
 673     void visit (const AssignListExp &e)
 674     {
 675         //            visitprivate(e);
 676     }
 677
 678     void visit (const NotExp &e)
 679     {
 680         //            visitprivate(e);
 681     }
 682
 683     void visit (const TransposeExp &e)
 684     {
 685         //            visitprivate(e);
 686     }
 687
 688     void visit (const VarDec &e)
 689     {
 690         visitprivate(e);
 691     }
 692
 693     void visit (const FunctionDec &e)
 694     {
 695         //            visitprivate(e);
 696     }
 697
 698     void visit(const ListExp &e)
 699     {
 700         visitprivate(e);
 701     }
 702     void visit (const MatrixExp &e)
 703     {
 704         //            visitprivate(e);
 705     }
 706
 707     void visit (const MatrixLineExp &e)
 708     {
 709         //            visitprivate(e);
 710     }
 711
 712     void visit (const CellExp &e)
 713     {
 714         //            visitprivate(e);
 715     }
 716
 717     void visit (const StringExp &e)
 718     {
 719         //            visitprivate(e);
 720     }
 721
 722     void visit (const CommentExp &e)
 723     {
 724         //            visitprivate(e);
 725     }
 726
 727     void genLLVMInitialize()
 728     {
 729         llvm::FunctionType *FT = llvm::FunctionType::get(llvm::Type::getVoidTy(*context), false);
 730         TheFunction = llvm::Function::Create(FT, llvm::Function::ExternalLinkage, "TheFunction", TheModule);
 731         llvm::BasicBlock *BB = llvm::BasicBlock::Create(llvm::getGlobalContext(), "entry", TheFunction);
 732         Builder->SetInsertPoint(BB);
 733     }
 734
 735     void genLLVMFinalize()
 736     {
 737         Builder->CreateRetVoid();
 738         TheFunction->dump();
 739     }
 740
 741     void compileAndExec()
 742     {
 743         void* res = ee->getPointerToFunction(TheFunction);
 744         jitptr_t myJit = (jitptr_t) res;
 745         myJit();
 746     }
 747
 748     void genLLVMPutSymbol(const symbol::Symbol * s, llvm::Value * v)
 749     {
 750         llvm::Value * llvmScilabContext = llvm::ConstantInt::get(uintptrType, (uintptr_t)scilabContext);
 751         llvmScilabContext = Builder->CreateIntToPtr(llvmScilabContext, llvm::PointerType::getUnqual(TheModule->getTypeByName("class.symbol::Context")));
 752
 753         llvm::Value * llvmSym = llvm::ConstantInt::get(uintptrType, (uintptr_t)s);
 754         llvmSym = Builder->CreateIntToPtr(llvmSym, llvm::PointerType::getUnqual(TheModule->getTypeByName("class.symbol::Symbol")));
 755         //llvmSym->dump();
 756
 757         Builder->CreateCall3(TheModule->getFunction("_ZN6symbol7Context3putERKNS_6SymbolERN5types12InternalTypeE"), llvmScilabContext, llvmSym, v);
 758     }
 759
 760     static void printScilabVar(types::InternalType * pIT)
 761     {
 762         std::wostringstream ostr;
 763
 764         //to manage lines information
 765         int iLines = ConfigVariable::getConsoleLines();
 766
 767         bool bFinish = false;
 768         do
 769         {
 770             //block by block
 771             bFinish = pIT->toString(ostr);
 772             scilabWriteW(ostr.str().c_str());
 773             if (bFinish == false && iLines != 0)
 774             {
 775                 //show message on prompt
 776                 bFinish = linesmore() == 1;
 777             }
 778             ostr.str(L"");
 779         }
 780         while (bFinish == false);
 781
 782         pIT->clearPrintState();
 783     }
 784
 785 };
 786 }
 787 #endif // !AST_JITVISITOR_HXX
 788
 789