संकलन। 5 और 1/2: बैक-एंड के रूप में llvm

Tyomitch "संकलन" ( यहाँ , यहाँ , यहाँ , यहाँ , यहाँ और यहाँ ), के लेखों की एक श्रृंखला में 4 भागों में वर्णित jsk खिलौना भाषा के अनुवादक के निर्माण पर विचार किया गया था ।

इस अनुवादक के लिए एक बैक-एंड के रूप में, टाइमॉच ने एक बाईटेकोड कार्यान्वयन और इस बाइटेकोड के लिए एक दुभाषिया प्रस्तावित किया।



मेरी राय में, बैकएंड के लिए मौजूदा समाधानों का उपयोग करने के लिए एक अधिक उचित दृष्टिकोण होगा, उदाहरण के लिए llvm, और "ठोस वाक्यों के बिना आलोचना के सिद्धांत - आलोचना" के सिद्धांत का पालन करते हुए, मैं ll llm के साथ इस छोटी jsk भाषा के लिए एक कार्यान्वयन विकल्प प्रस्तावित करता हूं।



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

फ्रंट-एंड डेवलपर के दृष्टिकोण से llvm कैसे काम करेगा?

काम करने के लिए llvm के लिए, आपको एक संदर्भ बनाने की आवश्यकता है, इसका उपयोग मॉड्यूल बनाने के लिए करें। प्रत्येक मॉड्यूल में कई कार्य हो सकते हैं। चूंकि jsk फ़ंक्शंस का समर्थन नहीं करता है, हम एक फ़ंक्शन - मुख्य () बनाएंगे।

प्रत्येक फ़ंक्शन में कोड के कई ब्लॉक हो सकते हैं।

कोड ब्लॉक क्या है?

अक्सर प्रोग्राम एक लेबल पर नियंत्रण को स्थानांतरित करने की आवश्यकता पैदा करते हैं जो अभी तक परिभाषित नहीं है। libjit आपको पहले एक लेबल बनाने और उपयोग करने की अनुमति देता है, और इसे बाद में परिभाषित करता है, Gnu llightning आपको कोड को नियंत्रण स्थानान्तरण लिखने की अनुमति देता है, और बाद में वांछित पते को बदलने के लिए इस कोड को पैच करता है, और llvm पूरी तरह से अलग दृष्टिकोण - कोड ब्लॉक का उपयोग करता है।



यही है, llvm एपीआई एक लेबल के रूप में ऐसी बात नहीं जानता है। यदि आपको नियंत्रण स्थानांतरित करने की आवश्यकता है, तो कोड ब्लॉक का एक लिंक कमांड को दिया जाता है। उदाहरण के लिए, निर्माण के लिए



if then else endif









LLVM API में, आपको तत्कालीन शाखा के लिए कोड ब्लॉक बनाने की जरूरत है, अन्य शाखा के लिए एक कोड ब्लॉक और इन ब्लॉकों को सशर्त शाखा कमांड में निर्दिष्ट करना होगा। कुछ इस तरह



BasicBlock *ThenBB = BasicBlock::Create(context, "");

BasicBlock *ElseBB = BasicBlock::Create(context, "");

BasicBlock *AfterIfBB = BasicBlock::Create(context, "");

Builder.CreateCondBr(CondV, ThenBB, ElseBB);



ThenBB, ElseBB, AfterIfBB.









वास्तविक कोड पीढ़ी के लिए, IRBuilder का उपयोग किया जाता है, जिसमें सभी LLVM कमांड उत्पन्न करने के लिए (लगभग बोलने वाले) तरीके होते हैं।

आपके द्वारा सभी कोड बनाए जाने के बाद, आगे क्या है?

यह हमारे विवेक पर है। हम केवल llvm मॉड्यूल के डंप () पद्धति का उपयोग करके पठनीय रूप में प्राप्त बायटेकोड को प्रिंट कर सकते हैं, कोड को निष्पादित कर सकते हैं (अर्थात, JIT कंपाइलर के रूप में llvm का उपयोग करें), या, हमारे मामले के लिए और अधिक सही ढंग से, फ़ाइल में बायटेकोड को सहेजें। यह हमें इस बाइट कोड को और अधिक ऑप्टिमाइज़ करने और मानक llvm टूल का उपयोग करके एक निष्पादन योग्य फ़ाइल में बदलने की अनुमति देगा।



इस प्रकार,

लक्ष्य परिभाषित हैं, कार्य निर्धारित हैं, कामरेड काम करते हैं

मैं यहां सभी कोड नहीं डाल सकता, अगर कोई भी स्रोतों के साथ खेलना चाहता है, तो संग्रह यहां या यहां उपलब्ध है ।

सबसे पहले, हमें स्रोत पाठ में कुछ हेडर शामिल करने की आवश्यकता है।

# जारी करें "llvm / DerivedTypes.h"

#include "llvm / LLVMContext.h"

#include "llvm / Module.h"

#include "llvm / Analysis / Verifier.h"

#include "llvm / Support / IRBuilder.h"

#include <llvm / support / raw_ostream.h>

#include <llvm / Bitcode / ReaderWriter.h>

नामस्थान llvm का उपयोग करना ;

इतना काफी होना चाहिए। अगला, हम संदर्भ को प्रारंभ करते हैं, मॉड्यूल, फ़ंक्शन में कोड जोड़ने के लिए मुख्य फ़ंक्शन और IRBuilder बनाते हैं



घोषणा में:

स्थिर मॉड्यूल * TheModule ;

स्थिर IRBuilder <> बिल्डर ( getGlobalContext ( ) ) ;

और कोड की शुरुआत इस प्रकार है:

LLVMContext & Context = getGlobalContext ( ) ;

TheModule = नया मॉड्यूल ( "jsk" , संदर्भ ) ;

const प्रकार * voidType = प्रकार :: getVoidTy ( संदर्भ ) ;



func_main = कास्ट < फ़ंक्शन > ( TheModule - > getOrInsertFunction ( "मुख्य" , voidType, NULL ) ) ;

func_main - > setCallingConv ( CallingConv :: C ) ;

BasicBlock * block = BasicBlock :: Create ( getGlobalContext ( ) , "code" , func_main ) ;

बिल्डर। सेटइन्स्ट्रॉफ़्ट ( ब्लॉक ) ;

कोड जनरेट करने के बाद, हम अपने डमी फंक्शन से बाहर निकलने के लिए एक रिट शून्य बनाते हैं और bytecode को a.out.bb फ़ाइल में डंप करते हैं

बिल्डर। CreateRetVoid ( ) ;



std :: string ErrStr ;

raw_fd_ostream bitcode ( "a.out.bc" , ErrStr, 0 ) ;

WriteBitcodeToFile ( TheModule, bitcode ) ;

bitcode। करीब ( ) ;

अब हमारी jsk भाषा के विशिष्ट संचालन के लिए कोड जनरेट करने के बारे में

चर

प्रत्येक चर के लिए, हम अनुदेश का उपयोग करके स्टैक पर एक स्थान आरक्षित करते हैं



%varname = alloca i32







या, एपीआई के संदर्भ में



Builder.CreateAlloca(IntegerType::get(context,32), 0, VarName.c_str());







समस्या यह है कि हम स्टैक पर एक जगह आवंटित नहीं कर सकते हैं जहां हम पहली बार चर से मिले थे। क्योंकि यदि एक लूप के बीच में एक चर होता है, तो हम चर की प्रतियों के साथ पूरे ढेर को खराब कर देंगे।



इसलिए, हमारे पास पहले से परिभाषित चर की एक सूची होनी चाहिए, और जब हम पाठ में एक चर मिलते हैं, तो जांच करें, और यदि यह पहली बार होता है, तो इसके लिए मेमोरी आवंटन को फ़ंक्शन कोड के शीर्ष पर रखें। यही है, वर्तमान फ़ंक्शन से पहला ब्लॉक लें, और इस ब्लॉक के शीर्ष पर एलोका कमांड जोड़ें। सौभाग्य से, llvm आपको केवल अंत में ही नहीं, बल्कि ब्लॉक की शुरुआत में भी कमांड लिखने की अनुमति देता है। यह कैसे किया जाता है, आप स्रोत कोड में देख सकते हैं - CreateEntryBlockAlloca () फ़ंक्शन;



परिवर्तनशील कार्य



Value *result = value->emit();

Builder.CreateStore(result,varreference);



..



store i32 %result, i32* %varreference









तदनुसार, चर का मूल्य प्राप्त करें





return Builder.CreateLoad(varref);



%val = load i32* %varref



बाइनरी और यूनरी ऑपरेशन।

यह यहाँ सरल है

स्विच ( ऑप ) {

केस '+' : रिटर्न बिल्डर। CreateAdd ( एल, आर ) ;

मामला '-' : रिटर्न बिल्डर। क्रिएटसब ( एल, आर ) ;

मामला '*' : रिटर्न बिल्डर। CreateMul ( L, R ) ;

मामला '/' : रिटर्न बिल्डर। CreateSDiv ( एल, आर ) ;

मामला '<' : tmp = बिल्डर। CreateICmpSLT ( एल, आर ) ; वापसी बिल्डर। CreateZExt ( tmp, IntegerType :: get ( getGlobalContext ( ) , 32 ) ) ;

मामला '>' : tmp = बिल्डर CreateICmpSGT ( एल, आर ) ; वापसी बिल्डर। CreateZExt ( tmp, IntegerType :: get ( getGlobalContext ( ) , 32 ) ) ;

मामला 'एल' : tmp = बिल्डर। CreateICmpSLE ( L, R ) ; वापसी बिल्डर। CreateZExt ( tmp, IntegerType :: get ( getGlobalContext ( ) , 32 ) ) ;

मामला 'जी' : tmp = बिल्डर। CreateICmpSGE ( L, R ) ; वापसी बिल्डर। CreateZExt ( tmp, IntegerType :: get ( getGlobalContext ( ) , 32 ) ) ;

मामला 'एन' : tmp = बिल्डर। CreateICmpNE ( एल, आर ) ; वापसी बिल्डर। CreateZExt ( tmp, IntegerType :: get ( getGlobalContext ( ) , 32 ) ) ;

मामला '=' : tmp = बिल्डर। CreateICmpEQ ( एल, आर ) ; वापसी बिल्डर। CreateZExt ( tmp, IntegerType :: get ( getGlobalContext ( ) , 32 ) ) ;



डिफ़ॉल्ट : त्रुटि ErrorV ( "अमान्य बाइनरी ऑपरेटर" ) ;

}

आईएफ और WHILE

जैसा कि पहले ही वर्णित है, हम कोड ब्लॉक का उपयोग करते हैं। उदाहरण के लिए IF:

मान * CondV = cond - > emit ( ) ;

// स्थिति की अभिव्यक्ति की तुलना 0 से करें

कंडव = बिल्डर। CreateICmpNE ( CondV, शून्य, "ifcond" ) ;

// IF शाखाओं के लिए कोड ब्लॉक

BasicBlock * ThenBB = BasicBlock :: Create ( getGlobalContext ( ) , "thenblock" ) ;

BasicBlock * ElseBB = BasicBlock :: Create ( getGlobalContext ( ) , "elseblock" ) ;

BasicBlock * MergeBB = BasicBlock :: बनाएँ ( getGlobalContext ( ) , "afterifblock" ) ;

// दरअसल IF के लिए ब्रांचिंग

बिल्डर। CreateCondBr ( CondV, ThenBB, ElseBB ) ;



// अगला, कोड को THEN शाखा में जोड़ें

बिल्डर। सेटइन्टरपॉइंट ( तबबीबी ) ;

यह - > फिर। उत्सर्जन ( ) ;

// "के बाद" करने के लिए "स्विच" के अंत में

बिल्डर। CreateBr ( MergeBB ) ;



TheFunction - > getBasicBlockList ( ) । push_back ( ElseBB ) ;

// अगला, ईएलएसई पलक में कोड जोड़ें

बिल्डर। सेटइन्टरपॉइंट ( ElseBB ) ;

यह - > अन्य। उत्सर्जन ( ) ;

// अंत में, "आईएफ के बाद" पर जाएं

बिल्डर। CreateBr ( MergeBB ) ;



TheFunction - > getBasicBlockList ( ) । push_back ( MergeBB ) ;

// IF के बाद, केवल MergeBB में कोड जोड़ें

बिल्डर। सेटइंस्ट्रॉफ़्ट ( मर्जबी ) ;

शून्य लौटें ;

WHILE के लिए:

BasicBlock * CondBB = BasicBlock :: Create ( getGlobalContext ( ) , "asxpr" , TheFunction ) ;

BasicBlock * LoopBB = BasicBlock :: Create ( getGlobalContext ( ) , "लूप" ) ;

BasicBlock * AfterBB = BasicBlock :: Create ( getGlobalContext ( ) , "after" ) ;

बिल्डर। CreateBr ( CondBB ) ;



// हालत ब्लॉक। यहां कोड जोड़ें। हम एक शर्त कोड उत्पन्न करते हैं, 0 से परिणाम की तुलना करें

// और अगर शर्त पूरी नहीं हुई है - AfterBB पर जाएं

बिल्डर। सेटइन्स्ट्रॉफ़्ट ( CondBB ) ;

मान * CondV = cond - > emit ( ) ;

अगर ( CondV == 0 ) वापसी 0 ;

// 0 के बराबर की तुलना करके एक बूल में हालत बदलें।

कंडव = बिल्डर। CreateICmpNE ( कोंडवी, शून्य, "व्हिलकॉन्ड" ) ;

बिल्डर। CreateCondBr ( CondV, LoopBB, AfterBB ) ;





// बॉडी ब्लॉक जबकि। हम यहां बॉडी कोड लिखते हैं, फिर WHILE कंडीशन में बदलाव करते हैं

TheFunction - > getBasicBlockList ( ) । push_back ( लूपबी ) ;

बिल्डर। सेटइन्स्ट्रॉफ़्ट ( LoopBB ) ;

मान * ऑप्स = यह - > ऑप्स। उत्सर्जन ( ) ;

बिल्डर। CreateBr ( CondBB ) ;





// ब्लॉक 'आफ्टर व्हाइल', फिलहाल हम यही कहते हैं

// कि इस ब्लॉक में निम्नलिखित सभी कोड लिखे जाने चाहिए

TheFunction - > getBasicBlockList ( ) । push_back ( AfterBB ) ;

बिल्डर। सेटइन्स्ट्रॉफ़्ट ( AfterBB ) ;

अंत में, हम अपने संकलक की कोशिश कर सकते हैं

#make

bison -d jsk.y

flex jsk.lex

g++ -O2 jsk.tab.c lex.yy.c `llvm-config --cxxflags --libs` -lrt -ldl -o jskc

jsk.tab.c: In function 'int yyparse()':

jsk.tab.c:2026: warning: deprecated conversion from string constant to 'char*'

jsk.tab.c:2141: warning: deprecated conversion from string constant to 'char*'

jsk.lex: In function 'int yylex()':

jsk.lex:34: warning: deprecated conversion from string constant to 'char*'

jsk.lex:35: warning: deprecated conversion from string constant to 'char*'

jsk.lex:39: warning: deprecated conversion from string constant to 'char*'









So. कंपाइलर तैयार है। आइए इसे कुछ परीक्षण कार्य पर आज़माएं। उदाहरण के लिए

a=b=88;

b=b+1;

echo("test4=",a," ",b,"\n");









महसूस किया है:



./jskc <test3.jsk



और हमें वर्तमान निर्देशिका में a.out.bc मिलता है। हम इसे अलग कर सकते हैं:



llvm-dis <aout.bc

; ModuleID = ''



@.format1 = internal constant [3 x i8] c"%d\00" ; <[3 x i8]*> [#uses=1]

@.format2 = internal constant [3 x i8] c"%s\00" ; <[3 x i8]*> [#uses=1]

@0 = internal constant [7 x i8] c"test4=\00" ; <[7 x i8]*> [#uses=1]

@1 = internal constant [2 x i8] c" \00" ; <[2 x i8]*> [#uses=1]

@2 = internal constant [2 x i8] c"\0A\00" ; <[2 x i8]*> [#uses=1]



define void @main() {

code:

%a = alloca i32 ; <i32*> [#uses=2]

%b = alloca i32 ; <i32*> [#uses=4]

%int_for_scanf___ = alloca i32 ; <i32*> [#uses=0]

store i32 88, i32* %b

store i32 88, i32* %a

%0 = load i32* %b ; [#uses=1]

%1 = add i32 %0, 1 ; [#uses=1]

store i32 %1, i32* %b

call void (i8*, ...)* @printf(i8* getelementptr inbounds ([3 x i8]* @.format2, i32 0, i32 0), i8* getelementptr inbounds ([7 x i8]* @0, i32 0, i32 0))

%2 = load i32* %a ; [#uses=1]

call void (i8*, ...)* @printf(i8* getelementptr inbounds ([3 x i8]* @.format1, i32 0, i32 0), i32 %2)

call void (i8*, ...)* @printf(i8* getelementptr inbounds ([3 x i8]* @.format2, i32 0, i32 0), i8* getelementptr inbounds ([2 x i8]* @1, i32 0, i32 0))

%3 = load i32* %b ; [#uses=1]

call void (i8*, ...)* @printf(i8* getelementptr inbounds ([3 x i8]* @.format1, i32 0, i32 0), i32 %3)

call void (i8*, ...)* @printf(i8* getelementptr inbounds ([3 x i8]* @.format2, i32 0, i32 0), i8* getelementptr inbounds ([2 x i8]* @2, i32 0, i32 0))

ret void

}



declare void @printf(i8*, ...)



declare void @scanf(i8*, ...)



declare void @exit(i32)





lli , ( ) - :



$ llvmc a.out.bc



(!) a.out, , JSK :



$ ls -al ./a.out

-rwxr-xr-x 1 walrus walrus 4639 2010-08-25 16:49 ./a.out



$ file a.out

a.out: ELF 32-bit LSB executable, Intel 80386, version 1 (SYSV), dynamically linked (uses shared libs), for GNU/Linux 2.6.15, not stripped



$ ldd a.out

linux-gate.so.1 => (0x00762000)

libc.so.6 => /lib/tls/i686/cmov/libc.so.6 (0x00456000)

/lib/ld-linux.so.2 (0x00ee4000)









,

$ ./a.out

test4=88 89









.