एलएलवीएम आईआर और गो

इस लेख में, हम देखेंगे कि गो प्रोग्राम कैसे बनाते हैं, जैसे कि कंपाइलर या स्टैटिक एनालाइज़र, जो LLVM IR असेंबली लैंग्वेज का उपयोग करके LLVM संकलन फ्रेमवर्क के साथ इंटरैक्ट करता है।

टीएल; डीआर हमने शुद्ध गो पर एलएलवीएम आईआर के साथ बातचीत के लिए एक पुस्तकालय लिखा था, कोड के लिंक देखें और एक उदाहरण परियोजना।

LLVM IR पर एक सरल उदाहरण

(एलएलवीएम आईआर से परिचित आप अगले भाग पर जा सकते हैं)।

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

एक कंपाइलर को डिज़ाइन करते समय, एक स्रोत भाषा को एक मध्यवर्ती प्रतिनिधित्व (IR, मध्यवर्ती प्रतिनिधित्व) में लक्ष्य आर्किटेक्चर (जैसे x86) में संकलित करने के बजाय एक विशाल लाभ होता है।


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


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

• सीमा: आईआर में स्रोत भाषा संकलित करता है
• मिडिललैंड: आईआर का अनुकूलन करता है
• बैकएंड: आईआर को मशीन कोड में संकलित करता है

LLVM IR कोडांतरक नमूना कार्यक्रम

एलएलवीएम आईआर असेंबलर कैसा दिखता है, इसका अंदाजा लगाने के लिए, निम्नलिखित कार्यक्रम पर विचार करें।

int f(int a, int b) { return a + 2*b; } int main() { return f(10, 20); } 

हम Clang का उपयोग करते हैं और उपरोक्त C कोड को LLVM IR कोडांतरक में संकलित करते हैं।

 define i32 @f(i32 %a, i32 %b) { ; <label>:0 %1 = mul i32 2, %b %2 = add i32 %a, %1 ret i32 %2 } define i32 @main() { ; <label>:0 %1 = call i32 @f(i32 10, i32 20) ret i32 %1 } 

उपरोक्त LLVM IR कोडांतरक कोड को देखते हुए, हम कुछ उल्लेखनीय LLVM IR विशेषताओं को देख सकते हैं, अर्थात्:

LLVM IR स्टेटिक रूप से टाइप किया जाता है (यानी 32-बिट पूर्णांकों को i32 द्वारा टाइप किया जाता है)।

फ़ंक्शन के भीतर स्थानीय चर की गुंजाइश है (यानी, मुख्य रूप से% 1 @f में% 1 से अलग है)।

(अस्थायी रजिस्टर) प्रत्येक कार्य में स्थानीय पहचानकर्ता (उदाहरण के लिए,% 1,% 2), आरोही क्रम में प्राप्त करते हैं। प्रत्येक फ़ंक्शन रजिस्टरों की एक अनंत संख्या (32 सामान्य-उद्देश्य रजिस्टरों तक सीमित नहीं) का उपयोग कर सकता है। वैश्विक पहचानकर्ता (जैसे @f) और स्थानीय पहचानकर्ता (जैसे% a,% 1) एक उपसर्ग (@ और%, क्रमशः) द्वारा प्रतिष्ठित हैं।

अधिकांश कमांड वही करते हैं जो आप उम्मीद करते हैं, इसलिए मुल गुणा, जोड़, जोड़ आदि करता है।

विधानसभा भाषाओं में प्रथागत है;

LLMV IR असेंबलर संरचना

LLVM IR असेंबली फ़ाइल की सामग्री एक मॉड्यूल है। मॉड्यूल में उच्च-स्तरीय घोषणाएँ शामिल हैं, जैसे कि वैश्विक चर और फ़ंक्शन।

एक फ़ंक्शन घोषणा में बेस ब्लॉक नहीं होते हैं, एक फ़ंक्शन परिभाषा में एक या अधिक बुनियादी ब्लॉक होते हैं (यानी, एक फ़ंक्शन बॉडी)।

LLVM IR मॉड्यूल का अधिक विस्तृत उदाहरण नीचे दिया गया है। वैश्विक चर @foo की परिभाषा और @f फ़ंक्शन की परिभाषा जिसमें तीन आधार ब्लॉक (% प्रविष्टि,% block_1 और% block_2) शामिल हैं।

 ;  ,  32-  21 @foo = global i32 21 ; f  42,   cond ,  0    define i32 @f(i1 %cond) { ;       ,     ;      entry: ;     br    block_1,  %cond ; ,   block_2   . br i1 %cond, label %block_1, label %block_2 ;     ,    ,     block_1: %tmp = load i32, i32* @foo %result = mul i32 %tmp, 2 ret i32 %result ;     ,     ,     block_2: ret i32 0 } 

आधार इकाई

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

टीम

एक कमांड जो कि जंप कमांड नहीं है, आमतौर पर गणना या मेमोरी एक्सेस (उदाहरण के लिए, ऐड, लोड) करता है, लेकिन प्रोग्राम के नियंत्रण प्रवाह को नहीं बदलता है।

टर्मिनेशन टीम

समाप्ति आदेश प्रत्येक आधार इकाई के अंत में स्थित है, और यह निर्धारित करता है कि आधार इकाई के अंत में संक्रमण कहां होगा। उदाहरण के लिए, टर्मिनेटिंग रिट कमांड कॉलिंग फ़ंक्शन के नियंत्रण प्रवाह को लौटाता है, और br संक्रमण, सशर्त या बिना शर्त के कार्य करता है।

एसएसए फॉर्म

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

मूल स्रोत कोड में एक से अधिक बार असाइन किए गए चर को संसाधित करने के लिए, LLVM IR में phi कमांड का उपयोग किया जाता है। Phi कमांड अनिवार्य रूप से इनपुट मानों के एक सेट से एक एकल मान लौटाता है, जिसके आधार पर निष्पादन कमांड इस कमांड तक पहुँच गया था। प्रत्येक इनपुट मान इस प्रकार एक पूर्ववर्ती इनपुट ब्लॉक के साथ जुड़ा हुआ है।

एक उदाहरण के रूप में, निम्नलिखित एलएलवीएम आईआर फ़ंक्शन पर विचार करें:

 define i32 @f(i32 %a) { ; <label>:0 switch i32 %a, label %default [ i32 42, label %case1 ] case1: %x.1 = mul i32 %a, 2 br label %ret default: %x.2 = mul i32 %a, 3 br label %ret ret: %x.0 = phi i32 [ %x.2, %default ], [ %x.1, %case1 ] ret i32 %x.0 } 

उपरोक्त उदाहरण में phi कमांड (जिसे कभी-कभी फी नोड भी कहा जाता है) संभव इनपुट मानों के सेट का उपयोग करके विभिन्न असाइनमेंट का अनुकरण करता है, निष्पादन थ्रेड में प्रत्येक संभावित पथ के लिए, चर असाइनमेंट के लिए अग्रणी। उदाहरण के लिए, डेटा स्ट्रीम में संबंधित पथों में से एक निम्नानुसार है:



सामान्य तौर पर, जब एक कंपाइलर विकसित होता है जो स्रोत कोड को LLVM IR में परिवर्तित करता है, तो सभी स्थानीय स्रोत कोड चर को SSA रूप में परिवर्तित किया जा सकता है, जिसके लिए चर का अपवाद होता है, जिसके लिए उनका पता लिया जाता है।

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

शुद्ध गो पर एलएलवीएम आईआर लाइब्रेरी

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

https://godoc.org/llvm.org/llvm/bindings/go/llvm : गो भाषा के लिए आधिकारिक LLVM बाइंडिंग।
github.com/llir/llvm : LLVM IR के साथ बातचीत के लिए एक स्वच्छ गो लाइब्रेरी।

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

यह लेख llir / llvm पर केंद्रित है, लेकिन अन्य पुस्तकालयों के साथ काम करने के लिए इसे सामान्यीकृत किया जा सकता है।

एक नया पुस्तकालय क्यों लिखें?

एलएलवीएम आईआर के साथ बातचीत के लिए एक स्वच्छ गो लाइब्रेरी विकसित करने के लिए मुख्य प्रेरणा लेखन संकलक और स्थैतिक विश्लेषण उपकरण बनाना था, जो एलएलवीएम आईआर संकलन ढांचे पर आधारित हैं, एक अधिक मजेदार कार्य। यह इस तथ्य से भी प्रभावित था कि गो के साथ आधिकारिक LLVM बाइंडिंग पर आधारित एक परियोजना का संकलन समय महत्वपूर्ण हो सकता है (TinyGo के लेखक @aykevl के लिए धन्यवाद, अब गतिशील लिंकिंग के कारण संकलन को गति देना संभव है, क्योंकि LLVM 4 के मानक संस्करण के विपरीत)।


एक और बड़ी प्रेरणा गो एपीआई को खरोंच से विकसित करने की कोशिश करना था। गो और llir / llvm के लिए LLVM बाइंडिंग API के बीच मुख्य अंतर यह है कि LLVM मान कैसे तैयार किए जाते हैं। गो के लिए एलएलवीएम बाइंडर्स में, एलएलवीएम मूल्यों को एक ठोस संरचनात्मक प्रकार के रूप में तैयार किया जाता है, जो संक्षेप में, सभी संभावित एलएलवीएम मूल्यों के लिए सभी संभव तरीकों को समाहित करता है। इस एपीआई का उपयोग करने वाले मेरे व्यक्तिगत अनुभव से पता चलता है कि यह जानना मुश्किल है कि किसी दिए गए मूल्य के लिए कॉल करने के लिए कौन से तरीकों की सबसेट की अनुमति है। उदाहरण के लिए, एक निर्देश ओपकोड प्राप्त करने के लिए, आप इंस्ट्रक्शनऑपकोड विधि कहते हैं, जो सहज है। हालाँकि, यदि आप इसके बजाय Opcode विधि को कॉल करते हैं, जिसे एक स्थिर अभिव्यक्ति का opcode प्राप्त करने के लिए डिज़ाइन किया गया है, तो आपको एक रनटाइम त्रुटि मिलेगी: "असंगत प्रकार का" कास्ट () तर्क! " (असंगत प्रकार के तर्क का रूपांतरण)।

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

उदाहरण का उपयोग करें

अब आइए विशिष्ट उपयोगों के कुछ उदाहरण देखें। हमारे पास एक पुस्तकालय है, लेकिन हमें LLVM IR के साथ क्या करना चाहिए?

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

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

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

नमूना इनपुट कोड - एलएलवीएम आईआर पार्सिंग

 //       LLVM IR,    //     package main import ( "fmt" "github.com/llir/llvm/asm" ) func main() { //    LLVM IR. m, err := asm.ParseFile("foo.ll") if err != nil { panic(err) } // ,    LLVM IR. // Print LLVM IR module. fmt.Println(m) } 

विश्लेषण उदाहरण - प्रसंस्करण एलएलवीएम आईआर

 //      LLVM IR     //  Graphviz DOT package main import ( "bytes" "fmt" "io/ioutil" "github.com/llir/llvm/asm" "github.com/llir/llvm/ir" ) func main() { //    LLVM IR. m, err := asm.ParseFile("foo.ll") if err != nil { panic(err) } //    . callgraph := genCallgraph(m) //      Graphviz DOT. if err := ioutil.WriteFile("callgraph.dot", callgraph, 0644); err != nil { panic(err) } } // genCallgraph      Graphviz DOT    LLVM IR func genCallgraph(m *ir.Module) []byte { buf := &bytes.Buffer{} buf.WriteString("digraph {\n") //      for _, f := range m.Funcs { //   caller := f.Ident() fmt.Fprintf(buf, "\t%q\n", caller) //       for _, block := range f.Blocks { //   ,       . for _, inst := range block.Insts { //  .   call. switch inst := inst.(type) { case *ir.InstCall: callee := inst.Callee.Ident() //        . fmt.Fprintf(buf, "\t%q -> %q\n", caller, callee) } } //     switch term := block.Term.(type) { case *ir.TermRet: //  - _ = term } } } buf.WriteString("}") return buf.Bytes() } 

नमूना आउटपुट कोड - एलएलवीएम आईआर जेनरेशन

 //     LLVM IR,    C, //    . // // int abs(int x); // // int seed = 0; // // // ref: https://en.wikipedia.org/wiki/Linear_congruential_generator // // a = 0x15A4E35 // // c = 1 // int rand(void) { // seed = seed*0x15A4E35 + 1; // return abs(seed); // } package main import ( "fmt" "github.com/llir/llvm/ir" "github.com/llir/llvm/ir/constant" "github.com/llir/llvm/ir/types" ) func main() { //      i32 := types.I32 zero := constant.NewInt(i32, 0) a := constant.NewInt(i32, 0x15A4E35) //  PRNG. c := constant.NewInt(i32, 1) //  PRNG. //    LLVM IR. m := ir.NewModule() //         . // // int abs(int x); abs := m.NewFunc("abs", i32, ir.NewParam("x", i32)) //         . // // int seed = 0; seed := m.NewGlobalDef("seed", zero) //        . // // int rand(void) { ... } rand := m.NewFunc("rand", i32) //           `rand`. entry := rand.NewBlock("") //         . tmp1 := entry.NewLoad(seed) tmp2 := entry.NewMul(tmp1, a) tmp3 := entry.NewAdd(tmp2, c) entry.NewStore(tmp3, seed) tmp4 := entry.NewCall(abs, tmp3) entry.NewRet(tmp4) //   LLVM IR  . fmt.Println(m) } 

निष्कर्ष

Llir / llvm का विकास और कार्यान्वयन किया गया था और योगदानकर्ताओं के एक समुदाय द्वारा नेतृत्व किया गया था, जिन्होंने न केवल कोड लिखा था, बल्कि विचार-विमर्श किया, प्रोग्रामिंग सत्रों को जोड़ा, डिबग किया, प्रोफाइल किया और सीखने की प्रक्रिया में उत्सुकता दिखाई।

Llir / llvm प्रोजेक्ट के सबसे कठिन हिस्सों में से एक LLVM IR के लिए एक EBNF व्याकरण का निर्माण किया गया था, जो LLVM 7.0 तक के संस्करण में संपूर्ण LLVM IR भाषा को कवर करता है। यहां कठिनाई स्वयं प्रक्रिया में नहीं है, लेकिन इस तथ्य में कि पूरी भाषा को कवर करने वाला आधिकारिक रूप से प्रकाशित व्याकरण नहीं है। कुछ खुले स्रोत समुदायों ने एलएलवीएम कोडांतरक के लिए औपचारिक व्याकरण को परिभाषित करने की कोशिश की है, लेकिन वे कवर करते हैं, जहां तक ​​हम जानते हैं, भाषा का केवल सबसेट है।

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

भविष्य अद्भुत है, खुश हैकिंग!

संदर्भ

1. एलएलवीएम पर एक बहुत अच्छी तरह से लिखा गया अध्याय , प्रारंभिक एलएलवीएम परियोजना के लेखक, "आर्किटेक्चर ऑफ ओपन सोर्स एप्लिकेशन" पुस्तक में लिखा गया है।

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

3. उन लोगों के लिए जो एलएलवीएम आईआर के लिए इनपुट भाषा से एक कंपाइलर लिखने में रुचि रखते हैं, पुस्तक " मैपिंग हाई लेवल कंस्ट्रक्ट्स टू एलएलवीएम आईआर " की सिफारिश की जाती है।

स्लाइड का एक अच्छा सेट एलएलवीएम है, ग्रेट डिटेल में , जो महत्वपूर्ण एलएलवीएम आईआर अवधारणाओं का वर्णन करता है, एलएलवीएम सी ++ एपीआई के लिए एक परिचय प्रदान करता है, और कुछ बहुत ही उपयोगी एलएलवीएम अनुकूलन मार्ग का वर्णन करता है।

एलएलवीएम के लिए आधिकारिक गो बाइंडिंग कई परियोजनाओं के लिए उपयुक्त हैं, वे एलएलवीएम सी एपीआई का प्रतिनिधित्व करते हैं, शक्तिशाली और स्थिर।

पोस्ट का एक अच्छा जोड़ गो में एलएलवीएम के लिए एक परिचय है।