LLVM ពីទស្សនៈ Go

ការបង្កើតកម្មវិធីចងក្រងគឺជាកិច្ចការដ៏លំបាកមួយ។ ប៉ុន្តែជាសំណាងល្អ ជាមួយនឹងការអភិវឌ្ឍន៍គម្រោងដូចជា LLVM ដំណោះស្រាយចំពោះបញ្ហានេះគឺមានភាពសាមញ្ញយ៉ាងខ្លាំង ដែលអនុញ្ញាតឱ្យអ្នកសរសេរកម្មវិធីតែមួយអាចបង្កើតភាសាថ្មីដែលជិតដំណើរការជាមួយ C. ការធ្វើការជាមួយ LLVM មានភាពស្មុគស្មាញដោយសារការពិតនេះ។ ប្រព័ន្ធត្រូវបានតំណាងដោយចំនួនដ៏ច្រើននៃលេខកូដ បំពាក់ដោយឯកសារតិចតួច។ ដើម្បីព្យាយាមកែតម្រូវចំណុចខ្វះខាតនេះ អ្នកនិពន្ធនៃសម្ភារៈ ដែលជាការបកប្រែដែលយើងកំពុងបោះពុម្ពថ្ងៃនេះ នឹងបង្ហាញឧទាហរណ៍នៃកូដដែលសរសេរនៅក្នុង Go និងបង្ហាញពីរបៀបដែលពួកវាត្រូវបានបកប្រែជាលើកដំបូងទៅជា ទៅ SSAហើយបន្ទាប់មកនៅក្នុង LLVM IR ដោយប្រើកម្មវិធីចងក្រង តូច GO. កូដ 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 ប៊ីត ឬ 64 ប៊ីត អាស្រ័យលើអ្នកចងក្រង និងគោលដៅនៃការចងក្រងត្រូវបានទទួលយកនៅពេលដែល LLVM បង្កើតកូដ IR ។ នេះគឺជាហេតុផលមួយក្នុងចំណោមហេតុផលជាច្រើនដែលកូដ LLVM IR មិនដូចដែលមនុស្សជាច្រើនគិតទេ វេទិកាឯករាជ្យ។ កូដបែបនេះដែលត្រូវបានបង្កើតឡើងសម្រាប់វេទិកាមួយ មិនអាចត្រូវបានគេយក និងចងក្រងសម្រាប់វេទិកាមួយផ្សេងទៀតទេ (លុះត្រាតែអ្នកស័ក្តិសមសម្រាប់ការដោះស្រាយបញ្ហានេះ ជាមួយនឹងការថែទាំយ៉ាងខ្លាំង).

ចំណុចគួរឱ្យចាប់អារម្មណ៍មួយទៀតដែលគួរកត់សម្គាល់គឺថាប្រភេទ i64 មិនមែនជាចំនួនគត់ដែលបានចុះហត្ថលេខាទេ៖ វាអព្យាក្រឹតក្នុងន័យតំណាងឱ្យសញ្ញានៃលេខ។ អាស្រ័យលើការណែនាំ វាអាចតំណាងឱ្យទាំងលេខដែលបានចុះហត្ថលេខា និងមិនបានចុះហត្ថលេខា។ ក្នុងករណីតំណាងនៃប្រតិបត្តិការបន្ថែមនេះមិនមានបញ្ហាទេដូច្នេះវាមិនមានភាពខុសប្លែកគ្នាក្នុងការធ្វើការជាមួយលេខដែលបានចុះហត្ថលេខាឬមិនបានចុះហត្ថលេខាទេ។ នៅទីនេះខ្ញុំចង់កត់សម្គាល់ថានៅក្នុងភាសា C ការលើសអថេរចំនួនគត់ដែលបានចុះហត្ថលេខានាំទៅរកអាកប្បកិរិយាដែលមិនបានកំណត់ ដូច្នេះ Clang frontend បន្ថែមទង់ទៅប្រតិបត្តិការ។ nsw (មិនមានចុះហត្ថលេខា) ដែលប្រាប់ LLVM ថាវាអាចសន្មត់ថាការបន្ថែមនោះមិនដែលលើស។

នេះអាចមានសារៈសំខាន់សម្រាប់ការបង្កើនប្រសិទ្ធភាពមួយចំនួន។ ឧទាហរណ៍ការបន្ថែមតម្លៃពីរ 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. ការណែនាំគឺមិនធម្មតាទេ ហើយអាចចំណាយពេលខ្លះដើម្បីយល់។ ចងចាំ​ថា ស៊ី។ ស៊ី។ ស៊ី គឺខ្លីសម្រាប់ Static Single Assignment។ នេះគឺជាការតំណាងកម្រិតមធ្យមនៃកូដដែលប្រើដោយអ្នកចងក្រង ដែលនៅក្នុងនោះអថេរនីមួយៗត្រូវបានកំណត់តម្លៃតែម្តងប៉ុណ្ណោះ។ នេះ​គឺ​ជា​ការ​ល្អ​សម្រាប់​ការ​បង្ហាញ​មុខងារ​សាមញ្ញ​ដូច​ជា​មុខងារ​របស់​យើង 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 optimization pass ហៅថា 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) ជារចនាសម្ព័ន្ធ (struct) ប៉ុន្តែតំណាងឱ្យពួកវាជាអង្គភាពបីដាច់ដោយឡែកអនុញ្ញាតឱ្យមានការបង្កើនប្រសិទ្ធភាពមួយចំនួន។ កម្មវិធីចងក្រងផ្សេងទៀតអាចតំណាងឱ្យផ្នែកនេះតាមវិធីផ្សេងទៀត អាស្រ័យលើអនុសញ្ញាហៅទូរសព្ទនៃមុខងាររបស់វេទិកាគោលដៅ។

លក្ខណៈពិសេសគួរឱ្យចាប់អារម្មណ៍មួយទៀតនៃកូដនេះគឺការប្រើប្រាស់ការណែនាំ 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