একটি Go দৃষ্টিকোণ থেকে LLVM

কম্পাইলার ডেভেলপ করা খুবই কঠিন কাজ। কিন্তু, সৌভাগ্যবশত, LLVM-এর মতো প্রকল্পগুলির বিকাশের সাথে, এই সমস্যার সমাধানটি ব্যাপকভাবে সরলীকৃত হয়েছে, যা এমনকি একজন একক প্রোগ্রামারকে একটি নতুন ভাষা তৈরি করতে দেয় যা C-এর পারফরম্যান্সের কাছাকাছি। সিস্টেমটি বিপুল পরিমাণ কোড দ্বারা উপস্থাপিত হয়, সামান্য ডকুমেন্টেশন দিয়ে সজ্জিত। এই ত্রুটিটি সংশোধন করার চেষ্টা করার জন্য, উপাদানটির লেখক, যার অনুবাদ আমরা আজ প্রকাশ করছি, 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 এর একটি দিকটির সারমর্ম দেখতে দেয়। যথা, কোডকে এসএসএ ফর্মে রূপান্তর করার সময়, প্রতিটি অভিব্যক্তি সবচেয়ে প্রাথমিক অংশে বিভক্ত হয় যার মধ্যে এটি গঠিত হয়। আমাদের ক্ষেত্রে, আদেশ 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 কোডটি প্ল্যাটফর্ম স্বাধীন নয় এমন অনেক কারণের মধ্যে এটি একটি। এই ধরনের কোড, একটি প্ল্যাটফর্মের জন্য তৈরি, অন্য প্ল্যাটফর্মের জন্য সহজভাবে নেওয়া এবং সংকলন করা যাবে না (যদি না আপনি এই সমস্যাটি সমাধানের জন্য উপযুক্ত হন) চরম যত্ন সহ).

আরেকটি আকর্ষণীয় পয়েন্ট লক্ষ্যনীয় যে টাইপ i64 এটি একটি স্বাক্ষরিত পূর্ণসংখ্যা নয়: সংখ্যার চিহ্নের প্রতিনিধিত্ব করার ক্ষেত্রে এটি নিরপেক্ষ। নির্দেশের উপর নির্ভর করে, এটি স্বাক্ষরিত এবং স্বাক্ষরবিহীন উভয় সংখ্যাই উপস্থাপন করতে পারে। সংযোজন ক্রিয়াকলাপের প্রতিনিধিত্বের ক্ষেত্রে, এটি কোন ব্যাপার নয়, তাই স্বাক্ষরিত বা স্বাক্ষরবিহীন সংখ্যার সাথে কাজ করার মধ্যে কোন পার্থক্য নেই। এখানে আমি লক্ষ্য করতে চাই যে C ভাষায়, একটি স্বাক্ষরিত পূর্ণসংখ্যা পরিবর্তনশীলকে উপচে পড়া অনির্ধারিত আচরণের দিকে নিয়ে যায়, তাই ক্ল্যাং ফ্রন্টএন্ড অপারেশনে একটি পতাকা যুক্ত করে nsw (কোন স্বাক্ষরিত মোড়ক), যা LLVM কে বলে যে এটি অনুমান করতে পারে যে সংযোজন কখনই ওভারফ্লো হয় না।

এটি কিছু অপ্টিমাইজেশনের জন্য গুরুত্বপূর্ণ হতে পারে। উদাহরণস্বরূপ, দুটি মান যোগ করা i16 একটি 32-বিট প্ল্যাটফর্মে (32-বিট রেজিস্টার সহ) প্রয়োজন, সংযোজন করার পরে, পরিসরে থাকার জন্য একটি চিহ্ন সম্প্রসারণ অপারেশন প্রয়োজন i16. এই কারণে, মেশিন রেজিস্টারের আকারের উপর ভিত্তি করে পূর্ণসংখ্যা ক্রিয়াকলাপ সম্পাদন করা প্রায়শই বেশি দক্ষ।

এই আইআর কোডের পরে কী হবে তা এখন আমাদের কাছে বিশেষ আগ্রহের বিষয় নয়। কোডটি অপ্টিমাইজ করা হয়েছে (কিন্তু আমাদের মতো একটি সাধারণ উদাহরণের ক্ষেত্রে, কিছুই অপ্টিমাইজ করা হয় না) এবং তারপরে মেশিন কোডে রূপান্তরিত হয়।

দ্বিতীয় উদাহরণ

পরবর্তী উদাহরণটি আমরা দেখব একটু বেশি জটিল হবে। যথা, আমরা একটি ফাংশন সম্পর্কে কথা বলছি যা পূর্ণসংখ্যার একটি স্লাইস যোগ করে:

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

এখানে আপনি ইতিমধ্যেই এসএসএ ফর্মে কোডের প্রতিনিধিত্ব করার জন্য সাধারণ আরও নির্মাণ দেখতে পারেন। সম্ভবত এই কোডের সবচেয়ে সুস্পষ্ট বৈশিষ্ট্য হল কোন কাঠামোগত প্রবাহ নিয়ন্ত্রণ কমান্ড নেই। গণনার প্রবাহ নিয়ন্ত্রণ করার জন্য, শুধুমাত্র শর্তসাপেক্ষ এবং শর্তহীন জাম্প আছে, এবং, যদি আমরা এই কমান্ডটিকে প্রবাহ নিয়ন্ত্রণের জন্য একটি কমান্ড হিসাবে বিবেচনা করি, একটি রিটার্ন কমান্ড।

প্রকৃতপক্ষে, এখানে আপনি মনোযোগ দিতে পারেন যে প্রোগ্রামটি কোঁকড়া ধনুর্বন্ধনী ব্যবহার করে ব্লকগুলিতে বিভক্ত নয় (ভাষার সি পরিবারের মতো)। এটি লেবেল দ্বারা বিভক্ত, সমাবেশ ভাষার স্মরণ করিয়ে দেয় এবং মৌলিক ব্লকের আকারে উপস্থাপিত হয়। এসএসএ-তে, মৌলিক ব্লকগুলিকে কোডের সংলগ্ন ক্রম হিসাবে সংজ্ঞায়িত করা হয় একটি লেবেল দিয়ে শুরু হয় এবং মৌলিক ব্লক সমাপ্তির নির্দেশাবলী দিয়ে শেষ হয়, যেমন − return и jump.

এই কোডের আরেকটি আকর্ষণীয় বিবরণ নির্দেশ দ্বারা প্রতিনিধিত্ব করা হয় phi. নির্দেশাবলী বেশ অস্বাভাবিক এবং বুঝতে কিছু সময় লাগতে পারে। মনে রাখবেন, যে এসএসএ স্ট্যাটিক একক অ্যাসাইনমেন্টের জন্য সংক্ষিপ্ত। এটি কম্পাইলারদের দ্বারা ব্যবহৃত কোডের একটি মধ্যবর্তী উপস্থাপনা, যেখানে প্রতিটি ভেরিয়েবলকে শুধুমাত্র একবার একটি মান বরাদ্দ করা হয়। আমাদের ফাংশনের মতো সাধারণ ফাংশন প্রকাশ করার জন্য এটি দুর্দান্ত myAddউপরে দেখানো হয়েছে, কিন্তু আরও জটিল ফাংশন যেমন এই বিভাগে আলোচিত ফাংশনের জন্য উপযুক্ত নয় sum. বিশেষ করে, লুপ চালানোর সময় ভেরিয়েবল পরিবর্তন হয় i и n.

এসএসএ একবার তথাকথিত নির্দেশ ব্যবহার করে পরিবর্তনশীল মান নির্ধারণের সীমাবদ্ধতাকে বাইপাস করে phi (এর নাম গ্রীক বর্ণমালা থেকে নেওয়া হয়েছে)। আসল বিষয়টি হল যে সি এর মতো ভাষার জন্য কোডের এসএসএ উপস্থাপনা তৈরি করার জন্য, আপনাকে কিছু কৌশল অবলম্বন করতে হবে। এই নির্দেশ কল করার ফলাফল হল ভেরিয়েবলের বর্তমান মান (i বা n), এবং মৌলিক ব্লকগুলির একটি তালিকা এর পরামিতি হিসাবে ব্যবহৃত হয়। উদাহরণস্বরূপ, এই নির্দেশ বিবেচনা করুন:

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

এর অর্থ নিম্নরূপ: যদি পূর্ববর্তী মৌলিক ব্লকটি একটি ব্লক ছিল entry (ইনপুট), তারপর t0 একটি ধ্রুবক 0, এবং যদি পূর্ববর্তী মৌলিক ব্লক ছিল for.body, তারপর আপনাকে মান নিতে হবে t6 এই ব্লক থেকে এই সব বেশ রহস্যময় মনে হতে পারে, কিন্তু এই প্রক্রিয়া যা SSA কাজ করে। মানুষের দৃষ্টিকোণ থেকে, এই সব কোড বোঝা কঠিন করে তোলে, কিন্তু প্রতিটি মান শুধুমাত্র একবার বরাদ্দ করা হয় তা অনেক অপ্টিমাইজেশনকে অনেক সহজ করে তোলে।

মনে রাখবেন যে আপনি যদি নিজের কম্পাইলার লেখেন তবে আপনাকে সাধারণত এই ধরণের জিনিসের সাথে মোকাবিলা করতে হবে না। এমনকি ঝনঝন এই সমস্ত নির্দেশনা তৈরি করে না phi, এটি একটি প্রক্রিয়া ব্যবহার করে alloca (এটি সাধারণ স্থানীয় ভেরিয়েবলের সাথে কাজ করার মতো)। তারপর, একটি LLVM অপ্টিমাইজেশান পাস চালানোর সময় বলা হয় mem2reg, নির্দেশাবলী alloca এসএসএ ফর্মে রূপান্তরিত। 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