ट्यूटोरियल के अध्याय 5 में आपका स्वागत है "एलएलवीएम के साथ एक प्रोग्रामिंग भाषा बनाना"। पिछले अध्यायों ( प्रथम , द्वितीय , तृतीय और चतुर्थ ) ने सरल बहुरूपदर्शक प्रोग्रामिंग भाषा के कार्यान्वयन और एलएलवीएम आईआर पीढ़ी के लिए समर्थन के समावेश के साथ-साथ बाद के अनुकूलन और जेआईटी संकलन का वर्णन किया। दुर्भाग्य से, अपने वर्तमान स्वरूप में, कैलिडोस्कोप लगभग बेकार है: इसमें कॉल और रिटर्न के अपवाद के साथ कोई नियंत्रण प्रवाह नहीं है। इसका मतलब यह है कि कोड में कोई सशर्त कूद नहीं हो सकता है, जो प्रोग्रामिंग भाषा को महत्वपूर्ण रूप से सीमित करता है। इस अध्याय में, हम "for" लूप "for" एक if/then/else अभिव्यक्ति और एक सरल जोड़कर बहुरूपदर्शक का विस्तार करते हैं।

अगर / फिर / एल्स

if/then/else उपयोग करने के लिए बहुरूपदर्शक का विस्तार करना एक काफी सरल कार्य है। इसके लिए लेक्सिकल और पार्सर्स, एएसटीएस और कोड जनरेटर के लिए इस "नई" अवधारणा के लिए समर्थन जोड़ने की आवश्यकता है। यह एक अच्छा उदाहरण है, क्योंकि यह दिखाता है कि समय के साथ एक भाषा को "निर्माण" करना कितना आसान है, धीरे-धीरे नए विचारों के उभरने के साथ इसका विस्तार होता है।

इससे पहले कि हम इस विस्तार को जोड़ते हैं, हमें अंत में क्या प्राप्त करना चाहते हैं, इसके बारे में बात करने की आवश्यकता है। और हम कुछ इस तरह लिखना चाहते हैं:

 def fib(x) if x < 3 then 1 else fib(x-1)+fib(x-2); 

बहुरूपदर्शक में, प्रत्येक निर्माण एक अभिव्यक्ति है। इस प्रकार, if/then/else किसी अन्य if/then/else तरह if/then/else , अभिव्यक्ति को एक मूल्य वापस करना चाहिए। चूंकि हम मुख्य रूप से कार्यात्मक रूप का उपयोग करते हैं, इसलिए हमें शर्त की गणना करनी चाहिए और फिर उसके मूल्य के आधार पर "then" या "else" मूल्य वापस करना चाहिए। यह सी-एक्सप्रेशन "?:" ।

if/then/else अभिव्यक्ति का शब्दार्थ यह है कि यह एक बूलियन के रूप में स्थिति का मूल्यांकन करता है: 0.0 को गलत माना जाता है, और बाकी सब सच है। यदि स्थिति सत्य है, तो पहले उपसर्ग का परिकलन किया जाता है और वापस लौटाया जाता है; यदि स्थिति झूठी है, तो दूसरी उपसक्रियता की गणना की जाती है और वापस कर दी जाती है। चूंकि कैलीडोस्कोप दुष्प्रभाव की अनुमति देता है, इसलिए इस व्यवहार को सुदृढ़ करना महत्वपूर्ण है।

अब जब हम जानते हैं कि हम क्या चाहते हैं, तो हम भागों में समझना शुरू करेंगे।

If / then / Else का समर्थन करने के लिए शाब्दिक विश्लेषक में सुधार

यहां सब कुछ सरल है। सबसे पहले, गणना के अनुरूप टोकन के लिए नए मान जोड़ें:

  //  tok_if = -6, tok_then = -7, tok_else = -8, 

अब हम शाब्दिक विश्लेषण में नए खोजशब्दों को पहचानते हैं। यह भी सरल है:

  ... if (IdentifierStr == "def") return tok_def; if (IdentifierStr == "extern") return tok_extern; 

  if (IdentifierStr == "if") return tok_if; if (IdentifierStr == "then") return tok_then; if (IdentifierStr == "else") return tok_else; 

  return tok_identifier; 

संशोधित एएसटी अगर / फिर / एल्स का समर्थन करने के लिए

एक नए प्रकार की अभिव्यक्ति का प्रतिनिधित्व करने के लिए, एक नया एएसटी नोड जोड़ें:

 /// IfExprAST -     if/then/else. class IfExprAST : public ExprAST { ExprAST *Cond, *Then, *Else; public: IfExprAST(ExprAST *cond, ExprAST *then, ExprAST *_else) : Cond(cond), Then(then), Else(_else) {} virtual Value *Codegen(); }; 

एएसटी नोड में विभिन्न उपप्रकारों के संकेत हैं।

यदि / फिर / Else का समर्थन करने के लिए पार्सर को परिष्कृत करना

अब जब हमारे पास शाब्दिक विश्लेषण में उपयुक्त टोकन और एएसटी नोड है, तो पार्सिंग तर्क बहुत सरल होगा। सबसे पहले, एक नए पार्सिंग फ़ंक्शन को परिभाषित करते हैं:

 /// ifexpr ::= 'if' expression 'then' expression 'else' expression static ExprAST *ParseIfExpr() { getNextToken(); //  if. // . ExprAST *Cond = ParseExpression(); if (!Cond) return 0; if (CurTok != tok_then) return Error("expected then"); getNextToken(); //  then ExprAST *Then = ParseExpression(); if (Then == 0) return 0; if (CurTok != tok_else) return Error("expected else"); getNextToken(); ExprAST *Else = ParseExpression(); if (!Else) return 0; return new IfExprAST(Cond, Then, Else); } 

अगला, इसे एक प्राथमिक अभिव्यक्ति के रूप में कनेक्ट करें:

 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(); 

  case tok_if: return ParseIfExpr(); 

  } } 

एलएलवीएम आईआर फॉर इफ / फिर / एल्स

अब जब हमारे पास एएसटी की पार्सिंग और बिल्डिंग है, तो अंतिम भाग एलएलवीएम कोड जनरेशन सपोर्ट के अतिरिक्त होगा। if/then/else जोड़ने में यह सबसे दिलचस्प हिस्सा if/then/else , क्योंकि यहां हम नई अवधारणाओं को पेश करेंगे। उपरोक्त कोड में सब कुछ पिछले अध्यायों में विस्तार से वर्णित किया गया है।

आइए एक साधारण उदाहरण देखें:

 extern foo(); extern bar(); 

 def baz(x) if x then foo() else bar(); 

यदि आप ऑप्टिमाइज़ेशन बंद कर देते हैं, तो आपको कालीदोस्कोप से प्राप्त होने वाला कोड जल्द ही मिल जाएगा:

 declare double @foo() declare double @bar() define double @baz(double %x) { entry: %ifcond = fcmp one double %x, 0.000000e+00 br i1 %ifcond, label %then, label %else then: ; preds = %entry %calltmp = call double @foo() br label %ifcont else: ; preds = %entry %calltmp1 = call double @bar() br label %ifcont ifcont: ; preds = %else, %then %iftmp = phi double [ %calltmp, %then ], [ %calltmp1, %else ] ret double %iftmp } 

नियंत्रण प्रवाह ग्राफ की कल्पना करने के लिए, आप एलएलवीएम " ऑप्ट " टूल की उत्कृष्ट विशेषता का उपयोग कर सकते हैं। यदि आप इस LLVM IR को "t.ll" में रखते हैं और "llvm-as < t.ll | opt -analyze -view-cfg" , तो एक विंडो दिखाई देगी जिसमें आप इस ग्राफ को देखेंगे:


इसे प्राप्त करने का दूसरा तरीका "F->viewCFG()" या "F->viewCFGOnly()" (जहां F "Function*" ) कॉल करना वास्तव में कोड में कॉल और recompiling या डीबगर में कॉल करना है। एलएलवीएम में विभिन्न रेखांकन की कल्पना के लिए कई उपयोगी विशेषताएं हैं।

आइए हम उत्पन्न कोड पर लौटते हैं, यह काफी सरल है: इनपुट ब्लॉक सशर्त अभिव्यक्ति (हमारे मामले में, "x" ) की गणना करता है और निर्देश का उपयोग करके 0.0 साथ परिणाम की तुलना करता है। "fcmp one" "fcmp one" । इस अभिव्यक्ति के परिणाम के आधार पर, कोड या तो "then" ब्लॉक या "else" ब्लॉक में जाता है, जिसमें सच्चे / झूठे मामलों के लिए अभिव्यक्ति होती है।

एक बार then/else ब्लॉकों के पूरा हो जाने के then/else , ये दोनों शाखाएँ "ifcont" ब्लॉक पर जाती हैं ताकि if/then/else बाद स्थित कोड को निष्पादित किया जा सके। इस मामले में, केवल एक चीज जो करना बाकी है, वह कॉलिंग फ़ंक्शन पर लौटती है। फिर सवाल उठता है: मुझे अभिव्यक्ति वापस करने के लिए कोड कैसे पता चलेगा?

इस प्रश्न के उत्तर में एक महत्वपूर्ण एसएसए ऑपरेशन: ऑपरेशन शामिल है Phi Phi । यदि आप SSA से परिचित नहीं हैं, तो विकिपीडिया लेख एक अच्छा परिचय होगा, और इसके बारे में अन्य परिचयात्मक लेख हैं जो आपके पसंदीदा खोज इंजन द्वारा आसानी से मिल सकते हैं। लघु संस्करण: Phi ऑपरेशन के "निष्पादन" के लिए उस ब्लॉक को "याद" करना पड़ता है जिससे हम आए थे। ऑपरेशन Phi मान और संबंधित इनपुट कंट्रोल यूनिट लेता है। इस मामले में, यदि नियंत्रण "then" ब्लॉक से आता है, "then" इसे "calltmp" मान मिलता है। यदि नियंत्रण "else" ब्लॉक से आता है, तो इसे "calltmp1" मान "calltmp1" ।

अब आप शायद सोचने लगे हैं: “अरे नहीं! इसका मतलब यह है कि मेरे सरल और सुरुचिपूर्ण सामने के छोर को एलएलवीएम का उपयोग करने के लिए एक एसएसए फॉर्म उत्पन्न करना शुरू करना होगा! " सौभाग्य से, यह मामला नहीं है, और हम दृढ़ता से सलाह देते हैं कि एसएसए भवन एल्गोरिथ्म को अपने सामने के छोर पर लागू न करें जब तक कि इसके लिए वास्तव में महत्वपूर्ण कारण न हो। व्यवहार में, औसत अनिवार्य प्रोग्रामिंग भाषा के लिए कोड में दो प्रकार के मूल्य हैं जिन्हें फी नोड्स की आवश्यकता हो सकती है:

1. उपयोगकर्ता चर प्रदान करने वाला कोड: = 1; = + 1; = 1; = + 1;
2. मान जो आपके एएसटी की संरचना में निहित हैं, जैसे कि इस मामले में फी नोड।

इस ट्यूटोरियल के अध्याय 7 में ("परिवर्तनशील चर"), हम नंबर 1 के बारे में बात करेंगे। इस बीच, बस मुझ पर भरोसा करें कि आपको इस मामले को संभालने के लिए एसएसए बनाने की जरूरत नहीं है। नंबर 2 के लिए, आपके पास एक विकल्प है: उन विधियों का उपयोग करें जो हम नंबर 1 के लिए वर्णन करते हैं, या आप सीधे फी नोड्स सम्मिलित कर सकते हैं, अगर यह आपके लिए सुविधाजनक है। इस मामले में, फी नोड्स उत्पन्न करना वास्तव में बहुत सरल है, इसलिए हमने ऐसा करने का फैसला किया।

ठीक है, यह कोड उत्पन्न करने का समय है!

अगर / फिर / के लिए कोड जनरेशन

कोड पीढ़ी के लिए, हम IfExprAST लिए IfExprAST विधि लागू करते हैं:

 Value *IfExprAST::Codegen() { Value *CondV = Cond->Codegen(); if (CondV == 0) return 0; //       0.0. CondV = Builder.CreateFCmpONE(CondV, ConstantFP::get(getGlobalContext(), APFloat(0.0)), "ifcond"); 

यह कोड सरल है और जैसा हमने पहले देखा था वैसा ही है। हम स्थिति के लिए अभिव्यक्ति प्राप्त करते हैं, और फिर 1-बिट (बूल) मूल्य के रूप में इसकी सच्चाई प्राप्त करने के लिए शून्य के साथ इस मूल्य की तुलना करते हैं।

  Function *TheFunction = Builder.GetInsertBlock()->getParent(); //     then  else.   'then'  //  . BasicBlock *ThenBB = BasicBlock::Create(getGlobalContext(), "then", TheFunction); BasicBlock *ElseBB = BasicBlock::Create(getGlobalContext(), "else"); BasicBlock *MergeBB = BasicBlock::Create(getGlobalContext(), "ifcont"); Builder.CreateCondBr(CondV, ThenBB, ElseBB); 

यह कोड आधार ब्लॉक बनाता है जो if/then/else से संबंधित हैं और उपरोक्त उदाहरण में ब्लॉक से मेल खाते हैं। पहली पंक्ति को वर्तमान Function ऑब्जेक्ट (गठित फ़ंक्शन का) मिलता है। वह Builder से वर्तमान आधार इकाई के बारे में पूछकर और उसका "मूल" (वर्तमान कार्य) प्राप्त कर लेती है।

वह फिर तीन ब्लॉक बनाता है। ध्यान दें कि यह "then" ब्लॉक के "TheFunction" को "TheFunction" पास करता है। यह निर्माता को निर्दिष्ट फ़ंक्शन के अंत में एक नया ब्लॉक सम्मिलित करने का कारण बनता है। दो अन्य ब्लॉक भी बनाए गए हैं, लेकिन अभी तक फ़ंक्शन में नहीं डाले गए हैं।

ब्लॉक बनाने के बाद, हम एक सशर्त शाखा उत्पन्न कर सकते हैं जो उनके बीच चयन करती है। ध्यान दें कि नए ब्लॉक का निहित निर्माण IRBuilder को प्रभावित नहीं करता है, इसलिए प्रविष्टि अभी भी उसी ब्लॉक में होती है जो हमने दर्ज किया था। यह भी ध्यान दें कि यह "then" ब्लॉक "else" ब्लॉक के लिए एक शाखा बनाता है, हालांकि "else" ब्लॉक को अभी तक फ़ंक्शन में नहीं डाला गया है। लेकिन सब कुछ क्रम में है: आगे के लिंक का समर्थन करने के लिए एलएलवीएम के लिए यह मानक तरीका है।

  //  . Builder.SetInsertPoint(ThenBB); Value *ThenV = Then->Codegen(); if (ThenV == 0) return 0; Builder.CreateBr(MergeBB); // Codegen of 'Then'    ,  ThenBB  PHI. ThenBB = Builder.GetInsertBlock(); 

सशर्त कूद डालने के बाद, हम बिल्डर को "then" ब्लॉक में सम्मिलित करना शुरू करने के लिए "then" । सख्ती से बोलते हुए, यह कॉल कर्सर को निर्दिष्ट ब्लॉक के अंत तक ले जाता है। हालाँकि, चूंकि "then" ब्लॉक खाली है, यह ब्लॉक की शुरुआत में हमारा इंसर्ट भी करता है। :)

एक बार कर्सर सेट हो जाने पर, हम एएसटी से "then" के लिए कोड का पुनरावृत्ति करते हैं। "then" ब्लॉक को पूरा करने के लिए, हम शाखा मर्ज ब्लॉक में बिना शर्त कूद बनाते हैं। एलएलवीएम आईआर के दिलचस्प (और बहुत महत्वपूर्ण) पहलुओं में से एक यह है कि नियंत्रण रेखा अनुदेश जैसे रिटर्न या शाखा के साथ सभी बेस ब्लॉक को "समाप्त" किया जाना चाहिए । इसका अर्थ है कि नियंत्रण का पूरा प्रवाह, जिसमें किसी अन्य कोड पर नियंत्रण स्थानांतरित होता है ( एलटी थ्रू ), एलएलवीआर आईआर में स्पष्ट रूप से मौजूद होना चाहिए। यदि इस नियम का उल्लंघन किया जाता है, तो सत्यापनकर्ता एक त्रुटि लौटाएगा।

अंतिम पंक्ति यहाँ महत्वपूर्ण है। एक शाखा मर्ज ब्लॉक में Phi नोड बनाते समय, हमें ब्लॉक / मान जोड़े को निर्दिष्ट करना चाहिए जो इंगित करता है कि Phi कैसे काम करेगा। यह ध्यान रखना महत्वपूर्ण है कि Phi नोड CFG में प्रत्येक ब्लॉक पूर्ववर्ती के लिए एक प्रवेश बिंदु प्राप्त करने की उम्मीद करता है। क्यों, क्या हमें वर्तमान ब्लॉक तब मिलता है जब हम इसे सिर्फ तब के पांच लाइनों में सेट करते हैं? समस्या यह है कि "then" अभिव्यक्ति वास्तव में उस ब्लॉक को बदल सकती है जो बिल्डर उत्पन्न करता है, उदाहरण के लिए, यदि इसमें निहित "if/then/else" अभिव्यक्ति है। चूंकि Codegen लिए एक पुनरावर्ती कॉल वर्तमान ब्लॉक को मनमाने ढंग से बदल सकता है, हमें उस कोड के लिए वर्तमान वास्तविक मान प्राप्त करना होगा जो Phi नोड में बनाया जाएगा।

  //   else. TheFunction->getBasicBlockList().push_back(ElseBB); Builder.SetInsertPoint(ElseBB); Value *ElseV = Else->Codegen(); if (ElseV == 0) return 0; Builder.CreateBr(MergeBB); //  'Else'    ,  ElseBB  PHI. ElseBB = Builder.GetInsertBlock(); 

"else" ब्लॉक के लिए कोड पीढ़ी "then" ब्लॉक के लिए कोड पीढ़ी के लगभग समान है। एकमात्र महत्वपूर्ण अंतर पहली पंक्ति में है, जो फ़ंक्शन में "else" ब्लॉक को जोड़ता है। याद रखें कि "else" ब्लॉक पहले बनाया गया था, लेकिन फ़ंक्शन में नहीं जोड़ा गया। अब जब "then" और "else" ब्लॉक उत्पन्न हो गए हैं, तो हम उनके मर्ज कोड के साथ समाप्त हो सकते हैं:

  //   . TheFunction->getBasicBlockList().push_back(MergeBB); Builder.SetInsertPoint(MergeBB); PHINode *PN = Builder.CreatePHI(Type::getDoubleTy(getGlobalContext()), 2, "iftmp"); PN->addIncoming(ThenV, ThenBB); PN->addIncoming(ElseV, ElseBB); return PN; } 

पहली दो पंक्तियाँ आप से परिचित हैं: पहला फ़ंक्शन ऑब्जेक्ट में "merge" ब्लॉक जोड़ता है। दूसरा ब्लॉक सम्मिलन कर्सर को स्थानांतरित करता है ताकि नव निर्मित कोड "merge" ब्लॉक में फिट हो जाए। फिर हमें PHI नोड बनाने और PHI लिए ब्लॉक / मान जोड़े सेट करने की आवश्यकता है।

अंत में, CodeGen फ़ंक्शन Phi नोड को if/then/else अभिव्यक्ति के लिए गणना किए गए मान के रूप में लौटाता है। ऊपर हमारे उदाहरण में, यह रिटर्न वैल्यू शीर्ष-स्तरीय फ़ंक्शन के कोड में जाएगा, जो रिटर्न स्टेटमेंट बनाएगा।

सामान्य तौर पर, अब हमारे पास बहुरूपदर्शक में सशर्त कोड निष्पादित करने की क्षमता है। इस विस्तार के साथ, कैलीडोस्कोप एक काफी व्यापक प्रोग्रामिंग भाषा है जो संख्यात्मक कार्यों की एक विस्तृत श्रृंखला की गणना कर सकता है। अब हम एक और उपयोगी अभिव्यक्ति जोड़ेंगे जो गैर-कार्यात्मक प्रोग्रामिंग भाषाओं से हमें परिचित है ...

पाश के लिए

अब जब हम जानते हैं कि भाषा पर बुनियादी नियंत्रण संरचनाओं को कैसे जोड़ा जाए, तो हमारे पास अधिक शक्तिशाली चीजें जोड़ने का एक उपकरण है। आइए कुछ और आक्रामक जोड़ने की कोशिश करें - अभिव्यक्ति "for" :

  extern putchard(char) 

  def printstar(n) for i = 1, i < n, 1.0 in putchard(42); # ascii 42 = '*' #  100  '*' printstar(100); 

यह अभिव्यक्ति एक नए चर (इस मामले में, "i" ) को परिभाषित करती है जो प्रारंभिक मूल्य से तब तक पुनरावृत्ति करता है जब तक कि स्थिति (इस मामले में, "i < n" ) सही हो जाती है, कदम के मूल्य से बढ़ जाती है (इस मामले में, "1.0" )। यदि चरण मान छोड़ा जाता है, तो डिफ़ॉल्ट रूप से यह 1.0 । लूप अभिव्यक्ति के अपने शरीर को निष्पादित करता है। चूंकि हमारे पास लौटने के लिए कुछ भी बेहतर नहीं है, हम बस पाश को परिभाषित करते हैं जैसे कि हमेशा 0.0 । बाद में, जब हम उत्परिवर्तनीय चर जोड़ते हैं, तो यह अधिक उपयोगी होगा।

पिछले मामले की तरह, उन बदलावों पर भी विचार करें, जिनकी हमें कलीदोस्कोप को चक्र का समर्थन करने की जरूरत है, भागों में।

लूपिकल विश्लेषक को 'लूप' के लिए सपोर्ट करना

लेक्सिकल एनालाइजर को उसी तरह से सप्लीमेंट किया जाता है, जिस तरह से if/then/else :

  ...   Token ... //  tok_if = -6, tok_then = -7, tok_else = -8, 

  tok_for = -9, tok_in = -10 

 ... in gettok ... if (IdentifierStr == "def") return tok_def; if (IdentifierStr == "extern") return tok_extern; if (IdentifierStr == "if") return tok_if; if (IdentifierStr == "then") return tok_then; if (IdentifierStr == "else") return tok_else; 

  if (IdentifierStr == "for") return tok_for; if (IdentifierStr == "in") return tok_in; 

  return tok_identifier; 

'पाश' के लिए समर्थन करने के लिए संशोधित एएसटी

एएसटी नोड भी सरल है। यह अपने नोड्स में चर नाम और लूप बॉडी की अभिव्यक्ति को संग्रहीत करता है।

 /// ForExprAST -     for/in. class ForExprAST : public ExprAST { std::string VarName; ExprAST *Start, *End, *Step, *Body; public: ForExprAST(const std::string &varname, ExprAST *start, ExprAST *end, ExprAST *step, ExprAST *body) : VarName(varname), Start(start), End(end), Step(step), Body(body) {} virtual Value *Codegen(); }; 

'फॉर ’लूप का समर्थन करने के लिए पार्सर को परिष्कृत करना

पार्सर कोड में परिवर्तन भी बहुत मानक हैं। यहां एकमात्र दिलचस्प बिंदु वैकल्पिक कदम मूल्य का प्रसंस्करण है। पार्सर इसे संसाधित करता है, यह देखने के लिए जाँचता है कि क्या दूसरा अल्पविराम मौजूद है। यदि नहीं, तो यह AST नोड में null करने के लिए चरण मान सेट करता है:

 /// forexpr ::= 'for' identifier '=' expr ',' expr (',' expr)? 'in' expression static ExprAST *ParseForExpr() { getNextToken(); //  for. if (CurTok != tok_identifier) return Error("expected identifier after for"); std::string IdName = IdentifierStr; getNextToken(); //  . if (CurTok != '=') return Error("expected '=' after for"); getNextToken(); //  '='. ExprAST *Start = ParseExpression(); if (Start == 0) return 0; if (CurTok != ',') return Error("expected ',' after for start value"); getNextToken(); ExprAST *End = ParseExpression(); if (End == 0) return 0; //   . ExprAST *Step = 0; if (CurTok == ',') { getNextToken(); Step = ParseExpression(); if (Step == 0) return 0; } if (CurTok != tok_in) return Error("expected 'in' after for"); getNextToken(); //  'in'. ExprAST *Body = ParseExpression(); if (Body == 0) return 0; return new ForExprAST(IdName, Start, End, Step, Body); } 

LLVM IR 'लूप' के लिए

अब हम दिलचस्प हिस्से पर आगे बढ़ेंगे: हम LLVM IR की पीढ़ी को आगे बढ़ाएंगे। हमारे उपरोक्त उदाहरण के लिए, हमें यह एलएलवीएम आईआर (ध्यान दें कि यह डंप अनुकूलन अक्षमता के साथ स्पष्टता के लिए उत्पन्न होता है)

 declare double @putchard(double) define double @printstar(double %n) { entry: ; initial value = 1.0 (inlined into phi) br label %loop loop: ; preds = %loop, %entry %i = phi double [ 1.000000e+00, %entry ], [ %nextvar, %loop ] ;  %calltmp = call double @putchard(double 4.200000e+01) ;  %nextvar = fadd double %i, 1.000000e+00 ;  %cmptmp = fcmp ult double %i, %n %booltmp = uitofp i1 %cmptmp to double %loopcond = fcmp one double %booltmp, 0.000000e+00 br i1 %loopcond, label %loop, label %afterloop afterloop: ; preds = %loop ; loop always returns 0.0 ret double 0.000000e+00 } 

इस लूप में वे सभी निर्माण शामिल हैं जो हमने पहले देखे थे: phi नोड, कई भाव और कुछ बुनियादी ब्लॉक। आइए देखें कि यह एक साथ कैसे फिट बैठता है।

'लूप' के लिए कोड जनरेशन

Codegen पहला भाग बहुत सरल है: हमें बस लूप के प्रारंभिक मूल्य के लिए एक अभिव्यक्ति मिलती है:

 Value *ForExprAST::Codegen() { // Emit the start code first, without 'variable' in scope. Value *StartVal = Start->Codegen(); if (StartVal == 0) return 0; 

अगला कदम लूप बॉडी की शुरुआत के लिए एलएलवीएम बेस यूनिट बनाना है। उपरोक्त मामले में, लूप का पूरा शरीर एक ब्लॉक होता है, लेकिन याद रखें कि बॉडी कोड में ही कई ब्लॉक शामिल हो सकते हैं (उदाहरण के लिए, यदि इसमें भाव हैं if/then/else या if/then/else for/in )।

  //       ,    //  . Function *TheFunction = Builder.GetInsertBlock()->getParent(); BasicBlock *PreheaderBB = Builder.GetInsertBlock(); BasicBlock *LoopBB = BasicBlock::Create(getGlobalContext(), "loop", TheFunction); //        LoopBB. Builder.CreateBr(LoopBB); 

यह कोड उसी के समान है, जिसे हमने if/then/else देखा था if/then/else । हमें वह ब्लॉक याद है जिसमें से हम लूप में आए हैं, क्योंकि हमें Phi नोड बनाने के लिए इसकी आवश्यकता होगी। फिर हम वास्तविक ब्लॉक बनाते हैं जो चक्र शुरू करता है, और दो ब्लॉकों के बीच बिना शर्त संक्रमण पैदा करता है।

  //    LoopBB. Builder.SetInsertPoint(LoopBB); //   PHI    Start. PHINode *Variable = Builder.CreatePHI(Type::getDoubleTy(getGlobalContext()), 2, VarName.c_str()); Variable->addIncoming(StartVal, PreheaderBB); 

अब "preheader" लूप के लिए "preheader" हेडर सेट हो गया है, हम लूप बॉडी कोड जनरेट करने के लिए आगे बढ़ते हैं। सबसे पहले, हम कर्सर को स्थानांतरित करते हैं और लूप वेरिएबल के लिए PHI नोड बनाते हैं। चूंकि हम पहले से ही प्रारंभिक मूल्य जानते हैं, इसलिए हम इसे Phi नोड में जोड़ते हैं। ध्यान दें कि Phi को अंततः दूसरा मूल्य मिलेगा, लेकिन हम अभी भी इसे सेट नहीं कर सकते हैं (क्योंकि यह अभी तक मौजूद नहीं है!)।

  //       PHI.    //  ,     ,  . Value *OldVal = NamedValues[VarName]; NamedValues[VarName] = Variable; //   . ,      ,   //   .  ,    , //  ,     . if (Body->Codegen() == 0) return 0; 

अब कोड अधिक दिलचस्प होता जा रहा है। हमारा "for" लूप चरित्र तालिका में एक नया चर पेश करता है। इसका मतलब है कि हमारी प्रतीक तालिका में फ़ंक्शन तर्क या लूप चर हो सकते हैं। इससे पहले कि हम लूप बॉडी कोड जनरेट करें, हम लूप वैरिएबल को उसके नाम के वर्तमान मान के रूप में जोड़ते हैं। कृपया ध्यान दें - यह काफी संभव है कि बाहरी दायरे में एक ही नाम के साथ पहले से ही एक चर है। आप इसे आसानी से एक त्रुटि बना सकते हैं (एक त्रुटि फेंकें और यदि null पहले से ही VarName के लिए एक प्रविष्टि है), लेकिन हम चर के ओवरलैप की अनुमति देंगे। उचित प्रसंस्करण के लिए, हम OldVal में एक संभावित ओवरलैपिंग मान OldVal (जो अतिव्यापी चर नहीं होने पर null होगा)।

प्रतीक तालिका में लूप चर सेट करने के बाद, कोड को पुन: शरीर में उत्पन्न किया जाता है। यह शरीर को लूप वेरिएबल का उपयोग करने की अनुमति देता है: इसका कोई भी संदर्भ स्वाभाविक रूप से प्रतीक तालिका में है।

  //   . Value *StepVal; if (Step) { StepVal = Step->Codegen(); if (StepVal == 0) return 0; } else { //   ,  1.0. StepVal = ConstantFP::get(getGlobalContext(), APFloat(1.0)); } Value *NextVar = Builder.CreateFAdd(Variable, StepVal, "nextvar"); 

जब शरीर उत्पन्न होता है, तो हम चरण मान जोड़कर या 1.0अगर यह सेट नहीं होता है, तो पुनरावृत्ति चर के अगले मूल्य की गणना करते हैं । "NextVar"लूप के अगले चरण में लूप वेरिएबल का मान है।

  //      . Value *EndCond = End->Codegen(); if (EndCond == 0) return EndCond; //       0.0. EndCond = Builder.CreateFCmpONE(EndCond, ConstantFP::get(getGlobalContext(), APFloat(0.0)), "loopcond"); 

अंत में, हम यह निर्धारित करने के लिए लूप के निकास मान की गणना करते हैं कि क्या लूप पूरा होना चाहिए। यह लगभग स्थिति में गणना के समान है if/then/else।

  //   " "   . BasicBlock *LoopEndBB = Builder.GetInsertBlock(); BasicBlock *AfterBB = BasicBlock::Create(getGlobalContext(), "afterloop", TheFunction); //      LoopEndBB. Builder.CreateCondBr(EndCond, LoopBB, AfterBB); //       AfterBB. Builder.SetInsertPoint(AfterBB); 

लूप के पूर्ण शरीर कोड के साथ, हमें केवल इसके लिए नियंत्रण प्रवाह को पूरा करने की आवश्यकता है। यह कोड ब्लॉक के अंत (नोड के लिए phi) को याद करता है , और फिर लूप से बाहर निकलने के लिए ब्लॉक बनाता है ( "afterloop")। बाहर निकलने की स्थिति के मूल्य के आधार पर, यह एक सशर्त संक्रमण बनाता है जो चक्र को फिर से निष्पादित करने या चक्र से बाहर निकलने के बीच चुनता है। किसी भी बाद के कोड को ब्लॉक में जोड़ा जाता है "afterloop", इसलिए हम सम्मिलन कर्सर को बिल्कुल वहीं स्थानांतरित करते हैं।

  //      PHI. Variable->addIncoming(NextVar, LoopEndBB); //   . if (OldVal) NamedValues[VarName] = OldVal; else NamedValues.erase(VarName); //  for   0.0. return Constant::getNullValue(Type::getDoubleTy(getGlobalContext())); } 

अंतिम कोड सफाई करता है: अब हमारे पास एक मूल्य है "NextVar"और हम PHI नोड में शामिल लूप मान जोड़ सकते हैं। उसके बाद, हम लूप वैरिएबल को प्रतीक तालिका से हटाते हैं, ताकि लूप के बाद यह गुंजाइश में न हो। अंत में, लूप के लिए उत्पन्न कोड हमेशा लौटता है 0.0, इसलिए हम वहां से लौटते हैं ForExprAST::Codegen।

यह ट्यूटोरियल में अध्याय का समापन करता है, "Kaleidoscope के लिए एक नियंत्रण प्रवाह जोड़ना।" इस अध्याय में, हमने LLVM IR के कुछ पहलुओं पर ध्यान दिया, जिन्हें फ्रंट-एंड डेवलपर्स को जानना आवश्यक है। हमारी गाथा के अगले अध्याय में, हम थोड़ा पागल होंगे और अपनी गरीब, निर्दोष प्रोग्रामिंग भाषा के लिए उपयोगकर्ता-परिभाषित ऑपरेटर जोड़ेंगे।

पूर्ण कोड सूची

यहाँ कोड की एक पूरी सूची दी गई है, जो भावों द्वारा विस्तारित है if/then/elseऔर for... इस प्रकार है:

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


और कोड ही:

 #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, //   tok_if = -6, tok_then = -7, tok_else = -8, tok_for = -9, tok_in = -10 }; static std::string IdentifierStr; // ,  tok_identifier static double NumVal; // ,  tok_number /// gettok -       . static int gettok() { static int LastChar = ' '; //  . while (isspace(LastChar)) LastChar = getchar(); if (isdigit(LastChar) || LastChar == '.') { // : [0-9.]+ IdentifierStr = LastChar; while (isalnum((LastChar = getchar()))) IdentifierStr += LastChar; if (IdentifierStr == "def") return tok_def; if (IdentifierStr == "extern") return tok_extern; if (IdentifierStr == "if") return tok_if; if (IdentifierStr == "then") return tok_then; if (IdentifierStr == "else") return tok_else; if (IdentifierStr == "for") return tok_for; if (IdentifierStr == "in") return tok_in; return tok_identifier; } if (isdigit(LastChar) || LastChar == '.') { // Number: [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(); }; /// IfExprAST -     if/then/else. class IfExprAST : public ExprAST { ExprAST *Cond, *Then, *Else; public: IfExprAST(ExprAST *cond, ExprAST *then, ExprAST *_else) : Cond(cond), Then(then), Else(_else) {} virtual Value *Codegen(); }; /// ForExprAST -     for/in. class ForExprAST : public ExprAST { std::string VarName; ExprAST *Start, *End, *Step, *Body; public: ForExprAST(const std::string &varname, ExprAST *start, ExprAST *end, ExprAST *step, ExprAST *body) : VarName(varname), Start(start), End(end), Step(step), Body(body) {} 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; } /// ifexpr ::= 'if' expression 'then' expression 'else' expression static ExprAST *ParseIfExpr() { getNextToken(); //  if. // . ExprAST *Cond = ParseExpression(); if (!Cond) return 0; if (CurTok != tok_then) return Error("expected then"); getNextToken(); //  then ExprAST *Then = ParseExpression(); if (Then == 0) return 0; if (CurTok != tok_else) return Error("expected else"); getNextToken(); ExprAST *Else = ParseExpression(); if (!Else) return 0; return new IfExprAST(Cond, Then, Else); } /// forexpr ::= 'for' identifier '=' expr ',' expr (',' expr)? 'in' expression static ExprAST *ParseForExpr() { getNextToken(); //  for. if (CurTok != tok_identifier) return Error("expected identifier after for"); std::string IdName = IdentifierStr; getNextToken(); //  . if (CurTok != '=') return Error("expected '=' after for"); getNextToken(); //  '='. ExprAST *Start = ParseExpression(); if (Start == 0) return 0; if (CurTok != ',') return Error("expected ',' after for start value"); getNextToken(); ExprAST *End = ParseExpression(); if (End == 0) return 0; //   . ExprAST *Step = 0; if (CurTok == ',') { getNextToken(); Step = ParseExpression(); if (Step == 0) return 0; } if (CurTok != tok_in) return Error("expected 'in' after for"); getNextToken(); //  'in'. ExprAST *Body = ParseExpression(); if (Body == 0) return 0; return new ForExprAST(IdName, Start, End, Step, Body); } /// primary /// ::= identifierexpr /// ::= numberexpr /// ::= parenexpr /// ::= ifexpr /// ::= forexpr 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(); case tok_if: return ParseIfExpr(); case tok_for: return ParseForExpr(); } } /// binoprhs /// ::= ('+' primary)* static ExprAST *ParseBinOpRHS(int ExprPrec, ExprAST *LHS) { //    ,    while (1) { int TokPrec = GetTokPrecedence(); //           , //  ,    if (TokPrec < ExprPrec) return LHS; // ,  ,    . int BinOp = CurTok; getNextToken(); //    //       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"); } Value *IfExprAST::Codegen() { Value *CondV = Cond->Codegen(); if (CondV == 0) return 0; //       0.0. CondV = Builder.CreateFCmpONE(CondV, ConstantFP::get(getGlobalContext(), APFloat(0.0)), "ifcond"); Function *TheFunction = Builder.GetInsertBlock()->getParent(); //     then  else.   'then'  //  . BasicBlock *ThenBB = BasicBlock::Create(getGlobalContext(), "then", TheFunction); BasicBlock *ElseBB = BasicBlock::Create(getGlobalContext(), "else"); BasicBlock *MergeBB = BasicBlock::Create(getGlobalContext(), "ifcont"); Builder.CreateCondBr(CondV, ThenBB, ElseBB); //  . Builder.SetInsertPoint(ThenBB); Value *ThenV = Then->Codegen(); if (ThenV == 0) return 0; Builder.CreateBr(MergeBB); //  'Then'    ,  ThenBB  PHI. ThenBB = Builder.GetInsertBlock(); //   else. TheFunction->getBasicBlockList().push_back(ElseBB); Builder.SetInsertPoint(ElseBB); Value *ElseV = Else->Codegen(); if (ElseV == 0) return 0; Builder.CreateBr(MergeBB); //  'Else'    ,  ElseBB  PHI. ElseBB = Builder.GetInsertBlock(); //   . TheFunction->getBasicBlockList().push_back(MergeBB); Builder.SetInsertPoint(MergeBB); PHINode *PN = Builder.CreatePHI(Type::getDoubleTy(getGlobalContext()), 2, "iftmp"); PN->addIncoming(ThenV, ThenBB); PN->addIncoming(ElseV, ElseBB); return PN; } Value *ForExprAST::Codegen() { // Output this as: // ... // start = startexpr // goto loop // loop: // variable = phi [start, loopheader], [nextvariable, loopend] // ... // bodyexpr // ... // loopend: // step = stepexpr // nextvariable = variable + step // endcond = endexpr // br endcond, loop, endloop // outloop: // Emit the start code first, without 'variable' in scope. Value *StartVal = Start->Codegen(); if (StartVal == 0) return 0; //       ,    //  . Function *TheFunction = Builder.GetInsertBlock()->getParent(); BasicBlock *PreheaderBB = Builder.GetInsertBlock(); BasicBlock *LoopBB = BasicBlock::Create(getGlobalContext(), "loop", TheFunction); //         LoopBB. Builder.CreateBr(LoopBB); //    LoopBB. Builder.SetInsertPoint(LoopBB); //   PHI    Start. PHINode *Variable = Builder.CreatePHI(Type::getDoubleTy(getGlobalContext()), 2, VarName.c_str()); Variable->addIncoming(StartVal, PreheaderBB); //       PHI.    //  ,     ,  . Value *OldVal = NamedValues[VarName]; NamedValues[VarName] = Variable; //   . ,      ,   //   .  ,    , //  ,     . if (Body->Codegen() == 0) return 0; //   . Value *StepVal; if (Step) { StepVal = Step->Codegen(); if (StepVal == 0) return 0; } else { //   ,  1.0. StepVal = ConstantFP::get(getGlobalContext(), APFloat(1.0)); } Value *NextVar = Builder.CreateFAdd(Variable, StepVal, "nextvar"); //      . Value *EndCond = End->Codegen(); if (EndCond == 0) return EndCond; //       0.0. EndCond = Builder.CreateFCmpONE(EndCond, ConstantFP::get(getGlobalContext(), APFloat(0.0)), "loopcond"); //   " "   . BasicBlock *LoopEndBB = Builder.GetInsertBlock(); BasicBlock *AfterBB = BasicBlock::Create(getGlobalContext(), "afterloop", TheFunction); //      LoopEndBB. Builder.CreateCondBr(EndCond, LoopBB, AfterBB); //       AfterBB. Builder.SetInsertPoint(AfterBB); //      PHI. Variable->addIncoming(NextVar, LoopEndBB); //   . if (OldVal) NamedValues[VarName] = OldVal; else NamedValues.erase(VarName); //  for   0.0. return Constant::getNullValue(Type::getDoubleTy(getGlobalContext())); } 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() { //      . 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; //  . // Prime the first token. 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; }