チュートリアル「LLVMを使用したプログラミング言語の作成」の第4章にようこそ。 前の章（ 1、2、3）では、最も単純なプログラミング言語の実装と、LLVM IR生成のサポートの追加について説明しました。 この章では、オプティマイザサポートの追加とJITコンパイラサポートの追加という2つの新しい手法について説明します。 これらのアドオンは、Kaleidoscopeプログラミング言語用の優れた効率的なコードを取得する方法を示します。

定数の最も単純な折りたたみ（定数の折りたたみ）

第3章のデモはエレガントで簡単に拡張できます。 残念ながら、完璧なコードとはほど遠いものです。 ただし、IRBuilderは、単純なコードをコンパイルする際に明らかな最適化を提供します。

 ready> def test(x) 1+2+x; Read function definition: define double @test(double %x) { entry: %addtmp = fadd double 3.000000e+00, %x ret double %addtmp }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

このコードは、入力の解析によって構築されたASTの文字通りの転写ではありません。 それ以外の場合、次のようになります。

  ready> def test（x）1 + 2 + x;
関数定義の読み取り：
二重@test（double％x）を定義する{
エントリー：
         ％addtmp = fadd double 2.000000e + 00、1.000000e + 00
         ％addtmp1 = fadd double％addtmp、％x
         ret double％addtmp1
 }

上で見たように、定数の折りたたみは非常に頻繁に使用され、非常に重要な最適化です。多くのプログラミング言語開発者がASTで定数の折りたたみをサポートするほどです。



LLVMでは、LLVM IRをビルドするすべての呼び出しがLLVM IR Builder



を通過するため、ASTでサポートを実装する必要はありませんLLVM IR Builder



自体は、定数を折りたたむことができるかどうかをチェックします。 単に定数を折りたたみ、代わりに新しい定数を返します。 指示を作成します。



まあ、それは簡単でした:)。 実際には、コードを生成するときは常にIRBuilder



を使用することをお勧めします。 使用時に「構文オーバーヘッド」はありません（どこでも定数チェックでコンパイラーを損なう必要はありません）、場合によっては、生成されるLLVM IRの量を大幅に減らすことができます（特にマクロプロセッサを備えた言語または多くの定数を使用する言語の場合）。



一方、 IRBuilder



、コードのすべての分析を「そのまま」、つまり、すでにビルドされたコードで実行するという事実によって制限されています。 少し複雑な例を取り上げると：

  ready> def test（x）（1 + 2 + x）*（x +（1 + 2））;
 ready>関数定義の読み取り：
二重@test（double％x）を定義する{
エントリー：
         ％addtmp = fadd double 3.000000e + 00、％x
         ％addtmp1 = fadd double％x、3.000000e + 00
         ％multmp = fmul double％addtmp、％addtmp1
         ret double％multmp
 }

この場合、作品の左右の部分は同じ値です。 「tmp = x + 3; result = tmp * tmp;”ダブルコンピューティングの代わりに” x + 3”。



残念ながら、ローカル分析ではこれを検出して修正することはできません。 これには、2つの変換が必要です。式の再関連付け（字句のアイデンティティを追加する）と、共通の部分式の削除（ Common Subexpression Elimination、CSE ）により、余分な追加命令が削除されます。 幸いなことに、LLVMはパッセージとして使用できる幅広い最適化を提供します。

LLVM最適化パス

LLVMは、さまざまなことを実行し、さまざまなトレードオフを伴う最適化パスを多数提供します。 他のシステムとは異なり、LLVMには、1組の最適化がすべての言語に適切であり、あらゆる場面に適しているという誤った考えを受け入れる場所がありません。 LLVMを使用すると、コンパイラーをエグゼキューターとして使用して、使用する最適化、順序、状況を完全に決定できます。



LLVMは、「モジュールを通過する」完全なパスと、残りを考慮せずに1つの機能だけで機能する「機能を通過する」パスの両方をサポートし、組み込みます。 パッセージとその仕組みの詳細については、ドキュメント「パスとLLVM パス リストを記述する 方法」を参照してください。



Kaleidoscopeの場合、現在、オンザフライ関数を生成しています。ユーザーが入力すると、一度に1つずつ生成されます。 私たちの目標は、現在の形式で最適化を最大限に活用することではありませんが、それにもかかわらず、簡単で高速なコードを取得したいと考えています。 したがって、ユーザーが入力した「機能に応じて」いくつかの最適化を選択します。 「静的なKaleidoscopeコンパイラ」を作成する場合、ファイル全体が解析されるまでオプティマイザーの起動を遅らせることを除いて、ほぼ同じコードを使用します。



機能的な最適化を得るために、作成する必要があります FunctionPassManager



実行するLLVM最適化を保存および整理する FunctionPassManager



。 次に、実行する最適化のセットを追加できます。 コードは次のとおりです。

  FunctionPassManager OurFPM(TheModule); //   .     ,  //       . OurFPM.add(new TargetData(*TheExecutionEngine->getTargetData())); //   AliasAnalysis  GVN. OurFPM.add(createBasicAliasAnalysisPass()); //   "peephole"  "bit-twiddling". OurFPM.add(createInstructionCombiningPass()); //  . OurFPM.add(createReassociatePass()); //   . OurFPM.add(createGVNPass()); //     (    ..). OurFPM.add(createCFGSimplificationPass()); OurFPM.doInitialization(); //   ,     . TheFPM = &OurFPM; //    " ". MainLoop();
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

このコードは、 "OurFPM"



という名前のFunctionPassManager



定義します。 作成するときは、モジュールにポインターを渡す必要があります。 これが完了したら、一連の"add"



呼び出しを使用してLLVMパスを追加します。 ほとんどの場合、最初のパスは定型的なものであり、後続の最適化でプログラムで使用されるデータ構造がわかるようにする必要があります。 変数"TheExecutionEngine"



は、次のセクションで取得するJITに関連付けられています。



この場合、4つの最適化パスを追加することにしました。 選択したパッセージは、広範なコードに役立つ「クリーニング」最適化のかなり標準的なセットです。 私は彼らが何をするのかを深くは述べませんが、私を信じてください、彼らは良い出発点です:)



PassManager



セットアップしPassManager



、使用する必要があります。 （ FunctionAST::Codegen



）新しい関数を生成した後、ユーザーに戻る前に実行します。

  if (Value *RetVal = Body->Codegen()) { //  . Builder.CreateRet(RetVal); //   ,    (). verifyFunction(*TheFunction);
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

 //  . TheFPM->run(*TheFunction);
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

 return TheFunction; }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

ご覧のとおり、これは非常に簡単です。 FunctionPassManager



LLVM Function*



最適化し、すぐに更新し、関数の本体を改善します（本当にそうすることを望みます）。 コードをもう一度テストしてみてください。

  ready> def test（x）（1 + 2 + x）*（x +（1 + 2））;
 ready>関数定義の読み取り：
二重@test（double％x）を定義する{
エントリー：
         ％addtmp = fadd double％x、3.000000e + 00
         ％multmp = fmul double％addtmp、％addtmp
         ret double％multmp
 }

予想どおり、追加結果とその再利用を保存した最適化されたコードが作成されました。



LLVMは、特定の状況で使用できる幅広い最適化を提供します。 さまざまな通路に関するいくつかのドキュメントが利用可能ですが、完全ではありません。 アイデアのもう1つの良い情報源は、llvm-gccまたはllvm-ldを使用するパッセージを調べることです。 optツールを使用すると、コマンドラインパッセージを試して、それらの機能を確認できます。



フロントエンドからかなり良いコードが得られたので、その実装について話しましょう！

JITコンパイラーの追加

LLVM IRで利用可能なコードには、さまざまなツールを適用できます。 たとえば、（上記で行ったように）最適化を実行したり、テキストまたはバイナリ形式で出力したり、プラットフォーム用にアセンブラーLLVM（.s）ファイルでコードをコンパイルしたり、JIT-を適用したりできます。コンパイル。 LLVM IRビューの素晴らしいところは、コンパイラのさまざまな部分の間で「単一」であることです。



このセクションでは、インタープリター用のJITコンパイルサポートを追加します。 Kaleidoscopeの主なアイデアは、ユーザーが関数またはトップレベルの式を入力して、すぐに結果を取得できることです。 たとえば、「1 + 2;」と入力する場合、3を計算して出力する必要があり、関数を定義する場合、コマンドラインから呼び出すことができます。



最初に、JITを宣言して初期化します。 これは、グローバル変数を追加してmain



呼び出すことで実行されます。

 static ExecutionEngine *TheExecutionEngine;
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

 ... int main() { ..
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

  //  JIT.    . TheExecutionEngine = EngineBuilder(TheModule).create();
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

  .. }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

これにより、抽象的な"Execution Engine"



が作成されます。これは、コンパイラーまたはLLVMインタープリターのいずれかです。 LLVMは、プラットフォームにJITコンパイラが存在する場合は自動的に選択します。存在しない場合は、インタプリタに戻ります。



ExecutionEngine



作成すると、JITを使用する準備が整います。 さまざまな便利なAPIがありますが、最も単純なのは"getPointerToFunction(F)"



メソッドです。 このメソッドは、指定されたLLVM関数をJITコンパイルし、生成されたマシンコードへの関数ポインターを返します。 この場合、これは、トップレベルの式を解析するコードを次のように変更できることを意味します。

 static void HandleTopLevelExpression() { //      . if (FunctionAST *F = ParseTopLevelExpr()) { if (Function *LF = F->Codegen()) { LF->dump(); //  .
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

 // JIT-,   . void *FPtr = TheExecutionEngine->getPointerToFunction(LF); //     ( ,  double), //       . double (*FP)() = (double (*)())(intptr_t)FPtr; fprintf(stderr, "Evaluated to %f\n", FP());
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

  }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

トップレベルの式は、引数を取らず実数を返す自律的な匿名LLVM関数として表現していることを思い出してください。 ネイティブプラットフォームでLLVM JITコンパイラを使用しているため、結果を関数型にキャストし、この関数を直接呼び出すことができます。 これは、JITでコンパイルされたコードと、アプリケーションに静的にリンクされているマシンコードの間に違いがないことを意味します。



これら2つの変更により、カレイドスコープが機能することがわかりました！

  ready> 4 + 5;
ダブル@ ""（）を定義する{
エントリー：
         ret double 9.000000e + 00
 }

 9.000000に評価

素晴らしい、それは動作するように見えます。 関数のダンプは、「doubleを返す引数を持たない関数」を示しています。これは、入力された各高レベル式に対して合成されます。 これは基本的な機能のみのデモンストレーションですが、さらに多くのことを実行できますか？

  ready> def testfunc（xy）x + y * 2;
関数定義の読み取り：
ダブル@testfunc（double％x、double％y）を定義する{
エントリー：
         ％multmp = fmul double％y、2.000000e + 00
         ％addtmp = fadd double％multmp、％x
         ret double％addtmp
 }

ready> testfunc（4、10）;

ダブル@ ""（）を定義する{
エントリー：
         ％calltmp = call double @testfunc（double 4.000000e + 00、double 1.000000e + 01）
         ret double％calltmp
 }

 24.000000に評価

これは、カスタムコードを実行できることを示していますが、微妙な点が1つあります。 testfunc



を呼び出す匿名関数でJITを呼び出しますが、testfunc自体では決して呼び出さないことに注意してください。 実際、すべての非匿名関数のJITは、 getPointerToFunction()



から戻る前に推移的に呼び出され、匿名関数からコンパイルされます。



JITは、マシンに割り当てられたメモリの解放、それらを更新するための関数の再コンパイルなどのために、他の多くのより高度なインターフェースを提供します。 ただし、この単純なコードの助けを借りても、驚くほど強力な機能が得られます-これを検証します（アイデアが見えるように匿名関数のダンプを削除しました:)：

  ready> extern sin（x）;
 externを読む： 
 double @sin（double）を宣言します

ready> extern cos（x）;

 externを読む： 
 double @cos（double）を宣言します

ready> sin（1.0）;

 0.841471に評価

ready> def foo（x）sin（x）* sin（x）+ cos（x）* cos（x）;

関数定義の読み取り：
ダブル@foo（double％x）を定義する{
エントリー：
         ％calltmp = call double @sin（double％x）
         ％multmp = fmul double％calltmp、％calltmp
         ％calltmp2 =ダブル@cosを呼び出す（double％x）
         ％multmp4 = fmul double％calltmp2、％calltmp2
         ％addtmp = fadd double％multmp、％multmp4
         ret double％addtmp
 }

ready> foo（4.0）;

 1.000000に評価

うわー、JITはどのようにsin



とcos



について学びましたか 答えは驚くほど簡単です。この例では、JITが関数の実行を開始し、関数呼び出しに到達しました。 彼は、関数がまだJITによってコンパイルされていないことに気付き、関数を評価するための標準的な一連の手順を呼び出しました。 この場合、その本体は関数に対して定義されていないため、JITは"dlsym("sin")"



呼び出しで終了します。 "sin"



JITアドレス空間で定義されているため、単にライブラリ関数を直接呼び出します。



LLVM JITは、未定義の関数の処理方法を制御するための多数のインターフェース（ ExecutionEngine.h



ファイルを参照）を提供します。 これにより、IRオブジェクトとアドレスの間に明示的なマッピングを確立でき、関数の名前を動的に動的に解決でき、関数が最初に使用されたときに関数の遅延JITコンパイルが可能になります。



この興味深いアプリケーションの1つは、操作用の任意のC ++コードを記述することで言語を拡張できることです。 たとえば、次を追加する場合：

 /// putchard -        0. extern "C" double putchard(double X) { putchar((char)X); return 0; }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

次のようなコードを使用して、コンソールに簡単な出力を生成できます。 "extern putchard(); putchard(120);"



これは、コンソールに小文字の「x」を出力します（120は「x」のASCIIコードです）。 Kaleidoscopeで同様のコードを使用して、ファイルI / O、コンソール入力、および他の多くの機能を実装できます。



これで、JITとオプティマイザーに関する章は終わりです。 現時点では、チューリング完全ではないユーザー指向プログラミング言語のコードをJITコンパイルおよび最適化できます。 次に、制御フロー制御を使用して言語を拡張し、途中でいくつかの興味深いLLVM IR問題に対処します。

完全なコードリスト

そして今、いつものように、私たちの作品のコードの完全なリストがあり、これは次のようにビルドできます：

#

g++ -g toy.cpp `llvm-config --cppflags --ldflags --libs core jit native` -O3 -o toy

#

./toy



Linuxでコンパイルする場合、-rdynamicオプションを追加します。 これにより、実行時の外部機能が適切に有効になります。



そして、コード自体は次のとおりです。

 #include "llvm/DerivedTypes.h" #include "llvm/ExecutionEngine/ExecutionEngine.h" #include "llvm/ExecutionEngine/JIT.h" #include "llvm/LLVMContext.h" #include "llvm/Module.h" #include "llvm/PassManager.h" #include "llvm/Analysis/Verifier.h" #include "llvm/Analysis/Passes.h" #include "llvm/Target/TargetData.h" #include "llvm/Target/TargetSelect.h" #include "llvm/Transforms/Scalar.h" #include "llvm/Support/IRBuilder.h" #include <cstdio> #include <string> #include <map> #include <vector> using namespace llvm; //===----------------------------------------------------------------------===// // Lexer ( ) //===----------------------------------------------------------------------===// //     [0-255],   , //       enum Token { tok_eof = -1, //  ( ) tok_def = -2, tok_extern = -3, //  ( : , ) tok_identifier = -4, tok_number = -5 }; static std::string IdentifierStr; // ,  tok_identifier static double NumVal; // ,  tok_number /// gettok -       . static int gettok() { static int LastChar = ' '; //  . while (isspace(LastChar)) LastChar = getchar(); if (isalpha(LastChar)) { // : [a-zA-Z][a-zA-Z0-9]* IdentifierStr = LastChar; while (isalnum((LastChar = getchar()))) IdentifierStr += LastChar; if (IdentifierStr == "def") return tok_def; if (IdentifierStr == "extern") return tok_extern; return tok_identifier; } if (isdigit(LastChar) || LastChar == '.') { // : [0-9.]+ std::string NumStr; do { NumStr += LastChar; LastChar = getchar(); } while (isdigit(LastChar) || LastChar == '.'); NumVal = strtod(NumStr.c_str(), 0); return tok_number; } if (LastChar == '#') { //     do LastChar = getchar(); while (LastChar != EOF && LastChar != '\n' && LastChar != '\r'); if (LastChar != EOF) return gettok(); } //   . if (LastChar == EOF) return tok_eof; //         ASCII int ThisChar = LastChar; LastChar = getchar(); return ThisChar; } //===----------------------------------------------------------------------===// // Abstract Syntax Tree (     ) //===----------------------------------------------------------------------===// /// ExprAST -      . class ExprAST { public: virtual ~ExprAST() {} virtual Value *Codegen() = 0; }; /// NumberExprAST -       (, "1.0"). class NumberExprAST : public ExprAST { double Val; public: NumberExprAST(double val) : Val(val) {} virtual Value *Codegen(); }; /// VariableExprAST -      (, "a"). class VariableExprAST : public ExprAST { std::string Name; public: VariableExprAST(const std::string &name) : Name(name) {} virtual Value *Codegen(); }; /// BinaryExprAST -      . class BinaryExprAST : public ExprAST { char Op; ExprAST *LHS, *RHS; public: BinaryExprAST(char op, ExprAST *lhs, ExprAST *rhs) : Op(op), LHS(lhs), RHS(rhs) {} virtual Value *Codegen(); }; /// CallExprAST -      . class CallExprAST : public ExprAST { std::string Callee; std::vector<ExprAST*> Args; public: CallExprAST(const std::string &callee, std::vector<ExprAST*> &args) : Callee(callee), Args(args) {} virtual Value *Codegen(); }; /// PrototypeAST -    ""  , ///        (,  , ///    ). class PrototypeAST { std::string Name; std::vector<std::string> Args; public: PrototypeAST(const std::string &name, const std::vector<std::string> &args) : Name(name), Args(args) {} Function *Codegen(); }; /// FunctionAST -     class FunctionAST { PrototypeAST *Proto; ExprAST *Body; public: FunctionAST(PrototypeAST *proto, ExprAST *body) : Proto(proto), Body(body) {} Function *Codegen(); }; //===----------------------------------------------------------------------===// // Parser (   ) //===----------------------------------------------------------------------===// /// CurTok/getNextToken -    . CurTok -   /// ,  . getNextToken     ///     CurTok. static int CurTok; static int getNextToken() { return CurTok = gettok(); } /// BinopPrecedence -      static std::map<char, int> BinopPrecedence; /// GetTokPrecedence -     . static int GetTokPrecedence() { if (!isascii(CurTok)) return -1; // ,     . int TokPrec = BinopPrecedence[CurTok]; if (TokPrec <= 0) return -1; return TokPrec; } /// Error* -       . ExprAST *Error(const char *Str) { fprintf(stderr, "Error: %s\n", Str);return 0;} PrototypeAST *ErrorP(const char *Str) { Error(Str); return 0; } FunctionAST *ErrorF(const char *Str) { Error(Str); return 0; } static ExprAST *ParseExpression(); /// identifierexpr /// ::= identifier /// ::= identifier '(' expression* ')' static ExprAST *ParseIdentifierExpr() { std::string IdName = IdentifierStr; getNextToken(); //  . if (CurTok != '(') //  . return new VariableExprAST(IdName); //  . getNextToken(); //  ( std::vector<ExprAST*> Args; if (CurTok != ')') { while (1) { ExprAST *Arg = ParseExpression(); if (!Arg) return 0; Args.push_back(Arg); if (CurTok == ')') break; if (CurTok != ',') return Error("Expected ')' or ',' in argument list"); getNextToken(); } } //  ')'. getNextToken(); return new CallExprAST(IdName, Args); } /// numberexpr ::= number static ExprAST *ParseNumberExpr() { ExprAST *Result = new NumberExprAST(NumVal); getNextToken(); //   return Result; } /// parenexpr ::= '(' expression ')' static ExprAST *ParseParenExpr() { getNextToken(); //  (. ExprAST *V = ParseExpression(); if (!V) return 0; if (CurTok != ')') return Error("expected ')'"); getNextToken(); //  ). return V; } /// primary /// ::= identifierexpr /// ::= numberexpr /// ::= parenexpr static ExprAST *ParsePrimary() { switch (CurTok) { default: return Error("unknown token when expecting an expression"); case tok_identifier: return ParseIdentifierExpr(); case tok_number: return ParseNumberExpr(); case '(': return ParseParenExpr(); } } /// binoprhs /// ::= ('+' primary)* static ExprAST *ParseBinOpRHS(int ExprPrec, ExprAST *LHS) { //    ,    while (1) { int TokPrec = GetTokPrecedence(); //           , //  ,    if (TokPrec < ExprPrec) return LHS; // ,  ,    . int BinOp = CurTok; getNextToken(); // eat binop //       ExprAST *RHS = ParsePrimary(); if (!RHS) return 0; //  BinOp   RHS  ,    RHS, //      RHS  LHS. int NextPrec = GetTokPrecedence(); if (TokPrec < NextPrec) { RHS = ParseBinOpRHS(TokPrec+1, RHS); if (RHS == 0) return 0; } //  LHS/RHS. LHS = new BinaryExprAST(BinOp, LHS, RHS); } } /// expression /// ::= primary binoprhs /// static ExprAST *ParseExpression() { ExprAST *LHS = ParsePrimary(); if (!LHS) return 0; return ParseBinOpRHS(0, LHS); } /// prototype /// ::= id '(' id* ')' static PrototypeAST *ParsePrototype() { if (CurTok != tok_identifier) return ErrorP("Expected function name in prototype"); std::string FnName = IdentifierStr; getNextToken(); if (CurTok != '(') return ErrorP("Expected '(' in prototype"); //    . std::vector<std::string> ArgNames; while (getNextToken() == tok_identifier) ArgNames.push_back(IdentifierStr); if (CurTok != ')') return ErrorP("Expected ')' in prototype"); //  . getNextToken(); //  ')'. return new PrototypeAST(FnName, ArgNames); } /// definition ::= 'def' prototype expression static FunctionAST *ParseDefinition() { getNextToken(); //  def. PrototypeAST *Proto = ParsePrototype(); if (Proto == 0) return 0; if (ExprAST *E = ParseExpression()) return new FunctionAST(Proto, E); return 0; } /// toplevelexpr ::= expression static FunctionAST *ParseTopLevelExpr() { if (ExprAST *E = ParseExpression()) { //   . PrototypeAST *Proto = new PrototypeAST("", std::vector<std::string>()); return new FunctionAST(Proto, E); } return 0; } /// external ::= 'extern' prototype static PrototypeAST *ParseExtern() { getNextToken(); //  extern. return ParsePrototype(); } //===----------------------------------------------------------------------===// // Code Generation () //===----------------------------------------------------------------------===// static Module *TheModule; static IRBuilder<> Builder(getGlobalContext()); static std::map<std::string, Value*> NamedValues; static FunctionPassManager *TheFPM; Value *ErrorV(const char *Str) { Error(Str); return 0; } Value *NumberExprAST::Codegen() { return ConstantFP::get(getGlobalContext(), APFloat(Val)); } Value *VariableExprAST::Codegen() { //      . Value *V = NamedValues[Name]; return V ? V : ErrorV("Unknown variable name"); } Value *BinaryExprAST::Codegen() { Value *L = LHS->Codegen(); Value *R = RHS->Codegen(); if (L == 0 || R == 0) return 0; switch (Op) { case '+': return Builder.CreateFAdd(L, R, "addtmp"); case '-': return Builder.CreateFSub(L, R, "subtmp"); case '*': return Builder.CreateFMul(L, R, "multmp"); case '<': L = Builder.CreateFCmpULT(L, R, "cmptmp"); //   0  1   0.0  1.0 return Builder.CreateUIToFP(L, Type::getDoubleTy(getGlobalContext()), "booltmp"); default: return ErrorV("invalid binary operator"); } } Value *CallExprAST::Codegen() { //      . Function *CalleeF = TheModule->getFunction(Callee); if (CalleeF == 0) return ErrorV("Unknown function referenced"); //    . if (CalleeF->arg_size() != Args.size()) return ErrorV("Incorrect # arguments passed"); std::vector<Value*> ArgsV; for (unsigned i = 0, e = Args.size(); i != e; ++i) { ArgsV.push_back(Args[i]->Codegen()); if (ArgsV.back() == 0) return 0; } return Builder.CreateCall(CalleeF, ArgsV.begin(), ArgsV.end(), "calltmp"); } Function *PrototypeAST::Codegen() { //   : double(double,double)  .. std::vector<const Type*> Doubles(Args.size(), Type::getDoubleTy(getGlobalContext())); FunctionType *FT = FunctionType::get(Type::getDoubleTy(getGlobalContext()), Doubles, false); Function *F = Function::Create(FT, Function::ExternalLinkage, Name, TheModule); //   (F)     ,     'Name'. //     ,      . if (F->getName() != Name) { //   ,      . F->eraseFromParent(); F = TheModule->getFunction(Name); //   (F)   , . if (!F->empty()) { ErrorF("redefinition of function"); return 0; } //   (F)    , . if (F->arg_size() != Args.size()) { ErrorF("redefinition of function with different # args"); return 0; } } //     . unsigned Idx = 0; for (Function::arg_iterator AI = F->arg_begin(); Idx != Args.size(); ++AI, ++Idx) { AI->setName(Args[Idx]); //      . NamedValues[Args[Idx]] = AI; } return F; } Function *FunctionAST::Codegen() { NamedValues.clear(); Function *TheFunction = Proto->Codegen(); if (TheFunction == 0) return 0; //      . BasicBlock *BB = BasicBlock::Create(getGlobalContext(), "entry", TheFunction); Builder.SetInsertPoint(BB); if (Value *RetVal = Body->Codegen()) { //  . Builder.CreateRet(RetVal); //   ,    (). verifyFunction(*TheFunction); //  . TheFPM->run(*TheFunction); return TheFunction; } //  ,   . TheFunction->eraseFromParent(); return 0; } //===----------------------------------------------------------------------===// // Top-Level parsing (  )   JIT //===----------------------------------------------------------------------===// static ExecutionEngine *TheExecutionEngine; static void HandleDefinition() { if (FunctionAST *F = ParseDefinition()) { if (Function *LF = F->Codegen()) { fprintf(stderr, "Read function definition:"); LF->dump(); } } else { //      . getNextToken(); } } static void HandleExtern() { if (PrototypeAST *P = ParseExtern()) { if (Function *F = P->Codegen()) { fprintf(stderr, "Read extern: "); F->dump(); } } else { //      . getNextToken(); } } static void HandleTopLevelExpression() { // Evaluate a top-level expression into an anonymous function. if (FunctionAST *F = ParseTopLevelExpr()) { if (Function *LF = F->Codegen()) { // JIT-,   . void *FPtr = TheExecutionEngine->getPointerToFunction(LF); //     ( ,  double), //       . double (*FP)() = (double (*)())(intptr_t)FPtr; fprintf(stderr, "Evaluated to %f\n", FP()); } } else { //      . getNextToken(); } } /// top ::= definition | external | expression | ';' static void MainLoop() { while (1) { fprintf(stderr, "ready> "); switch (CurTok) { case tok_eof: return; case ';': getNextToken(); break; //     . case tok_def: HandleDefinition(); break; case tok_extern: HandleExtern(); break; default: HandleTopLevelExpression(); break; } } } //===----------------------------------------------------------------------===// // "" ,     //   ("extern")   . //===----------------------------------------------------------------------===// /// putchard -        0. extern "C" double putchard(double X) { putchar((char)X); return 0; } //===----------------------------------------------------------------------===// // Main driver code (  ) //===----------------------------------------------------------------------===// int main() { InitializeNativeTarget(); LLVMContext &Context = getGlobalContext(); //    . // 1 -  . BinopPrecedence['<'] = 10; BinopPrecedence['+'] = 20; BinopPrecedence['-'] = 20; BinopPrecedence['*'] = 40; //  . fprintf(stderr, "ready> "); getNextToken(); //  ,     . TheModule = new Module("my cool jit", Context); //  JIT.     . std::string ErrStr; TheExecutionEngine = EngineBuilder(TheModule).setErrorStr(&ErrStr).create(); if (!TheExecutionEngine) { fprintf(stderr, "Could not create ExecutionEngine: %s\n", ErrStr.c_str()); exit(1); } FunctionPassManager OurFPM(TheModule); //   .     ,  //       . OurFPM.add(new TargetData(*TheExecutionEngine->getTargetData())); //   AliasAnalysis  GVN. OurFPM.add(createBasicAliasAnalysisPass()); //   "peephole"  "bit-twiddling". OurFPM.add(createInstructionCombiningPass()); //  . OurFPM.add(createReassociatePass()); //   . OurFPM.add(createGVNPass()); //     (    ..). OurFPM.add(createCFGSimplificationPass()); OurFPM.doInitialization(); //   ,     . TheFPM = &OurFPM; //    " ". MainLoop(); TheFPM = 0; //   . TheModule->dump(); return 0; }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

PS , :

• JIT- [ en ]
• [ ]
• . 5 1/2: llvm back-end [ ]
• . 8: [ ]
• [ ]
• LLVM : [ ]
• A Brief History of Just-In-Time [pdf, en]
• Debugging JITed Code With GDB [en]
• LLVM JIT Class Reference [en]