ट्यूटोरियल "एलएलवीएम के साथ एक प्रोग्रामिंग भाषा बनाना" के अध्याय 3 में आपका स्वागत है। इस अध्याय में, हम देखेंगे कि अध्याय 2 में निर्मित AST (Abstract Syntax Tree) को LLVM IR में कैसे बदला जाए। वह आपको LLVM के कुछ पहलुओं के बारे में बताएगा, और यह भी प्रदर्शित करेगा कि इसका उपयोग करना कितना आसान है। आप देखेंगे कि एलएलवीएम आईआर कोड के प्रत्यक्ष निर्माण की तुलना में लेक्सिकल और पार्सिंग के लिए बहुत अधिक काम की आवश्यकता थी।

नोट : इस अध्याय के कोड को LLVM 2.2 या बाद के संस्करण की आवश्यकता है। एलएलवीएम 2.1 संस्करणों के साथ, यह कोड काम नहीं करेगा। यह भी ध्यान देने योग्य है कि आपको अपने एलएलवीएम रिलीज़ से मेल खाने वाले इस ट्यूटोरियल के संस्करण का उपयोग करना चाहिए: आप आधिकारिक रिलीज़ के साथ आने वाले दस्तावेज़ का उपयोग कर सकते हैं या llvm.org पर रिलीज़ पेज पर जा सकते हैं ।

हम कोड पीढ़ी के लिए तैयार हैं

LLVM IR उत्पन्न करने के लिए, हमें कुछ सरल सेटअपों की आवश्यकता है। सबसे पहले, हम प्रत्येक एएसटी वर्ग के लिए वर्चुअल कोड जनरेशन मेथड ( Codegen ) को परिभाषित करते हैं:

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

 }; ...

Codegen() विधि अपने सभी आश्रितों के साथ दिए गए एएसटी नोड के लिए आईआर लौटाएगी, और वे सभी LLVM Value ऑब्जेक्ट लौटाएंगे। "Value" एलएलवीएम में " स्टेटिक सिंगल असिस्मेंट ( एसएसए ) रजिस्टर " या "एसएसए वैल्यूज़" का प्रतिनिधित्व करने के लिए उपयोग किया जाने वाला वर्ग है। एसएसए में सबसे महत्वपूर्ण बिंदु यह है कि उनके मूल्य की गणना संबंधित अनुदेश के निष्पादन के रूप में की जाती है और वे तब तक एक नया मूल्य प्राप्त नहीं कर सकते हैं (और यदि) अनुदेश को फिर से निष्पादित किया जाता है। दूसरे शब्दों में, SSA मान को "बदलने" का कोई तरीका नहीं है। अधिक जानकारी के लिए, स्टेटिक सिंगल असाइनमेंट के बारे में पढ़ें - ये अवधारणाएं वास्तव में बहुत स्वाभाविक लगती हैं जैसे ही आप उन पर ध्यान देते हैं।

ध्यान दें कि ExprAST वर्गों के पदानुक्रम में आभासी तरीकों को जोड़ने के बजाय, यह विज़िटर डिज़ाइन पैटर्न या किसी अन्य विधि का उपयोग करने के लिए समझ में आ सकता है। फिर, इस ट्यूटोरियल में हम अच्छे सॉफ्टवेयर डेवलपमेंट के तरीकों पर ध्यान नहीं देंगे: हमारा लक्ष्य सादगी है - और हमारे लिए वर्चुअल तरीका जोड़ना आसान है।

हमें त्रुटियों को संभालने के लिए एक विधि की भी आवश्यकता है, जो कि पार्सर के लिए उपयोग की गई थी। हम कोड जनरेशन के दौरान पाए जाने वाले त्रुटि संदेशों के लिए इस विधि का उपयोग करेंगे (उदाहरण के लिए, अघोषित मापदंडों का उपयोग करते हुए):

 Value *ErrorV(const char *Str) { Error(Str); return 0; } static Module *TheModule; static IRBuilder<> Builder(getGlobalContext()); static std::map<std::string, Value*> NamedValues;

इन स्थैतिक चर कोड पीढ़ी के दौरान इस्तेमाल किया जाएगा। TheModule एक LLVM कंस्ट्रक्शन है जिसमें कोड के एक टुकड़े में सभी फ़ंक्शन और वैश्विक चर शामिल हैं। ज्यादातर मामलों में, ये शीर्ष-स्तरीय संरचनाएं हैं जो एलएलवीएम आईआर निहित कोड के लिए उपयोग करता है।

Builder ऑब्जेक्ट एक सहायक वस्तु है जो LLVM निर्देशों को उत्पन्न करना आसान बनाता है। कक्षा टेम्पलेट उदाहरण IRBuilder IRBuilder निर्देश डालने के लिए वर्तमान स्थान को ट्रैक करता है और नए निर्देश बनाने के लिए तरीके शामिल करता है।

NamedValues नक्शा इस NamedValues नज़र NamedValues है कि वर्तमान दायरे में किन मूल्यों को परिभाषित किया गया है और उनका LLVM प्रतिनिधित्व क्या है। (दूसरे शब्दों में, यह कोड के लिए एक वर्ण तालिका है)। कैलीडोस्कोप में वर्तमान रूप में, केवल एक चीज जिसे संदर्भित किया जा सकता है वह फ़ंक्शन पैरामीटर है। इस प्रकार, इस नक्शे में, फ़ंक्शन बॉडी के लिए कोड बनाते समय, इस फ़ंक्शन के पैरामीटर स्थित होंगे।

यह सब जानते हुए, हम किसी भी भाव के लिए कोड बनाने के बारे में बात कर सकते हैं। ध्यान दें, यह माना जाता है कि Builder "कुछ भी" में कोड उत्पन्न करने के लिए पहले से ही बनाया गया है। अभी के लिए, हम मानते हैं कि यह पहले ही हो चुका है, और हम इसका उपयोग कोड को बचाने के लिए करेंगे।

अभिव्यक्ति कोड पीढ़ी

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

 Value *NumberExprAST::Codegen() { return ConstantFP::get(getGlobalContext(), APFloat(Val)); }

LLVM IR में, संख्यात्मक स्थिरांक को ConstantFP वर्ग द्वारा दर्शाया जाता है, जिसमें APFloat के रूप में संख्यात्मक मान APFloat ( APFloat में वास्तविक स्थिरांक को मनमाने ढंग से सटीक संख्या में डालने की क्षमता होती है)। यह कोड ConstantFP बनाता है और रिटर्न करता है। ध्यान दें कि LLVM IR में सभी स्थिरांक अनूठे (विशिष्ट) और साझा (साझा) हैं। यह इस कारण से है कि एपीआई "new foo(..)" या "foo::Create(..)" बजाय मुहावरे "foo::get(...)" का उपयोग करता है।

 Value *VariableExprAST::Codegen() { //      . Value *V = NamedValues[Name]; return V ? V : ErrorV("Unknown variable name"); }

एलएलवीएम का उपयोग करते समय परिवर्तनीय संदर्भ भी काफी सरल हैं। कैलीडोस्कोप के सरल संस्करण में, हम मानते हैं कि चर पहले से ही कहीं सेट है और इसका मूल्य उपलब्ध है। व्यवहार में, NamedValues मानचित्र पर मान केवल फ़ंक्शन तर्क हो सकते हैं। यह कोड केवल यह जांचता है कि निर्दिष्ट नाम नक्शे पर परिभाषित किया गया है (यदि नहीं, तो यह एक अज्ञात चर का एक लिंक है) और इसके लिए एक मान लौटाता है। बाद के अध्यायों में, हम स्थानीय चर और पाश काउंटर चर के लिए समर्थन जोड़ देंगे।

 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"); } }

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

उपरोक्त उदाहरण में, LLVM Builder वर्ग अंत में अपना मूल्य दिखाता है। IRBuilder पता है कि नए बनाए गए निर्देशों को कहां सम्मिलित करना है, और आपको जो कुछ भी करने की आवश्यकता है, वह निर्दिष्ट करें कि कौन से निर्देश बनाने हैं (उदाहरण के लिए, "CreateFAdd" ), जो उपयोग करने के लिए "CreateFAdd" करता है (इस मामले में L और R) और, यदि आवश्यक हो, जिसका उपयोग करना है उत्पन्न निर्देश के लिए नाम।

एलएलवीएम में एक और बड़ी विशेषता नाम असाइनमेंट है। उदाहरण के लिए, यदि उपरोक्त कई बार "addtmp" चर का उपयोग करता है, तो LLVM स्वचालित रूप से प्रत्येक बार एक अद्वितीय संख्यात्मक प्रत्यय प्रदान करेगा। निर्देशों के लिए स्थानीय मूल्य नाम वैकल्पिक हैं, लेकिन वे आईआर डिप्स को पढ़ने के लिए बहुत आसान बनाते हैं।

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

दूसरी ओर, fcmp विनिर्देश कहता है कि fcmp निर्देश हमेशा "i1" (एक सिंगल-बिट पूर्णांक) मान लौटाता है। समस्या यह है कि बहुरूपदर्शक में हमें 0.0 या 1.0 के मान की आवश्यकता होती है। ऐसा करने के लिए, हम fcmp को fcmp साथ uitofp । यह निर्देश एक अहस्ताक्षरित पूर्णांक को एक वास्तविक फ़्लोटिंग बिंदु में परिवर्तित करता है। इसके विपरीत, अगर हम sitofp उपयोग करते हैं , तो '<' ऑपरेटर इनपुट मान के आधार पर 0.0 और -1.0 लौटाएगा।

 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"); }

किसी फ़ंक्शन को कॉल करने के लिए LLVM कोड बनाना काफी सरल है। उपरोक्त कोड एलएलवीएम मॉड्यूल के प्रतीक तालिका में फ़ंक्शन नाम की खोज करता है। याद रखें कि एलएलवीएम मॉड्यूल एक कंटेनर है जिसमें सभी कार्य शामिल हैं जिनका उपयोग हम जेआईटी संकलन के लिए कर सकते हैं। प्रत्येक फ़ंक्शन को एक नाम देते हुए, हम फ़ंक्शन नामों की खोज की अनुमति देने के लिए LLVM प्रतीक तालिका का उपयोग कर सकते हैं।

कॉल करने के लिए फ़ंक्शन प्राप्त करने के बाद, हम पास किए जाने वाले प्रत्येक तर्क के लिए कोड को पुन: उत्पन्न करते हैं और LLVM कॉल निर्देश बनाते हैं। ध्यान दें कि डिफ़ॉल्ट रूप से एलएलवीएम सी के रूप में फ़ंक्शन कॉलिंग सम्मेलनों का उपयोग करता है, जो आपको अतिरिक्त प्रयास के बिना "sin" और "cos" जैसे मानक पुस्तकालय कार्यों के लिए इन कॉलों का उपयोग करने की अनुमति देता है।

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

फंक्शन कोड जनरेशन

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

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

कुछ लाइनों में यह कोड वास्तव में वास्तविक शक्ति दिखाता है। सबसे पहले, ध्यान दें कि यह फ़ंक्शन "Value*" बजाय "Function*" देता है। चूंकि "प्रोटोटाइप" वास्तव में फ़ंक्शन के लिए बाहरी इंटरफ़ेस की बात करता है (गणना की गई अभिव्यक्ति के बजाय), यह उसके लिए फ़ंक्शन के लिए उत्पन्न कोड के अनुरूप एलएलवीएम फ़ंक्शन को वापस करने के लिए समझ में आता है।

"FunctionType::get" कॉल करना एक फ़ंक्शनटाइप बनाता है जिसका उपयोग इस प्रोटोटाइप के लिए किया जाना चाहिए। चूंकि कैलिडोस्कोप में सभी फ़ंक्शन तर्क वास्तविक संख्या हैं, इसलिए पहली पंक्ति "एन" वास्तविक संख्या से एलएलवीएम वेक्टर बनाती है। फिर, FunctionType::get टाइप FunctionType::get मेथड का प्रयोग एक फंक्शन टाइप बनाने के लिए किया जाता है जो "N" मान्य तर्कों को लेता है और परिणाम के रूप में एक वैध तर्क देता है। कृपया ध्यान दें कि एलएलवीएम के प्रकार स्थिर हैं, स्थिरांक के रूप में, इसलिए आपको "new" नहीं चाहिए, लेकिन "get" (शब्दों पर मूल नाटक में: "... इसलिए आप इसे " नहीं " बनाते हैं, लेकिन " प्राप्त "करते हैं)। ।

अंतिम पंक्ति वास्तव में एक फ़ंक्शन बनाती है जो प्रोटोटाइप से मेल खाती है। यह उपयोग के लिए प्रकार, संबंध और नाम और प्रविष्टि के लिए मॉड्यूल को इंगित करता है। " बाहरी लिंकेज " का मतलब है कि एक फ़ंक्शन को वर्तमान मॉड्यूल के बाहर परिभाषित किया जा सकता है और / या इसे मॉड्यूल के बाहर बुलाया जा सकता है। "Name" उपयोगकर्ता द्वारा निर्दिष्ट नाम को परिभाषित करता है, "TheModule" इंगित करता है कि यह नाम "TheModule" वर्ण तालिका में पंजीकृत है।

  //   (F)     ,     'Name'. //     ,      . if (F->getName() != Name) { //   ,      . F->eraseFromParent(); F = TheModule->getFunction(Name);

जब नाम संघर्ष की बात आती है, तो मॉड्यूल की प्रतीक तालिका प्रतीक तालिका के समान ही कार्य करती है: यदि एक नया फ़ंक्शन एक नाम के साथ बनाया गया है जिसे पहले प्रतीक तालिका में जोड़ा गया था, तो इसे मॉड्यूल में जोड़ते समय इसका नाम बदल दिया जाएगा। उपरोक्त कोड इस तथ्य का उपयोग करता है यह निर्धारित करने के लिए कि क्या समान फ़ंक्शन पहले घोषित किया गया था।

बहुरूपदर्शक में, कार्यों का पुनर्वितरण दो मामलों में हो सकता है। सबसे पहले, यदि हम एक से अधिक फ़ंक्शन की extern परिभाषा का उपयोग करना चाहते हैं, जब तक कि उनके प्रोटोटाइप मेल नहीं खाते (चूंकि सभी तर्क एक ही प्रकार के हैं, हमें सिर्फ यह जांचने की आवश्यकता है कि क्या तर्कों की संख्या मेल खाती है)। दूसरी बात, यदि हम कार्यों की extern परिभाषा और उसके बाद शरीर की परिभाषा का उपयोग करना चाहते हैं। पारस्परिक पुनरावर्ती कार्यों को परिभाषित करते समय यह आवश्यक है।

इसे लागू करने के लिए, उपरोक्त कोड पहले यह देखने के लिए जाँच करता है कि क्या फ़ंक्शन नामों का कोई विरोध है या नहीं। यदि वहाँ है, तो यह अभी बनाए गए फ़ंक्शन को हटा देता है ( "getFunction" को कॉल करके), और फिर दिए गए नाम के साथ एक मौजूदा फ़ंक्शन प्राप्त करने के लिए "getFunction" को कॉल करता है। यह ध्यान देने योग्य है कि एलएलवीएम में कई एपीआई में "erase" फ़ॉर्म और "remove" फ़ॉर्म दोनों हैं। "remove" विधि अपने मूल ऑब्जेक्ट (उदाहरण के लिए, एक मॉड्यूल से एक फ़ंक्शन) से एक ऑब्जेक्ट को अलग (अनलिंक) करती है और उसे वापस करती है। "erase" विधि एक ऑब्जेक्ट को अलग करती है (अनलिंक) और फिर उसे हटा देती है।

  //   (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; } }

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

  //     . 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; }

फ़ंक्शन फ़ंक्शन प्रोटोटाइप के लिए कोड का अंतिम भाग एक फ़ंक्शन के लिए तर्कों का एक लूप है, जो LLVM ऑब्जेक्ट नाम, संबंधित तर्कों को निर्दिष्ट करता है, और VariableExprAST AST नोड द्वारा बाद के उपयोग के लिए NamedValues मानचित्र में तर्क दर्ज करता है। फिर यह एक फंक्शन ऑब्जेक्ट लौटाता है। ध्यान दें कि हम परस्पर विरोधी तर्क नामों की जांच नहीं करते हैं (उदाहरण के लिए, "extern Foo (aba)" )। लेकिन यह काफी सरल और सरल रूप से उस विधि का उपयोग करके किया जा सकता है जो हमने ऊपर उपयोग किया था।

 Function *FunctionAST::Codegen() { NamedValues.clear(); Function *TheFunction = Proto->Codegen(); if (TheFunction == 0) return 0;

कार्यों को परिभाषित करने के लिए कोड पीढ़ी काफी सरल रूप से शुरू होती है: हम सिर्फ प्रोटोटाइप कोड पीढ़ी ( Proto ) कहते हैं और सुनिश्चित करते हैं कि सब कुछ ठीक है। हम यह सुनिश्चित करने के लिए NamedValues कार्ड को भी साफ करते हैं कि हम जो अंतिम कार्य कर रहे हैं उसका कुछ भी नहीं बचा है। प्रोटोटाइप कोड उत्पन्न करना सुनिश्चित करता है कि हमारे पास एक तैयार एलएलवीएम कार्यात्मक वस्तु है ताकि हम आगे बढ़ सकें।

  //      . BasicBlock *BB = BasicBlock::Create(getGlobalContext(), "entry", TheFunction); Builder.SetInsertPoint(BB); if (Value *RetVal = Body->Codegen()) {

अब हम बिल्डर के साथ काम करने के लिए आगे बढ़ेंगे। पहली पंक्ति एक नया बेस ब्लॉक बनाती है [ en ] (जिसे "entry" कहा जाता है), जिसे TheFunction में डाला गया है। दूसरी पंक्ति बिल्डर को बताती है कि नए निर्देशों को नई आधार इकाई के अंत में डाला जाएगा। एलएलवीएम में बेस ब्लॉक फ़ंक्शंस का एक महत्वपूर्ण हिस्सा है जो नियंत्रण प्रवाह ग्राफ को परिभाषित करता है । चूंकि हमारे पास अभी तक कोई नियंत्रण प्रवाह नहीं है, इसलिए हमारे कार्यों में केवल एक ब्लॉक होगा। लेकिन हम इसे अध्याय 5 :) में ठीक करेंगे।

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

एक बार सम्मिलन बिंदु सेट होने के बाद, हम रूट फ़ंक्शन एक्सप्रेशन के लिए CodeGen() का उपयोग करके कोड जनरेशन को CodeGen() करते हैं। यदि कोई त्रुटि नहीं होती है, तो इनपुट ब्लॉक में अभिव्यक्ति गणना कोड जोड़ें और गणना की जाने वाली मान लौटाएं। फिर, त्रुटियों की अनुपस्थिति में, हम एलएलवीएम निर्देश "ret" बनाते हैं, जो फ़ंक्शन को पूरा करता है। फ़ंक्शन के निर्माण के बाद, हम LLVM में निर्मित "verifyFunction" प्रक्रिया को कॉल करते हैं। यह निर्धारित कोड पर विभिन्न स्थिरता जांच करता है कि हमारे संकलक सब कुछ सही कर रहे हैं। इस प्रक्रिया का उपयोग करना बहुत महत्वपूर्ण है: यह कई कीड़े पकड़ सकता है। जब फ़ंक्शन समाप्त हो जाता है और सत्यापित होता है, तो हम इसे वापस कर देते हैं।

  //  ,   . TheFunction->eraseFromParent(); return 0; }

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

दरअसल, इस कोड में एक बग है। "PrototypeAST:: Codegen" पहले से परिभाषित पूर्व घोषणाओं को वापस कर सकता है, हमारा कोड वास्तव में उन्हें हटा सकता है। इस बग को ठीक करने के कई तरीके हैं, सोचें कि आप क्या कर सकते हैं! यहाँ एक छोटा सा परीक्षण मामला है:

 extern foo(ab); # o,  "foo". def foo(ab) c; # ,   'c'. def bar() foo(1, 2); # ,   "foo"

मुख्य कार्यक्रम और अंतिम विचारों में परिवर्तन

वास्तव में, अब तक एलएलवीएम कोड पीढ़ी ने हमें थोड़ा सा दिया है, सिवाय इसके कि हम दिलचस्प आईआर कॉल देख सकते हैं। हमारे कोड में कोड जेनरेशन को "हैंडलेडिफिनिशन", "हैंडलेक्स्टर्न", इत्यादि कोड कोड का उपयोग करके कॉल किया जाएगा, और फिर एलएलवीएम आईआर को डंप किया जाएगा। इसके लिए धन्यवाद, हम साधारण कार्यों के लिए LLVM IR देख सकते हैं। उदाहरण के लिए:

  तैयार> 4 + 5;
 शीर्ष-स्तरीय अभिव्यक्ति पढ़ें:
 परिभाषित डबल @ "" () {
 प्रविष्टि:
         दोहरा दोहरा 9.000000e + 00
 }

ध्यान दें कि कैसे पार्सर एक अनाम फ़ंक्शन के रूप में एक शीर्ष-स्तरीय अभिव्यक्ति देता है। यह सुविधाजनक होगा जब हम अगले अध्याय में JIT समर्थन जोड़ेंगे। यह भी ध्यान दें कि कोड "बहुत ही शाब्दिक", "सीधे तौर पर" का अनुवाद करता है, IRBuilder द्वारा बनाए गए स्थिरांक के सरल तह को छोड़कर कोई अनुकूलन नहीं हैं। हम अगले अध्याय में स्पष्ट रूप से अनुकूलन जोड़ देंगे।

  तैयार> डिफ फू (ab) a * a + 2 * a * b + b * b;
 फ़ंक्शन परिभाषा पढ़ें:
 डबल @ परिभाषित करें (डबल% ए, डबल% बी) {
 प्रविष्टि:
         % मल्टीम्प = fmul डबल% a,% a
         % मल्टीम्प 1 = fmul डबल 2.000000e + 00,% a
         % मल्टीम्प 2 = एफएमएल डबल% मल्टीम्प 1,% बी
         % addtmp = fadd डबल% मल्टीम्प,% multmp2
         % बहु = fmul डबल% b,% b
         % addtmp4 = fadd डबल% addtmp,% multmp3
         दोहरा% addtmp4
 }

यहां कुछ सरल अंकगणितीय ऑपरेशन दिए गए हैं। एलएलवीएम Builder' कॉल के हड़ताली समानता पर ध्यान दें जिसका उपयोग हम निर्देश बनाने के लिए करते हैं।

  तैयार> डिफ बार (ए) फू (ए, ४.०) + बार (३१३३;);
 फ़ंक्शन परिभाषा पढ़ें:
 परिभाषित डबल @ बार (डबल% ए) {
 प्रविष्टि:
         % calltmp = कॉल डबल @foo (डबल% a, डबल 4.000000e + 00)
         % calltmp1 = कॉल डबल @ बार (डबल 3.133700e + 04)
         % addtmp = fadd डबल% calltmp,% calltmp1
         दोहरा% addtmp
 }

यहाँ कुछ फ़ंक्शन कॉल हैं। ध्यान दें कि यदि आप इसे कॉल करते हैं तो यह फ़ंक्शन लंबे समय तक निष्पादित किया जाएगा। भविष्य में, हम सशर्त प्रवाह नियंत्रण जोड़ देंगे, जिससे पुनरावृत्ति वास्तव में उपयोगी हो जाएगी :)।

  तैयार> बाहरी कॉशन (x);
 बाहरी पढ़ें: 
 डबल @cos (डबल) घोषित करें

तैयार> cos (1.234);

 शीर्ष-स्तरीय अभिव्यक्ति पढ़ें:
 परिभाषित डबल @ "" () {
 प्रविष्टि:
         % calltmp = कॉल डबल @cos (डबल 1.234000e + 00)
         दोहरे% कॉलटैंप को पुनःप्राप्त करें
 }

यहां extern है लाइब्रेरी फंक्शन "cos" और इसके कॉल के लिए extern ।

  तैयार> ^ डी
 ;  मॉड्यूल = 'मेरा शांत जिठ'

 परिभाषित डबल @ "" () {
 प्रविष्टि:
         % addtmp = fadd double 4.000000e + 00, 5.000000e + 00
         दोहरा% addtmp
 }

 डबल @ परिभाषित करें (डबल% ए, डबल% बी) {
 प्रविष्टि:
         % मल्टीम्प = fmul डबल% a,% a
         % मल्टीम्प 1 = fmul डबल 2.000000e + 00,% a
         % मल्टीम्प 2 = एफएमएल डबल% मल्टीम्प 1,% बी
         % addtmp = fadd डबल% मल्टीम्प,% multmp2
         % बहु = fmul डबल% b,% b
         % addtmp4 = fadd डबल% addtmp,% multmp3
         दोहरा% addtmp4
 }

 परिभाषित डबल @ बार (डबल% ए) {
 प्रविष्टि:
         % calltmp = कॉल डबल @foo (डबल% a, डबल 4.000000e + 00)
         % calltmp1 = कॉल डबल @ बार (डबल 3.133700e + 04)
         % addtmp = fadd डबल% calltmp,% calltmp1
         दोहरा% addtmp
 }

 डबल @cos (डबल) घोषित करें

 परिभाषित डबल @ "" () {
 प्रविष्टि:
         % calltmp = कॉल डबल @cos (डबल 1.234000e + 00)
         दोहरा दोहरा कॉलटैंप
 }

वर्तमान डेमो से बाहर निकलने पर, एक आईआर डंप पूरे उत्पन्न मॉड्यूल के लिए वापस आ जाएगा।यहां आप एक दूसरे का जिक्र करते हुए सभी कार्यों के साथ पूरी तस्वीर देख सकते हैं।

यह बहुरूपदर्शक ट्यूटोरियल के तीसरे अध्याय का समापन करता है। अगले अध्याय में, हम JIT समर्थन और अनुकूलक जोड़ने पर विचार करेंगे ताकि आप वास्तव में कोड निष्पादित करना शुरू कर सकें!

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

यहां हमारे काम करने के उदाहरण की एक पूरी कोड सूची है, उदाहरण के लिए, एक विस्तारित एलएलवीएम कोड जनरेटर। चूंकि हम LLVM पुस्तकालयों का उपयोग करते हैं, इसलिए हमें उन्हें अपने कोड से लिंक करना होगा। ऐसा करने के लिए, निम्नानुसार llvm-config टूल का उपयोग करें :

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

और अंत में, कोड ही:

 #include "llvm/DerivedTypes.h" #include "llvm/LLVMContext.h" #include "llvm/Module.h" #include "llvm/Analysis/Verifier.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(); //    //       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; 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); return TheFunction; } //  ,   . TheFunction->eraseFromParent(); return 0; } //===----------------------------------------------------------------------===// // Top-Level parsing (  )   JIT //===----------------------------------------------------------------------===// 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()) { fprintf(stderr, "Read top-level expression:"); LF->dump(); } } 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() { LLVMContext &Context = getGlobalContext(); //    . // 1 -  . BinopPrecedence['<'] = 10; BinopPrecedence['+'] = 20; BinopPrecedence['-'] = 20; BinopPrecedence['*'] = 40; //  . fprintf(stderr, "ready> "); getNextToken(); //  ,     . TheModule = new Module("my cool jit", Context); //    " ". MainLoop(); //   . TheModule->dump(); return 0; }

LLVM का उपयोग करके एक प्रोग्रामिंग भाषा बनाना। भाग 3: एलएलवीएम आईआर कोड पीढ़ी

हम कोड पीढ़ी के लिए तैयार हैं

अभिव्यक्ति कोड पीढ़ी

फंक्शन कोड जनरेशन

मुख्य कार्यक्रम और अंतिम विचारों में परिवर्तन

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

More articles: