ट्यूटोरियल के अध्याय 4 में आपका स्वागत है "एलएलवीएम के साथ एक प्रोग्रामिंग भाषा बनाना"। पिछले अध्यायों ( 1 , 2 और 3 ) ने सरलतम प्रोग्रामिंग भाषा के कार्यान्वयन और इसमें एलएलवीएम आईआर पीढ़ी के लिए समर्थन को जोड़ा। इस अध्याय में दो नई तकनीकों का वर्णन किया गया है: ऑप्टिमाइज़र समर्थन जोड़ना और जेआईटी संकलक समर्थन जोड़ना। ये ऐड-ऑन यह प्रदर्शित करेंगे कि हमारी बहुरूपदर्शक प्रोग्रामिंग भाषा के लिए अच्छा, कुशल कोड कैसे प्राप्त करें।

स्थिरांक की सबसे सरल तह (निरंतर तह)

अध्याय 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 }

यह कोड इनपुट को पार्स करके निर्मित एएसटी का शाब्दिक प्रतिलेखन नहीं है। अन्यथा, यह होगा:

  तैयार> डिफ टेस्ट (एक्स) 1 + 2 + एक्स;
 फ़ंक्शन परिभाषा पढ़ें:
 परिभाषित डबल @test (डबल% x) {
 प्रविष्टि:
         % addtmp = fadd double 2.000000e + 00, 1.000000e + 00
         % addtmp1 = fadd डबल% addtmp,% x
         दोहरा% addtmp1 को पुनःप्राप्त करें
 }

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

एलएलवीएम के साथ, आपको एएसटी में इसके समर्थन को लागू करने की आवश्यकता नहीं है, क्योंकि एलएलवीएम आईआर के निर्माण के लिए सभी कॉल LLVM IR Builder माध्यम से जाते हैं, जो स्वयं जांचता है कि क्या स्थिरांक को गिराना संभव है। यह सिर्फ स्थिरांक बनाता है और इसके बजाय एक नया स्थिरांक लौटाता है। एक निर्देश बनाने के लिए।

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

दूसरी ओर, IRBuilder इस तथ्य IRBuilder सीमित है कि यह कोड के सभी विश्लेषण करता है "जैसा है", अर्थात, पहले से निर्मित कोड के साथ। यदि आप थोड़ा और जटिल उदाहरण लेते हैं:

  तैयार> डीईटी टेस्ट (एक्स) (1 + 2 + x) * (x + (1 + 2));
 तैयार> पढ़ें समारोह की परिभाषा:
 परिभाषित डबल @test (डबल% x) {
 प्रविष्टि:
         % addtmp = fadd double 3.000000e + 00,% x
         % addtmp1 = fadd डबल% x, 3.000000e + 00
         % मल्टीम्प = fmul डबल% एडटम्प,% addtmp1
         दोहरा दोहरा मल्टीप
 }

इस मामले में, काम के बाएं और दाएं हिस्से समान मूल्य हैं। हम वास्तव में "tmp = x + 3" जैसी किसी चीज़ के लिए चाहेंगे; परिणाम = tmp * tmp; ”डबल कंप्यूटिंग के बजाय“ x + 3 ”।

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

एलएलवीएम ऑप्टिमाइज़ेशन पास

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

एलएलवीएम समर्थन करता है और इसमें "मॉड्यूल के माध्यम से" और "फ़ंक्शन के माध्यम से" दोनों पास शामिल हैं, जो केवल एक फ़ंक्शन पर काम करते हैं, बाकी को ध्यान में रखे बिना। पैसेज और वे कैसे काम करते हैं, इसके बारे में अधिक जानकारी के लिए, डॉक्यूमेंट कैसे लिखें एक पास और एलएलवीएम पास सूची देखें ।

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

कार्यात्मक अनुकूलन प्राप्त करने के लिए, हमें बनाना होगा FunctionPassManager FunctionPassManager उस LLVM अनुकूलन को संग्रहीत और व्यवस्थित करता है जिसे हम चलाना चाहते हैं। फिर हम चलाने के लिए अनुकूलन का एक सेट जोड़ सकते हैं। कोड निम्नानुसार है:

  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 को परिभाषित करता है। बनाते समय, मॉड्यूल को एक पॉइंटर पास करना होगा। एक बार यह हो जाने के बाद, हम LLVM पास को जोड़ने के लिए ऐड कॉल की एक श्रृंखला का उपयोग करते हैं। पहला पास ज्यादातर मामलों में बॉयलरप्लेट है, यह आवश्यक है ताकि बाद के अनुकूलन को पता चले कि कार्यक्रम में कौन से डेटा संरचना का उपयोग किया जाता है। "TheExecutionEngine" चर JIT के साथ जुड़ा हुआ है, जो हमें अगले भाग में मिलेगा।

इस मामले में, हमने 4 अनुकूलन पास जोड़ने का फैसला किया। हमारे द्वारा चुने गए मार्ग "सफाई" अनुकूलन के एक काफी मानक सेट हैं जो कोड की एक विस्तृत श्रृंखला के लिए उपयोगी हैं। मैं गहराई से नहीं जाता कि वे क्या करते हैं, लेकिन मेरा विश्वास करो, वे एक अच्छे शुरुआती बिंदु हैं :)।

PassManager स्थापना के बाद, हमें इसका उपयोग करना चाहिए। हम इसे अपने नए फ़ंक्शन ( FunctionAST::Codegen ) में जेनरेट करने के बाद चलाते हैं, लेकिन उपयोगकर्ता के पास लौटने से पहले:

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

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

 return TheFunction; }

जैसा कि आप देख सकते हैं, यह बहुत सरल है। FunctionPassManager ऑप्टिमाइज़ करता है और तुरंत LLVM Function* अपडेट करता है, जिससे LLVM Function* की बॉडी में सुधार होता है। अब हमारे कोड को फिर से परखने की कोशिश करें:

  तैयार> डीईटी टेस्ट (एक्स) (1 + 2 + x) * (x + (1 + 2));
 तैयार> पढ़ें समारोह की परिभाषा:
 परिभाषित डबल @test (डबल% x) {
 प्रविष्टि:
         % addtmp = fadd डबल% x, 3.000000e + 00
         % मल्टीम्प = fmul डबल% एडटम्प,% एडटम्प
         दोहरा दोहरा मल्टीप
 }

जैसा कि अपेक्षित था, अब हमारे पास अतिरिक्त परिणाम और इसके पुन: उपयोग को बचाने के साथ एक अच्छी तरह से अनुकूलित कोड है।

LLVM कुछ परिस्थितियों में उपयोग किए जा सकने वाले अनुकूलन की एक विस्तृत श्रृंखला प्रदान करता है। विभिन्न वॉकवे पर कुछ दस्तावेज उपलब्ध हैं, लेकिन यह बहुत पूरा नहीं है। विचारों का एक और अच्छा स्रोत इसके साथ आने वाले मार्गों को देखना है जो कि llvm-gcc या llvm-ld का उपयोग करते हैं। ऑप्ट टूल आपको कमांड लाइन मार्ग के साथ प्रयोग करने और यह देखने की अनुमति देता है कि वे क्या करते हैं।

अब जब हमारे सामने के छोर से एक बहुत अच्छा कोड है, तो हम इसके कार्यान्वयन के बारे में बात कर सकते हैं!

एक जेआईटी कंपाइलर जोड़ना

एलएलवीएम आईआर में उपलब्ध कोड के लिए कई प्रकार के उपकरण लगाए जा सकते हैं। उदाहरण के लिए, आप इसके लिए ऑप्टिमाइज़ेशन चला सकते हैं (जैसा कि हमने ऊपर किया था), आप इसे टेक्स्ट या बाइनरी फॉर्म में आउटपुट कर सकते हैं, आप कुछ प्लेटफ़ॉर्म के लिए कोड को कोडांतरक LLVM (.s) फ़ाइल में संकलित कर सकते हैं या आप JIT- को इसके लिए आवेदन कर सकते हैं। संकलन। LLVM IR दृश्य के बारे में महान बात यह है कि यह संकलक के विभिन्न भागों के बीच "एकल" है।

इस खंड में, हम अपने दुभाषिया के लिए JIT संकलन समर्थन जोड़ेंगे। कैलीडोस्कोप का मुख्य विचार यह है कि उपयोगकर्ता एक फ़ंक्शन या शीर्ष-स्तरीय अभिव्यक्ति दर्ज कर सकता है और तुरंत परिणाम प्राप्त कर सकता है। उदाहरण के लिए, "1 + 2" दर्ज करते समय, हमें 3 की गणना और आउटपुट करना होगा, और एक फ़ंक्शन को परिभाषित करते समय, हम इसे कमांड लाइन से कॉल कर सकते हैं।

सबसे पहले, हम जेआईटी को घोषित और शुरू करेंगे। यह एक वैश्विक चर को जोड़कर और इसे main कॉल करके किया जाता है:

 static ExecutionEngine *TheExecutionEngine;

 ... int main() { ..

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

  .. }

यह एक अमूर्त "Execution Engine" बनाता है, जो एक संकलक या एक एलएलवीएम दुभाषिया हो सकता है। एलएलवीएम स्वचालित रूप से आपके लिए जेआईटी कंपाइलर का चयन करेगा यदि यह आपके प्लेटफ़ॉर्म के लिए मौजूद है, अन्यथा यह इंटरप्रेटर पर वापस आ जाएगा।

ExecutionEngine बनाने के बाद, JIT उपयोग करने के लिए तैयार है। विभिन्न उपयोगी एपीआई हैं, लेकिन सरलतम "getPointerToFunction(F)" विधि है। यह विधि JIT, निर्दिष्ट LLVM फ़ंक्शन को संकलित करती है और उत्पन्न मशीन कोड के लिए फ़ंक्शन पॉइंटर लौटाती है। हमारे मामले में, इसका मतलब है कि हम उस कोड को बदल सकते हैं जो शीर्ष-स्तरीय अभिव्यक्ति को निम्नानुसार पार करता है:

 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 कंपाइलर का उपयोग करते हैं, आप बस परिणाम को एक कार्यात्मक प्रकार में डाल सकते हैं और सीधे इस फ़ंक्शन को कॉल कर सकते हैं। इसका मतलब यह है कि जेआईटी-संकलित कोड और मशीन कोड के बीच कोई अंतर नहीं है जो आपके आवेदन में सांख्यिकीय रूप से जुड़ा हुआ है।

इन दो परिवर्तनों के साथ, हम अब बहुरूपदर्शक को काम करते देख सकते हैं!

  तैयार> 4 + 5;
 परिभाषित डबल @ "" () {
 प्रविष्टि:
         दोहरा दोहरा 9.000000e + 00
 }

 9.000000 पर मूल्यांकन किया गया

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

  तैयार> def testfunc (xy) x + y * 2;
 फ़ंक्शन परिभाषा पढ़ें:
 डबल @testfunc को परिभाषित करें (डबल% x, डबल% y) {
 प्रविष्टि:
         % मल्टीम्प = fmul डबल% y, 2.000000e + 00
         % addtmp = fadd डबल% मल्टीम्प,% x
         दोहरा% addtmp
 }

तैयार> testfunc (4, 10);

 परिभाषित डबल @ "" () {
 प्रविष्टि:
         % calltmp = कॉल डबल @testfunc (डबल 4.000000e + 00, डबल 1.000000e + 01)
         दोहरे% कॉलटैंप को पुनःप्राप्त करें
 }

 24.000000 पर मूल्यांकन किया गया

इससे पता चलता है कि हम कस्टम कोड निष्पादित कर सकते हैं, लेकिन एक सूक्ष्म बिंदु है। ध्यान दें कि हम JIT को एक अनाम फ़ंक्शन पर कॉल testfunc , जो testfunc कॉल testfunc , लेकिन इसे कभी भी टेस्टफंक पर कॉल नहीं करता है। वास्तव में, सभी गैर-अनाम कार्यों के लिए JIT को getPointerToFunction() कहा जाता है और getPointerToFunction() से लौटने से पहले एक अनाम फ़ंक्शन से संकलित किया जाता है।

जेआईटी कई अन्य चीजों के लिए और अधिक उन्नत इंटरफेस प्रदान करता है, जैसे कि मशीन को फ्री-मेमोरी आवंटित करना, उन्हें अपडेट करने के लिए पुनर्मूल्यांकन कार्य आदि। हालाँकि, इस सरल कोड की सहायता से, हमें आश्चर्यजनक रूप से शक्तिशाली सुविधाएँ मिलती हैं - हम इसे सत्यापित करेंगे (मैंने अनाम कार्यों के डंप को हटा दिया है ताकि आप केवल विचार देख सकें :):

  तैयार> बाहरी पाप (एक्स);
 बाहरी पढ़ें: 
 डबल @sin (डबल) घोषित करें

तैयार> बाहरी कॉशन (x);

 बाहरी पढ़ें: 
 डबल @cos (डबल) घोषित करें

तैयार> पाप (1.0);

 0.841471 में मूल्यांकन किया गया

तैयार> डीओ फू (एक्स) पाप (एक्स) * पाप (एक्स) + कॉस (एक्स) * कॉस (एक्स);

 फ़ंक्शन परिभाषा पढ़ें:
 परिभाषित डबल @foo (डबल% x) {
 प्रविष्टि:
         % calltmp = कॉल डबल @ एसिन (डबल% x)
         % मल्टीम्प = fmul डबल% कॉलटैंप,% कॉलटैंप
         % calltmp2 = call double @cos (डबल% x)
         % multmp4 = fmul डबल% calltmp2,% calltmp2
         % addtmp = fadd डबल% मल्टीम्प,% मल्टीम्प 4
         दोहरा% addtmp
 }

तैयार> फू (4.0);

 1.000000 का मूल्यांकन किया गया

वाह, JIT ने sin और cos बारे में कैसे सीखा? जवाब आश्चर्यजनक रूप से सरल है: इस उदाहरण में, जेआईटी ने फ़ंक्शन को निष्पादित करना शुरू कर दिया और फ़ंक्शन कॉल पर पहुंच गया। उन्होंने महसूस किया कि फ़ंक्शन को अभी तक JIT द्वारा संकलित नहीं किया गया था और फ़ंक्शन के मूल्यांकन के लिए प्रक्रियाओं का एक मानक सेट कहा जाता था। इस मामले में, इसके शरीर को कार्य के लिए परिभाषित नहीं किया गया है, इसलिए JIT "dlsym("sin")" लिए एक कॉल के साथ समाप्त होगा। चूंकि "sin" जेआईटी पता स्थान में परिभाषित किया गया है, इसलिए यह सीधे लाइब्रेरी फ़ंक्शन को कॉल करता है।

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

इसके दिलचस्प अनुप्रयोगों में से एक यह है कि अब हम संचालन के लिए मनमाना C ++ कोड लिखकर भाषा का विस्तार कर सकते हैं। उदाहरण के लिए, यदि हम जोड़ते हैं:

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

अब हम इस कोड की तरह कुछ का उपयोग करके कंसोल के लिए सरल आउटपुट का उत्पादन कर सकते हैं: "extern putchard(); putchard(120);" जो कंसोल में लोअरकेस 'x' को प्रिंट करता है (120 'x' के लिए ASCII कोड है)। फ़ाइल I / O, कंसोल इनपुट और कई अन्य विशेषताओं को लागू करने के लिए Kaleidoscope में समान कोड का उपयोग किया जा सकता है।

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

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

और अब, हमेशा की तरह, हमारे कार्यों के लिए कोड की एक पूरी सूची, जिसे आप इस तरह बना सकते हैं:

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

लिनक्स पर संकलन करते समय, -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]

LLVM का उपयोग करके एक प्रोग्रामिंग भाषा बनाना। भाग 4: JIT और अनुकूलक समर्थन जोड़ना

स्थिरांक की सबसे सरल तह (निरंतर तह)

एलएलवीएम ऑप्टिमाइज़ेशन पास

एक जेआईटी कंपाइलर जोड़ना

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

PS , :

More articles: