> ## Content Index
> Fetch the complete content index at: https://arabroot.io/llms.txt
> Use this file to discover other available public pages before exploring further.

# LLVM من الداخل: البنية التي تقف خلف Clang و Rust
- URL: https://arabroot.io/articles/llvm-البنية-التي-تقف-خلف-clang-و-rust-و-swift/
- Published: 2026-10-31T07:14:30.000Z
- Updated: 2026-10-31T08:15:03.000Z
- Description: نكتب LLVM IR لإجمالي فاتورة بأيدينا ونشغله، ونقارن ما يكتبه Clang وrustc لنفس الدالة، ونترجم ملفاً واحداً إلى ثلاثة معالجات، ونرى لماذا تبني عليه لغات كثيرة.
- Author: فريق عرب رووت
- Tags: الأدلة التقنية, أساسيات الحاسب والبرمجة

بعد قصة حماية رقم الفاتورة التي حذفها المترجم في [المقال السابق](https://arabroot.io/articles/%D9%83%D9%8A%D9%81-%D9%8A%D8%B9%D9%85%D9%84-%D8%A7%D9%84%D9%85%D8%AA%D8%B1%D8%AC%D9%85-%D9%85%D9%86-%D8%A7%D9%84%D9%83%D9%88%D8%AF-%D8%A7%D9%84%D9%89-ir-%D9%88%D8%A7%D9%84%D8%AA%D8%AD%D8%B3%D9%8A%D9%86%D8%A7%D8%AA-%D9%88%D9%83%D9%88%D8%AF-%D8%A7%D9%84%D8%A7%D9%84%D8%A9/)، اقترح أحد أعضاء فريق الفواتير أن تعاد كتابة المكتبة بلغة 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، وكان هدفه كما يذكر [موقع المشروع](https://llvm.org/?ref=arabroot.io) تقديم طريقة ترجمة حديثة مبنية على صيغة SSA تدعم الترجمة الثابتة والديناميكية لأي لغة. ونشر Chris Lattner التصميم الأول في [رسالة الماجستير عام 2002](https://llvm.org/pubs/2002-12-LattnerMSThesis.html?ref=arabroot.io). وكان الاسم في البداية اختصاراً لعبارة Low Level Virtual Machine، ولكن المشروع نما ولم يعد للاسم علاقة بالآلات الافتراضية، والموقع نفسه يقول اليوم إن LLVM ليس اختصاراً لشيء، وإنما اسم المشروع كاملاً. لذلك إذا سمعت «آلة LLVM الافتراضية» فاعرف أنها تسمية قديمة: LLVM لا ينفذ Bytecode كما فعلت آلتنا في الجزء الثاني من المفسر، وإنما يترجم إلى كود الآلة الحقيقي.

والفكرة التي جعلت LLVM مختلفاً عن المترجمات التي سبقته هي أنه مجموعة مكتبات لا برنامج واحد. ففي المقال السابق رأينا أن GCC مقسم إلى واجهة أمامية ووسط وواجهة خلفية، ولكن هذه الأجزاء مرتبطة داخل برنامج واحد، ولا يسهل أن تأخذ الوسط وحده وتبني عليه لغتك. أما في LLVM فكل جزء مكتبة لها واجهة واضحة، والتمثيل الوسيط نفسه لغة كاملة موثقة في [مرجع لغة LLVM IR](https://llvm.org/docs/LangRef.html?ref=arabroot.io)، يمكن أن تكتبها في ملف نصي، وتقرأها، وتمررها بين أدوات منفصلة. وشرح Lattner هذا القرار في [فصل LLVM من كتاب The Architecture of Open Source Applications](https://aosabook.org/en/v1/llvm.html?ref=arabroot.io). والأدوات التي سوف نستخدمها كلها تأتي مع حزمة `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](https://llvm.org/docs/DeveloperPolicy.html?ref=arabroot.io)، وهي رخصة تسمح للشركات بأن تبني عليه مترجمات مغلقة المصدر. وهذا، مع تصميم المكتبات، من أسباب انتشاره في الشركات وفي اللغات الجديدة، بينما GCC برخصة GPLv3، وتحدثنا عن أثر الرخص في مقال [من يقرر مستقبل لغات البرمجة](https://arabroot.io/articles/%D9%85%D9%88%D8%A7%D8%B5%D9%81%D8%A7%D8%AA-%D9%84%D8%BA%D8%A7%D8%AA-%D8%A7%D9%84%D8%A8%D8%B1%D9%85%D8%AC%D8%A9-%D9%88%D8%AA%D8%B7%D8%A8%D9%8A%D9%82%D8%A7%D8%AA%D9%87%D8%A7-%D9%88%D8%AD%D9%88%D9%83%D9%85%D8%AA%D9%87%D8%A7/).

![بنية 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](https://arabroot.io/content/images/2026/10/llvm-explained-01-architecture.webp)

لغات كثيرة وتمثيل وسيط واحد ومعالجات كثيرة: 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 دون أي لغة مصدر:

```llvm
; 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` في مجلد المختبر ينفذها كلها:

```bash
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`:

```text
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](https://llvm.org/docs/CommandGuide/lli.html?ref=arabroot.io) يشرح خياراته. ومكتبات JIT في LLVM هي ما تستخدمه مشاريع مثل محركات قواعد البيانات التي تترجم الاستعلامات أثناء التشغيل.

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

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

```text
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`:

```text
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 في نهاية كل كتلة، ومع ذلك الخطآن اللذان رفضهما المحلل والمحقق](https://arabroot.io/content/images/2026/10/llvm-explained-02-anatomy.webp)

تشريح الدالة التي كتبناها بأيدينا: كتل تنتهي كل منها بتفرع أو عودة، وphi حيث تلتقي الطرق

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

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

```llvm
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` حيث تلزم:

```llvm
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](https://arabroot.io/content/images/2026/10/llvm-explained-03-mem2reg.webp)

الواجهة الأمامية تكتب كوداً بسيطاً يستخدم الذاكرة، ومرحلة mem2reg تحوله إلى SSA لكل اللغات

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

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

```llvm
; 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`:

```text
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](https://llvm.org/docs/Passes.html?ref=arabroot.io) تصف كل واحدة، و[صفحة مدير المراحل الجديد](https://llvm.org/docs/NewPassManager.html?ref=arabroot.io) تشرح كيف ترتب في خطوط مثل `default<O2>`. والفائدة العملية أنك تستطيع أن تشغل مرحلة واحدة على ملفك، كما فعلنا مع `mem2reg`، لترى أثرها وحدها، وهذا ما لا يسمح به GCC بسهولة.

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

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

```text
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 على نفس الجهاز:

```text
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`. والجزء الأخير من السكربت يضيف السطرين إلى ملفنا ويعيد التحسين:

```text
== 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 لها دون تحسين:

```llvm
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 في المرجع](https://llvm.org/docs/LangRef.html?ref=arabroot.io#add-instruction) يقول ذلك صراحة، و[قسم القيم السامة](https://llvm.org/docs/LangRef.html?ref=arabroot.io#poison-values) يشرح أن أي استخدام لها في قرار يجعل السلوك غير معرف. أي أن LLVM لا يعرف شيئاً عن معيار C، والذي يعرفه هو العلامة التي وضعها Clang لأن معيار C يقول إن التجاوز سلوك غير معرف. وهذا ما فعله المحسن بها:

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

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

```llvm
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`:

```rust
// 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`:

```llvm
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](https://doc.rust-lang.org/rustc/codegen-options/index.html?ref=arabroot.io). والدالة `line_total` في نفس الملف فيها ثلاثة فحوص: لكل ضرب، وللقسمة لأن قسمة أصغر عدد على سالب واحد تتجاوز المدى. ثم البناء الرسمي `-C opt-level=2`، حيث تطفأ هذه الفحوص افتراضياً:

```llvm
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`، فكل علامة وعد، وكل وعد فرصة تحسين وخطر في نفس الوقت. وفي [مقال أمان الذاكرة](https://arabroot.io/articles/%D8%A7%D9%85%D8%A7%D9%86-%D8%A7%D9%84%D8%B0%D8%A7%D9%83%D8%B1%D8%A9-memory-safety-%D9%84%D9%85%D8%A7%D8%B0%D8%A7-%D8%AA%D8%AF%D9%81%D8%B9-%D8%A7%D9%84%D8%AD%D9%83%D9%88%D9%85%D8%A7%D8%AA-%D9%86%D8%AD%D9%88-rust/) رأينا الجانب الآخر من هذه الوعود في الذاكرة.

![الحماية 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 والملف اليدوي](https://arabroot.io/content/images/2026/10/llvm-explained-04-nsw.webp)

نفس المحسن ونفس الحماية: كلمة nsw التي تكتبها الواجهة الأمامية هي التي تقرر هل تبقى الحماية

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

الوعد الثاني لأي تمثيل وسيط هو أن الواجهة الخلفية لكل معالج تستقبل نفس الملف. والأداة `llc` تأخذ الخيار `-mtriple` لتحدد المعالج الهدف، وحزمة `llvm` في Debian مبنية بكل المعالجات المدعومة، والأمر `llvm-config --targets-built` طبع لنا قائمة فيها X86 وAArch64 وRISCV وWebAssembly وغيرها. والجزء الخامس من السكربت يترجم الدالة `line_total` من الملف المحسن إلى ثلاثة معالجات، و[توثيق llc](https://llvm.org/docs/CommandGuide/llc.html?ref=arabroot.io) يشرح الخيارات:

```text
== 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](https://llvm.org/docs/RISCVUsage.html?ref=arabroot.io) تشرح هذه الإضافات.
- مع `-mattr=+m` عادت تعليمات `mul` و`mulh`، والرقم السحري يقرأ من الذاكرة بالتعليمتين `lui` و`ld` بدل أن يبنى في المسجل. وفي الواقع كل توزيعات Linux على RISC-V تستخدم مجموعة إضافات أوسع تشمل M، لذلك يكتب Clang ذلك تلقائياً عندما تعطيه الهدف الكامل، ولكن `llc` مع ملف لا يذكر شيئاً يعطيك أبسط معالج.

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

```text
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](https://arabroot.io/content/images/2026/10/llvm-explained-05-targets.webp)

نفس ملف IR وأربع ترجمات: الخوارزمية واحدة، والتعليمات حسب ما يملكه كل معالج

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

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

```llvm
; 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]` بعد أن عددنا الحروف بأعيننا، فرفض المحلل الملف:

```text
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` إلى كل عملية عشرية ومررناه مرة ثانية:

```text
== 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 من الداخل](https://arabroot.io/articles/%D8%A7%D9%84%D8%A3%D8%B1%D9%82%D8%A7%D9%85-%D8%A7%D9%84%D8%B9%D8%B4%D8%B1%D9%8A%D8%A9-floating-point-%D9%85%D9%86-%D8%A7%D9%84%D8%AF%D8%A7%D8%AE%D9%84/)، لذلك لا يحق للمحسن أن يعيد الترتيب كما فعل مع الأعداد الصحيحة في `line_total`.
- مع العلامة `fast` صار المحسن حراً: ضرب في 100 قبل الضرب في النسبة بدل بعده، وحول القسمة على 100 إلى ضرب في `1.000000e-02`. والعدد 0.01 لا يمثل بدقة في `double`، فهذه النتيجة قد تختلف عن القسمة في حالات حدية، مع أنها أعطت 391.00 هنا. والعلامة `fast` هي ما يضعه Clang عندما تبني بالخيار `-ffast-math`، و[قسم Fast-Math Flags في المرجع](https://llvm.org/docs/LangRef.html?ref=arabroot.io#fast-math-flags) يشرح كل وعد فيها، ومنها أن القيم ليست `NaN` ولا لا نهائية.

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

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

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

- Rust: الواجهة الأمامية في `rustc` تحلل الكود وتتحقق من الملكية والاستعارة على تمثيلات خاصة بها، ثم تكتب LLVM IR وتسلمه للمحسن والواجهة الخلفية، كما يشرح [دليل مطوري rustc](https://rustc-dev-guide.rust-lang.org/backend/codegen.html?ref=arabroot.io). ورأينا بأعيننا أن `rustc` في Debian يستخدم LLVM 19.1.7 نفسه.
- Swift: يمر الكود بتمثيل وسيط خاص باللغة اسمه SIL، تطبق عليه تحسينات تحتاج معرفة Swift نفسها، ثم يحول إلى LLVM IR، كما في [وصف بنية مترجم Swift](https://www.swift.org/documentation/swift-compiler/?ref=arabroot.io). وهذا نمط شائع في اللغات الحديثة: تمثيل وسيط أعلى يفهم اللغة، ثم LLVM IR للتحسينات العامة وكود الآلة.
- Zig: بنت على LLVM منذ البداية، ولكنها اليوم تحاول الابتعاد عنه، والسبب ثمن LLVM.

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

- زمن الترجمة: مئتا تشغيل لمراحل على ملف من نحو 35 سطراً عمل كثير، وفي المشاريع الكبيرة يأخذ LLVM جزءاً كبيراً من زمن الترجمة، وخاصة في البناء المحسن. لذلك يوجد لمترجم Rust واجهة خلفية بديلة مبنية على Cranelift للبناء السريع أثناء التطوير، في [مستودع rustc\_codegen\_cranelift](https://github.com/rust-lang/rustc%5Fcodegen%5Fcranelift?ref=arabroot.io)، وواجهة أخرى مبنية على GCC لدعم معالجات لا يدعمها LLVM، في [مستودع rustc\_codegen\_gcc](https://github.com/rust-lang/rustc%5Fcodegen%5Fgcc?ref=arabroot.io).
- الارتباط بإصدار: كل إصدار من LLVM يغير بعض واجهاته البرمجية، فاللغة المبنية عليه تتبعه في كل ترقية، وأخطاؤه تصبح أخطاءها.
- الحجم: مكتبات LLVM كبيرة، وبناؤها من المصدر يأخذ وقتاً طويلاً، وهذا يثقل على من يريد مترجماً صغيراً سهل البناء.
- الوعود المشتركة: دلالات LLVM نفسها، مثل القيم السامة، صممت في الأصل حول احتياجات C وC++، واللغات الأخرى تحتاج أن تكتب IR بحذر حتى لا ترث وعوداً لا تريدها، كما رأينا مع `nsw`.

ولهذه الأسباب فتح فريق Zig في 2023 [القضية رقم 16270](https://github.com/ziglang/zig/issues/16270?ref=arabroot.io) بعنوان جعل برنامج Zig الرئيسي لا يعتمد على مكتبات LLVM وLLD وClang، وفي الإصدار 0.15 صارت الواجهة الخلفية الخاصة بها لمعالجات x86-64 هي الافتراضية في وضع Debug، و[ملاحظات إصدار Zig 0.15.1](https://ziglang.org/download/0.15.1/release-notes.html?ref=arabroot.io) تذكر أن الترجمة في وضع Debug صارت أسرع بخمس مرات بها. ولاحظ أن الهدف ليس رمي LLVM، فهو باق كخيار للبناء الرسمي حيث يهم التحسين، وإنما أن لا تدفع ثمنه في كل مرة تحفظ فيها ملفاً أثناء التطوير. وهذا نفس الميزان الذي رأيناه في سلسلة المفسر: كل مرحلة إضافية تعطي سرعة في التنفيذ، وتأخذ سرعة من البناء.

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

| الحالة                                         | الأنسب                                               | والسبب                                                                                |
| ---------------------------------------------- | ---------------------------------------------------- | ------------------------------------------------------------------------------------- |
| لغة صيغ صغيرة داخل نظام، مثل لغة الفواتير      | مفسر شجري أو Bytecode كما في الجزأين الأولين         | لا تحتاج كود آلة، والبساطة والأمان أهم من السرعة                                      |
| لغة عامة تريد أداء C على معالجات كثيرة         | توليد LLVM IR                                        | مئات المراحل وواجهات خلفية لكل معالج مجاناً، كما فعلت Rust وSwift                     |
| لغة تريد ترجمة سريعة جداً أثناء التطوير        | واجهة خلفية خفيفة مثل Cranelift، وLLVM للبناء الرسمي | المحسن ثقيل على زمن البناء، وهذا ما دفع Zig وrustc\_codegen\_cranelift إلى واجهات أخف |
| تحتاج JIT داخل برنامجك لاستعلامات أو صيغ ثقيلة | مكتبات JIT في LLVM                                   | lli شغل 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 فقط:

```bash
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.

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

[![](https://arabroot.io/content/images/2026/10/compiler-pipeline-cover-cover.webp)دليلداخل المترجم Compiler: من الكود إلى IR وكود الآلةنفتح GCC وClang على ملف C صغير ونقرأ كل مرحلة يمر بها، من الشجرة إلى SSA والتحسينات وكود الآلة، ونرى كيف حذف المترجم فحصاً بسبب سلوك غير معرف.](https://arabroot.io/articles/%D9%83%D9%8A%D9%81-%D9%8A%D8%B9%D9%85%D9%84-%D8%A7%D9%84%D9%85%D8%AA%D8%B1%D8%AC%D9%85-%D9%85%D9%86-%D8%A7%D9%84%D9%83%D9%88%D8%AF-%D8%A7%D9%84%D9%89-ir-%D9%88%D8%A7%D9%84%D8%AA%D8%AD%D8%B3%D9%8A%D9%86%D8%A7%D8%AA-%D9%88%D9%83%D9%88%D8%AF-%D8%A7%D9%84%D8%A7%D9%84%D8%A9/)[![](https://arabroot.io/content/images/2026/10/bytecode-vm-cover-cover.webp)دليلمن شجرة AST إلى Bytecode وآلة افتراضية VM بيدكنحول لغة الصيغ من الجزء الأول إلى Bytecode تنفذه آلة مكدس صغيرة، ونقرأ مخرجها بجانب dis في CPython، ونقيس بصدق من أين تأتي السرعة.](https://arabroot.io/articles/%D9%85%D9%86-%D8%B4%D8%AC%D8%B1%D8%A9-ast-%D8%A7%D9%84%D9%89-bytecode-%D9%88%D8%A7%D9%84%D8%A9-%D8%A7%D9%81%D8%AA%D8%B1%D8%A7%D8%B6%D9%8A%D8%A9-vm/)[![](https://arabroot.io/content/images/2026/10/compilation-jit-cover-cover.webp)دليلالمترجم Compiler والمفسر Interpreter و JIT و WebAssemblyنشغل دالة واحدة بلغة C وPython وJavaScript وWebAssembly على نفس الجهاز، ونفتح ما كتبه كل مترجم لنعرف لماذا اختلف الوقت من ثلث ثانية إلى دقيقة.](https://arabroot.io/articles/%D8%A7%D9%84%D9%85%D8%AA%D8%B1%D8%AC%D9%85-%D9%88%D8%A7%D9%84%D9%85%D9%81%D8%B3%D8%B1-%D9%88-jit-%D9%88-webassembly-%D8%A8%D8%A7%D9%84%D8%AA%D9%81%D8%B5%D9%8A%D9%84/)[![](https://arabroot.io/content/images/2026/10/language-specs-cover-cover.webp)دليلاللغة شيء والمترجم شيء آخر: من يقرر مستقبل لغات البرمجة؟لماذا لا تصح جمل مثل «Python بطيئة»، وما الفرق بين مواصفة اللغة والبرامج التي تطبقها، ومن يقرر مستقبلها.](https://arabroot.io/articles/%D9%85%D9%88%D8%A7%D8%B5%D9%81%D8%A7%D8%AA-%D9%84%D8%BA%D8%A7%D8%AA-%D8%A7%D9%84%D8%A8%D8%B1%D9%85%D8%AC%D8%A9-%D9%88%D8%AA%D8%B7%D8%A8%D9%8A%D9%82%D8%A7%D8%AA%D9%87%D8%A7-%D9%88%D8%AD%D9%88%D9%83%D9%85%D8%AA%D9%87%D8%A7/)[![](https://arabroot.io/content/images/2026/10/memory-safety-rust-cover-cover.webp)دليلأمان الذاكرة Memory Safety: لماذا تدفع الحكومات نحو Rust؟ماذا طلبت الحكومات فعلاً بشأن C وC++، ولماذا تسبب أخطاء الذاكرة أغلب الثغرات الخطيرة، ومتى يكون Rust هو الاختيار الصحيح.](https://arabroot.io/articles/%D8%A7%D9%85%D8%A7%D9%86-%D8%A7%D9%84%D8%B0%D8%A7%D9%83%D8%B1%D8%A9-memory-safety-%D9%84%D9%85%D8%A7%D8%B0%D8%A7-%D8%AA%D8%AF%D9%81%D8%B9-%D8%A7%D9%84%D8%AD%D9%83%D9%88%D9%85%D8%A7%D8%AA-%D9%86%D8%AD%D9%88-rust/)[![](https://arabroot.io/content/images/2026/10/package-managers-cover-cover.webp)دليلمديرو الحزم Package Managers: npm و pip و Maven و Cargoنجرب npm وpip وMaven وCargo على مشروع واحد بأربع لغات، فنقيس كم حزمة تأتي مع كل سطر، ونرى كيف يجعل ملف القفل التثبيت متطابقاً، وكيف خدع حرف واحد في اسم مكتبة مطوري Rust.](https://arabroot.io/articles/%D9%85%D8%AF%D9%8A%D8%B1%D9%88-%D8%A7%D9%84%D8%AD%D8%B2%D9%85-npm-%D9%88-pip-%D9%88-maven-%D9%88-cargo/)

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

- أكتوبر 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.