गो के संदर्भ में एलएलवीएम

कंपाइलर विकास एक बहुत मुश्किल काम है। लेकिन, सौभाग्य से, एलएलवीएम जैसी परियोजनाओं के विकास के साथ, इस समस्या का समाधान बहुत सरल है, जो एक भी प्रोग्रामर को एक नई भाषा बनाने की अनुमति देता है जो सी। के प्रदर्शन के करीब है। एलएलवीएम के साथ काम करना इस तथ्य से जटिल है कि इस प्रणाली को बड़ी मात्रा में कोड द्वारा दर्शाया गया है, जो छोटे दस्तावेज से लैस है। इस दोष को ठीक करने का प्रयास करने के लिए, सामग्री के लेखक, जिसे हम आज प्रकाशित करते हैं, गो में लिखे गए कोड के उदाहरणों को प्रदर्शित करने जा रहे हैं और दिखाते हैं कि कैसे वे TinyGO संकलक का उपयोग करके पहले गो SSA और फिर LLVM IR में प्रेषित होते हैं । गो एसएसए और एलएलवीएम आईआर कोड को थोड़ा संपादित किया गया है, कुछ जो कि यहां दिए गए स्पष्टीकरण से संबंधित नहीं है, इन स्पष्टीकरणों को अधिक समझने के लिए इसे यहां से हटा दिया गया है।

पहला उदाहरण

पहला कार्य जो मैं यहां करने जा रहा हूं, वह संख्याओं को जोड़ने का एक सरल तंत्र है:

func myAdd(a, b int) int{    return a + b } 

यह फ़ंक्शन बहुत सरल है, और, शायद, कुछ भी आसान नहीं है, साथ नहीं आना। यह निम्नलिखित गो एसएसए कोड का अनुवाद करता है:

 func myAdd(a int, b int) int: entry:   t0 = a + b                                                    int   return t0 

फ़ंक्शन के इस प्रतिनिधित्व के साथ, डेटा प्रकारों के बारे में संकेत दाईं ओर रखे जाते हैं, ज्यादातर मामलों में आप उन्हें अनदेखा कर सकते हैं।

यह छोटा उदाहरण पहले से ही आपको एसएसए के एक पहलू का सार देखने की अनुमति देता है। अर्थात्, जब कोड को SSA रूप में परिवर्तित किया जाता है, तो प्रत्येक अभिव्यक्ति को सबसे प्राथमिक भागों में विभाजित किया जाता है, जिसमें यह शामिल होता है। हमारे मामले में, return a + b कमांड, वास्तव में, दो संचालन का प्रतिनिधित्व करता है: दो संख्याओं को जोड़ना और परिणाम वापस करना।

इसके अलावा, यहां आप प्रोग्राम के बुनियादी ब्लॉकों को देख सकते हैं, इस कोड में केवल एक ब्लॉक है - इनपुट (एंट्री ब्लॉक)। हम नीचे दिए गए ब्लॉक के बारे में अधिक बात करेंगे।

गो एसएसए कोड को आसानी से एलएलवीएम आईआर में परिवर्तित किया जा सकता है:

 define i64 @myAdd(i64 %a, i64 %b) { entry: %0 = add i64 %a, %b ret i64 %0 } 

आप देख सकते हैं कि यद्यपि अन्य सिंटैक्टिक निर्माण यहां उपयोग किए जाते हैं, फ़ंक्शन की संरचना मूल रूप से नहीं बदली गई है। LLVM IR कोड, C. SS के समान, गो SSA कोड की तुलना में थोड़ा अधिक मजबूत है। यहां फ़ंक्शन डिक्लेरेशन में सबसे पहले उस पर लौटाए गए डेटा प्रकार का विवरण आता है, तर्क प्रकार को तर्क नाम से पहले इंगित किया जाता है। इसके अलावा, IR पार्सिंग को आसान बनाने के लिए, वैश्विक संस्थाओं के नाम @ प्रतीक द्वारा पहले दिए गए हैं, और % वर्णों द्वारा स्थानीय संस्थाओं के नाम से पहले (फ़ंक्शन को एक वैश्विक इकाई भी माना जाता है)।

इस कोड की एक विशेषता जो आपको ध्यान देने की आवश्यकता है, वह यह है कि गो int का प्रतिनिधित्व करने का निर्णय, जिसे कंपाइलर और संकलन के उद्देश्य के आधार पर 32-बिट या 64-बिट मान द्वारा दर्शाया जा सकता है, जब एलएलवीएम किया जाता है। आईआर कोड। यह कई कारणों में से एक है कि एलएलवीएम आईआर कोड स्वतंत्र नहीं है। एक प्लेटफ़ॉर्म के लिए बनाया गया ऐसा कोड बस किसी अन्य प्लेटफ़ॉर्म के लिए नहीं लिया जा सकता है और संकलित नहीं किया जा सकता है (जब तक कि आप अत्यधिक सावधानी के साथ इस कार्य को नहीं करते )

ध्यान देने योग्य एक और दिलचस्प बात यह है कि टाइप i64 एक हस्ताक्षरित पूर्णांक नहीं है: यह संख्या के संकेत का प्रतिनिधित्व करने के मामले में तटस्थ है। निर्देश के आधार पर, यह हस्ताक्षरित संख्या और अहस्ताक्षरित संख्या दोनों का प्रतिनिधित्व कर सकता है। जोड़ के संचालन का प्रतिनिधित्व करने के मामले में, यह एक भूमिका नहीं निभाता है, इसलिए संकेत के साथ या बिना संख्या के साथ काम करने में कोई अंतर नहीं है। यहां, मैं यह नोट करना चाहूंगा कि सी में, एक हस्ताक्षरित पूर्णांक चर का अतिप्रवाह अपरिभाषित व्यवहार की ओर जाता है, इसलिए, nsw ऑपरेशन में nsw (कोई हस्ताक्षरित रैप) ध्वज नहीं जोड़ता है, जो LLVM को इंगित करता है कि यह इस धारणा से आगे बढ़ सकता है। इसके अलावा अतिप्रवाह कभी नहीं होता है।

यह कुछ अनुकूलन के लिए महत्वपूर्ण हो सकता है। उदाहरण के लिए, 32-बिट प्लेटफ़ॉर्म (32-बिट रजिस्टरों के साथ) पर दो i16 मानों को जोड़ने की आवश्यकता होती है, इसके अलावा पूरा होने के बाद, i16 रेंज में बने रहने के लिए साइन एक्सटेंशन ऑपरेशन। इस वजह से, अक्सर रजिस्टर के मशीन के आकार को ध्यान में रखते हुए पूर्णांक संचालन करना अधिक कुशल होता है।

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

दूसरा उदाहरण

निम्नलिखित उदाहरण, जिसे हम जांचेंगे, थोड़ा और अधिक जटिल होगा। अर्थात्, हम एक ऐसे फ़ंक्शन के बारे में बात कर रहे हैं जो पूर्णांकों का टुकड़ा प्रस्तुत करता है:

 func sum(numbers []int) int {   n := 0   for i := 0; i < len(numbers); i++ {       n += numbers[i]   }   return n } 

यह कोड निम्नलिखित गो एसएसए कोड में परिवर्तित हो जाता है:

 func sum(numbers []int) int: entry:   jump for.loop for.loop:   t0 = phi [entry: 0:int, for.body: t6] #n                       int   t1 = phi [entry: 0:int, for.body: t7] #i                       int   t2 = len(numbers)                                              int   t3 = t1 < t2                                                  bool   if t3 goto for.body else for.done for.body:   t4 = &numbers[t1]                                             *int   t5 = *t4                                                       int   t6 = t0 + t5                                                   int   t7 = t1 + 1:int                                                int   jump for.loop for.done:   return t0 

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

वास्तव में, यहां आप इस तथ्य पर ध्यान दे सकते हैं कि प्रोग्राम को घुंघराले ब्रेसिज़ (जैसे सी परिवार की भाषाओं में) का उपयोग करके ब्लॉक में विभाजित नहीं किया गया है। यह लेबलों से विभाजित होता है, जो असेंबली भाषाओं से मिलता-जुलता है, और बेस ब्लॉक के रूप में प्रस्तुत किया जाता है। एसएसए में, बेस ब्लॉक एक लेबल के साथ शुरू होने वाले कोड के सन्निहित अनुक्रम हैं और बेस ब्लॉक को पूरा करने के निर्देशों के साथ समाप्त होते हैं, उदाहरण के लिए, return और jump ।

इस कोड का एक और दिलचस्प विवरण phi निर्देश है। निर्देश काफी असामान्य है, यह पता लगाने में कुछ समय लग सकता है। याद रखें कि एसएसए स्टेटिक सिंगल असाइनमेंट के लिए छोटा है। यह संकलक द्वारा प्रयुक्त कोड का एक मध्यवर्ती प्रतिनिधित्व है, जिसमें प्रत्येक चर को केवल एक बार सौंपा गया है। यह ऊपर दिखाए गए हमारे myAdd फ़ंक्शन जैसे सरल कार्यों को व्यक्त करने के लिए बहुत अच्छा है, लेकिन इस अनुभाग में चर्चा किए गए sum फ़ंक्शन जैसे अधिक जटिल कार्यों के लिए नहीं। विशेष रूप से, लूप के निष्पादन के दौरान, चर i और n परिवर्तन।

SSA तथाकथित phi अनुदेश (इसका नाम ग्रीक वर्णमाला से लिया गया है) का उपयोग करके चर मानों के एकल असाइनमेंट पर प्रतिबंध को phi देता है। तथ्य यह है कि सी जैसी भाषाओं के लिए एसएसए-प्रतिनिधित्व का गठन किया जा सकता है, इसके लिए आपको कुछ तरकीबों का सहारा लेना होगा। इस निर्देश को कॉल करने का परिणाम चर ( i या n ) का वर्तमान मूल्य है, और बेस ब्लॉक की एक सूची इसके मापदंडों के रूप में उपयोग की जाती है। उदाहरण के लिए, इस निर्देश पर विचार करें:

 t0 = phi [entry: 0:int, for.body: t6] #n 

इसका अर्थ इस प्रकार है: यदि पिछला बेस ब्लॉक एक entry (इनपुट) ब्लॉक था, तो t0 निरंतर 0 , और यदि पिछला बेस ब्लॉक for.body था, तो आपको इस ब्लॉक से मान t6 लेने की आवश्यकता है। यह सब बल्कि रहस्यमय लग सकता है, लेकिन इस तंत्र के लिए धन्यवाद, एसएसए सुनिश्चित किया जाता है। मानवीय दृष्टिकोण से, यह सब कोड की समझ को जटिल करता है, लेकिन यह तथ्य कि प्रत्येक मूल्य को केवल एक बार सौंपा जाता है, बहुत अधिक अनुकूलन को सरल करता है।

ध्यान दें कि यदि आप अपना खुद का कंपाइलर लिख रहे हैं, तो आमतौर पर आपको ऐसी चीजों से जूझना नहीं पड़ता। यहां तक ​​कि alloca इन सभी phi निर्देशों को उत्पन्न नहीं करता है, यह alloca तंत्र का उपयोग करता है (यह सामान्य स्थानीय चर के साथ काम करता है)। फिर, जब LL2M ऑप्टिमाइज़ेशन पास करते हैं, जिसे mem2reg कहा जाता है, तो alloca निर्देशों को SSA फॉर्म में बदल दिया जाता है। TinyGo, हालांकि, गो एसएसए से इनपुट प्राप्त करता है, जो कि, सुविधाजनक रूप से, पहले से ही एसएसए रूप में परिवर्तित हो गया है।

मध्यवर्ती कोड के इस टुकड़े का एक और नवाचार यह है कि सूचकांक द्वारा टुकड़ा तत्वों तक पहुंच पते की गणना के संचालन और प्राप्त सूचक के डेरेफेरिंग ऑपरेशन के रूप में प्रस्तुत की जाती है। यहां आप आईआर-कोड के लिए स्थिरांक का प्रत्यक्ष जोड़ देख सकते हैं (उदाहरण के लिए - 1:int )। myAdd फ़ंक्शन के साथ उदाहरण में myAdd इसका उपयोग नहीं किया गया था। अब जब हम इन विशेषताओं का पता लगा लेते हैं, तो हम इस पर एक नज़र डालेंगे कि यह कोड LLVM IR फॉर्म में परिवर्तित करते समय क्या बदल जाएगा:

 define i64 @sum(i64* %ptr, i64 %len, i64 %cap) { entry: br label %for.loop for.loop:                                         ; preds = %for.body, %entry %0 = phi i64 [ 0, %entry ], [ %5, %deref.next ] %1 = phi i64 [ 0, %entry ], [ %6, %deref.next ] %2 = icmp slt i64 %1, %len br i1 %2, label %for.body, label %for.done for.body:                                         ; preds = %for.loop %3 = getelementptr i64, i64* %ptr, i64 %1 %4 = load i64, i64* %3 %5 = add i64 %0, %4 %6 = add i64 %1, 1 br label %for.loop for.done:                                         ; preds = %for.loop ret i64 %0 } 

यहां, पहले की तरह, हम उसी संरचना को देख सकते हैं, जिसमें अन्य वाक्यात्मक निर्माण शामिल हैं। उदाहरण के लिए, phi कॉल में, मान और लेबल स्वैप किए जाते हैं। हालांकि, वहाँ भी कुछ विशेष ध्यान देने लायक है।

शुरुआत के लिए, यहां आप फ़ंक्शन के पूरी तरह से अलग हस्ताक्षर देख सकते हैं। LLVM स्लाइस का समर्थन नहीं करता है, परिणामस्वरूप, अनुकूलन के रूप में, TinyGo संकलक, जिसने इस मध्यवर्ती कोड को उत्पन्न किया, इस डेटा संरचना के विवरण को भागों में विभाजित किया। वह संरचना (संरचना) के रूप में तीन स्लाइस तत्वों ( ptr , len और cap ) का प्रतिनिधित्व कर सकता था, लेकिन उन्हें तीन अलग-अलग संस्थाओं के रूप में प्रस्तुत करना कुछ अनुकूलन के लिए अनुमति देता है। अन्य कंपाइलर स्लाइस को किसी अन्य तरीके से प्रस्तुत कर सकते हैं, यह लक्ष्य प्लेटफॉर्म के कार्यों को कॉल करने के लिए सम्मेलनों पर निर्भर करता है।

इस कोड की एक और दिलचस्प विशेषता getelementptr (जिसे अक्सर शॉर्ट के लिए जीईपी कहा जाता है) का उपयोग होता है।

यह निर्देश पॉइंटर्स के साथ काम करता है और इसका उपयोग एक स्लाइस तत्व को पॉइंटर प्राप्त करने के लिए किया जाता है। उदाहरण के लिए, आइए इसकी तुलना C में लिखे निम्न कोड से करें:

 int* sliceptr(int *ptr, int index) {   return &ptr[index]; } 

या इसके समकक्ष निम्नलिखित के साथ:

 int* sliceptr(int *ptr, int index) {   return ptr + index; } 

यहाँ सबसे महत्वपूर्ण बात यह है कि getelementptr स्टेटमेंट getelementptr ऑपरेशन नहीं getelementptr । यह केवल मौजूदा के आधार पर एक नए पॉइंटर की गणना करता है। इसे mul रूप में व्याख्या किया जा सकता है और हार्डवेयर स्तर पर add सकते हैं। GEP निर्देशों पर विवरण यहां पाया जा सकता है ।

इस मध्यवर्ती कोड की एक और दिलचस्प विशेषता icmp निर्देश का उपयोग है। यह एक सामान्य-उद्देश्य निर्देश है जिसका उपयोग पूर्णांक तुलनाओं को लागू करने के लिए किया जाता है। इस निर्देश का परिणाम हमेशा प्रकार i1 का मान होता है - एक तार्किक मूल्य। इस मामले में, कीवर्ड slt (इससे कम पर हस्ताक्षर किए गए) का उपयोग करके एक तुलना की जाती है, क्योंकि हम int प्रकार से पहले दर्शाए गए दो नंबरों की तुलना कर रहे हैं। यदि हम दो अहस्ताक्षरित पूर्णांक की तुलना करते हैं, तो हम एक निर्देश के रूप में icmp उपयोग करेंगे, और तुलना में उपयोग किया गया कीवर्ड सही होगा। फ्लोटिंग पॉइंट नंबरों की तुलना करने के लिए, एक और निर्देश का उपयोग किया जाता है, fcmp , जो एक समान तरीके से काम करता है।

परिणाम

मेरा मानना ​​है कि इस लेख में मैंने एलएलवीएम आईआर की सबसे महत्वपूर्ण विशेषताओं की जांच की। बेशक, अभी भी बहुत कुछ है। विशेष रूप से, कोड के मध्यवर्ती प्रतिनिधित्व में, कई एनोटेशन हो सकते हैं जो ऑप्टिमाइज़र पास के दौरान कंपाइलर को ज्ञात कोड की कुछ विशेषताओं को ध्यान में रखते हैं जो आईआर में दूसरे तरीके से व्यक्त नहीं किए जा सकते हैं। उदाहरण के लिए, ये inbounds निर्देश, या nsw और nuw , जिन्हें add स्टेटमेंट में जोड़ा जा सकता है। वही private कीवर्ड पर लागू होता है, जो ऑप्टिमाइज़र को इंगित करता है कि उसके द्वारा चिह्नित फ़ंक्शन को वर्तमान संकलन इकाई के बाहर से संदर्भित नहीं किया जाएगा। यह आपको कई दिलचस्प इंटरप्रोसेरुरल ऑप्टिमाइज़ेशन करने की अनुमति देता है, जैसे अप्रयुक्त तर्कों को समाप्त करना।

आप प्रलेखन में एलएलवीएम के बारे में अधिक पढ़ सकते हैं, जिसे आप अक्सर अपने एलएलवीएम-आधारित कंपाइलर को विकसित करते समय संदर्भित करेंगे। यहां एक गाइड है जो बहुत सरल भाषा के लिए संकलक विकास पर चर्चा करता है। जानकारी के ये दोनों स्रोत आपके अपने कंपाइलर बनाते समय काम आएंगे।

प्रिय पाठकों! क्या आप LLVM का उपयोग करते हैं?