हम स्विफ्ट कंपाइलर का अध्ययन करना जारी रखते हैं। यह हिस्सा स्विफ्ट इंटरमीडिएट भाषा को समर्पित है।

यदि आपने पिछले वाले नहीं देखे हैं, तो मेरा सुझाव है कि आप लिंक का अनुसरण करें और पढ़ें:

• घटकों का सामान्य अवलोकन ।
• स्रोत फ़ाइल पार्स कर रहा है ।

SILGen

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

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

इस फॉर्म के लिए धन्यवाद, कंपाइलर के लिए कोड को ऑप्टिमाइज़ करना आसान है। नीचे छद्म कोड पर एक उदाहरण है। जाहिर है, पहली पंक्ति अनावश्यक है:

a = 1 a = 2 b = a 

लेकिन यह केवल हमारे लिए है। यह निर्धारित करने के लिए संकलक को पढ़ाने के लिए, किसी को गैर-तुच्छ एल्गोरिदम लिखना होगा। लेकिन एसएसए के साथ, यह बहुत आसान है। अब, एक साधारण संकलक के लिए भी, यह स्पष्ट होगा कि चर a1 के मान का उपयोग नहीं किया गया है, और यह रेखा निम्न हो सकती है:

 a1 = 1 a2 = 2 b1 = a2 

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

एसआईएल जेनरेटर का उपयोग करना

SIL उत्पन्न करने के लिए, -emit-silgen ध्वज का उपयोग करें:

 swiftc -emit-silgen main.swift 

आदेश का परिणाम:

 sil_stage raw import Builtin import Swift import SwiftShims let x: Int // x sil_global hidden [let] @$S4main1xSivp : $Int // main sil @main : $@convention(c) (Int32, UnsafeMutablePointer<Optional<UnsafeMutablePointer<Int8>>>) -> Int32 { bb0(%0 : $Int32, %1 : $UnsafeMutablePointer<Optional<UnsafeMutablePointer<Int8>>>): alloc_global @$S4main1xSivp // id: %2 %3 = global_addr @$S4main1xSivp : $*Int // user: %8 %4 = metatype $@thin Int.Type // user: %7 %5 = integer_literal $Builtin.Int2048, 16 // user: %7 // function_ref Int.init(_builtinIntegerLiteral:) %6 = function_ref @$SSi22_builtinIntegerLiteralSiBi2048__tcfC : $@convention(method) (Builtin.Int2048, @thin Int.Type) -> Int // user: %7 %7 = apply %6(%5, %4) : $@convention(method) (Builtin.Int2048, @thin Int.Type) -> Int // user: %8 store %7 to [trivial] %3 : $*Int // id: %8 %9 = integer_literal $Builtin.Int32, 0 // user: %10 %10 = struct $Int32 (%9 : $Builtin.Int32) // user: %11 return %10 : $Int32 // id: %11 } // end sil function 'main' // Int.init(_builtinIntegerLiteral:) sil [transparent] [serialized] @$SSi22_builtinIntegerLiteralSiBi2048__tcfC : $@convention(method) (Builtin.Int2048, @thin Int.Type) -> Int 

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

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

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

उदाहरण के लिए, टाइप 2048 का पूर्णांक शाब्दिक और 16 का मान। इस रेखा पर बनाया गया है। यह शाब्दिक पांचवें रजिस्टर में संग्रहीत है और इसका उपयोग सातवें के मान की गणना करने के लिए किया जाएगा:

 %5 = integer_literal $Builtin.Int2048, 16 // user: %7 

एक फ़ंक्शन घोषणा कीवर्ड के साथ शुरू होती है। निम्नलिखित @ @ उपसर्ग के साथ नाम है, सम्मेलन, मापदंडों, रिटर्न प्रकार, और फ़ंक्शन कोड को कॉल करना। Int.init initializer के लिए (_builtinIntegerLiteral :), यह, निश्चित रूप से, निर्दिष्ट नहीं है, क्योंकि यह फ़ंक्शन किसी अन्य मॉड्यूल से है, और इसे केवल घोषित करने की आवश्यकता है, लेकिन परिभाषित नहीं। एक डॉलर का संकेत एक प्रकार के संकेत की शुरुआत को दर्शाता है:

 // Int.init(_builtinIntegerLiteral:) sil [transparent] [serialized] @$SSi22_builtinIntegerLiteralSiBi2048__tcfC : $@convention(method) (Builtin.Int2048, @thin Int.Type) -> Int 

अधिवेशन बुलाना इंगित करता है कि किसी फ़ंक्शन को ठीक से कैसे कॉल करें। यह मशीन कोड उत्पन्न करने के लिए आवश्यक है। इन सिद्धांतों का विस्तृत विवरण इस लेख के दायरे से परे है।

इनिशियलाइज़र का नाम, साथ ही संरचनाओं, वर्गों, विधियों, प्रोटोकॉल के नाम विकृत हैं (नाम मैन्ग्रिंग)। यह एक ही बार में कई समस्याओं को हल करता है।

सबसे पहले, यह विभिन्न मॉड्यूल और नेस्टेड संस्थाओं में समान नामों का उपयोग करने की अनुमति देता है। उदाहरण के लिए, पहली विधि fff के लिए , S4main3AAAV3fffSiyF नाम का उपयोग किया जाता है , और दूसरे के लिए, S4main3BBBV3fffSiyF का उपयोग किया जाता है :

 struct AAA { func fff() -> Int { return 8 } } struct BBB { func fff() -> Int { return 8 } } 

एस का मतलब है स्विफ्ट, 4 मॉड्यूल नाम में वर्णों की संख्या है, और 3 वर्ग नाम में है। शाब्दिक इनिशियलाइज़र में, Si मानक प्रकार Swift.Int को दर्शाता है।

दूसरे, नाम में फ़ंक्शन तर्कों के नाम और प्रकार जोड़े जाते हैं। यह अधिभार के उपयोग की अनुमति देता है। उदाहरण के लिए, पहली विधि के लिए, S4main3AAAV3fff3iiiS2i_tF उत्पन्न होता है, और दूसरे के लिए - S4main3AAAV3fff3dddSiSd_tF :

 struct AAA { func fff(iii internalName: Int) -> Int { return 8 } func fff(ddd internalName: Double) -> Int { return 8 } } 

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

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

मुख्य फ़ंक्शन में एक आधार इकाई होती है, जो फ़ंक्शन में दिए गए सभी मापदंडों को इनपुट के रूप में लेती है और इसके सभी कोड होते हैं, क्योंकि इसमें कोई शाखाएं नहीं हैं:

 bb0(%0 : $Int32, %1 : $UnsafeMutablePointer<Optional<UnsafeMutablePointer<Int8>>>): 

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

 // before if 2 > 5 { // true } else { // false } // after 

इस स्थिति में, कम से कम 4 बेस ब्लॉक के लिए जनरेट किया जाएगा:

• ब्रांचिंग से पहले कोड,
• ऐसे मामले जब अभिव्यक्ति सही है
• ऐसे मामले जब अभिव्यक्ति झूठी है
• ब्रांचिंग के बाद कोड।

cond_br - सशर्त कूद के लिए निर्देश। यदि छद्म-रजिस्टर% 14 का मान सत्य है, तो bb1 को अवरुद्ध करने के लिए संक्रमण किया जाता है । यदि नहीं, तो bb2 में । br - बिना शर्त कूद जो निर्दिष्ट बेस ब्लॉक का निष्पादन शुरू करता है:

 // before cond_br %14, bb1, bb2 // id: %15 bb1: // true br bb3 // id: %21 bb2: // Preds: bb0 // false br bb3 // id: %27 bb3: // Preds: bb2 bb1 // after 

स्रोत कोड:

• सिलिकॉन कार्यान्वयन फ़ाइलें ,
• एसआई हैडर फाइलें ,
• एसआई कार्यान्वयन फ़ाइलें ,
• एसआईएल प्रलेखन ।

एसआईएल ने परिवर्तनों की गारंटी दी

अंतिम चरण में प्राप्त किए गए कच्चे मध्यवर्ती प्रतिनिधित्व को शुद्धता के लिए विश्लेषित किया जाता है और विहित में रूपांतरित किया जाता है: चिह्नित कार्य पारदर्शी इनलाइन होते हैं (फ़ंक्शन कॉल को इसके शरीर द्वारा प्रतिस्थापित किया जाता है), निरंतर अभिव्यक्तियों के मूल्यों की गणना की जाती है, फ़ंक्शन की जाँच की जाती है कि मान वापस करने वाले फ़ंक्शन सभी कोड शाखाओं और इतने पर ऐसा करें।

ये रूपांतरण अनिवार्य हैं और कोड ऑप्टिमाइज़ेशन अक्षम होने पर भी किए जाते हैं।

कैनन एसआई जनरेशन

विहित एसआईएल उत्पन्न करने के लिए, -मिट-साइल फ्लैग का उपयोग किया जाता है:

 swiftc -emit-sil main.swift 

आदेश का परिणाम:

 sil_stage canonical import Builtin import Swift import SwiftShims let x: Int // x sil_global hidden [let] @$S4main1xSivp : $Int // main sil @main : $@convention(c) (Int32, UnsafeMutablePointer<Optional<UnsafeMutablePointer<Int8>>>) -> Int32 { bb0(%0 : $Int32, %1 : $UnsafeMutablePointer<Optional<UnsafeMutablePointer<Int8>>>): alloc_global @$S4main1xSivp // id: %2 %3 = global_addr @$S4main1xSivp : $*Int // user: %6 %4 = integer_literal $Builtin.Int64, 16 // user: %5 %5 = struct $Int (%4 : $Builtin.Int64) // user: %6 store %5 to %3 : $*Int // id: %6 %7 = integer_literal $Builtin.Int32, 0 // user: %8 %8 = struct $Int32 (%7 : $Builtin.Int32) // user: %9 return %8 : $Int32 // id: %9 } // end sil function 'main' // Int.init(_builtinIntegerLiteral:) sil public_external [transparent] [serialized] @$SSi22_builtinIntegerLiteralSiBi2048__tcfC : $@convention(method) (Builtin.Int2048, @thin Int.Type) -> Int { // %0 // user: %2 bb0(%0 : $Builtin.Int2048, %1 : $@thin Int.Type): %2 = builtin "s_to_s_checked_trunc_Int2048_Int64"(%0 : $Builtin.Int2048) : $(Builtin.Int64, Builtin.Int1) // user: %3 %3 = tuple_extract %2 : $(Builtin.Int64, Builtin.Int1), 0 // user: %4 %4 = struct $Int (%3 : $Builtin.Int64) // user: %5 return %4 : $Int // id: %5 } // end sil function '$SSi22_builtinIntegerLiteralSiBi2048__tcfC' 

इस तरह के एक सरल उदाहरण में कुछ बदलाव हैं। ऑप्टिमाइज़र के वास्तविक काम को देखने के लिए, आपको कोड को थोड़ा जटिल करना होगा। उदाहरण के लिए, इसके अलावा जोड़ें:

 let x = 16 + 8 

उनके कच्चे एसआईएल में, आप इन शाब्दिक बातों को जोड़ सकते हैं:

 %13 = function_ref @$SSi1poiyS2i_SitFZ : $@convention(method) (Int, Int, @thin Int.Type) -> Int // user: %14 %14 = apply %13(%8, %12, %4) : $@convention(method) (Int, Int, @thin Int.Type) -> Int // user: %15 

लेकिन विहित में अब यह नहीं है। इसके बजाय, 24 का एक निरंतर मूल्य उपयोग किया जाता है:

 %4 = integer_literal $Builtin.Int64, 24 // user: %5 

स्रोत कोड:

• एसआई ऑप्टिमाइज़र अनिवार्य

सिल अनुकूलन

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

स्रोत कोड:

• एसआई ऑप्टिमाइज़र हेडर
• एसआई ऑप्टिमाइज़र कार्यान्वयन फ़ाइलें

चूंकि एसआईएल एक स्विफ्ट फीचर है, इसलिए मैंने इस बार कार्यान्वयन के उदाहरण नहीं दिखाए। हम अगले भाग में कोष्ठक संकलक पर लौटेंगे जब हम LLVM IR पीढ़ी में लगे होंगे।