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