أساسيات الحاسب والبرمجة الأدلة التقنية

LLVM من الداخل: البنية التي تقف خلف Clang و Rust

نكتب LLVM IR لإجمالي فاتورة بأيدينا ونشغله، ونقارن ما يكتبه Clang وrustc لنفس الدالة، ونترجم ملفاً واحداً إلى ثلاثة معالجات، ونرى لماذا تبني عليه لغات كثيرة.

LLVM من الداخل: البنية التي تقف خلف Clang و Rust

بعد قصة حماية رقم الفاتورة التي حذفها المترجم في المقال السابق، اقترح أحد أعضاء فريق الفواتير أن تعاد كتابة المكتبة بلغة Rust، وجاء السؤال المتوقع من مدير الفريق: هل سوف نخسر السرعة التي انتقلنا إلى C من أجلها؟ وإذا شغلت rustc --version --verbose على أي جهاز فسوف ترى في آخر سطر شيئاً مثل LLVM version: 19.1.7، وهو نفس الرقم الذي يطبعه clang --version على نفس الجهاز. أي أن المترجمين، مع أن اللغتين مختلفتان تماماً، يسلمان الكود في النهاية لنفس البنية، وهذه البنية هي LLVM، وهي التي تقف خلف Clang وRust وSwift وكثير غيرها.

وفي هذا المقال سوف نفتح LLVM من الداخل بنفس طريقة المقال السابق: نقرأ ما يخرج منه حرفياً. سوف نكتب التمثيل الوسيط LLVM IR لإجمالي الفاتورة بأيدينا، ونشغله، ونخطئ فيه عن قصد لنرى من يمسك الخطأ، ثم نرى ما يكتبه Clang وما يكتبه rustc لنفس الدالة، ونمرر الكود على المحسن opt، ثم نترجم نفس الملف بالأداة llc إلى ثلاثة معالجات مختلفة. وفي الطريق سوف نجيب عن سؤال مدير الفريق، ونرى لماذا لم تحذف Rust حماية رقم الفاتورة مع أنها تستخدم نفس المحسن الذي حذفها في C.

وسوف نناقش في هذا المقال ما يلي:

  • ما هو LLVM ومن أين جاء، ومكوناته: التمثيل الوسيط IR، والمحسن opt، والمولد llc، والمنفذ lli.
  • قراءة LLVM IR وكتابته بأيدينا: الأنواع، والكتل، ودوال phi، وكيف يرفض المحقق Verifier الكود الخاطئ.
  • ما يكتبه Clang دون تحسين، ولماذا يملأ الكود بالتعليمة alloca، والمرحلة mem2reg التي تحوله إلى SSA.
  • المحسن opt ومراحله، وما لم نكتبه في IR بأيدينا: وصف البيانات Data Layout.
  • العلامة nsw: كيف تحمل IR وعود اللغة، ولماذا اختلفت C عن Rust في نفس الحماية.
  • ملف IR واحد إلى x86-64 وAArch64 وRISC-V، ولماذا استدعى كود RISC-V دالة لعملية ضرب.
  • لماذا تبني Rust وSwift وZig على LLVM، وما الثمن، ولماذا تحاول Zig الابتعاد عنه.

ما هو LLVM؟ مكتبة مترجمات Compiler Infrastructure لا آلة افتراضية

بدأ LLVM كمشروع بحثي في جامعة Illinois، وكان هدفه كما يذكر موقع المشروع تقديم طريقة ترجمة حديثة مبنية على صيغة SSA تدعم الترجمة الثابتة والديناميكية لأي لغة. ونشر Chris Lattner التصميم الأول في رسالة الماجستير عام 2002. وكان الاسم في البداية اختصاراً لعبارة Low Level Virtual Machine، ولكن المشروع نما ولم يعد للاسم علاقة بالآلات الافتراضية، والموقع نفسه يقول اليوم إن LLVM ليس اختصاراً لشيء، وإنما اسم المشروع كاملاً. لذلك إذا سمعت «آلة LLVM الافتراضية» فاعرف أنها تسمية قديمة: LLVM لا ينفذ Bytecode كما فعلت آلتنا في الجزء الثاني من المفسر، وإنما يترجم إلى كود الآلة الحقيقي.

والفكرة التي جعلت LLVM مختلفاً عن المترجمات التي سبقته هي أنه مجموعة مكتبات لا برنامج واحد. ففي المقال السابق رأينا أن GCC مقسم إلى واجهة أمامية ووسط وواجهة خلفية، ولكن هذه الأجزاء مرتبطة داخل برنامج واحد، ولا يسهل أن تأخذ الوسط وحده وتبني عليه لغتك. أما في LLVM فكل جزء مكتبة لها واجهة واضحة، والتمثيل الوسيط نفسه لغة كاملة موثقة في مرجع لغة LLVM IR، يمكن أن تكتبها في ملف نصي، وتقرأها، وتمررها بين أدوات منفصلة. وشرح Lattner هذا القرار في فصل LLVM من كتاب The Architecture of Open Source Applications. والأدوات التي سوف نستخدمها كلها تأتي مع حزمة llvm في Debian:

  • clang: الواجهة الأمامية للغات C وC++ وObjective-C، وتكتب LLVM IR بالخيار -emit-llvm.
  • opt: المحسن، يأخذ IR ويطبق عليه المراحل Passes ويعيد IR.
  • llc: الواجهة الخلفية، تأخذ IR وتكتب لغة التجميع أو ملفاً كائناً لمعالج تختاره.
  • lli: ينفذ IR مباشرة بالترجمة أثناء التشغيل JIT، دون أن تبني ملفاً تنفيذياً.
  • llvm-link وllvm-as وllvm-dis: لدمج ملفات IR والتحويل بين الصيغة النصية .ll والصيغة الثنائية .bc المسماة Bitcode.

ورخصة LLVM هي Apache 2.0 مع استثناءات خاصة بالمشروع، كما في سياسة المطورين في LLVM، وهي رخصة تسمح للشركات بأن تبني عليه مترجمات مغلقة المصدر. وهذا، مع تصميم المكتبات، من أسباب انتشاره في الشركات وفي اللغات الجديدة، بينما GCC برخصة GPLv3، وتحدثنا عن أثر الرخص في مقال من يقرر مستقبل لغات البرمجة.

بنية LLVM: واجهات أمامية لعدة لغات هي clang للغة C وrustc للغة Rust وswiftc للغة Swift وzig، كلها تكتب LLVM IR، ثم المحسن opt بمراحله، ثم llc إلى x86-64 وAArch64 وRISC-V وWebAssembly، وlli ينفذ IR مباشرة بالترجمة أثناء التشغيل، مع ملاحظة أن clang وrustc في المختبر يستخدمان نفس LLVM 19.1.7
لغات كثيرة وتمثيل وسيط واحد ومعالجات كثيرة: clang وrustc في المختبر يطبعان نفس الإصدار LLVM 19.1.7

التمثيل الوسيط LLVM IR: لغة تجميع بأنواع

أقرب وصف لصيغة LLVM IR أنها لغة تجميع لمعالج خيالي، ولكن بثلاثة فروق كبيرة عن لغة التجميع الحقيقية. الأول أن كل قيمة لها نوع صريح: i64 عدد صحيح من 64 بت، وi1 قيمة منطقية من بت واحد، وptr مؤشر. ولاحظ أن الأعداد الصحيحة لا تحمل إشارة في نوعها، فالعدد i64 ليس موجباً ولا سالباً، وإنما العملية هي التي تحدد: sdiv قسمة بإشارة Signed، وudiv قسمة بلا إشارة Unsigned، وicmp slt مقارنة «أصغر من» بإشارة. والثاني أن عدد المسجلات غير محدود، فكل قيمة تأخذ اسماً جديداً يبدأ بالعلامة %. والثالث أن IR في صيغة SSA التي شرحناها في المقال السابق: كل اسم يسند مرة واحدة، والدمج عند التقاء الطرق بالتعليمة phi.

نكتب IR بأيدينا Hand-written IR

أفضل طريقة لفهم IR أن تكتبه، فهذا الملف total.ll هو حساب إجمالي الفاتورة من المقال السابق، مكتوباً مباشرة بلغة LLVM IR دون أي لغة مصدر:

; total.ll: an invoice total written by hand in LLVM IR
;   line_total(price, qty) = price * qty * 115 / 100
;   invoice_total(price[], qty[], n) = sum of line_total over n lines

define i64 @line_total(i64 %price, i64 %qty) {
entry:
  %sub = mul i64 %price, %qty
  %taxed = mul i64 %sub, 115
  %total = sdiv i64 %taxed, 100
  ret i64 %total
}

define i64 @invoice_total(ptr %price, ptr %qty, i64 %n) {
entry:
  %empty = icmp sle i64 %n, 0
  br i1 %empty, label %done, label %loop

loop:
  %i = phi i64 [ 0, %entry ], [ %next, %loop ]
  %sum = phi i64 [ 0, %entry ], [ %sum.next, %loop ]
  %p.addr = getelementptr i64, ptr %price, i64 %i
  %q.addr = getelementptr i64, ptr %qty, i64 %i
  %p = load i64, ptr %p.addr
  %q = load i64, ptr %q.addr
  %t = call i64 @line_total(i64 %p, i64 %q)
  %sum.next = add i64 %sum, %t
  %next = add i64 %i, 1
  %more = icmp slt i64 %next, %n
  br i1 %more, label %loop, label %done

done:
  %result = phi i64 [ 0, %entry ], [ %sum.next, %loop ]
  ret i64 %result
}

في الملف أعلاه لاحظ التالي:

  • السطور التي تبدأ بالفاصلة المنقوطة تعليقات، وdefine i64 @line_total تعرف دالة تعيد i64، والأسماء العامة مثل الدوال تبدأ بالعلامة @ والمحلية بالعلامة %.
  • كل دالة مقسمة إلى كتل Basic Blocks لكل منها اسم مثل entry وloop وdone، وكل كتلة تنتهي بتعليمة تنهيها Terminator، مثل br التي تتفرع أو ret التي تعيد. ولا يوجد «سقوط» من كتلة إلى التي بعدها كما في لغة التجميع، فكل انتقال مكتوب صراحة.
  • العداد %i والمجموع %sum لا يمكن أن يتغيرا داخل الحلقة لأن كل اسم يسند مرة واحدة، لذلك تأتي قيمتهما من phi: [ 0, %entry ] عند الدخول، و[ %next, %loop ] بعد كل دورة. وهذا نفس ما رأيناه في مخرج -fdump-tree-ssa من GCC، ولكن هنا نكتبه نحن.
  • التعليمة getelementptr، واختصارها الشائع GEP، تحسب عنوان العنصر رقم %i في مصفوفة من i64 دون أن تقرأ الذاكرة، ثم تأتي load لتقرأ. وفصل الحساب عن القراءة يجعل تحليل الذاكرة أسهل للمحسن.
  • الكتلة done يصل إليها التنفيذ من طريقين، من entry إذا كانت الفاتورة فارغة ومن loop بعد آخر سطر، لذلك نحتاج phi ثالثة تختار بين الصفر والمجموع.

نشغل IR: مع برنامج C ومع JIT في lli

ملف IR ليس برنامجاً كاملاً، فليس فيه main، لذلك كتبنا main.c صغيراً يستدعي invoice_total لفاتورة من ثلاثة أسطر. وكل التجارب تعمل داخل Container من debian:trixie-slim فيه حزم clang وllvm وrustc من Debian، والملف llvm.sh في مجلد المختبر ينفذها كلها:

docker build -t scc1-cc lab/
docker run --rm -v "$PWD/lab":/lab -w /lab scc1-cc sh llvm.sh

والجزء الأول من السكربت يتحقق من الملف، ثم يبنيه مع main.c بالمترجم Clang، ثم يترجم main.c نفسه إلى IR، ويدمج الملفين بالأداة llvm-link، وينفذ الناتج بالأداة lli:

total.ll: verified
invoice_total = 632
lli (JIT) runs the linked IR:
invoice_total = 632

النتيجة 632 في الطريقتين، وهي 120 × 3 × 1.15 = 414 و50 × 2 × 1.15 = 115 و9 × 10 × 1.15 = 103.5 التي صارت 103 لأن القسمة صحيحة. ولاحظ أن Clang قبل ملف .ll كما يقبل ملف .c، لأنه يدخل IR مباشرة إلى المحسن ويتجاوز الواجهة الأمامية. والسطر الثاني نفذه lli دون أن يبني أي ملف تنفيذي، فقد ترجم IR إلى كود الآلة في الذاكرة ثم قفز إليه، وهذا نفس ما يفعله أي JIT، وتوثيق lli يشرح خياراته. ومكتبات JIT في LLVM هي ما تستخدمه مشاريع مثل محركات قواعد البيانات التي تترجم الاستعلامات أثناء التشغيل.

ثلاث صيغ لنفس IR: النص والـ Bitcode والذاكرة

الملف total.ll هو الصيغة النصية التي يقرؤها الإنسان، ولكن LLVM نفسه يتعامل مع IR بثلاث صيغ متكافئة تماماً: النص بالامتداد .ll، والصيغة الثنائية المضغوطة Bitcode بالامتداد .bc، والكائنات داخل الذاكرة التي تعمل عليها المكتبات. والأداة llvm-as تحول النص إلى Bitcode، وllvm-dis تعيده نصاً. والجزء السابع من السكربت يفعل ذلك، ثم يقارن أول أربعة بايتات من ملف كائن عادي بملف كائن بناه Clang بالخيار -flto:

total.ll: 999 bytes of text, total.bc: 1648 bytes of bitcode
first 4 bytes of total.bc:  42 43 c0 de
define i64 @line_total(i64 %price, i64 %qty) {
entry:
  %sub = mul i64 %price, %qty
  %taxed = mul i64 %sub, 115
  %total = sdiv i64 %taxed, 100
  ret i64 %total
}
clang -O2 -c      : first 4 bytes  7f 45 4c 46
clang -O2 -flto -c: first 4 bytes  42 43 c0 de

في المخرج أعلاه لاحظ التالي:

  • ملف Bitcode أكبر من النص في هذه الحالة، 1648 بايتاً مقابل 999، لأن الملف صغير جداً، والصيغة الثنائية تحمل رأساً وجداول ثابتة الحجم تقريباً. وفي الملفات الكبيرة ينقلب الأمر، ولكن الهدف الأساسي من Bitcode ليس الحجم، وإنما أن القراءة والكتابة أسرع بكثير من تحليل النص.
  • الملف يبدأ بالبايتات 42 43 c0 de، أي الحرفين BC ثم 0xC0DE، وهذا رقمه السحري، بنفس الفكرة التي وضعنا بها CALC في أول Bytecode لغتنا في الجزء الثاني، وCPython في أول ملفات .pyc.
  • الملف الكائن العادي يبدأ بالبايتات 7f 45 4c 46، أي ELF، فهو كود آلة في صيغة ELF. أما مع -flto فالملف الذي سماه Clang .o هو في الحقيقة Bitcode، وهذا ما رأيناه في المقال السابق مع GCC: التحسين وقت الربط يعني أن الملفات تحمل التمثيل الوسيط بدل كود الآلة، ويكمل المحسن عمله على البرنامج كله عند الربط.
  • والنص الذي أعادته llvm-dis هو نفس الدالة التي كتبناها، بلا تعليقاتنا، لأن التعليقات لا تدخل في Bitcode.

ماذا يحدث إذا خالفنا قواعد SSA؟ المحقق Verifier

لكي نعرف ما يحمينا عندما نكتب IR بأيدينا أو نولده من لغتنا، كتبنا نسختين خاطئتين عن قصد. الأولى broken-ssa.ll تسند %sum.next مرتين، والثانية broken-dom.ll تعيد %t من الكتلة done بدل %result:

opt: /lab/broken-ssa.ll:27:3: error: multiple definition of local value named 'sum.next'
  %sum.next = add i64 %sum.next, 1
  ^
Instruction does not dominate all uses!
  %t = call i64 @line_total(i64 %p, i64 %q)
  ret i64 %t
opt: /lab/broken-dom.ll: error: input module is broken!

في المخرج أعلاه لاحظ التالي:

  • الخطأ الأول أمسكه المحلل نفسه قبل أي تحقق، برقم السطر والعمود: «multiple definition of local value»، لأن قاعدة الإسناد الواحد جزء من قواعد اللغة.
  • الخطأ الثاني أصعب وأخطر، فالنص صحيح نحوياً، والقيمة %t موجودة فعلاً في الدالة، ولكنها تعرف في الكتلة loop، والتنفيذ قد يصل إلى done من entry مباشرة عندما تكون الفاتورة فارغة، فلا تكون %t قد حسبت أصلاً. وقاعدة SSA تقول إن تعريف كل قيمة يجب أن يسيطر Dominate على كل استخدام لها، أي أن كل طريق من بداية الدالة إلى الاستخدام يجب أن يمر بالتعريف، والمحقق Verifier فحص هذا ورفض الملف: «Instruction does not dominate all uses».

وهذه قيمة مهمة لمن يبني لغة على LLVM: المحقق يمسك أخطاء المولد الذي كتبته قبل أن تصبح كوداً خاطئاً يعمل بصمت. والخيار -passes=verify يشغله وحده، ومن يولد IR من برنامجه يستدعي نفس الدالة من المكتبة بعد كل دالة يولدها.

الدالة invoice_total من total.ll مقسمة إلى ثلاث كتل entry وloop وdone مع الأسهم بينها، وشرح لكل جزء: الأنواع i64 وptr وi1، والأسماء المحلية بالعلامة % والعامة بالعلامة @، ودوال phi في رأس الحلقة وفي done، وgetelementptr ثم load، والتعليمة br في نهاية كل كتلة، ومع ذلك الخطآن اللذان رفضهما المحلل والمحقق
تشريح الدالة التي كتبناها بأيدينا: كتل تنتهي كل منها بتفرع أو عودة، وphi حيث تلتقي الطرق

ماذا يكتب Clang؟ alloca ثم مرحلة mem2reg

كتابة IR بأيدينا جعلتنا نفكر في phi لكل متغير يتغير في حلقة، وهذا عمل مرهق لأي واجهة أمامية، فكيف يفعله Clang؟ الإجابة أنه لا يفعله. فالواجهة الأمامية في Clang تضع كل متغير محلي في خانة في المكدس بالتعليمة alloca، وتكتب فيه بالتعليمة store وتقرأ منه بالتعليمة load، فلا تحتاج أن تفكر في SSA أبداً، لأن الذاكرة يمكن الكتابة فيها أكثر من مرة. وهذا ما كتبه Clang دون تحسين للدالة line_total من ملف invoice.c في المقال السابق:

define internal i64 @line_total(i64 noundef %0, i64 noundef %1, i64 noundef %2) #0 {
  %4 = alloca i64, align 8
  %5 = alloca i64, align 8
  %6 = alloca i64, align 8
  %7 = alloca i64, align 8
  store i64 %0, ptr %4, align 8
  store i64 %1, ptr %5, align 8
  store i64 %2, ptr %6, align 8
  %8 = load i64, ptr %4, align 8
  %9 = load i64, ptr %5, align 8
  %10 = mul nsw i64 %8, %9
  %11 = load i64, ptr %6, align 8
  %12 = sub nsw i64 %10, %11
  store i64 %12, ptr %7, align 8
  %13 = load i64, ptr %7, align 8
  %14 = call i32 @tax_rate()
  %15 = add nsw i32 100, %14
  %16 = sext i32 %15 to i64
  %17 = mul nsw i64 %13, %16
  %18 = sdiv i64 %17, 100
  ret i64 %18
}

وهذا يشبه تماماً ما رأيناه في لغة التجميع مع -O0 في المقال السابق: كل معامل يحفظ في المكدس ثم يقرأ منه في السطر التالي. والخيار -disable-O0-optnone يمنع Clang من وضع علامة optnone على الدوال في -O0، حتى نستطيع أن نمررها على المحسن بأيدينا. ثم يأتي دور مرحلة mem2reg، التي تبحث عن كل alloca لا يأخذ أحد عنوانها، وتحولها إلى قيم SSA، وتضع phi حيث تلزم:

define internal i64 @line_total(i64 noundef %0, i64 noundef %1, i64 noundef %2) #0 {
  %4 = mul nsw i64 %0, %1
  %5 = sub nsw i64 %4, %2
  %6 = call i32 @tax_rate()
  %7 = add nsw i32 100, %6
  %8 = sext i32 %7 to i64
  %9 = mul nsw i64 %5, %8
  %10 = sdiv i64 %9, 100
  ret i64 %10
}

اختفت الخانات الأربع وكل عمليات القراءة والكتابة، وبقي الحساب وحده. وهذا التقسيم من أذكى قرارات LLVM: كل لغة تكتب واجهة أمامية بسيطة تستخدم الذاكرة، ومرحلة واحدة في الوسط تحول الجميع إلى SSA، وهي المرحلة التي تظهر باسم PromotePass في قائمة المراحل التي سوف نراها بعد قليل. وهي أيضاً ما يجعل rustc وغيره يكتبون IR بنفس الطريقة.

ولاحظ في المخرجين العلامة nsw بعد كل mul وadd وsub، وهي اختصار No Signed Wrap، ولم نكتبها في ملفنا. وهذه العلامة سوف تكون مفتاح قصة الحماية، فاحفظها.

ثلاث مراحل للدالة line_total: Clang -O0 بأربع تعليمات alloca وأربع store وأربع load، ثم بعد mem2reg ثمانية أسطر بلا ذاكرة، ثم بعد التحسين الكامل والدمج حيث صار الاستدعاء tax_rate ثابتاً 115 داخل invoice_total
الواجهة الأمامية تكتب كوداً بسيطاً يستخدم الذاكرة، ومرحلة mem2reg تحوله إلى SSA لكل اللغات

المحسن opt ومراحله Passes

الآن نمرر ملفنا total.ll على المحسن بنفس مستوى -O2، والخيار -passes='default<O2>' يطلب نفس قائمة المراحل التي يستخدمها Clang. وهذا الناتج كاملاً:

; ModuleID = '/lab/total.ll'
source_filename = "/lab/total.ll"

; Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
define range(i64 -92233720368547758, 92233720368547759) i64 @line_total(i64 %price, i64 %qty) local_unnamed_addr #0 {
entry:
  %sub = mul i64 %price, 115
  %taxed = mul i64 %sub, %qty
  %total = sdiv i64 %taxed, 100
  ret i64 %total
}

; Function Attrs: nofree norecurse nosync nounwind memory(argmem: read)
define i64 @invoice_total(ptr nocapture readonly %price, ptr nocapture readonly %qty, i64 %n) local_unnamed_addr #1 {
entry:
  %empty = icmp slt i64 %n, 1
  br i1 %empty, label %done, label %loop

loop:                                             ; preds = %entry, %loop
  %i = phi i64 [ %next, %loop ], [ 0, %entry ]
  %sum = phi i64 [ %sum.next, %loop ], [ 0, %entry ]
  %p.addr = getelementptr i64, ptr %price, i64 %i
  %q.addr = getelementptr i64, ptr %qty, i64 %i
  %p = load i64, ptr %p.addr, align 4
  %q = load i64, ptr %q.addr, align 4
  %sub.i = mul i64 %p, 115
  %taxed.i = mul i64 %sub.i, %q
  %total.i = sdiv i64 %taxed.i, 100
  %sum.next = add i64 %total.i, %sum
  %next = add nuw nsw i64 %i, 1
  %more = icmp slt i64 %next, %n
  br i1 %more, label %loop, label %done

done:                                             ; preds = %loop, %entry
  %result = phi i64 [ 0, %entry ], [ %sum.next, %loop ]
  ret i64 %result
}

attributes #0 = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
attributes #1 = { nofree norecurse nosync nounwind memory(argmem: read) }

في المخرج أعلاه لاحظ التالي:

  • الدالة line_total ما زالت موجودة لأننا لم نقل إنها خاصة بالملف، ولكن داخل الحلقة لم يعد هناك call، فقد دمجها المحسن وأضاف إلى أسمائها اللاحقة .i أي Inlined.
  • غير المحسن ترتيب الضرب: كتبنا price * qty ثم الضرب في 115، فصار الضرب في الثابت أولاً، وهذا عمل مرحلة ReassociatePass التي تعيد ترتيب العمليات التي يجوز إعادة ترتيبها حتى تجمع الثوابت معاً.
  • أضاف المحسن معلومات لم نكتبها: memory(none) على line_total أي أنها لا تلمس الذاكرة، وnocapture readonly على المؤشرين في invoice_total أي أنها تقرأ منهما فقط ولا تحتفظ بهما، وrange(...) على نتيجة line_total لأن القسمة على 100 تحصر النتيجة في جزء من مئة من مدى i64. وهذا نفس نوع الاستنتاج الذي جعل GCC يحسب الدالة النقية مرة واحدة في المقال السابق، وفائدته أن المستدعين يستطيعون أن يحسنوا أكثر.
  • العداد صار add nuw nsw i64 %i, 1، أي أن المحسن أثبت أن %i تبدأ من صفر وتتوقف قبل %n، فلا يمكن أن تتجاوز المدى، فأضاف العلامتين بنفسه.
  • القراءتان صارتا align 4، وهذه مشكلة سوف نعود إليها في القسم التالي.

وكم مرحلة مرت على ملف من نحو 35 سطراً؟ الخيار -debug-pass-manager يطبع كل مرحلة وهي تعمل، والجزء الثاني من السكربت يعدها ويطبع أول أربعين مرحلة عملت على invoice_total:

passes run by default<O2>: 202
distinct pass names: 81
EntryExitInstrumenterPass LowerExpectIntrinsicPass SimplifyCFGPass SROAPass EarlyCSEPass PromotePass InstCombinePass SimplifyCFGPass InvalidateAnalysisPass<llvm::AAManager> SROAPass EarlyCSEPass SpeculativeExecutionPass JumpThreadingPass CorrelatedValuePropagationPass SimplifyCFGPass InstCombinePass AggressiveInstCombinePass LibCallsShrinkWrapPass TailCallElimPass SimplifyCFGPass ReassociatePass ConstraintEliminationPass LoopSimplifyPass LCSSAPass LoopInstSimplifyPass LoopSimplifyCFGPass LICMPass LoopRotatePass LICMPass SimpleLoopUnswitchPass SimplifyCFGPass InstCombinePass LoopSimplifyPass LCSSAPass LoopIdiomRecognizePass IndVarSimplifyPass LoopDeletionPass LoopFullUnrollPass SROAPass VectorCombinePass

202 تشغيل لمراحل من 81 نوعاً مختلفاً، وأسماؤها تحكي ما يحدث: SimplifyCFGPass تنظف مخطط سير التحكم وتعمل مرات كثيرة، وSROAPass وPromotePass تحولان الذاكرة إلى قيم، وInstCombinePass تجمع التعليمات البسيطة في تعليمات أبسط، وLICMPass تخرج من الحلقة كل حساب لا يتغير داخلها، وLoopRotatePass تفعل نفس التدوير الذي رأيناه في GCC. وصفحة المراحل في توثيق LLVM تصف كل واحدة، وصفحة مدير المراحل الجديد تشرح كيف ترتب في خطوط مثل default<O2>. والفائدة العملية أنك تستطيع أن تشغل مرحلة واحدة على ملفك، كما فعلنا مع mem2reg، لترى أثرها وحدها، وهذا ما لا يسمح به GCC بسهولة.

المراحل Passes والتحليلات Analyses: ماذا يحدث داخل كل مرحلة؟

إذا نظرت إلى السجل الكامل الذي يطبعه -debug-pass-manager، وليس إلى أسماء المراحل فقط، فسوف تجد نوعين من السطور، وهذه أول عشرة سطور خاصة بالدالة invoice_total:

Running pass: EntryExitInstrumenterPass on invoice_total (15 instructions)
Running pass: LowerExpectIntrinsicPass on invoice_total (15 instructions)
Running pass: SimplifyCFGPass on invoice_total (15 instructions)
Running analysis: TargetIRAnalysis on invoice_total
Running analysis: AssumptionAnalysis on invoice_total
Running pass: SROAPass on invoice_total (15 instructions)
Running analysis: DominatorTreeAnalysis on invoice_total
Running pass: EarlyCSEPass on invoice_total (15 instructions)
Running analysis: TargetLibraryAnalysis on invoice_total
Invalidating analysis: DominatorTreeAnalysis on invoice_total

السطور التي تبدأ بعبارة Running pass مراحل تغير الكود، والسطور التي تبدأ بعبارة Running analysis تحليلات تحسب معلومات عن الكود دون أن تغيره، مثل DominatorTreeAnalysis التي تحسب شجرة السيطرة، أي أي كتلة يمر بها كل طريق إلى كتلة أخرى، وهي نفس المعلومة التي استخدمها المحقق ليرفض broken-dom.ll. والمرحلة التي تحتاج تحليلاً تطلبه من المدير، والمدير يحسبه مرة ويحفظه حتى تأتي مرحلة تغير الكود بطريقة تجعله قديماً، فيظهر السطر Invalidating analysis ويحذفه، ويحسب من جديد عندما تطلبه مرحلة أخرى. وهذا التصميم يحل مشكلة حقيقية في أي محسن: التحليلات مكلفة، والمراحل كثيرة، وحساب كل تحليل قبل كل مرحلة يجعل المترجم بطيئاً جداً، وحفظه دون إبطال يجعل المراحل تعمل على معلومات خاطئة. والرقم بين القوسين، مثل (15 instructions)، عدد تعليمات الدالة لحظة المرحلة، ويمكنك أن تراه ينقص أو يزيد مع تقدم التحسين، فالدمج يزيده، وحذف الكود الميت ينقصه.

مشكلة حقيقية: ما لم نكتبه في IR، وصف البيانات Data Layout

القراءة load i64 ... align 4 تعني أن المحسن افترض أن عنوان كل عدد من 64 بت مضاعف للرقم 4 فقط، مع أن المترجم على x86-64 يضع كل long على حد 8 بايتات. ولم يحدث هذا بسبب خطأ في المحسن، وإنما لأن ملفنا لم يقل أي شيء عن المعالج. فكل ملف يكتبه Clang يبدأ بسطرين نسيناهما، وهذا ما كتبه Clang وما كتبه rustc على نفس الجهاز:

target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128"
target triple = "x86_64-pc-linux-gnu"
target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu"

السطر target triple يحدد المعالج ونظام التشغيل، والسطر target datalayout نص مضغوط يصف حجم كل نوع ومحاذاته في الذاكرة، فالجزء i64:64 يعني أن العدد من 64 بت يحاذى على 64 بت أي 8 بايتات، وe في البداية تعني Little Endian. وعندما يغيب هذا الوصف يستخدم LLVM قيماً افتراضية من المرجع، وفيها محاذاة أصغر للنوع i64. والجزء الأخير من السكربت يضيف السطرين إلى ملفنا ويعيد التحسين:

== total.ll (no target lines) after opt -O2:
  %p = load i64, ptr %p.addr, align 4
  %q = load i64, ptr %q.addr, align 4
== the same IR with clang's target datalayout and triple, after opt -O2:
  %p = load i64, ptr %p.addr, align 8
  %q = load i64, ptr %q.addr, align 8

مع الوصف صارت المحاذاة 8 كما يجب. والمحاذاة الأصغر من الحقيقة لا تجعل الكود خاطئاً، ولكنها تمنع المحسن من استخدام تعليمات تفترض المحاذاة الكاملة. والدرس الأكبر هنا أن LLVM IR ليس مستقلاً عن المعالج تماماً كما يبدو: فالواجهة الأمامية تكتب حجم long وترتيب المعاملات في الاستدعاء ABI ووصف البيانات لمعالج محدد قبل أن يصل IR إلى المحسن، لذلك لا تأخذ ملف .ll كتبه Clang لمعالج x86-64 وتترجمه إلى معالج آخر، وإنما اطلب من Clang أن يكتبه للمعالج الهدف من البداية بالخيار --target. ونحن نستطيع أن نترجم ملفنا إلى أي معالج في قسم llc لأنه لا يعتمد على أي شيء خاص بالمعالج، فلا يوجد فيه long ولا هياكل ولا استدعاء لمكتبة النظام.

العلامة nsw: كيف تحمل IR وعود اللغة

الآن نعود إلى سؤال مدير الفريق، ونبدأ بالحماية التي اختفت. والملف ub.c هنا فيه الدالة fits_after_increment وحدها، وهذا ما كتبه Clang لها دون تحسين:

define dso_local i32 @fits_after_increment(i32 noundef %0) #0 {
  %2 = alloca i32, align 4
  store i32 %0, ptr %2, align 4
  %3 = load i32, ptr %2, align 4
  %4 = add nsw i32 %3, 1
  %5 = load i32, ptr %2, align 4
  %6 = icmp sgt i32 %4, %5
  %7 = zext i1 %6 to i32
  ret i32 %7
}

السطر المهم هو %4 = add nsw i32 %3, 1. والعلامة nsw هي الطريقة التي تقول بها الواجهة الأمامية للغة C لكل المراحل بعدها: «هذا الجمع لا يتجاوز المدى بإشارة، وإذا تجاوزه فالنتيجة قيمة سامة Poison». وتعريف التعليمة add في المرجع يقول ذلك صراحة، وقسم القيم السامة يشرح أن أي استخدام لها في قرار يجعل السلوك غير معرف. أي أن LLVM لا يعرف شيئاً عن معيار C، والذي يعرفه هو العلامة التي وضعها Clang لأن معيار C يقول إن التجاوز سلوك غير معرف. وهذا ما فعله المحسن بها:

define dso_local noundef i32 @fits_after_increment(i32 noundef %0) local_unnamed_addr #0 {
  ret i32 1
}

نفس return 1 التي رأيناها في GCC. والآن التجربة التي تبين أن السبب العلامة وحدها: أخذنا نفس IR وحذفنا كلمة nsw فقط بالأمر sed، ومررناه على نفس المحسن بنفس المستوى:

define dso_local range(i32 0, 2) i32 @fits_after_increment(i32 noundef %0) local_unnamed_addr #0 {
  %2 = icmp ne i32 %0, 2147483647
  %3 = zext i1 %2 to i32
  ret i32 %3
}

دون العلامة لم يستطع المحسن أن يفترض شيئاً، فالجمع يلف عند الحد، فحول الحماية إلى المقارنة الصحيحة الوحيدة: icmp ne i32 %0, 2147483647، أي «النتيجة 1 إلا إذا كانت x هي أكبر قيمة». ولاحظ أن المحسن لم يحسب الجمع أصلاً، وإنما فهم معنى الحماية وكتبها بأقصر شكل.

نفس الدالة في Rust: إيقاف البرنامج Panic أو اللف Wrapping

والآن كتبنا نفس الدالتين بلغة Rust في الملف invoice.rs:

// invoice.rs: the same invoice total and the same guard, written in Rust
#[no_mangle]
pub fn line_total(price: i64, qty: i64) -> i64 {
    price * qty * 115 / 100
}

#[no_mangle]
pub fn invoice_total(price: &[i64], qty: &[i64]) -> i64 {
    price.iter().zip(qty).map(|(p, q)| line_total(*p, *q)).sum()
}

#[no_mangle]
pub fn fits_after_increment(x: i32) -> bool {
    x + 1 > x
}

وهذا ما كتبه rustc للحماية دون تحسين، أي -C opt-level=0:

define zeroext i1 @fits_after_increment(i32 %x) unnamed_addr #0 {
start:
  %0 = call { i32, i1 } @llvm.sadd.with.overflow.i32(i32 %x, i32 1)
  %_3.0 = extractvalue { i32, i1 } %0, 0
  %_3.1 = extractvalue { i32, i1 } %0, 1
  br i1 %_3.1, label %panic, label %bb1

bb1:                                              ; preds = %start
  %_0 = icmp sgt i32 %_3.0, %x
  ret i1 %_0

panic:                                            ; preds = %start
; call core::panicking::panic_const::panic_const_add_overflow
  call void @_ZN4core9panicking11panic_const24panic_const_add_overflow17h44eace8930cb0ff0E(ptr align 8 @alloc_4aaa80a4ab7e0dd4918dffc0d31cd6ce) #10
  unreachable
}

لا يوجد هنا add nsw أبداً، وإنما الدالة llvm.sadd.with.overflow.i32 التي تعيد النتيجة ومعها بت يقول هل حدث تجاوز، فإذا حدث ذهب التنفيذ إلى الكتلة panic التي توقف البرنامج برسالة. وهذا لأن Rust تفعل فحص التجاوز Overflow Checks في بناء التطوير، كما في توثيق خيارات rustc. والدالة line_total في نفس الملف فيها ثلاثة فحوص: لكل ضرب، وللقسمة لأن قسمة أصغر عدد على سالب واحد تتجاوز المدى. ثم البناء الرسمي -C opt-level=2، حيث تطفأ هذه الفحوص افتراضياً:

define noundef range(i64 -92233720368547758, 92233720368547759) i64 @line_total(i64 noundef %price, i64 noundef %qty) unnamed_addr #0 {
start:
  %_4 = mul i64 %price, 115
  %_3 = mul i64 %_4, %qty
  %_0 = sdiv i64 %_3, 100
  ret i64 %_0
}
define noundef zeroext i1 @fits_after_increment(i32 noundef %x) unnamed_addr #0 {
start:
  %_0 = icmp ne i32 %x, 2147483647
  ret i1 %_0
}

في المخرج أعلاه لاحظ التالي:

  • الدالة line_total هي حرفياً نفس ما كتبه المحسن من ملفنا اليدوي ومن Clang: mul i64 %price, 115 ثم الضرب في الكمية ثم sdiv على 100، ومع نفس range. وهذه إجابة سؤال مدير الفريق: الحساب نفسه يصل إلى نفس المحسن ونفس الواجهة الخلفية، فيخرج نفس الكود. والفروق في الأداء بين C وRust تأتي من أماكن أخرى، مثل فحوص حدود المصفوفات، وطريقة استخدام الذاكرة، والمكتبات، لا من المترجم الخلفي.
  • الحماية في Rust صارت icmp ne i32 %x, 2147483647، أي نفس ما خرج من IR بعد أن حذفنا nsw. والسبب أن Rust تعرف تجاوز المدى في البناء الرسمي بأنه لف معرف، فلا تضع nsw على الجمع، فلا يستطيع المحسن أن يفترض أنه لا يحدث، فتبقى الحماية.

أي أن نفس المحسن، بنفس المراحل، حذف الحماية في C وأبقاها في Rust، والفرق كله في كلمة واحدة كتبتها الواجهة الأمامية حسب وعود لغتها. وهذا يعطيك طريقة عملية لفهم أي لغة مبنية على LLVM: انظر ماذا تكتب واجهتها الأمامية من علامات مثل nsw وnuw وnoalias وinbounds، فكل علامة وعد، وكل وعد فرصة تحسين وخطر في نفس الوقت. وفي مقال أمان الذاكرة رأينا الجانب الآخر من هذه الوعود في الذاكرة.

الحماية x + 1 > x في ثلاثة مسارات إلى نفس المحسن: Clang يكتب add nsw فيصبح الناتج ret i32 1، ونفس IR دون nsw يصبح icmp ne x, 2147483647، وrustc في التطوير يكتب sadd.with.overflow مع panic، وفي البناء الرسمي يكتب add عادية فيصبح الناتج icmp ne x, 2147483647، مع ملاحظة أن line_total خرجت متطابقة من Clang وrustc والملف اليدوي
نفس المحسن ونفس الحماية: كلمة nsw التي تكتبها الواجهة الأمامية هي التي تقرر هل تبقى الحماية

من IR واحد إلى ثلاثة معالجات: llc

الوعد الثاني لأي تمثيل وسيط هو أن الواجهة الخلفية لكل معالج تستقبل نفس الملف. والأداة llc تأخذ الخيار -mtriple لتحدد المعالج الهدف، وحزمة llvm في Debian مبنية بكل المعالجات المدعومة، والأمر llvm-config --targets-built طبع لنا قائمة فيها X86 وAArch64 وRISCV وWebAssembly وغيرها. والجزء الخامس من السكربت يترجم الدالة line_total من الملف المحسن إلى ثلاثة معالجات، وتوثيق llc يشرح الخيارات:

== llc -O2 -mtriple=x86_64-pc-linux-gnu
line_total:                             # @line_total
	imulq	%rsi, %rdi
	imulq	$115, %rdi, %rcx
	movabsq	$-6640827866535438581, %rdx     # imm = 0xA3D70A3D70A3D70B
	movq	%rcx, %rax
	imulq	%rdx
	addq	%rdx, %rcx
	movq	%rcx, %rax
	shrq	$63, %rax
	sarq	$6, %rcx
	addq	%rax, %rcx
	movq	%rcx, %rax
	retq
== llc -O2 -mtriple=aarch64-linux-gnu
line_total:                             // @line_total
	mul	x8, x0, x1
	mov	w9, #115                        // =0x73
	mul	x8, x8, x9
	mov	x9, #55051                      // =0xd70b
	movk	x9, #28835, lsl #16
	movk	x9, #2621, lsl #32
	movk	x9, #41943, lsl #48
	smulh	x9, x8, x9
	add	x8, x9, x8
	asr	x9, x8, #6
	add	x0, x9, x8, lsr #63
	ret
== llc -O2 -mtriple=riscv64-linux-gnu
line_total:                             # @line_total
	addi	sp, sp, -16
	sd	ra, 8(sp)                       # 8-byte Folded Spill
	call	__muldi3
	li	a1, 115
	call	__muldi3
	li	a1, 100
	ld	ra, 8(sp)                       # 8-byte Folded Reload
	addi	sp, sp, 16
	tail	__divdi3
== llc -O2 -mtriple=riscv64-linux-gnu -mattr=+m
line_total:                             # @line_total
	lui	a2, %hi(.LCPI0_0)
	ld	a2, %lo(.LCPI0_0)(a2)
	mul	a0, a0, a1
	li	a1, 115
	mul	a0, a0, a1
	mulh	a1, a0, a2
	add	a0, a1, a0
	srli	a1, a0, 63
	srai	a0, a0, 6
	add	a0, a0, a1
	ret

في المخرج أعلاه لاحظ التالي:

  • في x86-64 ستجد نفس الحيلة التي رأيناها في GCC: القسمة على 100 صارت ضرباً في 0xA3D70A3D70A3D70B ثم إزاحة وتصحيح للإشارة، والمعاملان يأتيان في المسجلين %rdi و%rsi حسب طريقة الاستدعاء في Linux.
  • في AArch64 نفس الرقم السحري، ولكن المعالج لا يستطيع أن يضع ثابتاً من 64 بت في تعليمة واحدة، فبناه على أربع مراحل: mov ثم ثلاث movk كل منها تضع 16 بت في مكانها. والتعليمة smulh تعطي النصف الأعلى من حاصل الضرب، والمعاملان في x0 وx1. نفس الخوارزمية، بلغة معالج آخر.
  • في RISC-V حدث شيء لم نتوقعه: لا يوجد أي ضرب ولا قسمة، وإنما ثلاثة استدعاءات call __muldi3 مرتين وtail __divdi3. والسبب أن المعالج riscv64 في أبسط أشكاله لا يحتوي تعليمات ضرب وقسمة، فهي في إضافة اسمها M Extension، وعندما لا نخبر llc أن المعالج يدعمها يستدعي دوال مكتبة تنفذها بالجمع والإزاحة. وصفحة استخدام RISC-V في توثيق LLVM تشرح هذه الإضافات.
  • مع -mattr=+m عادت تعليمات mul وmulh، والرقم السحري يقرأ من الذاكرة بالتعليمتين lui وld بدل أن يبنى في المسجل. وفي الواقع كل توزيعات Linux على RISC-V تستخدم مجموعة إضافات أوسع تشمل M، لذلك يكتب Clang ذلك تلقائياً عندما تعطيه الهدف الكامل، ولكن llc مع ملف لا يذكر شيئاً يعطيك أبسط معالج.

وهذا نفس درس -march في المقال السابق من زاوية أخرى: المعالج ليس اسماً فقط، وإنما اسم ومجموعة إضافات، وكود الآلة يتغير كثيراً بحسبها. ولكي نتأكد أن الملفات الكائنية حقيقية لكل معالج، بنينا كلاً منها بالخيار -filetype=obj وقرأنا نوع المعالج من رأس ملف ELF بالأداة readelf:

x86_64-pc-linux-gnu    Advanced Micro Devices X86-64
aarch64-linux-gnu      AArch64
riscv64-linux-gnu      RISC-V
الدالة line_total من نفس ملف IR المحسن بأربعة أعمدة: x86-64 بالتعليمة imulq والرقم السحري، وAArch64 ببناء الثابت بأربع تعليمات mov وmovk ثم smulh، وRISC-V الأساسي باستدعاءات __muldi3 و__divdi3، وRISC-V مع الإضافة M بتعليمات mul وmulh
نفس ملف IR وأربع ترجمات: الخوارزمية واحدة، والتعليمات حسب ما يملكه كل معالج

صيغة الفواتير كتمثيل LLVM IR: الأعداد العشرية Floating Point والخيار fast

بدأت هذه المرحلة بصيغة واحدة نفذناها بمفسر شجري ثم بآلة افتراضية: round((price * qty - discount) * (1 + tax), 2). فكيف تبدو لو ولدها مترجم لغتنا كتمثيل LLVM IR؟ كتبناها بأيدينا في الملف formula.ll بالنوع double، ومعها main تطبع النتيجة بالدالة printf من مكتبة C، فتعلمنا في الطريق كيف يصرح IR عن دالة خارجية بالكلمة declare، وكيف يعرف نصاً ثابتاً كمصفوفة بايتات:

; formula.ll: the benchmark formula of the interpreter series, round((price * qty - discount) * (1 + tax), 2), as LLVM IR
@fmt = private constant [16 x i8] c"formula = %.2f\0A\00"

declare i32 @printf(ptr, ...)
declare double @llvm.round.f64(double)

define double @formula(double %price, double %qty, double %discount, double %tax) {
entry:
  %gross = fmul double %price, %qty
  %net = fsub double %gross, %discount
  %rate = fadd double 1.0, %tax
  %total = fmul double %net, %rate
  %scaled = fmul double %total, 100.0
  %rounded = call double @llvm.round.f64(double %scaled)
  %result = fdiv double %rounded, 100.0
  ret double %result
}

define i32 @main() {
entry:
  %v = call double @formula(double 120.0, double 3.0, double 20.0, double 0.15)
  call i32 (ptr, ...) @printf(ptr @fmt, double %v)
  ret i32 0
}

وفي المحاولة الأولى كتبنا طول النص [17 x i8] بعد أن عددنا الحروف بأعيننا، فرفض المحلل الملف:

lli: lli: f17.ll:2:35: error: constant expression type mismatch: got type '[16 x i8]' but expected '[17 x i8]'
@fmt = private constant [17 x i8] c"formula = %.2f\0A\00"
                                  ^

النص formula = %.2f مع سطر جديد وصفر النهاية 16 بايتاً لا 17، وIR لا يحسب الطول عنك لأن كل نوع فيه صريح، وهذا ثمن الدقة التي تجعله سهلاً على الأدوات. وكل مولد IR حقيقي يحسب هذه الأطوال في الكود، ولا يكتبها إنسان. وبعد التصحيح شغلنا الملف بالأداة lli، ثم مررناه على المحسن، ثم أضفنا العلامة fast إلى كل عملية عشرية ومررناه مرة ثانية:

== lli formula.ll
formula = 391.00
== opt -O2: formula
define double @formula(double %price, double %qty, double %discount, double %tax) local_unnamed_addr #2 {
entry:
  %gross = fmul double %price, %qty
  %net = fsub double %gross, %discount
  %rate = fadd double %tax, 1.000000e+00
  %total = fmul double %net, %rate
  %scaled = fmul double %total, 1.000000e+02
  %rounded = tail call double @llvm.round.f64(double %scaled)
  %result = fdiv double %rounded, 1.000000e+02
  ret double %result
}
== opt -O2 with fast-math flags on every operation: formula
define double @formula(double %price, double %qty, double %discount, double %tax) local_unnamed_addr #2 {
entry:
  %gross = fmul fast double %qty, %price
  %net = fsub fast double %gross, %discount
  %rate = fadd fast double %tax, 1.000000e+00
  %total = fmul fast double %net, 1.000000e+02
  %scaled = fmul fast double %total, %rate
  %rounded = tail call double @llvm.round.f64(double %scaled)
  %result = fmul fast double %rounded, 1.000000e-02
  ret double %result
}
== lli on the fast-math version
formula = 391.00

في المخرج أعلاه لاحظ التالي:

  • النتيجة 391.00، نفس ما أعطاه المفسر الشجري والآلة الافتراضية في الجزأين الأولين، ولكن هذه المرة من كود آلة حقيقي كتبه JIT في lli.
  • المحسن مع -O2 لم يغير أي عملية حسابية تقريباً، فقط بدل ترتيب معاملي الجمع. والسبب أن الجمع والضرب في الأعداد العشرية ليسا تجميعيين، فالترتيب يغير النتيجة في البت الأخير أحياناً، كما شرحنا في مقال الأرقام العشرية Floating Point من الداخل، لذلك لا يحق للمحسن أن يعيد الترتيب كما فعل مع الأعداد الصحيحة في line_total.
  • مع العلامة fast صار المحسن حراً: ضرب في 100 قبل الضرب في النسبة بدل بعده، وحول القسمة على 100 إلى ضرب في 1.000000e-02. والعدد 0.01 لا يمثل بدقة في double، فهذه النتيجة قد تختلف عن القسمة في حالات حدية، مع أنها أعطت 391.00 هنا. والعلامة fast هي ما يضعه Clang عندما تبني بالخيار -ffast-math، وقسم Fast-Math Flags في المرجع يشرح كل وعد فيها، ومنها أن القيم ليست NaN ولا لا نهائية.

وهذا يعيدنا إلى درس nsw من زاوية الأعداد العشرية: كل علامة تكتبها الواجهة الأمامية وعد يسمح للمحسن بتحسينات، ولا تكتب في كود مالي وعداً لا تريده، لذلك لا يستخدم -ffast-math في حساب الفواتير.

لماذا تبني Rust و Swift و Zig على LLVM؟

بعد كل ما رأيناه تصبح الإجابة واضحة: من يصمم لغة جديدة يريد أن يركز على اللغة نفسها، أي القواعد والأنواع ونظام الذاكرة ورسائل الخطأ، ولا يريد أن يكتب من الصفر مئات المراحل التي رأيناها، وواجهة خلفية لكل معالج، وتوزيع مسجلات، وكشفاً لتعليمات التوجيه. وLLVM يعطيه كل هذا مقابل شيء واحد: أن يكتب IR صحيحاً. وكل لغة كبيرة اليوم استخدمته بطريقتها:

  • Rust: الواجهة الأمامية في rustc تحلل الكود وتتحقق من الملكية والاستعارة على تمثيلات خاصة بها، ثم تكتب LLVM IR وتسلمه للمحسن والواجهة الخلفية، كما يشرح دليل مطوري rustc. ورأينا بأعيننا أن rustc في Debian يستخدم LLVM 19.1.7 نفسه.
  • Swift: يمر الكود بتمثيل وسيط خاص باللغة اسمه SIL، تطبق عليه تحسينات تحتاج معرفة Swift نفسها، ثم يحول إلى LLVM IR، كما في وصف بنية مترجم Swift. وهذا نمط شائع في اللغات الحديثة: تمثيل وسيط أعلى يفهم اللغة، ثم LLVM IR للتحسينات العامة وكود الآلة.
  • Zig: بنت على LLVM منذ البداية، ولكنها اليوم تحاول الابتعاد عنه، والسبب ثمن LLVM.

وثمن LLVM حقيقي، ويجب أن تعرفه قبل أن تبني عليه:

  • زمن الترجمة: مئتا تشغيل لمراحل على ملف من نحو 35 سطراً عمل كثير، وفي المشاريع الكبيرة يأخذ LLVM جزءاً كبيراً من زمن الترجمة، وخاصة في البناء المحسن. لذلك يوجد لمترجم Rust واجهة خلفية بديلة مبنية على Cranelift للبناء السريع أثناء التطوير، في مستودع rustc_codegen_cranelift، وواجهة أخرى مبنية على GCC لدعم معالجات لا يدعمها LLVM، في مستودع rustc_codegen_gcc.
  • الارتباط بإصدار: كل إصدار من LLVM يغير بعض واجهاته البرمجية، فاللغة المبنية عليه تتبعه في كل ترقية، وأخطاؤه تصبح أخطاءها.
  • الحجم: مكتبات LLVM كبيرة، وبناؤها من المصدر يأخذ وقتاً طويلاً، وهذا يثقل على من يريد مترجماً صغيراً سهل البناء.
  • الوعود المشتركة: دلالات LLVM نفسها، مثل القيم السامة، صممت في الأصل حول احتياجات C وC++، واللغات الأخرى تحتاج أن تكتب IR بحذر حتى لا ترث وعوداً لا تريدها، كما رأينا مع nsw.

ولهذه الأسباب فتح فريق Zig في 2023 القضية رقم 16270 بعنوان جعل برنامج Zig الرئيسي لا يعتمد على مكتبات LLVM وLLD وClang، وفي الإصدار 0.15 صارت الواجهة الخلفية الخاصة بها لمعالجات x86-64 هي الافتراضية في وضع Debug، وملاحظات إصدار Zig 0.15.1 تذكر أن الترجمة في وضع Debug صارت أسرع بخمس مرات بها. ولاحظ أن الهدف ليس رمي LLVM، فهو باق كخيار للبناء الرسمي حيث يهم التحسين، وإنما أن لا تدفع ثمنه في كل مرة تحفظ فيها ملفاً أثناء التطوير. وهذا نفس الميزان الذي رأيناه في سلسلة المفسر: كل مرحلة إضافية تعطي سرعة في التنفيذ، وتأخذ سرعة من البناء.

هل تبني لغتك على LLVM؟ جدول قرار Decision Table

الحالةالأنسبوالسبب
لغة صيغ صغيرة داخل نظام، مثل لغة الفواتيرمفسر شجري أو Bytecode كما في الجزأين الأولينلا تحتاج كود آلة، والبساطة والأمان أهم من السرعة
لغة عامة تريد أداء C على معالجات كثيرةتوليد LLVM IRمئات المراحل وواجهات خلفية لكل معالج مجاناً، كما فعلت Rust وSwift
لغة تريد ترجمة سريعة جداً أثناء التطويرواجهة خلفية خفيفة مثل Cranelift، وLLVM للبناء الرسميالمحسن ثقيل على زمن البناء، وهذا ما دفع Zig وrustc_codegen_cranelift إلى واجهات أخف
تحتاج JIT داخل برنامجك لاستعلامات أو صيغ ثقيلةمكتبات JIT في LLVMlli شغل IR من الذاكرة مباشرة، والمكتبات نفسها متاحة لبرنامجك
تريد أبسط طريق لكود آلة دون تعلم IRتوليد C ثم ترجمتهأبسط في البداية، ولكنك ترث السلوك غير المعرف في C
تحليل كود موجود أو كتابة أداة فحصمرحلة opt خاصة بك على IRكل اللغات المبنية على LLVM تصل إليك بنفس الصيغة

أخطاء شائعة Common Mistakes مع LLVM IR

  • كتابة IR أو توليده دون target datalayout وtarget triple: القراءات صارت align 4 بدل 8 لأن المحسن استخدم القيم الافتراضية.
  • افتراض أن IR الذي كتبه Clang مستقل عن المعالج: حجم long وطريقة الاستدعاء ووصف البيانات مكتوبة فيه لمعالج محدد.
  • بناء كود مالي بالخيار -ffast-math: المحسن حول القسمة على 100 إلى ضرب في 0.01 الذي لا يمثل بدقة.
  • نسيان أن العلامات وعود: وضع nsw على جمع قد يتجاوز المدى جعل المحسن يحذف الحماية، وعدم وضعها حيث يجوز يضيع تحسينات.
  • استخدام قيمة في كتلة لا يسيطر عليها تعريفها: %t من الحلقة في done، والمحقق وحده أمسك الخطأ، فشغله دائماً على ما تولده.
  • محاولة كتابة phi لكل متغير في الواجهة الأمامية: اكتب alloca وload وstore واترك mem2reg تحول الكود كما يفعل Clang.
  • ترجمة لمعالج باسمه فقط: riscv64 دون الإضافة M استدعى __muldi3 لكل عملية ضرب.
  • تسمية LLVM «آلة افتراضية»: هو مترجم يكتب كود الآلة، والاسم لم يعد اختصاراً.
  • افتراض أن LLVM مجاني في زمن البناء: 202 تشغيل لمراحل على ملف من نحو 35 سطراً، لذلك تبحث اللغات عن واجهات أسرع للتطوير.

قائمة تحقق Checklist قبل أن تولد LLVM IR من لغتك

  • كل ملف يبدأ بالسطرين target datalayout وtarget triple للمعالج الهدف.
  • المحقق يعمل على كل دالة تولدها، في الاختبارات على الأقل.
  • المتغيرات المحلية في alloca في كتلة البداية، وmem2reg أو default<O2> تحولها.
  • كل علامة تضعها مثل nsw وnuw وnoalias مكتوب سببها في قواعد لغتك، وما لا تعد به لغتك لا تكتبه.
  • فحوص التجاوز إن أردتها بالدوال llvm.*.with.overflow كما يفعل rustc.
  • تجربة الترجمة إلى أكثر من معالج بالأداة llc، مع الإضافات الصحيحة لكل معالج.
  • قياس زمن البناء مع زمن التنفيذ، وخطة لبناء سريع أثناء التطوير.

تدريب عملي Practice

  • ترجم total-O2.ll بالأمر llc -mtriple=wasm32-unknown-unknown واقرأ الناتج، ولاحظ كيف يبدو كود آلة مكدس بعد أن رأينا آلة المكدس في الجزء الثاني من المفسر.
  • أضف nsw إلى الجمع %sum.next في total.ll ومرره على opt، ثم فكر: هل هذا الوعد صحيح لفاتورة حقيقية؟
  • غير الحماية في invoice.rs إلى x.checked_add(1).is_some() واقرأ IR في المستويين.

حذف المختبر Cleanup

كل التشغيلات استخدمت --rm، والملفات الوسيطة كتبت في /tmp داخل الـ Container، وبقيت الـ Image فقط:

docker rmi scc1-cc

الخلاصة

وصلنا لنهاية الموضوع، وأهم ما فيه:

  • LLVM مجموعة مكتبات مترجمات، لا آلة افتراضية، وقلبها تمثيل وسيط نصي موثق تكتبه أي لغة وتقرؤه كل الأدوات: opt وllc وlli.
  • LLVM IR لغة تجميع بأنواع ومسجلات غير محدودة في صيغة SSA، والمحلل والمحقق يرفضان الإسناد المكرر والقيمة التي لا يسيطر تعريفها على استخدامها.
  • Clang يكتب alloca لكل متغير، وmem2reg تحول الكود إلى SSA لكل اللغات، والمحسن طبق 202 تشغيل لمراحل من 81 نوعاً على ملف من نحو 35 سطراً.
  • غياب target datalayout جعل المحاذاة 4 بدل 8، وIR الذي يكتبه Clang مرتبط بمعالج محدد.
  • العلامة nsw وعد من اللغة: Clang يكتبها فيحذف المحسن الحماية، وrustc لا يكتبها فتبقى الحماية، والحساب نفسه خرج متطابقاً من C وRust والملف اليدوي.
  • نفس IR صار x86-64 وAArch64 وRISC-V، وRISC-V دون الإضافة M استدعى دوال مكتبة للضرب والقسمة.
  • Rust وSwift تبنيان على LLVM لتركزا على اللغة، والثمن زمن البناء والارتباط بالإصدارات، ولذلك صارت Zig 0.15 تستخدم واجهتها الخاصة في وضع Debug.

وفي المقال التالي من هذه المرحلة بإذن الله نكمل الطريق بعد المترجم: ماذا يحدث بين الملف الكائن والبرنامج الذي يعمل، أي الربط والتحميل.

دليلداخل المترجم Compiler: من الكود إلى IR وكود الآلةنفتح GCC وClang على ملف C صغير ونقرأ كل مرحلة يمر بها، من الشجرة إلى SSA والتحسينات وكود الآلة، ونرى كيف حذف المترجم فحصاً بسبب سلوك غير معرف.دليلمن شجرة AST إلى Bytecode وآلة افتراضية VM بيدكنحول لغة الصيغ من الجزء الأول إلى Bytecode تنفذه آلة مكدس صغيرة، ونقرأ مخرجها بجانب dis في CPython، ونقيس بصدق من أين تأتي السرعة.دليلالمترجم Compiler والمفسر Interpreter و JIT و WebAssemblyنشغل دالة واحدة بلغة C وPython وJavaScript وWebAssembly على نفس الجهاز، ونفتح ما كتبه كل مترجم لنعرف لماذا اختلف الوقت من ثلث ثانية إلى دقيقة.دليلاللغة شيء والمترجم شيء آخر: من يقرر مستقبل لغات البرمجة؟لماذا لا تصح جمل مثل «Python بطيئة»، وما الفرق بين مواصفة اللغة والبرامج التي تطبقها، ومن يقرر مستقبلها.دليلأمان الذاكرة Memory Safety: لماذا تدفع الحكومات نحو Rust؟ماذا طلبت الحكومات فعلاً بشأن C وC++، ولماذا تسبب أخطاء الذاكرة أغلب الثغرات الخطيرة، ومتى يكون Rust هو الاختيار الصحيح.دليلمديرو الحزم Package Managers: npm و pip و Maven و Cargoنجرب npm وpip وMaven وCargo على مشروع واحد بأربع لغات، فنقيس كم حزمة تأتي مع كل سطر، ونرى كيف يجعل ملف القفل التثبيت متطابقاً، وكيف خدع حرف واحد في اسم مكتبة مطوري Rust.

سجل التحديثات

  • أكتوبر 2026: كتابة المقال، وتنفيذ كل التجارب داخل Container من الـ Image الرسمية debian:trixie-slim (Debian 13.7) مع Clang وLLVM 19.1.7 وrustc 1.85.1 المبني على LLVM 19.1.7 من حزم Debian، على Docker Engine 29.8.0.
نشرة عرب رووت | ArabRoot

معرفة تستحق مكاناً في بريدك.

مقالات مختارة وأدوات مفيدة وأفكار لمشروعك القادم، في رسالة واحدة كل أسبوع.

يمكنك إلغاء الاشتراك متى شئت. الخصوصية

تم استلام طلبك. افتح بريدك واضغط رابط التأكيد لإتمام الاشتراك.