ગો પરિપ્રેક્ષ્યમાં એલએલવીએમ

કમ્પાઈલર ડેવલપ કરવું એ ખૂબ જ મુશ્કેલ કાર્ય છે. પરંતુ, સદભાગ્યે, LLVM જેવા પ્રોજેક્ટના વિકાસ સાથે, આ સમસ્યાનો ઉકેલ ખૂબ જ સરળ બનાવવામાં આવ્યો છે, જે એક પ્રોગ્રામરને એક નવી ભાષા બનાવવાની મંજૂરી આપે છે જે C ની નજીક હોય. LLVM સાથે કામ કરવું એ હકીકત દ્વારા જટિલ છે કે આ સિસ્ટમને કોડની વિશાળ માત્રા દ્વારા રજૂ કરવામાં આવે છે, જે ઓછા દસ્તાવેજોથી સજ્જ છે. આ ખામીને સુધારવાનો પ્રયાસ કરવા માટે, સામગ્રીના લેખક, જેનો અનુવાદ અમે આજે પ્રકાશિત કરી રહ્યા છીએ, તે Go માં લખેલા કોડના ઉદાહરણો દર્શાવવા જઈ રહ્યા છે અને બતાવશે કે તેનો પ્રથમ અનુવાદ કેવી રીતે કરવામાં આવે છે. SSA જાઓ, અને પછી કમ્પાઇલરનો ઉપયોગ કરીને LLVM IR માં ટિનીગો. 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 કોડ ગો SSA કોડ કરતાં થોડો મજબૂત છે, C જેવો જ છે. અહીં, ફંક્શન ડિક્લેરેશનમાં, પહેલા ડેટા પ્રકારનું વર્ણન છે જે તે પરત કરે છે, દલીલના નામ પહેલાં દલીલનો પ્રકાર દર્શાવેલ છે. વધુમાં, IR પદચ્છેદનને સરળ બનાવવા માટે, વૈશ્વિક સંસ્થાઓના નામ પ્રતીકની આગળ આવે છે. @, અને સ્થાનિક નામો પહેલાં એક પ્રતીક છે % (એક કાર્યને વૈશ્વિક એન્ટિટી પણ ગણવામાં આવે છે).

આ કોડ વિશે નોંધ લેવા જેવી બાબત એ છે કે ગોનો પ્રકાર પ્રતિનિધિત્વ નિર્ણય int, જે કમ્પાઇલર અને સંકલનના લક્ષ્યના આધારે 32-બીટ અથવા 64-બીટ મૂલ્ય તરીકે રજૂ કરી શકાય છે, જ્યારે LLVM IR કોડ જનરેટ કરે છે ત્યારે સ્વીકારવામાં આવે છે. LLVM IR કોડ ન હોવાના ઘણા કારણો પૈકી આ એક છે, જેમ કે ઘણા લોકો વિચારે છે, પ્લેટફોર્મ સ્વતંત્ર છે. આવો કોડ, એક પ્લેટફોર્મ માટે બનાવવામાં આવ્યો છે, તેને બીજા પ્લેટફોર્મ માટે સરળતાથી લઈ અને કમ્પાઈલ કરી શકાતો નથી (જ્યાં સુધી તમે આ સમસ્યાને ઉકેલવા માટે યોગ્ય ન હોવ. અત્યંત કાળજી સાથે).

નોંધવા યોગ્ય અન્ય રસપ્રદ મુદ્દો એ છે કે પ્રકાર i64 સાઇન કરેલ પૂર્ણાંક નથી: તે સંખ્યાના ચિહ્નને રજૂ કરવાના સંદર્ભમાં તટસ્થ છે. સૂચનાના આધારે, તે સહી કરેલ અને સહી ન કરેલ બંને નંબરોનું પ્રતિનિધિત્વ કરી શકે છે. ઉમેરણ કામગીરીની રજૂઆતના કિસ્સામાં, આ કોઈ વાંધો નથી, તેથી સહી કરેલ અથવા સહી ન કરેલ નંબરો સાથે કામ કરવામાં કોઈ તફાવત નથી. અહીં હું નોંધવા માંગુ છું કે C ભાષામાં, સાઇન કરેલ પૂર્ણાંક ચલને ઓવરફ્લો કરવાથી અવ્યાખ્યાયિત વર્તન તરફ દોરી જાય છે, તેથી ક્લેંગ ફ્રન્ટએન્ડ ઓપરેશનમાં ધ્વજ ઉમેરે છે. nsw (કોઈ સહી કરેલ લપેટી નથી), જે એલએલવીએમને કહે છે કે તે માની શકે છે કે ઉમેરણ ક્યારેય ઓવરફ્લો થતું નથી.

કેટલાક ઑપ્ટિમાઇઝેશન માટે આ મહત્વપૂર્ણ હોઈ શકે છે. ઉદાહરણ તરીકે, બે મૂલ્યો ઉમેરી રહ્યા છે i16 32-બીટ પ્લેટફોર્મ પર (32-બીટ રજિસ્ટર સાથે) શ્રેણીમાં રહેવા માટે, વધારા પછી, સાઇન વિસ્તરણ કામગીરીની જરૂર છે 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.

એસએસએ કહેવાતી સૂચનાનો ઉપયોગ કરીને એકવાર ચલ મૂલ્યો સોંપવા પરના પ્રતિબંધને બાયપાસ કરે છે phi (તેનું નામ ગ્રીક મૂળાક્ષરો પરથી લેવામાં આવ્યું છે). હકીકત એ છે કે C જેવી ભાષાઓ માટે કોડની SSA રજૂઆત જનરેટ કરવા માટે, તમારે કેટલીક યુક્તિઓનો આશરો લેવો પડશે. આ સૂચનાને કૉલ કરવાનું પરિણામ એ ચલનું વર્તમાન મૂલ્ય છે (i અથવા n), અને મૂળભૂત બ્લોક્સની સૂચિ તેના પરિમાણો તરીકે ઉપયોગમાં લેવાય છે. ઉદાહરણ તરીકે, આ સૂચનાને ધ્યાનમાં લો:

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

તેનો અર્થ નીચે મુજબ છે: જો અગાઉનો મૂળભૂત બ્લોક બ્લોક હતો entry (ઇનપુટ), પછી t0 એક સ્થિર છે 0, અને જો અગાઉનો મૂળભૂત બ્લોક હતો for.body, તો તમારે મૂલ્ય લેવાની જરૂર છે t6 આ બ્લોકમાંથી. આ બધું તદ્દન રહસ્યમય લાગે છે, પરંતુ આ પદ્ધતિ જ SSA ને કાર્ય કરે છે. માનવ પરિપ્રેક્ષ્યમાં, આ બધું કોડને સમજવું મુશ્કેલ બનાવે છે, પરંતુ હકીકત એ છે કે દરેક મૂલ્ય ફક્ત એક જ વાર સોંપવામાં આવે છે તે ઘણા ઑપ્ટિમાઇઝેશનને વધુ સરળ બનાવે છે.

નોંધ કરો કે જો તમે તમારું પોતાનું કમ્પાઈલર લખો છો, તો તમારે સામાન્ય રીતે આ પ્રકારની સામગ્રી સાથે વ્યવહાર કરવો પડશે નહીં. રણકાર પણ આ બધી સૂચનાઓ જનરેટ કરતું નથી 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 ડિરેફરન્સિંગ કામગીરી કરતું નથી. તે માત્ર હાલના એકના આધારે નવા નિર્દેશકની ગણતરી કરે છે. તે સૂચનાઓ તરીકે લઈ શકાય છે 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