यह स्विफ्ट कंपाइलर की मेरी समीक्षा का अंतिम भाग है। मैं आपको दिखाता हूं कि एएसटी से एलएलवीएम आईआर कैसे उत्पन्न करें और एक वास्तविक सीमांत क्या है। यदि आपने पिछले भागों को नहीं पढ़ा है, तो लिंक का अनुसरण करें:

• सामान्य घटक अवलोकन
• स्रोत फ़ाइल पार्स कर रहा है
• मध्यवर्ती भाषा स्विफ्ट

एलएलवीएम आईआर जनरल

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

कार्यान्वयन का उदाहरण

मध्यवर्ती दृश्य उत्पन्न करने के लिए, आपको LLVM लाइब्रेरी के साथ सहभागिता करने की आवश्यकता है। यह C ++ में लिखा गया है, लेकिन चूंकि आप इसे स्विफ्ट से नहीं बुला सकते हैं, इसलिए आपको C-इंटरफ़ेस का उपयोग करना होगा। लेकिन आप सी-लाइब्रेरी की ओर रुख नहीं कर सकते।

इसे एक मॉड्यूल में लपेटने की आवश्यकता है। इसे आसान बनाएं। यहाँ एक अच्छा निर्देश है। एलएलवीएम के लिए, ऐसा आवरण पहले से ही सार्वजनिक डोमेन में मौजूद है, इसलिए इसे लेना आसान है।

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

एक मध्यवर्ती दृश्य उत्पन्न करने के लिए, संबंधित LLVMIRGen वर्ग बनाया गया था। शुरुआती में, यह पार्सर द्वारा बनाई गई एएसटी लेता है:

import cllvm class LLVMIRGen { private let ast: ASTNode init(ast: ASTNode) { self.ast = ast } 

PrintTo (_, डंप) विधि पीढ़ी शुरू करती है और इसे पठनीय रूप में एक फ़ाइल में सहेजती है। डंप पैरामीटर का उपयोग कंसोल में समान जानकारी को वैकल्पिक रूप से आउटपुट करने के लिए किया जाता है:

 func printTo(_ fileName: String, dump: Bool) { 

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

 let module = generateModule() defer { LLVMDisposeModule(module) } 

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

 let builder = generateBuilder() defer { LLVMDisposeBuilder(builder) } 

मानक पुट फ़ंक्शन का उपयोग करके कोष्ठक से कंसोल तक संख्या का उत्पादन किया जाएगा। उससे संपर्क करने के लिए, आपको इसे घोषित करने की आवश्यकता है। यह generateExternalPutsFunction विधि में होता है। मॉड्यूल को इसे पारित किया जाता है क्योंकि घोषणा को इसमें जोड़ने की आवश्यकता होती है। PutFunction स्थिरांक एक पॉइंटर को एक फंक्शन में स्टोर करेगा ताकि इसे एक्सेस किया जा सके:

 let putsFunction = generateExternalPutsFunction(module: module) 

एसआईएफ चरण में स्विफ्ट कंपाइलर ने मुख्य कार्य किया। चूंकि ब्रेस कंपाइलर में ऐसा मध्यवर्ती प्रतिनिधित्व नहीं है, इसलिए फ़ंक्शन एलएलवीएम आईआर में तुरंत उत्पन्न होगा।

ऐसा करने के लिए, generateMainFunction विधि (बिल्डर, मॉड्यूल, mainInternalGenerator) का उपयोग करें । मुख्य कार्य नहीं कहा जाएगा। इसलिए, आपको इसके लिए सूचक को सहेजने की आवश्यकता नहीं है:

 generateMainFunction(builder: builder, module: module) { // ... } 

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

 generateMainFunction(builder: builder, module: module) { handleAST(ast, putsFunction: putsFunction, builder: builder) } 

विधि के अंत में, परिणामी मध्यवर्ती प्रतिनिधित्व कंसोल में आउटपुट होता है और फ़ाइल में सहेजा जाता है:

 if dump { LLVMDumpModule(module) } LLVMPrintModuleToFile(module, fileName, nil) 

अब और तरीकों के बारे में। मॉड्यूल वांछित नाम के साथ LLVMModuleCreateWithName () फ़ंक्शन को कॉल करके उत्पन्न होता है:

 private func generateModule() -> LLVMModuleRef { let moduleName = "BraceCompiller" return LLVMModuleCreateWithName(moduleName) } 

बिल्डर को और भी आसान बनाया गया है। उसे मापदंडों की आवश्यकता नहीं है:

 private func generateBuilder() -> LLVMBuilderRef { return LLVMCreateBuilder() } 

एक फ़ंक्शन घोषित करने के लिए, आपको सबसे पहले इसके पैरामीटर के लिए मेमोरी आवंटित करने और इसमें Int8 को एक पॉइंटर को बचाने की आवश्यकता है। अगला, फ़ंक्शन का प्रकार बनाने के लिए LLVMFunctionType () को कॉल करें, इसे रिटर्न वैल्यू के प्रकार से गुजरते हुए, तर्क प्रकारों का एक सरणी (सी-सरणी मूल्यों के संगत अनुक्रम के लिए एक संकेतक है) और उनकी संख्या। LLVMAddFunction () मॉड्यूल में पुट फ़ंक्शन जोड़ता है और इसके लिए एक पॉइंटर लौटाता है:

 private func generateExternalPutsFunction(module: LLVMModuleRef) -> LLVMValueRef { var putParamTypes = UnsafeMutablePointer<LLVMTypeRef?>.allocate(capacity: 1) defer { putParamTypes.deallocate() } putParamTypes[0] = LLVMPointerType(LLVMInt8Type(), 0) let putFunctionType = LLVMFunctionType(LLVMInt32Type(), putParamTypes, 1, 0) return LLVMAddFunction(module, "puts", putFunctionType) } 

मुख्य एक समान तरीके से बनाया गया है, लेकिन इसमें एक निकाय जोड़ा जाता है। एसआईएल की तरह, इसमें बेस ब्लॉक होते हैं। ऐसा करने के लिए, LLVMAppendBasicBlock () विधि को कॉल करें, फ़ंक्शन और इसे करने के लिए ब्लॉक का नाम गुजर रहा है।

अब बिल्डर खेल में आता है। LLVMPositionBuilderAtEnd () कॉल करके, यह अभी भी खाली ब्लॉक के अंत में चला जाता है, और क्लोजर मेनइंटरटेनर () के अंदर, फ़ंक्शन बॉडी को इसके साथ जोड़ा जाएगा।

विधि के अंत में, निरंतर मान 0 मुख्य से लौटाया जाता है। यह इस कार्य में अंतिम निर्देश है:

 private func generateMainFunction(builder: LLVMBuilderRef, module: LLVMModuleRef, mainInternalGenerator: () -> Void) { let mainFunctionType = LLVMFunctionType(LLVMInt32Type(), nil, 0, 0) let mainFunction = LLVMAddFunction(module, "main", mainFunctionType) let mainEntryBlock = LLVMAppendBasicBlock(mainFunction, "entry") LLVMPositionBuilderAtEnd(builder, mainEntryBlock) mainInternalGenerator() let zero = LLVMConstInt(LLVMInt32Type(), 0, 0) LLVMBuildRet(builder, zero) } 

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

 private func handleAST(_ ast: ASTNode, putsFunction: LLVMValueRef, builder: LLVMBuilderRef) { switch ast { case let .brace(childNode): guard let childNode = childNode else { break } handleAST(childNode, putsFunction: putsFunction, builder: builder) case let .number(value): generatePrint(value: value, putsFunction: putsFunction, builder: builder) } } 

पुट्स कॉल LLVMBuildCall () फ़ंक्शन का उपयोग करके उत्पन्न होता है । इसके लिए एक बिल्डर, एक सूचक को एक फ़ंक्शन, तर्क और उनकी संख्या को पास करना होगा। LLVMBuildGlobalStringPtr () एक स्ट्रिंग को पकड़ने के लिए एक वैश्विक स्थिरांक बनाता है। वह एकमात्र तर्क होगा:

 private func generatePrint(value: Int, putsFunction: LLVMValueRef, builder: LLVMBuilderRef) { let putArgumentsSize = MemoryLayout<LLVMValueRef?>.size let putArguments = UnsafeMutablePointer<LLVMValueRef?>.allocate(capacity: 1) defer { putArguments.deallocate() } putArguments[0] = LLVMBuildGlobalStringPtr(builder, "\(value)", "print") _ = LLVMBuildCall(builder, putsFunction, putArguments, 1, "put") } 

LLVM IR पीढ़ी शुरू करने के लिए, आपको LLVMIRGen वर्ग का एक उदाहरण बनाने और PrintTo (_, डंप) विधि को कॉल करने की आवश्यकता है :

 let llvmIRGen = LLVMIRGen(ast: ast) llvmIRGen.printTo(outputFilePath, dump: false) 

चूंकि अब कोष्ठक संकलक पूरी तरह से तैयार है, आप इसे कमांड लाइन से शुरू कर सकते हैं। ऐसा करने के लिए, आपको इसे ( निर्देश ) एकत्र करना होगा और कमांड निष्पादित करना होगा:

 build/debug/BraceCompiler Example/input.b Example/output.ll 

परिणाम यह मध्यवर्ती प्रतिनिधित्व है:

 ; ModuleID = 'BraceCompiller' source_filename = "BraceCompiller" @print = private unnamed_addr constant [5 x i8] c"5678\00" declare i32 @puts(i8*) define i32 @main() { entry: %put = call i32 @puts(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @print, i32 0, i32 0)) ret i32 0 } 

एलएलवीएम आईआर स्विफ्ट जनरेटर का उपयोग करना

एलएलवीएम आईआर में एक एसएसए रूप भी है, लेकिन यह निम्न स्तर का है और कोडांतरक की तरह अधिक है। निर्देशों का विवरण प्रलेखन में पाया जा सकता है।

वैश्विक पहचानकर्ता % के साथ b> @ </ b , स्थानीय से शुरू होते हैं। ऊपर दिए गए उदाहरण में, स्ट्रिंग "5678 \ 00" को वैश्विक स्थिर b> @print </ b में संग्रहीत किया जाता है, और फिर कॉल स्टेटमेंट का उपयोग करके फ़ंक्शन b> @puts </ b को कॉल किया जाता है।

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

 let x = 16 let y = x + 7 

-Emit-ir ध्वज LLVM IR उत्पन्न करने के लिए जिम्मेदार है:

 swiftc -emit-ir main.swift 

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

 ; ModuleID = '-' source_filename = "-" target datalayout = "em:o-i64:64-f80:128-n8:16:32:64-S128" target triple = "x86_64-apple-macosx10.14.0" %TSi = type <{ i64 }> @"$S4main1xSivp" = hidden global %TSi zeroinitializer, align 8 @"$S4main1ySivp" = hidden global %TSi zeroinitializer, align 8 @__swift_reflection_version = linkonce_odr hidden constant i16 3 @llvm.used = appending global [1 x i8*] [i8* bitcast (i16* @__swift_reflection_version to i8*)], section "llvm.metadata", align 8 define i32 @main(i32, i8**) #0 { entry: %2 = bitcast i8** %1 to i8* store i64 16, i64* getelementptr inbounds (%TSi, %TSi* @"$S4main1xSivp", i32 0, i32 0), align 8 %3 = load i64, i64* getelementptr inbounds (%TSi, %TSi* @"$S4main1xSivp", i32 0, i32 0), align 8 %4 = call { i64, i1 } @llvm.sadd.with.overflow.i64(i64 %3, i64 7) %5 = extractvalue { i64, i1 } %4, 0 %6 = extractvalue { i64, i1 } %4, 1 br i1 %6, label %8, label %7 ; <label>:7: ; preds = %entry store i64 %5, i64* getelementptr inbounds (%TSi, %TSi* @"$S4main1ySivp", i32 0, i32 0), align 8 ret i32 0 ; <label>:8: ; preds = %entry call void @llvm.trap() unreachable } ; Function Attrs: nounwind readnone speculatable declare { i64, i1 } @llvm.sadd.with.overflow.i64(i64, i64) #1 ; Function Attrs: noreturn nounwind declare void @llvm.trap() #2 attributes #0 = { "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "target-cpu"="penryn" "target-features"="+cx16,+fxsr,+mmx,+sahf,+sse,+sse2,+sse3,+sse4.1,+ssse3,+x87" } attributes #1 = { nounwind readnone speculatable } attributes #2 = { noreturn nounwind } !llvm.module.flags = !{!0, !1, !2, !3, !4, !5, !6, !7} !llvm.linker.options = !{!8, !9, !10} !llvm.asan.globals = !{!11} !0 = !{i32 1, !"Objective-C Version", i32 2} !1 = !{i32 1, !"Objective-C Image Info Version", i32 0} !2 = !{i32 1, !"Objective-C Image Info Section", !"__DATA,__objc_imageinfo,regular,no_dead_strip"} !3 = !{i32 4, !"Objective-C Garbage Collection", i32 1536} !4 = !{i32 1, !"Objective-C Class Properties", i32 64} !5 = !{i32 1, !"wchar_size", i32 4} !6 = !{i32 7, !"PIC Level", i32 2} !7 = !{i32 1, !"Swift Version", i32 6} !8 = !{!"-lswiftSwiftOnoneSupport"} !9 = !{!"-lswiftCore"} !10 = !{!"-lobjc"} !11 = !{[1 x i8*]* @llvm.used, null, null, i1 false, i1 true} 

एक वास्तविक संकलक का मध्यवर्ती प्रतिनिधित्व थोड़ा अधिक जटिल है। इसमें अतिरिक्त ऑपरेशन हैं, लेकिन आवश्यक निर्देश ढूंढना मुश्किल नहीं है। यहां वैश्विक स्थिरांक x और y विकृत नामों के साथ घोषित किए गए हैं:

 @"$S4main1xSivp" = hidden global %TSi zeroinitializer, align 8 @"$S4main1ySivp" = hidden global %TSi zeroinitializer, align 8 

यहाँ मुख्य कार्य की परिभाषा शुरू होती है:

 define i32 @main(i32, i8**) #0 { 

सबसे पहले, मान 16 इसे स्थिर x में संग्रहीत किया जाता है:

 store i64 16, i64* getelementptr inbounds (%TSi, %TSi* @"$S4main1xSivp", i32 0, i32 0), align 8 

फिर इसे रजिस्टर 3 में लोड किया जाता है और शाब्दिक 7 के साथ कॉल करने के लिए उपयोग किया जाता है:

 %3 = load i64, i64* getelementptr inbounds (%TSi, %TSi* @"$S4main1xSivp", i32 0, i32 0), align 8 %4 = call { i64, i1 } @llvm.sadd.with.overflow.i64(i64 %3, i64 7) 

अतिप्रवाह चेक अतिरिक्त रिटर्न संरचना। इसका पहला मूल्य जोड़ का परिणाम है, और दूसरा एक झंडा है जो इंगित करता है कि क्या कोई अतिप्रवाह था।

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

 %5 = extractvalue { i64, i1 } %4, 0 %6 = extractvalue { i64, i1 } %4, 1 

अब ओवरफ्लो संकेत छठे रजिस्टर में संग्रहीत किया जाता है। यह मान शाखा निर्देश का उपयोग करके सत्यापित किया जाता है। यदि कोई अतिप्रवाह था, तो लेबल 7 ब्लॉक को संक्रमण होगा, यदि नहीं, तो लेबल 7 को :

 br i1 %6, label %8, label %7 

इनमें से सबसे पहले, ट्रैप () को कॉल करने से प्रोग्राम का निष्पादन बाधित होता है। दूसरे में, जोड़ का परिणाम स्थिर y में संग्रहीत होता है, और 0 को मुख्य फ़ंक्शन से लौटाया जाता है:

 ; <label>:7: ; preds = %entry store i64 %5, i64* getelementptr inbounds (%TSi, %TSi* @"$S4main1ySivp", i32 0, i32 0), align 8 ret i32 0 ; <label>:8: ; preds = %entry call void @llvm.trap() unreachable 

विधानसभा कोड पीढ़ी

स्विफ्ट कंपाइलर असेंबली कोड भी प्रदर्शित कर सकता है। ऐसा करने के लिए, -मिट-असेंबली ध्वज को पास करें:

 swiftc -emit-assembly main.swift 

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

  .section __TEXT,__text,regular,pure_instructions .build_version macos, 10, 14 .globl _main .p2align 4, 0x90 _main: .cfi_startproc pushq %rbp .cfi_def_cfa_offset 16 .cfi_offset %rbp, -16 movq %rsp, %rbp .cfi_def_cfa_register %rbp movq $16, _$S4main1xSivp(%rip) movq _$S4main1xSivp(%rip), %rax addq $7, %rax seto %cl movl %edi, -4(%rbp) movq %rsi, -16(%rbp) movq %rax, -24(%rbp) movb %cl, -25(%rbp) jo LBB0_2 xorl %eax, %eax movq -24(%rbp), %rcx movq %rcx, _$S4main1ySivp(%rip) popq %rbp retq LBB0_2: ud2 .cfi_endproc .private_extern _$S4main1xSivp .globl _$S4main1xSivp .zerofill __DATA,__common,_$S4main1xSivp,8,3 .private_extern _$S4main1ySivp .globl _$S4main1ySivp .zerofill __DATA,__common,_$S4main1ySivp,8,3 .private_extern ___swift_reflection_version .section __TEXT,__const .globl ___swift_reflection_version .weak_definition ___swift_reflection_version .p2align 1 ___swift_reflection_version: .short 3 .no_dead_strip ___swift_reflection_version .linker_option "-lswiftSwiftOnoneSupport" .linker_option "-lswiftCore" .linker_option "-lobjc" .section __DATA,__objc_imageinfo,regular,no_dead_strip L_OBJC_IMAGE_INFO: .long 0 .long 1600 .subsections_via_symbols 

ऊपर वर्णित मध्यवर्ती प्रतिनिधित्व के कोड को समझने के बाद, आप कोडांतरक निर्देश पा सकते हैं जो इसे उत्पन्न करता है। यहां 16 को एक स्थिर में संग्रहीत किया जा रहा है और इसे % rax रजिस्टर में लोड किया जा रहा है:

 movq $16, _$S4main1xSivp(%rip) movq _$S4main1xSivp(%rip), %rax 

यहाँ 7 और स्थिरांक का मान है। परिणाम का परिणाम % rax रजिस्टर में रखा गया है:

 addq $7, %rax 

और यह इस प्रकार है कि स्थिर y में परिणाम लोड हो रहा है:

 movq %rax, -24(%rbp) movq -24(%rbp), %rcx movq %rcx, _$S4main1ySivp(%rip) 

स्रोत कोड:

• आईआर जनरल

निष्कर्ष

स्विफ्ट एक अच्छी तरह से संरचित कंपाइलर है, और इसकी सामान्य वास्तुकला का पता लगाना मुश्किल नहीं था। मुझे यह भी आश्चर्य हुआ कि एलएलवीएम का उपयोग करके, आप आसानी से अपनी खुद की प्रोग्रामिंग भाषा लिख ​​सकते हैं। बेशक, कोष्ठक संकलक बहुत ही आदिम है, लेकिन बहुरूपदर्शक कार्यान्वयन भी वास्तव में समझने योग्य है। मैं ट्यूटोरियल से कम से कम पहले तीन अध्यायों को पढ़ने की सलाह देता हूं।

जो भी पढ़े उसका धन्यवाद। मैं स्विफ्ट कंपाइलर का अध्ययन करना जारी रखूंगा और शायद इसके बारे में लिखूंगा। उससे जुड़े किन विषयों में आपकी रुचि होगी?

उपयोगी लिंक:

• आधिकारिक स्विफ्ट वेबसाइट
• आधिकारिक मंच
• तेजी से विकास
• प्राथमिक भंडार
• LLVM
• बहुरूपदर्शक ट्यूटोरियल
• कोष्ठक संकलक