जाने परिप्रेक्ष्यबाट LLVM

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

पहिलो उदाहरण

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

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

यो प्रकार्य धेरै सरल छ, र, सायद, केहि पनि सरल हुन सक्दैन। यसले निम्न Go SSA कोडमा अनुवाद गर्छ:

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

यस दृश्यको साथ, डेटा प्रकार संकेतहरू दायाँ तिर राखिन्छन् र धेरै जसो अवस्थामा बेवास्ता गर्न सकिन्छ।

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

थप रूपमा, यहाँ तपाइँ कार्यक्रमको आधारभूत ब्लकहरू हेर्न सक्नुहुन्छ; यस कोडमा त्यहाँ एक मात्र ब्लक छ - प्रविष्टि ब्लक। हामी तल ब्लकहरूको बारेमा थप कुरा गर्नेछौं।

Go SSA कोड सजिलै LLVM IR मा रूपान्तरण गर्दछ:

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

तपाईले के याद गर्न सक्नुहुन्छ कि यद्यपि विभिन्न सिन्ट्याक्टिक संरचनाहरू यहाँ प्रयोग गरिन्छ, प्रकार्यको संरचना मूल रूपमा अपरिवर्तित छ। LLVM IR कोड Go SSA कोड भन्दा अलि बलियो छ, C जस्तै। यहाँ, प्रकार्य घोषणामा, पहिले यसले फर्काउने डेटा प्रकारको विवरण छ, तर्कको नाम अघि तर्क प्रकार संकेत गरिएको छ। थप रूपमा, IR पार्सिङलाई सरल बनाउन, विश्वव्यापी संस्थाहरूको नाम प्रतीकको अगाडि राखिएको छ। @, र स्थानीय नाम अघि त्यहाँ एक प्रतीक छ % (एक प्रकार्य पनि विश्वव्यापी इकाई मानिन्छ)।

यस कोडको बारेमा ध्यान दिनु पर्ने एउटा कुरा भनेको Go को प्रकारको प्रतिनिधित्व निर्णय हो int, जसलाई 32-bit वा 64-bit मानको रूपमा प्रतिनिधित्व गर्न सकिन्छ, कम्पाइलर र संकलनको लक्ष्यमा निर्भर गर्दै, LLVM ले IR कोड उत्पन्न गर्दा स्वीकार गरिन्छ। यो धेरै कारणहरू मध्ये एक हो जुन LLVM IR कोड होइन, धेरै मानिसहरूले सोच्छन्, प्लेटफर्म स्वतन्त्र। एउटा प्लेटफर्मको लागि सिर्जना गरिएको यस्तो कोड अर्को प्लेटफर्मको लागि मात्र लिन र कम्पाइल गर्न सकिँदैन (जबसम्म तपाईं यो समस्या समाधान गर्न उपयुक्त हुनुहुन्न। अत्यधिक हेरचाह संग).

अर्को चाखलाग्दो बिन्दु ध्यान दिन लायक छ कि प्रकार i64 हस्ताक्षर गरिएको पूर्णांक होइन: यो संख्याको चिन्ह प्रतिनिधित्व गर्ने सन्दर्भमा तटस्थ छ। निर्देशनमा निर्भर गर्दै, यसले दुवै हस्ताक्षरित र अहस्ताक्षरित नम्बरहरू प्रतिनिधित्व गर्न सक्छ। थप कार्य को प्रतिनिधित्व को मामला मा, यो केहि फरक पर्दैन, त्यसैले हस्ताक्षर वा अहस्ताक्षरित संख्या संग काम मा कुनै फरक छैन। यहाँ म नोट गर्न चाहन्छु कि C भाषामा, साइन इन्टिजर चर ओभरफ्लो गर्दा अपरिभाषित व्यवहार हुन्छ, त्यसैले क्ल्याङ्ग फ्रन्टएन्डले सञ्चालनमा झण्डा थप्छ। nsw (कुनै हस्ताक्षरित र्‍याप छैन), जसले LLVM लाई बताउँछ कि यसले जोड कहिल्यै ओभरफ्लो हुँदैन भनेर मान्न सक्छ।

यो केहि अप्टिमाइजेसनहरूको लागि महत्त्वपूर्ण हुन सक्छ। उदाहरणका लागि, दुई मानहरू थप्दै i16 ३२-बिट प्लेटफर्ममा (३२-बिट रेजिस्टरहरू सहित) आवश्यक पर्दछ, थप पछि, दायरामा रहनको लागि साइन विस्तार कार्य i16। यस कारणले गर्दा, मेसिन दर्ता साइजहरूमा आधारित पूर्णांक कार्यहरू गर्न यो प्रायः अधिक कुशल हुन्छ।

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

दोस्रो उदाहरण

अर्को उदाहरण हामीले हेर्नेछौं अलि बढी जटिल हुनेछ। अर्थात्, हामी एक प्रकार्यको बारेमा कुरा गर्दैछौं जसले पूर्णांकको टुक्रालाई जोड्छ:

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

यो कोड निम्न Go SSA कोडमा रूपान्तरण गर्दछ:

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

यहाँ तपाईंले पहिले नै SSA फारममा कोड प्रतिनिधित्व गर्नको लागि सामान्य थप निर्माणहरू देख्न सक्नुहुन्छ। सायद यस कोडको सबैभन्दा स्पष्ट विशेषता भनेको कुनै संरचित प्रवाह नियन्त्रण आदेशहरू छैनन् भन्ने तथ्य हो। गणनाको प्रवाह नियन्त्रण गर्न, त्यहाँ केवल सशर्त र बिना शर्त जम्पहरू छन्, र, यदि हामीले यो आदेशलाई प्रवाह नियन्त्रण गर्न आदेशको रूपमा विचार गर्छौं भने, फिर्ता आदेश।

वास्तवमा, यहाँ तपाइँ यस तथ्यमा ध्यान दिन सक्नुहुन्छ कि कार्यक्रम घुमाउरो कोष्ठकहरू प्रयोग गरेर ब्लकहरूमा विभाजित गरिएको छैन (भाषाहरूको C परिवारमा जस्तै)। यसलाई लेबलहरूद्वारा विभाजित गरिएको छ, विधानसभा भाषाहरूको सम्झना दिलाउने, र आधारभूत ब्लकहरूको रूपमा प्रस्तुत गरिएको छ। SSA मा, आधारभूत ब्लकहरूलाई लेबलबाट सुरु हुने र आधारभूत ब्लक पूरा गर्ने निर्देशनहरूसँग समाप्त हुने कोडको सन्तुलित अनुक्रमहरूको रूपमा परिभाषित गरिन्छ, जस्तै − return и jump.

यस कोडको अर्को रोचक विवरण निर्देशन द्वारा प्रतिनिधित्व गरिएको छ phi। निर्देशनहरू एकदम असामान्य छन् र बुझ्न केही समय लाग्न सक्छ। याद गर्नुहोस्, त्यो एसएसए स्थिर एकल असाइनमेन्टको लागि छोटो छ। यो कम्पाइलरहरू द्वारा प्रयोग गरिएको कोडको मध्यवर्ती प्रतिनिधित्व हो, जसमा प्रत्येक चरलाई एक पटक मात्र मान तोकिएको छ। यो हाम्रो प्रकार्य जस्तै साधारण प्रकार्यहरू व्यक्त गर्नको लागि उत्कृष्ट छ myAddमाथि देखाइएको छ, तर यो खण्डमा छलफल गरिएको प्रकार्य जस्ता थप जटिल कार्यहरूको लागि उपयुक्त छैन sum। विशेष गरी, लूपको कार्यान्वयनको क्रममा चरहरू परिवर्तन हुन्छन् i и n.

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

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

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

ध्यान दिनुहोस् कि यदि तपाइँ तपाइँको आफ्नै कम्पाइलर लेख्नुहुन्छ भने, तपाइँ सामान्यतया यस प्रकारको सामान संग सम्झौता गर्नु पर्दैन। Clang ले यी सबै निर्देशनहरू उत्पन्न गर्दैन phi, यो एक संयन्त्र प्रयोग गर्दछ alloca (यो साधारण स्थानीय चरहरूसँग काम गर्ने जस्तो देखिन्छ)। त्यसपछि, LLVM अप्टिमाइजेसन पास चलाउँदा भनिन्छ mem2reg, निर्देशन alloca SSA फारममा रूपान्तरण गरियो। तथापि, TinyGo ले Go SSA बाट इनपुट प्राप्त गर्दछ, जुन, सुविधाजनक रूपमा, पहिले नै SSA फारममा रूपान्तरण गरिएको छ।

विचाराधीन मध्यवर्ती कोडको टुक्राको अर्को नवीनता यो हो कि अनुक्रमणिका द्वारा स्लाइस तत्वहरूमा पहुँच ठेगाना गणना गर्ने अपरेशनको रूपमा प्रतिनिधित्व गरिन्छ र नतिजा सूचकलाई डिरेफरेन्स गर्ने अपरेशनको रूपमा प्रतिनिधित्व गरिन्छ। यहाँ तपाईँले IR कोडमा स्थिरांकको प्रत्यक्ष जोड देख्न सक्नुहुन्छ (उदाहरणका लागि - 1:int)। प्रकार्य संग उदाहरण मा 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 (प्रायः GEP को रूपमा संक्षिप्त)।

यो निर्देशन सूचकहरूसँग काम गर्दछ र एक टुक्रा तत्वमा सूचक प्राप्त गर्न प्रयोग गरिन्छ। उदाहरण को लागी, यसलाई C मा लेखिएको निम्न कोड संग तुलना गरौं:

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

वा निम्न बराबरको साथ:

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

यहाँ सबैभन्दा महत्त्वपूर्ण कुरा भनेको निर्देशनहरू हो getelementptr dereferencing कार्यहरू प्रदर्शन गर्दैन। यो केवल अवस्थित एक मा आधारित नयाँ सूचक गणना गर्दछ। यसलाई निर्देशनको रूपमा लिन सकिन्छ mul и add हार्डवेयर स्तर मा। तपाईले GEP निर्देशनहरूको बारेमा थप पढ्न सक्नुहुन्छ यहाँ.

यो मध्यवर्ती कोड को अर्को रोचक विशेषता निर्देशन को प्रयोग हो icmp। यो पूर्णांक तुलनाहरू लागू गर्न प्रयोग गरिने सामान्य उद्देश्य निर्देशन हो। यस निर्देशनको नतिजा सधैं प्रकारको मान हो i1 - तार्किक मूल्य। यस अवस्थामा, कुञ्जी शब्द प्रयोग गरेर तुलना गरिन्छ slt (हस्ताक्षर भन्दा कम), किनकि हामी पहिले प्रकार द्वारा प्रतिनिधित्व गरिएको दुई संख्याहरू तुलना गर्दैछौं int। यदि हामी दुई अहस्ताक्षरित पूर्णाङ्कहरू तुलना गर्दै थियौं भने, हामी प्रयोग गर्नेछौं icmp, र तुलनामा प्रयोग गरिएको कुञ्जी शब्द हुनेछ ult। फ्लोटिंग बिन्दु संख्याहरू तुलना गर्न, अर्को निर्देशन प्रयोग गरिन्छ, fcmp, जसले समान रूपमा काम गर्दछ।

परिणामहरू

मलाई विश्वास छ कि यस सामग्रीमा मैले LLVM IR को सबैभन्दा महत्त्वपूर्ण विशेषताहरू समावेश गरेको छु। निस्सन्देह, यहाँ धेरै धेरै छ। विशेष गरी, कोडको मध्यवर्ती प्रतिनिधित्वले धेरै एनोटेसनहरू समावेश गर्न सक्छ जसले अनुकूलन पासहरूलाई कम्पाइलरलाई ज्ञात कोडका केही सुविधाहरूलाई ध्यानमा राख्न अनुमति दिन्छ जुन अन्यथा IR मा व्यक्त गर्न सकिँदैन। उदाहरणका लागि, यो झण्डा हो inbounds GEP निर्देशनहरू, वा झण्डाहरू nsw и nuw, जुन निर्देशनहरूमा थप्न सकिन्छ add। त्यहि कुञ्जी शब्दको लागि जान्छ private, अप्टिमाइजरलाई संकेत गर्दै कि यसले चिन्ह लगाउने प्रकार्य हालको संकलन एकाई बाहिरबाट सन्दर्भ गरिने छैन। यसले प्रयोग नगरिएका तर्कहरू हटाउने जस्ता धेरै रोचक अन्तरप्रक्रियात्मक अप्टिमाइजेसनहरूको लागि अनुमति दिन्छ।

तपाईले LLVM को बारेमा थप पढ्न सक्नुहुन्छ कागजात, जुन तपाइँ तपाइँको आफ्नै LLVM- आधारित कम्पाइलर विकास गर्दा प्राय: सन्दर्भ गर्नुहुनेछ। यहाँ गाईड, जसले धेरै सरल भाषाको लागि कम्पाइलर विकास गर्न हेर्छ। तपाईंको आफ्नै कम्पाइलर सिर्जना गर्दा जानकारीका यी दुवै स्रोतहरू तपाईंको लागि उपयोगी हुनेछ।

प्रिय पाठकहरु! के तपाइँ LLVM प्रयोग गर्दै हुनुहुन्छ?

स्रोत: www.habr.com