> ## 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.

# معمارية المعالج ISA: لماذا لا يعمل برنامج x86 على ARM؟
- URL: https://arabroot.io/articles/معمارية-المعالج-isa-ولماذا-لا-يعمل-برنامج-x86-على-arm/
- Published: 2026-11-16T18:38:49.000Z
- Updated: 2026-11-16T21:59:31.000Z
- Description: نترجم نفس برنامج C لثلاث معماريات ونقرأ تعليماته سطراً سطراً، لنفهم ما الذي يجعل الملف التنفيذي يعمل على معالج ويرفضه معالج آخر.
- Author: فريق عرب رووت
- Tags: الأدلة التقنية, أساسيات الحاسب والبرمجة, لينكس والسيرفرات

إذا فتحت صفحة الإصدارات لأي أداة مشهورة على GitHub، مثل محرك قاعدة بيانات أو أداة سطر أوامر، فسوف تجد نفس الأداة بنفس رقم الإصدار في عدة ملفات: واحد ينتهي بـ `linux-amd64` وآخر بـ `linux-arm64` وربما ثالث بـ `riscv64`، وقد تسأل نفسك: لماذا لا يكفي ملف واحد؟ الكود نفسه واحد، والنظام نفسه Linux، فما الذي يجعل ملفاً يعمل على السيرفر وآخر يرفض العمل عليه برسالة غريبة مثل `exec format error`؟ ونفس السؤال يظهر عندما تبني Docker Image على جهاز Mac حديث ثم ترفعها إلى VPS فلا تعمل، أو عندما تشتري Raspberry Pi وتكتشف أن البرنامج الذي تعرفه على حاسبك لا يوجد له ملف جاهز لهذه اللوحة.

والإجابة المختصرة أن الملف التنفيذي ليس «برنامجاً» بالمعنى المجرد، وإنما بايتات مكتوبة بلغة معالج محدد، وهذه اللغة اسمها معمارية مجموعة التعليمات Instruction Set Architecture، واختصاراً ISA. وقد ذكرنا هذا باختصار في مقال [كيف يعمل المعالج من الداخل](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%B9%D8%A7%D9%84%D8%AC-cpu-%D9%85%D9%86-%D8%A7%D9%84%D8%AF%D8%A7%D8%AE%D9%84/#isa) عندما قارنا دالة واحدة مترجمة لـ x86-64 وARM64، وفي مقال [ماذا يحدث عندما تشغل Hello World](https://arabroot.io/articles/%D8%B1%D8%AD%D9%84%D8%A9-hello-world-%D9%85%D9%86-%D9%84%D9%88%D8%AD%D8%A9-%D8%A7%D9%84%D9%85%D9%81%D8%A7%D8%AA%D9%8A%D8%AD-%D8%A7%D9%84%D9%89-%D8%A7%D9%84%D8%B4%D8%A7%D8%B4%D8%A9/#arch-mismatch) عندما رأينا الخطأ لأول مرة، أما هنا فسوف نفتح الموضوع كاملاً، وهذا أول مقال في مرحلة المعالجات من مسار أساسيات الحاسب. وسوف نناقش في هذا المقال ما يلي:

- ما هي ال ISA بالضبط، ولماذا نسميها عقداً بين البرنامج والشريحة، وما الفرق بينها وبين المعمارية الدقيقة Microarchitecture.
- الأشياء الستة التي تحددها ال ISA: التعليمات والمسجلات والعنونة والترميز ونموذج الذاكرة والصلاحيات.
- الواجهة الثنائية ABI واتفاقية الاستدعاء Calling Convention، ولماذا لا تكفي ال ISA وحدها لتشغيل برنامج.
- مختبر حقيقي: نفس برنامج C مترجم لثلاث معماريات هي x86-64 وARM64 وRISC-V، نقرأ تعليماته سطراً سطراً، ونرى الخطأ `exec format error` كما يحدث فعلاً، ثم نشغل الملفات عبر المحاكي QEMU.
- برنامج بلغة التجميع Assembly دون مكتبة C لكل معمارية، يطلب من النواة مباشرة، لنرى أين يختلف كل شيء.
- لماذا لا يعمل برنامج x86 على ARM، وما الطبقات التي يتوقف عندها.
- ماذا يحدث داخل نفس المعمارية عندما يبني المترجم لمستوى أعلى من معالجك، مع خطأ `Illegal instruction` حقيقي.
- ما يعنيه كل هذا لك عملياً: أسماء المعماريات في Docker وفي ملفات الإصدارات، والأخطاء الشائعة، وجدول قرار.

## ما هي معمارية مجموعة التعليمات ISA؟

معمارية مجموعة التعليمات هي الوصف الكامل لما يستطيع المعالج أن يفهمه وينفذه، كما يراه البرنامج: ما التعليمات الموجودة، وما المسجلات التي تعمل عليها، وكيف تكتب كل تعليمة بالبايتات، وماذا يحدث عند الخطأ أو المقاطعة. والكلمة المهمة هنا «كما يراه البرنامج»، لأن ال ISA لا تقول شيئاً عن كيفية تنفيذ المعالج للتعليمة من الداخل، وإنما تقول فقط: إذا وضعت هذه البايتات في الذاكرة وأشرت إليها، فسوف تحصل على هذه النتيجة.

ولتقريب الفكرة تخيل ال ISA كعقد بين طرفين لا يعرف أحدهما الآخر: الطرف الأول هو من يكتب المترجم Compiler ونظام التشغيل والبرامج، والطرف الثاني هو الشركة التي تصمم الشريحة. فالمترجم ينتج بايتات مطابقة للعقد، والشريحة تنفذ أي بايتات مطابقة للعقد، وبالتالي يستطيع برنامج ترجم في 2010 أن يعمل على معالج صنع في 2026، ويستطيع معالج من AMD أن يشغل برنامجاً ترجم على جهاز فيه معالج Intel، لأن الطرفين التزما بنفس العقد وهو x86-64\. والصورة التالية تبين هذه الفكرة: ثلاثة ملفات لنفس البرنامج من مختبر هذا المقال، وتحت كل ملف العقد الذي كتب به، وتحت كل عقد عدة شرائح مختلفة تماماً من الداخل:

![رسم من ثلاثة أعمدة: في الأعلى ثلاثة ملفات لنفس البرنامج price-x86_64 وprice-aarch64 وprice-riscv64 ولكل منها رقم معمارية في رأس ELF، وتحتها ثلاثة صناديق ملونة للمعماريات x86-64 وARM64 وRISC-V مع طول التعليمة وعدد المسجلات، وتحتها شرائح مختلفة لكل معمارية مثل Core i7-7700K وRyzen 9 9950X لـ x86-64 وApple M وGraviton وRaspberry Pi 5 لـ ARM64 وJH7110 وQEMU لـ RISC-V، وفي الأسفل ملاحظتان: داخل العمود الواحد يعمل نفس الملف على كل الشرائح، وبين الأعمدة ترفضه النواة بالخطأ Exec format error](https://arabroot.io/content/images/2026/11/isa-explained-01-contract.webp)

ال ISA عقد: ملف واحد لكل عقد، وشرائح كثيرة تحت كل عقد

ولاحظ في الصورة أن الحد الحقيقي ليس بين الشركات وإنما بين العقود، فمعالج Intel ومعالج AMD في نفس العمود لأنهما يتكلمان x86-64، بينما معالج Apple ومعالج Raspberry Pi وسيرفرات AWS Graviton في عمود آخر لأنها تتكلم ARM64، مع أن الشركات الثلاث مختلفة. وهذا ما يجعل جملة «برنامج x86 لا يعمل على ARM» دقيقة، وجملة «برنامج Intel لا يعمل على AMD» غير صحيحة.

### المعمارية الدقيقة Microarchitecture: نفس العقد وشرائح مختلفة

إذا كانت ال ISA هي العقد، فالمعمارية الدقيقة Microarchitecture هي الطريقة التي ينفذ بها مصمم الشريحة هذا العقد: كم مرحلة في خط التنفيذ Pipeline، وكم تعليمة يفك في النبضة الواحدة، وحجم ال Cache، ودقة متوقع التفرعات، وهل ينفذ التعليمات خارج الترتيب. وهذه الأشياء التي شرحناها في [مقال المعالج من الداخل](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%B9%D8%A7%D9%84%D8%AC-cpu-%D9%85%D9%86-%D8%A7%D9%84%D8%AF%D8%A7%D8%AE%D9%84/#pipeline) كلها من المعمارية الدقيقة، ولا يراها البرنامج إلا كفرق في السرعة. فمعالج جهاز التجارب في هذا المقال، وهو Intel Core i7-7700K، معماريته الدقيقة اسمها Kaby Lake، ومعالج AMD Ryzen 9 9950X معماريته الدقيقة Zen 5 كما تذكر [صفحته عند AMD](https://www.amd.com/en/products/processors/desktops/ryzen/9000-series/amd-ryzen-9-9950x.html?ref=arabroot.io)، وهما مختلفان تماماً من الداخل، ولكن نفس الملف التنفيذي يعمل على الاثنين دون تغيير.

والعكس صحيح أيضاً: يمكن أن تكون المعمارية الدقيقة متشابهة جداً بين شريحتين بعقدين مختلفين، فأفكار مثل التنفيذ خارج الترتيب Out-of-Order Execution وتوقع التفرعات موجودة اليوم في معالجات x86-64 وARM64 وRISC-V الكبيرة كلها. وبالتالي عندما تقرأ مقارنة بين «Intel وApple» فاسأل نفسك أولاً: هل المقارنة بين عقدين، أم بين تصميمين داخليين، أم بين مصنعين؟ لأن هذه ثلاثة أسئلة مختلفة، وسوف نعود إليها في مقال [CISC أم RISC](#further) من نفس المرحلة.

والصورة التالية فيها ثلاث صور حقيقية لثلاث شرائح من ثلاثة عقود: معالج Intel Core i7-12700KF يتكلم x86-64، ولوحة Raspberry Pi 5 التي يتكلم معالجها ARM64، ولوحة StarFive VisionFive 2 التي يتكلم معالجها RISC-V:

![ثلاث صور حقيقية متجاورة: على اليمين معالج Intel Core i7-12700KF بغطائه المعدني الفضي ومكتوب عليه اسمه ورمز SRL4P أمام علبته الزرقاء، وفي الوسط لوحة Raspberry Pi 5 الخضراء وعليها شريحة المعالج المعدنية ومنافذ USB وHDMI، وعلى اليسار لوحة StarFive VisionFive 2 السوداء وعليها شريحة JH7110 ومنافذ USB الزرقاء ومنفذا شبكة](https://arabroot.io/content/images/2026/11/isa-explained-02-three-isas.webp)

ثلاث شرائح وثلاثة عقود: x86-64 ثم ARM64 ثم RISC-V. الصور من Wikimedia Commons: [Core i7-12700KF](https://commons.wikimedia.org/wiki/File:2023%5FIntel%5FCore%5Fi7%5F12700KF%5F%281%29.jpg?ref=arabroot.io) لـ Jacek Halicki بترخيص CC BY-SA 4.0، و[Raspberry Pi 5](https://commons.wikimedia.org/wiki/File:Raspberry%5FPi%5F5%5FSBC.jpg?ref=arabroot.io) لـ SimonWaldherr بترخيص CC BY 4.0، و[VisionFive 2](https://commons.wikimedia.org/wiki/File:Starfive%5FVisionFive2%5FSingle%5FBoard%5FComputer.jpg?ref=arabroot.io) لـ Teeks99 بترخيص CC BY-SA 4.0، واقتطعنا صورة Intel حول المعالج

ومن الخارج لا يوجد ما يدلك على العقد، فكلها شرائح مربعة على لوحات، ولذلك لا تعتمد على الشكل أو اسم الجهاز لتعرف المعمارية، وإنما على أمر واحد مثل `uname -m` كما سوف نرى في [الجزء العملي](#practical).

## ماذا تحدد ال ISA بالضبط؟

قد يبدو تعريف «لغة المعالج» غامضاً، ولكنه في الحقيقة مكتوب في مستندات طويلة جداً تنشرها الشركات: [دليل Intel للمطورين](https://www.intel.com/content/www/us/en/developer/articles/technical/intel-sdm.html?ref=arabroot.io) لـ x86-64، و[دليل معمارية Arm](https://developer.arm.com/documentation/ddi0487/latest?ref=arabroot.io) لـ ARM64، و[دليل RISC-V](https://github.com/riscv/riscv-isa-manual?ref=arabroot.io) المفتوح على GitHub. وإذا جمعت ما في هذه المستندات فسوف تجد ستة أشياء أساسية، تبينها الصورة التالية مع مثال حقيقي لكل منها من مخرج المختبر:

![ست بطاقات مرقمة: التعليمات مع مثال add على x86-64 وldr على ARM64، والمسجلات مع عددها 16 و31 و32، والعنونة مع مثال lea بعنوان أساس ومؤشر مضروب في 8، والترميز مع التعليمة ret بطول بايت واحد على x86-64 وأربعة على ARM64 واثنين على RISC-V، والذاكرة مع ترتيب البايتات little endian، والصلاحيات مع تعليمات syscall وsvc وecall](https://arabroot.io/content/images/2026/11/isa-explained-03-parts.webp)

ستة أشياء في كل ISA، والأمثلة كلها من مخرج المختبر

وفيما يلي كل واحد منها باختصار، لأننا سوف نراها كلها في المختبر:

1. **التعليمات Instructions:** قائمة العمليات المتاحة، مثل الجمع والضرب والمقارنة والقفز وتحميل قيمة من الذاكرة وتخزينها. وبعض ال ISAs فيها تعليمات تفعل أشياء كثيرة في خطوة واحدة، مثل تعليمة x86-64 التي تقرأ من الذاكرة وتجمع في نفس الوقت، وبعضها يفصل القراءة عن الحساب، وهذا الفرق هو أصل نقاش CISC وRISC.
2. **المسجلات Registers:** الخانات الصغيرة داخل المعالج التي تجري عليها الحسابات، وعددها وحجمها جزء من العقد: في x86-64 ستة عشر مسجلاً عاماً بحجم 64 بت من `rax` إلى `r15`، وفي ARM64 واحد وثلاثون من `x0` إلى `x30`، وفي RISC-V اثنان وثلاثون من `x0` إلى `x31`، والأول منها `x0` قيمته صفر دائماً.
3. **العنونة Addressing Modes:** الطرق التي تصف بها التعليمة مكان البيانات في الذاكرة، مثل «العنوان في هذا المسجل» أو «العنوان في هذا المسجل زائد ثمانية أضعاف ذاك».
4. **الترميز Encoding:** كيف تكتب كل تعليمة بالبايتات، وهذا هو الجزء الذي يجعل الملف غير مفهوم لمعالج آخر، فالتعليمة `ret` مثلاً هي البايت `c3` في x86-64، والبايتات `d65f03c0` في ARM64، والبايتان `8082` في RISC-V.
5. **نموذج الذاكرة Memory Model:** ترتيب البايتات Endianness، وأحجام البيانات، والقواعد التي تحدد متى ترى نواة ما كتبته نواة أخرى، وهذه القواعد الأخيرة هي سبب كثير من مشاكل التزامن التي ذكرناها في [مقال الخيوط والأقفال](https://arabroot.io/articles/%D8%A7%D9%84%D8%AE%D9%8A%D9%88%D8%B7-threads-%D9%88%D8%A7%D9%84%D8%A3%D9%82%D9%81%D8%A7%D9%84-%D9%88-async-%D9%84%D9%84%D9%85%D8%A8%D8%B1%D9%85%D8%AC%D9%8A%D9%86/).
6. **الصلاحيات والاستثناءات Privilege and Exceptions:** مستويات التنفيذ مثل وضع النواة ووضع المستخدم، وماذا يحدث عند المقاطعة أو الخطأ، وكيف يطلب البرنامج خدمة من النواة، وهذا ما شرحناه بالتفصيل في [مقال استدعاءات النظام](https://arabroot.io/articles/%D9%81%D8%B6%D8%A7%D8%A1-%D8%A7%D9%84%D9%86%D9%88%D8%A7%D8%A9-%D9%88%D9%81%D8%B6%D8%A7%D8%A1-%D8%A7%D9%84%D9%85%D8%B3%D8%AA%D8%AE%D8%AF%D9%85-%D9%88%D8%A7%D8%B3%D8%AA%D8%AF%D8%B9%D8%A7%D8%A1%D8%A7%D8%AA-%D8%A7%D9%84%D9%86%D8%B8%D8%A7%D9%85/) على x86-64.

ولاحظ ما لا يوجد في القائمة: عدد الأنوية، وحجم ال Cache، والسرعة بالجيجاهرتز، وعدد مراحل خط التنفيذ. هذه كلها من المعمارية الدقيقة، ولذلك يمكن أن يتكلم معالج بنواتين ومعالج بمئة وثمانية وعشرين نواة نفس العقد تماماً.

## الواجهة الثنائية ABI: لماذا لا تكفي ال ISA وحدها؟

قد يتساءل البعض: إذا كان معالجا جهازين يتكلمان x86-64، فهل يعمل أي ملف من الأول على الثاني؟ والإجابة: ليس بالضرورة، لأن البرنامج لا يتكلم مع المعالج وحده، وإنما مع نظام التشغيل والمكتبات أيضاً، وهنا يأتي عقد ثان فوق ال ISA اسمه الواجهة الثنائية للتطبيقات Application Binary Interface، واختصاراً ABI. وال ABI تجيب عن أسئلة لا تجيب عنها ال ISA: في أي مسجل تضع المعامل الأول للدالة؟ وأين تجد القيمة الراجعة؟ وأي المسجلات يجب أن تحافظ عليها الدالة لمن استدعاها؟ وكيف تحاذى ال Stack؟ وما رقم كل طلب من النواة؟ وما شكل الملف التنفيذي نفسه؟

ولنأخذ مثالاً يبين أن ال ABI شيء منفصل عن ال ISA: على Linux تتبع برامج x86-64 الوثيقة [System V x86-64 psABI](https://gitlab.com/x86-psABIs/x86-64-ABI?ref=arabroot.io)، وفيها يأتي المعامل الأول في `rdi` والثاني في `rsi`، بينما على Windows تتبع نفس المعالجات [اتفاقية Microsoft لـ x64](https://learn.microsoft.com/en-us/cpp/build/x64-calling-convention?ref=arabroot.io)، وفيها يأتي المعامل الأول في `rcx` والثاني في `rdx`. فنفس العقد x86-64 ونفس المعالج، ولكن دالة مترجمة لأحد النظامين تقرأ معاملاتها من المسجلات الخطأ إذا استدعيتها من الآخر. وهذا أحد أسباب أن ملف `.exe` لا يعمل على Linux مباشرة، مع أن التعليمات نفسها مفهومة للمعالج.

وأهم جزء في ال ABI للمطور هو اتفاقية الاستدعاء Calling Convention، والصورة التالية تلخصها للمعماريات الثلاث على Linux بحسب [psABI لـ x86-64](https://gitlab.com/x86-psABIs/x86-64-ABI?ref=arabroot.io) و[AAPCS64 لـ ARM64](https://github.com/ARM-software/abi-aa/blob/main/aapcs64/aapcs64.rst?ref=arabroot.io) و[psABI لـ RISC-V](https://github.com/riscv-non-isa/riscv-elf-psabi-doc?ref=arabroot.io)، مع طريقة الطلب من النواة كما تصفها صفحة [syscall(2)](https://man7.org/linux/man-pages/man2/syscall.2.html?ref=arabroot.io):

![جدول بثلاثة أعمدة x86-64 وaarch64 وriscv64: المعاملات الثلاثة الأولى في rdi rsi rdx أو x0 x1 x2 أو a0 a1 a2، والقيمة الراجعة في rax أو x0 أو a0، وعنوان الرجوع على ال Stack أو في x30 أو في ra، وتعليمة استدعاء الدالة call أو bl أو jal، وتعليمة الطلب من النواة syscall أو svc #0 أو ecall، ومسجل رقم الطلب rax أو x8 أو a7، ورقما write وexit هما 1 و60 على x86-64 و64 و93 على المعماريتين الأخريين، ورقم المعمارية في رأس ELF 0x3e و0xb7 و0xf3](https://arabroot.io/content/images/2026/11/isa-explained-04-abi.webp)

اتفاقية الاستدعاء وطلبات النواة على Linux للمعماريات الثلاث

في الجدول أعلاه لاحظ التالي:

- عنوان الرجوع في x86-64 يوضع على ال Stack بالتعليمة `call` نفسها، بينما في ARM64 وRISC-V يوضع في مسجل خاص هو `x30` أو `ra`، وهذا فرق في ال ISA نفسها وليس في ال ABI فقط، وسوف نرى أثره في كود الدالة `main`.
- أرقام طلبات النواة ليست واحدة: الطلب `write` رقمه 1 على x86-64 و64 على ARM64 وRISC-V، والسبب أن Linux على x86-64 احتفظ بترتيب قديم في [جدوله الخاص](https://github.com/torvalds/linux/blob/master/arch/x86/entry/syscalls/syscall%5F64.tbl?ref=arabroot.io)، بينما المعماريات الأحدث تستخدم [الجدول المشترك](https://github.com/torvalds/linux/blob/master/include/uapi/asm-generic/unistd.h?ref=arabroot.io) الذي وضع لها.
- رقم المعمارية في رأس ملف ELF هو أول ما تنظر إليه النواة قبل التشغيل، وقيمه موثقة في صفحة [elf(5)](https://man7.org/linux/man-pages/man5/elf.5.html?ref=arabroot.io)، وسوف نقرؤه بالبايت في المختبر.

وتغير ال ABI بين إصدارين من نفس المكتبة مشكلة أخرى شرحناها في مقال [الرابط والمحمل](https://arabroot.io/articles/%D8%A7%D9%84%D8%B1%D8%A7%D8%A8%D8%B7-linker-%D9%88%D8%A7%D9%84%D9%85%D8%AD%D9%85%D9%84-loader-%D9%85%D8%A7%D8%B0%D8%A7-%D9%8A%D8%AD%D8%AF%D8%AB-%D9%82%D8%A8%D9%84-main/#what-if-abi)، أما هنا فيهمنا ال ABI بين المعمارية والنظام.

## تجهيز المختبر Lab Setup

سوف نترجم نفس البرنامج لثلاث معماريات على جهاز واحد، وهذا ممكن لأن المترجم لا يحتاج أن يعمل على المعالج الذي يترجم له، وهذا ما يسمى الترجمة المتقاطعة Cross Compilation. ونحتاج لذلك ثلاثة مترجمات GCC ومكتبة C لكل معمارية، وأدوات `objdump` لكل معمارية لقراءة التعليمات، والمحاكي QEMU في وضع المستخدم User Mode لتشغيل الملفات الغريبة عن جهازنا، وكلها في Debian 13\. والملف التالي هو Dockerfile المختبر:

```dockerfile
FROM debian:trixie-slim
RUN apt-get update && apt-get install -y --no-install-recommends \
      gcc libc6-dev gcc-aarch64-linux-gnu libc6-dev-arm64-cross gcc-riscv64-linux-gnu libc6-dev-riscv64-cross \
      binutils qemu-user file cpuid nasm qemu-system-x86 qemu-system-gui- \
    && rm -rf /var/lib/apt/lists/*
WORKDIR /lab
```

نبني ال Image ونفتح Container يرى مجلد المختبر:

```bash
mkdir isa-lab && cd isa-lab      # put the Dockerfile and the lab files here
docker build -t cs1-isa:1 .
docker run --rm -it --name cs1-isa -v "$PWD:/lab" cs1-isa:1 bash
```

وحجم ال Image النهائي قرابة 400 MB، والحزمتان `nasm` و`qemu-system-x86` لن نحتاجهما هنا، ولكننا نستخدم نفس ال Image في مقال [قصة x86](#further) لنقلع قطاع إقلاع حقيقياً، فثبتناهما مرة واحدة. والأمر `uname -m` داخل ال Container يطبع `x86_64`، أي أن كل ما سوف نشغله دون محاكي يعمل على معالج Intel Core i7-7700K مباشرة.

## نفس البرنامج لثلاث معماريات

البرنامج الذي سوف نتابعه صغير عن قصد، فهو دالة تجمع أسعار سلة مشتريات ثم تضيف عليها نسبة الضريبة، ودالة `main` تستدعيها وتطبع النتيجة:

```c
// price.c: the same small C program, compiled for three instruction sets
#include <stdio.h>

__attribute__((noinline))
long total(const long *prices, long n, long tax_percent)
{
    long sum = 0;
    for (long i = 0; i < n; i++)
        sum += prices[i];
    return sum + sum * tax_percent / 100;
}

int main(void)
{
    long prices[4] = {120, 80, 45, 255};
    printf("total = %ld\n", total(prices, 4, 15));
    return 0;
}
```

والخاصية `noinline` تمنع المترجم من دمج الدالة داخل `main`، لأنه بدونها سوف يحسب النتيجة كلها وقت الترجمة ويطبع الرقم مباشرة، كما رأينا في مقال [داخل المترجم](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/#inlining)، ونحن نريد أن نرى كيف تمر المعاملات بين دالتين. الآن نترجم البرنامج ثلاث مرات، مرة بكل مترجم، ونطلب ملفات ثابتة Static لا تحتاج مكتبات من النظام، ثم نسأل الأداة [file](https://man7.org/linux/man-pages/man1/file.1.html?ref=arabroot.io) عن كل ملف:

```bash
gcc -O2 -static price.c -o price-x86_64
aarch64-linux-gnu-gcc -O2 -static price.c -o price-aarch64
riscv64-linux-gnu-gcc -O2 -static price.c -o price-riscv64
file price-x86_64 price-aarch64 price-riscv64
```

والمخرج سوف يكون كما يلي:

```text
price-x86_64:  ELF 64-bit LSB executable, x86-64, version 1 (GNU/Linux), statically linked, BuildID[sha1]=a0e45fc3e51fa4851fcefc7d79ce9fa77e2519a7, for GNU/Linux 3.2.0, not stripped
price-aarch64: ELF 64-bit LSB executable, ARM aarch64, version 1 (GNU/Linux), statically linked, BuildID[sha1]=2a8e3fee933cec660b69729321b8cf83d6b0da41, for GNU/Linux 3.7.0, not stripped
price-riscv64: ELF 64-bit LSB executable, UCB RISC-V, RVC, double-float ABI, version 1 (GNU/Linux), statically linked, BuildID[sha1]=edadcd32dd0a67ab6721d690a9ad5123e4f7a5db, for GNU/Linux 4.15.0, not stripped
```

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

- الملفات الثلاثة من نوع ELF بحجم كلمة 64 بت، وكلها `LSB`، أي أن البايت الأقل وزناً يأتي أولاً Little Endian، فالمعماريات الثلاث تتفق هنا.
- الكلمة التي تختلف هي المعمارية: `x86-64` ثم `ARM aarch64` ثم `UCB RISC-V`، والحرفان UCB إشارة إلى جامعة كاليفورنيا في بيركلي حيث بدأ مشروع RISC-V.
- ملف RISC-V يذكر شيئين إضافيين: `RVC`، أي أنه يستخدم الامتداد C للتعليمات المضغوطة بطول بايتين، و`double-float ABI`، أي أن ال ABI تمرر الأرقام العشرية في مسجلات الفاصلة العائمة. وهذا مثال واضح على أن ال ABI جزء من هوية الملف، فملف بنفس المعمارية وبال ABI الأخرى لا يربط مع مكتبات هذا النظام.
- الرقم بعد `for GNU/Linux` هو أقدم نواة يدعمها الملف، وهو أحدث في RISC-V لأن دعمه في Linux أحدث.

والأداة `file` تعرف المعمارية من رأس الملف، فلنقرأ نفس المعلومة بأنفسنا: الأداة [readelf](https://man7.org/linux/man-pages/man1/readelf.1.html?ref=arabroot.io) تعرض الحقل بالاسم، والأمر `od` يعرض البايتين في الموضع 18 من بداية الملف، وهو مكان الحقل `e_machine` في رأس ELF:

```bash
for f in price-x86_64 price-aarch64 price-riscv64; do
  readelf -h $f | grep Machine
  od -A d -t x1 -j 18 -N 2 $f | head -1
done
```

والمخرج سوف يكون كما يلي:

```text
  Machine:                           Advanced Micro Devices X86-64
0000018 3e 00
  Machine:                           AArch64
0000018 b7 00
  Machine:                           RISC-V
0000018 f3 00
```

لاحظ أولاً أن اسم المعمارية x86-64 في رأس ELF هو «Advanced Micro Devices X86-64»، أي AMD، وليس Intel، والسبب أن AMD هي التي صممت هذا الامتداد ذا 64 بت للمعمارية x86 في بداية الألفية، وهي قصة نرويها في مقال [قصة x86](#further). ولاحظ ثانياً أن البايتين `3e 00` يقرآن من اليمين لأن الترتيب Little Endian، فالقيمة هي `0x003e` أي 62، وهذا ما سوف تقارنه النواة برقم معماريتها بعد قليل. وقد شرحنا قراءة الأرقام الست عشرية وترتيب البايتات في مقال [الأنظمة العددية](https://arabroot.io/articles/%D8%A7%D9%84%D8%A7%D9%86%D8%B8%D9%85%D8%A9-%D8%A7%D9%84%D8%B9%D8%AF%D8%AF%D9%8A%D8%A9-%D9%88%D8%A7%D9%84%D8%AB%D9%86%D8%A7%D8%A6%D9%8A-%D9%84%D9%84%D9%85%D8%A8%D8%B1%D9%85%D8%AC%D9%8A%D9%86/).

### الخطأ exec format error كما يحدث فعلاً

الآن نشغل الملفات الثلاثة مباشرة على جهازنا:

```bash
./price-x86_64
./price-aarch64
./price-riscv64
```

والمخرج سوف يكون كما يلي، والأوامر هنا داخل سكربت المختبر `run.sh`، ولذلك تبدأ رسائل الخطأ باسمه ورقم السطر:

```text
total = 575
run.sh: line 10: ./price-aarch64: cannot execute binary file: Exec format error
run.sh: line 11: ./price-riscv64: cannot execute binary file: Exec format error
```

الملف الأول عمل وطبع 575، وهو مجموع الأسعار 500 مضافاً إليه 15% أي 75\. أما الآخران فرفضتهما النواة قبل أن ينفذ منهما أي بايت. والذي حدث أن الصدفة bash طلبت من النواة تشغيل الملف بالطلب `execve`، والنواة قرأت رأس الملف ووجدت رقم معمارية لا يطابق رقمها، فبحثت هل سجل أحد برنامجاً يتعامل مع هذا النوع من الملفات عبر الميزة [binfmt\_misc](https://docs.kernel.org/admin-guide/binfmt-misc.html?ref=arabroot.io)، ولم تجد، فرجعت بالخطأ `ENOEXEC` الذي تصفه صفحة [execve(2)](https://man7.org/linux/man-pages/man2/execve.2.html?ref=arabroot.io) بأنه ملف بصيغة غير معروفة أو لمعمارية أخرى، والصدفة حولته إلى الرسالة التي تراها، وخرجت بالرمز 126 الذي تستخدمه bash لملف موجود لا يمكن تنفيذه. والصورة التالية ترسم هذا المسار:

![أربع خطوات مرقمة: الطرفية تطلب execve لتشغيل ./price-aarch64، ثم النواة تقرأ البايتين b7 00 في الموضع 18 من رأس ELF، ثم تسأل هل هذه معماريتي ورقمها 0x3e فالجواب لا، ثم تبحث في جدول binfmt_misc، وتحتها نتيجتان: صندوق أحمر لا يوجد فيه الرفض برسالة Exec format error ورمز الخروج 126، وصندوق أخضر فيه المحاكاة بالأمر qemu-aarch64 ونتيجة total = 575](https://arabroot.io/content/images/2026/11/isa-explained-05-exec-path.webp)

القرار يحدث في رأس الملف قبل أي تعليمة

### مشكلة واجهناها: نفس الأمر نجح بعد ساعات

بعد ساعات من التجربة السابقة أعدنا تشغيل نفس الأوامر الثلاثة على نفس الجهاز لنتأكد من المخرج، فكانت النتيجة مختلفة تماماً:

```text
### run directly
total = 575
total = 575
exit=0
total = 575
exit=0
```

الملفات الثلاثة عملت دون أي محاك ظاهر، مع أننا لم نغير شيئاً في ال Image ولا في الملفات. والسبب في جدول binfmt\_misc نفسه، فهذا الجدول على Docker Desktop مشترك بين كل ال Containers لأنها تعمل على نواة واحدة داخل جهاز WSL2، ويستطيع أي Container بصلاحيات كاملة أن يسجل فيه محاكياً. وهذا ما رأيناه عندما قرأنا الجدول قبل التجربة الأولى وبعد الثانية بالأمر `ls /proc/sys/fs/binfmt_misc/` من Container بالخيار `--privileged`:

```text
### earlier (before the price run): ls /proc/sys/fs/binfmt_misc/
python3.11
register
status
### later: ls /proc/sys/fs/binfmt_misc/ ; head -3 qemu-aarch64
python3.11
qemu-aarch64
qemu-riscv64
register
status
enabled
interpreter /usr/bin/qemu-aarch64
flags: POCF
```

في المخرج أعلاه لاحظ أن الجدول في المرة الأولى لم يكن فيه إلا مدخل لا علاقة له بـ ARM، ثم ظهر فيه مدخلان `qemu-aarch64` و`qemu-riscv64`، وكل منهما يقول للنواة: «أي ملف ELF بهذا الرأس سلمه إلى البرنامج `/usr/bin/qemu-aarch64`». والحرف F في `flags` يعني أن النواة فتحت ملف المحاكي وقت التسجيل وتحتفظ به، ولذلك يعمل حتى داخل Container لا يوجد فيه هذا الملف أصلاً. وهذا هو نفس ما حدث في مقال [Hello World](https://arabroot.io/articles/%D8%B1%D8%AD%D9%84%D8%A9-hello-world-%D9%85%D9%86-%D9%84%D9%88%D8%AD%D8%A9-%D8%A7%D9%84%D9%85%D9%81%D8%A7%D8%AA%D9%8A%D8%AD-%D8%A7%D9%84%D9%89-%D8%A7%D9%84%D8%B4%D8%A7%D8%B4%D8%A9/#arch-mismatch) عندما عمل ملف ARM الثابت على جهاز x86-64\. والدرس العملي هنا أنك إذا رأيت ملف ARM «يعمل» على جهاز x86-64 فلا تفترض أن المعالج فهمه، وإنما اقرأ جدول binfmt\_misc على المضيف، لأن نفس الملف سوف يرفض على أي سيرفر لم يسجل فيه أحد محاكياً.

### التشغيل عبر المحاكي QEMU

المحاكي QEMU في وضع المستخدم، كما يصفه [توثيق QEMU](https://www.qemu.org/docs/master/user/main.html?ref=arabroot.io)، يشغل برنامج Linux مترجماً لمعمارية أخرى: يقرأ تعليماته ويترجمها إلى تعليمات المعالج الحقيقي أثناء التشغيل، ويحول طلبات النواة من أرقام المعمارية الغريبة إلى أرقام النواة الحقيقية. نشغله يدوياً هذه المرة:

```bash
qemu-aarch64 ./price-aarch64
qemu-riscv64 ./price-riscv64
```

والمخرج سوف يكون كما يلي:

```text
total = 575
total = 575
```

نفس النتيجة من ثلاثة ملفات لا يشترك منها اثنان في بايت واحد من التعليمات، وهذا هو المعنى العملي للعقد: البرنامج واحد على مستوى C، وثلاثة ملفات مختلفة على مستوى الآلة. والمحاكاة لها كلفة كبيرة في السرعة، لأن كل تعليمة غريبة تتحول إلى عدة تعليمات حقيقية، وهذا موضوع مقال المحاكاة والترجمة الثنائية في نفس المرحلة، والمهم هنا أن المحاكي يعطينا طريقة لتشغيل ما نترجمه دون أن نشتري ثلاث لوحات.

## نقرأ نفس الدالة بثلاث لغات

الآن نفتح الملفات ونقرأ تعليمات الدالة `total` في كل منها بالأداة [objdump](https://sourceware.org/binutils/docs/binutils/objdump.html?ref=arabroot.io)، ولكل معمارية نسختها من الأداة:

```bash
objdump -d --disassemble=total price-x86_64
aarch64-linux-gnu-objdump -d --disassemble=total price-aarch64
riscv64-linux-gnu-objdump -d --disassemble=total price-riscv64
```

### على x86-64

والمخرج الأول سوف يكون كما يلي، بعد حذف أسطر العناوين:

```text
0000000000401730 <total>:
  401730:	48 85 f6             	test   %rsi,%rsi
  401733:	7e 43                	jle    401778 <total+0x48>
  401735:	48 8d 04 f7          	lea    (%rdi,%rsi,8),%rax
  401739:	31 c9                	xor    %ecx,%ecx
  40173b:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)
  401740:	48 03 0f             	add    (%rdi),%rcx
  401743:	48 83 c7 08          	add    $0x8,%rdi
  401747:	48 39 f8             	cmp    %rdi,%rax
  40174a:	75 f4                	jne    401740 <total+0x10>
  40174c:	48 b8 0b d7 a3 70 3d 	movabs $0xa3d70a3d70a3d70b,%rax
  401753:	0a d7 a3
  401756:	48 0f af d1          	imul   %rcx,%rdx
  40175a:	48 89 d6             	mov    %rdx,%rsi
  40175d:	48 f7 ea             	imul   %rdx
  401760:	48 8d 04 32          	lea    (%rdx,%rsi,1),%rax
  401764:	48 c1 fe 3f          	sar    $0x3f,%rsi
  401768:	48 c1 f8 06          	sar    $0x6,%rax
  40176c:	48 29 f0             	sub    %rsi,%rax
  40176f:	48 01 c8             	add    %rcx,%rax
  401772:	c3                   	ret
  401773:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)
  401778:	31 c0                	xor    %eax,%eax
  40177a:	c3                   	ret
```

كل سطر فيه ثلاثة أعمدة: عنوان التعليمة في الذاكرة، ثم بايتاتها كما هي في الملف، ثم ترجمتها إلى لغة التجميع Assembly. وفي المخرج أعلاه لاحظ التالي:

- **المعاملات في مسجلات ال ABI:** مؤشر الأسعار في `rdi`، والعدد `n` في `rsi`، ونسبة الضريبة في `rdx`، كما في الجدول السابق تماماً. والسطر الأول `test %rsi,%rsi` يفحص هل `n` صفر أو سالب، فيقفز إلى آخر الدالة ويرجع صفراً.
- **العنونة المركبة:** التعليمة `lea (%rdi,%rsi,8),%rax` تحسب عنوان نهاية المصفوفة في خطوة واحدة: بداية المصفوفة زائد العدد مضروباً في 8، لأن كل `long` ثمانية بايتات. وهذه إحدى طرق العنونة التي تقدمها x86-64.
- **الحلقة أربع تعليمات:** من العنوان `401740` إلى `40174a`، وأولها `add (%rdi),%rcx` تقرأ السعر من الذاكرة وتجمعه على المجموع في تعليمة واحدة، وهذه صفة مهمة في x86-64: كثير من التعليمات الحسابية تستطيع أن تأخذ أحد معاملاتها من الذاكرة مباشرة.
- **أطوال مختلفة:** `c3` بايت واحد، و`add (%rdi),%rcx` ثلاثة بايتات، و`movabs` عشرة بايتات تحمل رقماً كاملاً بحجم 64 بت داخل التعليمة نفسها، حتى أن `objdump` قسمها على سطرين.
- **القسمة على 100 اختفت:** المترجم لم يستخدم تعليمة قسمة، لأنها بطيئة، وإنما ضرب في الرقم السحري `0xa3d70a3d70a3d70b` وأخذ الجزء الأعلى من الناتج بالتعليمة `imul %rdx` ثم أزاح بست خانات، وهي حيلة معروفة تعطي نفس نتيجة القسمة على ثابت.
- **تعليمات `nopl`:** لا تفعل شيئاً، ووظيفتها أن تجعل بداية الحلقة على عنوان مضاعف لـ 16، لأن الجلب أسرع من عنوان محاذى على هذا المعالج.

### على ARM64

والمخرج الثاني سوف يكون كما يلي:

```text
00000000004007a0 <total>:
  4007a0:	f100003f 	cmp	x1, #0x0
  4007a4:	5400024d 	b.le	4007ec <total+0x4c>
  4007a8:	8b010c04 	add	x4, x0, x1, lsl #3
  4007ac:	d2800003 	mov	x3, #0x0                   	// #0
  4007b0:	f8408401 	ldr	x1, [x0], #8
  4007b4:	8b010063 	add	x3, x3, x1
  4007b8:	eb00009f 	cmp	x4, x0
  4007bc:	54ffffa1 	b.ne	4007b0 <total+0x10>  // b.any
  4007c0:	d29ae161 	mov	x1, #0xd70b                	// #55051
  4007c4:	9b037c40 	mul	x0, x2, x3
  4007c8:	f2ae1461 	movk	x1, #0x70a3, lsl #16
  4007cc:	f2c147a1 	movk	x1, #0xa3d, lsl #32
  4007d0:	f2f47ae1 	movk	x1, #0xa3d7, lsl #48
  4007d4:	9b417c01 	smulh	x1, x0, x1
  4007d8:	8b000021 	add	x1, x1, x0
  4007dc:	9346fc21 	asr	x1, x1, #6
  4007e0:	cb80fc20 	sub	x0, x1, x0, asr #63
  4007e4:	8b030000 	add	x0, x0, x3
  4007e8:	d65f03c0 	ret
  4007ec:	d2800000 	mov	x0, #0x0                   	// #0
  4007f0:	d65f03c0 	ret
```

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

- **كل تعليمة أربعة بايتات بالضبط:** العمود الثاني دائماً ثمانية أرقام ست عشرية، والعناوين تزيد بأربعة في كل سطر، وهذا ما يقصد بالطول الثابت.
- **المعاملات في `x0` و`x1` و`x2`:** نفس الدالة، ونفس ترتيب المعاملات، ولكن بأسماء مسجلات أخرى بحسب AAPCS64.
- **القراءة منفصلة عن الجمع:** الحلقة أربع تعليمات أيضاً، ولكن السعر يقرأ بالتعليمة `ldr x1, [x0], #8` ثم يجمع بالتعليمة `add x3, x3, x1`، لأن ARM64 معمارية Load-Store: التعليمات الحسابية لا تلمس الذاكرة أبداً، والتحميل والتخزين لهما تعليمات خاصة. ولاحظ أن `ldr` نفسها تزيد المؤشر بثمانية بعد القراءة، وهذه طريقة عنونة اسمها Post-Index.
- **الرقم السحري على أربع مراحل:** لأن التعليمة طولها 32 بت فقط، فلا يمكن أن تحمل رقماً بحجم 64 بت كاملاً، لذلك بناه المترجم بأربع تعليمات: `mov` تضع أول 16 بت، ثم ثلاث `movk` تضع كل منها 16 بت في مكانها. وهذا ثمن الطول الثابت: أربع تعليمات و16 بايتاً مقابل تعليمة واحدة و10 بايتات في x86-64.
- **ثلاثة معاملات في التعليمة:** `add x4, x0, x1, lsl #3` تجمع `x0` مع `x1` مزاحاً بثلاث خانات وتضع الناتج في مسجل ثالث، دون أن تغير أياً من المصدرين، بينما في x86-64 أغلب التعليمات تكتب الناتج فوق أحد المصدرين.

### على RISC-V

والمخرج الثالث سوف يكون كما يلي:

```text
00000000000104b6 <total>:
   104b6:	04b05063          	blez	a1,104f6 <total+0x40>
   104ba:	058e                	slli	a1,a1,0x3
   104bc:	00b506b3          	add	a3,a0,a1
   104c0:	4781                	li	a5,0
   104c2:	6118                	ld	a4,0(a0)
   104c4:	0521                	addi	a0,a0,8
   104c6:	97ba                	add	a5,a5,a4
   104c8:	fea69de3          	bne	a3,a0,104c2 <total+0xc>
   104cc:	02f60633          	mul	a2,a2,a5
   104d0:	a3d71537          	lui	a0,0xa3d71
   104d4:	a3d50513          	addi	a0,a0,-1475 # ffffffffa3d70a3d <__BSS_END__+0xffffffffa3cebd45>
   104d8:	70a3d737          	lui	a4,0x70a3d
   104dc:	70b70713          	addi	a4,a4,1803 # 70a3d70b <__BSS_END__+0x709b8a13>
   104e0:	1502                	slli	a0,a0,0x20
   104e2:	953a                	add	a0,a0,a4
   104e4:	02a61533          	mulh	a0,a2,a0
   104e8:	43f65713          	srai	a4,a2,0x3f
   104ec:	9532                	add	a0,a0,a2
   104ee:	8519                	srai	a0,a0,0x6
   104f0:	8d19                	sub	a0,a0,a4
   104f2:	953e                	add	a0,a0,a5
   104f4:	8082                	ret
   104f6:	4501                	li	a0,0
   104f8:	8082                	ret
```

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

- **طولان فقط:** بعض التعليمات ثمانية أرقام ست عشرية، أي أربعة بايتات، وبعضها أربعة أرقام، أي بايتان، وهذه الأخيرة من الامتداد C الذي ذكرته `file` باسم RVC. فالتعليمة `add a5,a5,a4` بايتان فقط لأنها شائعة جداً ولها صيغة مختصرة، بينما `mul` أربعة بايتات.
- **أسماء المسجلات حسب وظيفتها:** المعاملات في `a0` و`a1` و`a2`، وهي أسماء ال ABI للمسجلات `x10` إلى `x12`، والحرف a من كلمة Argument.
- **المقارنة والقفز في تعليمة واحدة:** `blez a1` تقفز إذا كان `a1` أصغر من أو يساوي صفراً، و`bne a3,a0` تقارن مسجلين وتقفز إذا اختلفا، ولا توجد أعلام Flags كما في `cmp` ثم `jne` في x86-64 أو `cmp` ثم `b.ne` في ARM64\. وهذا قرار تصميم في RISC-V يبسط المعالج لأنه لا يحتاج سجلاً خاصاً للأعلام تكتب فيه كل تعليمة.
- **الحلقة أربع تعليمات مرة ثالثة:** `ld` ثم `addi` ثم `add` ثم `bne`، وهي Load-Store مثل ARM64، ولكن المؤشر يزاد بتعليمة منفصلة لأن RISC-V لا تملك عنونة Post-Index.
- **الرقم السحري بست تعليمات:** `lui` و`addi` تبنيان النصف الأعلى، ومثلهما للنصف الأدنى، ثم إزاحة وجمع، لأن الرقم الفوري Immediate في تعليمات RISC-V قصير.

وإذا جمعت الملاحظات الثلاث فسوف تجد أن الحلقة نفسها أربع تعليمات في المعماريات الثلاث، وأن الفرق الحقيقي في التفاصيل: هل تقرأ التعليمة الحسابية من الذاكرة، وهل يوجد سجل أعلام، وكيف يبنى رقم كبير، وكم بايتاً تأخذ كل تعليمة. وهذه التفاصيل هي موضوع مقال CISC أم RISC الذي يأتي بعد هذا المقال، حيث نقيس حجم الكود وعدد التعليمات المنفذة على برنامج أكبر.

### اتفاقية الاستدعاء بعينك: الدالة main

الآن ننظر إلى الطرف الآخر، أي من يستدعي `total`، لنرى ال ABI وهي تعمل:

```bash
objdump -d --disassemble=main price-x86_64
aarch64-linux-gnu-objdump -d --disassemble=main price-aarch64
riscv64-linux-gnu-objdump -d --disassemble=main price-riscv64
```

والمخرج سوف يكون كما يلي، الأول x86-64 ثم ARM64 ثم RISC-V:

```text
0000000000401570 <main>:
  401570:	48 83 ec 28          	sub    $0x28,%rsp
  401574:	ba 0f 00 00 00       	mov    $0xf,%edx
  401579:	be 04 00 00 00       	mov    $0x4,%esi
  40157e:	66 0f 6f 05 aa 6b 07 	movdqa 0x76baa(%rip),%xmm0        # 478130 <slashdot.0+0x67a>
  401585:	00
  401586:	48 89 e7             	mov    %rsp,%rdi
  401589:	0f 29 04 24          	movaps %xmm0,(%rsp)
  40158d:	66 0f 6f 05 ab 6b 07 	movdqa 0x76bab(%rip),%xmm0        # 478140 <slashdot.0+0x68a>
  401594:	00
  401595:	0f 29 44 24 10       	movaps %xmm0,0x10(%rsp)
  40159a:	e8 91 01 00 00       	call   401730 <total>
  40159f:	48 8d 3d 6a 4a 07 00 	lea    0x74a6a(%rip),%rdi        # 476010 <__rseq_flags+0xc>
  4015a6:	48 89 c6             	mov    %rax,%rsi
  4015a9:	31 c0                	xor    %eax,%eax
  4015ab:	e8 30 32 00 00       	call   4047e0 <_IO_printf>
  4015b0:	31 c0                	xor    %eax,%eax
  4015b2:	48 83 c4 28          	add    $0x28,%rsp
  4015b6:	c3                   	ret

0000000000400500 <main>:
  400500:	d00002e3 	adrp	x3, 45e000 <__PRETTY_FUNCTION__.0+0x68>
  400504:	91040063 	add	x3, x3, #0x100
  400508:	a9bd7bfd 	stp	x29, x30, [sp, #-48]!
  40050c:	d28001e2 	mov	x2, #0xf                   	// #15
  400510:	d2800081 	mov	x1, #0x4                   	// #4
  400514:	910003fd 	mov	x29, sp
  400518:	910043e0 	add	x0, sp, #0x10
  40051c:	4c40a07e 	ld1	{v30.16b-v31.16b}, [x3]
  400520:	4c00a01e 	st1	{v30.16b-v31.16b}, [x0]
  400524:	9400009f 	bl	4007a0 <total>
  400528:	aa0003e1 	mov	x1, x0
  40052c:	f00002a0 	adrp	x0, 457000 <__pthread_mutex_cond_lock_full+0x640>
  400530:	91242000 	add	x0, x0, #0x908
  400534:	94000493 	bl	401780 <_IO_printf>
  400538:	52800000 	mov	w0, #0x0                   	// #0
  40053c:	a8c37bfd 	ldp	x29, x30, [sp], #48
  400540:	d65f03c0 	ret

000000000001037e <main>:
   1037e:	7179                	addi	sp,sp,-48
   10380:	07800813          	li	a6,120
   10384:	05000693          	li	a3,80
   10388:	02d00713          	li	a4,45
   1038c:	0ff00793          	li	a5,255
   10390:	463d                	li	a2,15
   10392:	4591                	li	a1,4
   10394:	850a                	mv	a0,sp
   10396:	f406                	sd	ra,40(sp)
   10398:	e042                	sd	a6,0(sp)
   1039a:	e436                	sd	a3,8(sp)
   1039c:	e83a                	sd	a4,16(sp)
   1039e:	ec3e                	sd	a5,24(sp)
   103a0:	116000ef          	jal	104b6 <total>
   103a4:	85aa                	mv	a1,a0
   103a6:	00040517          	auipc	a0,0x40
   103aa:	68250513          	addi	a0,a0,1666 # 50a28 <__rseq_flags+0x4>
   103ae:	17f000ef          	jal	10d2c <_IO_printf>
   103b2:	70a2                	ld	ra,40(sp)
   103b4:	4501                	li	a0,0
   103b6:	6145                	addi	sp,sp,48
   103b8:	8082                	ret
```

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

- **نفس القيم في مسجلات مختلفة:** قبل كل استدعاء توضع نسبة الضريبة 15، وهي `0xf`، في المعامل الثالث (`edx` ثم `x2` ثم `a2`)، والعدد 4 في المعامل الثاني (`esi` ثم `x1` ثم `a1`)، وعنوان المصفوفة على ال Stack في المعامل الأول (`rdi` ثم `x0` ثم `a0`).
- **ثلاث طرق لنسخ الأسعار:** x86-64 نسخت الأسعار الأربعة من نسخة جاهزة في الملف بتعليمات SIMD بعرض 128 بت (`movdqa` و`movaps`)، وARM64 فعلت نفس الشيء بتعليمة `ld1` و`st1` على مسجلين بعرض 128 بت، أما RISC-V فوضعت كل سعر برقمه في مسجل ثم خزنته، لأن مترجمها لم يستخدم امتداد المتجهات Vector هنا، فالقيم 120 و80 و45 و255 ظاهرة في الكود.
- **أين يذهب عنوان الرجوع:** في x86-64 لا ترى أي حفظ له، لأن `call` تضعه على ال Stack تلقائياً و`ret` تأخذه من هناك. أما في ARM64 فالتعليمة `bl` تضعه في `x30`، ولأن `main` نفسها سوف تستدعي دوال أخرى تغير `x30`، فقد حفظته في أول سطر بالتعليمة `stp x29, x30` واسترجعته قبل الرجوع بالتعليمة `ldp`. ونفس الشيء في RISC-V مع `sd ra,40(sp)` و`ld ra,40(sp)`.
- **النتيجة تنتقل إلى المعامل الثاني لـ printf:** القيمة الراجعة من `total` في `rax` أو `x0` أو `a0`، ثم تنسخ إلى المعامل الثاني لـ `printf`، لأن المعامل الأول هو نص التنسيق `"total = %ld\n"`.
- **السطر `xor %eax,%eax` قبل `printf`:** قاعدة خاصة في ABI لـ x86-64 للدوال ذات المعاملات المتغيرة: يجب أن يحمل `al` عدد معاملات الفاصلة العائمة في مسجلات SIMD، وهنا لا يوجد أي معامل عشري فهو صفر. ولا توجد هذه القاعدة في المعماريتين الأخريين، وهذا مثال صغير على أن ال ABI تختلف في تفاصيل لا تخطر على بالك.

## دون مكتبة C: الطلب من النواة بثلاث لغات

في كل ما سبق كانت مكتبة C تخفي عنا الجزء الأخير، وهو كيف تصل `printf` إلى النواة. لنكتب الآن نفس البرنامج الصغير بلغة التجميع لكل معمارية، دون أي مكتبة: يطلب من النواة أن تكتب سطراً على المخرج القياسي، ثم يطلب الخروج. والملفات الثلاثة كما يلي:

```asm
# hello-x86_64.S: write(1, msg, 13) then exit(0), no C library
        .global _start
        .text
_start: mov  $1, %rax          # syscall number: write = 1 on x86-64
        mov  $1, %rdi          # arg 1: fd 1 (stdout)
        lea  msg(%rip), %rsi   # arg 2: address of the text
        mov  $13, %rdx         # arg 3: length
        syscall
        mov  $60, %rax         # exit = 60
        xor  %rdi, %rdi        # status 0
        syscall
        .data
msg:    .ascii "Hello x86-64\n"
```

```asm
// hello-aarch64.S: write(1, msg, 13) then exit(0), no C library
        .global _start
        .text
_start: mov  x8, #64           // syscall number: write = 64 on arm64
        mov  x0, #1            // arg 1: fd 1 (stdout)
        adr  x1, msg           // arg 2: address of the text
        mov  x2, #13           // arg 3: length
        svc  #0
        mov  x8, #93           // exit = 93
        mov  x0, #0            // status 0
        svc  #0
msg:    .ascii "Hello ARM64!\n"
```

```asm
# hello-riscv64.S: write(1, msg, 13) then exit(0), no C library
        .global _start
        .text
_start: li   a7, 64            # syscall number: write = 64 on riscv64
        li   a0, 1             # arg 1: fd 1 (stdout)
        lla  a1, msg           # arg 2: address of the text
        li   a2, 13            # arg 3: length
        ecall
        li   a7, 93            # exit = 93
        li   a0, 0             # status 0
        ecall
        .data
msg:    .ascii "Hello RISC-V\n"
```

نترجمها دون مكتبة C بالخيار `-nostdlib`، ونشغلها:

```bash
gcc -nostdlib -static hello-x86_64.S -o hello-x86_64
aarch64-linux-gnu-gcc -nostdlib -static hello-aarch64.S -o hello-aarch64
riscv64-linux-gnu-gcc -nostdlib -static hello-riscv64.S -o hello-riscv64
./hello-x86_64
qemu-aarch64 ./hello-aarch64
qemu-riscv64 ./hello-riscv64
```

والمخرج سوف يكون كما يلي:

```text
Hello x86-64
Hello ARM64!
Hello RISC-V
```

وإذا فتحنا الملفات بـ `objdump` فسوف نرى الترجمة الحقيقية لكل سطر، وهذا مخرج الملفات الثلاثة:

```text
0000000000401000 <_start>:
  401000:	48 c7 c0 01 00 00 00 	mov    $0x1,%rax
  401007:	48 c7 c7 01 00 00 00 	mov    $0x1,%rdi
  40100e:	48 8d 35 eb 0f 00 00 	lea    0xfeb(%rip),%rsi        # 402000 <msg>
  401015:	48 c7 c2 0d 00 00 00 	mov    $0xd,%rdx
  40101c:	0f 05                	syscall
  40101e:	48 c7 c0 3c 00 00 00 	mov    $0x3c,%rax
  401025:	48 31 ff             	xor    %rdi,%rdi
  401028:	0f 05                	syscall

00000000004000d4 <_start>:
  4000d4:	d2800808 	mov	x8, #0x40                  	// #64
  4000d8:	d2800020 	mov	x0, #0x1                   	// #1
  4000dc:	100000c1 	adr	x1, 4000f4 <msg>
  4000e0:	d28001a2 	mov	x2, #0xd                   	// #13
  4000e4:	d4000001 	svc	#0x0
  4000e8:	d2800ba8 	mov	x8, #0x5d                  	// #93
  4000ec:	d2800000 	mov	x0, #0x0                   	// #0
  4000f0:	d4000001 	svc	#0x0

0000000000010144 <_start>:
   10144:	04000893          	li	a7,64
   10148:	4505                	li	a0,1
   1014a:	00001597          	auipc	a1,0x1
   1014e:	01858593          	addi	a1,a1,24 # 11162 <__DATA_BEGIN__>
   10152:	4635                	li	a2,13
   10154:	00000073          	ecall
   10158:	05d00893          	li	a7,93
   1015c:	4501                	li	a0,0
   1015e:	00000073          	ecall
```

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

- **ثلاث تعليمات للعبور إلى النواة:** `syscall` بالبايتين `0f 05`، و`svc #0` بالبايتات `d4000001`، و`ecall` بالبايتات `00000073`. وكلها تفعل نفس الشيء من حيث المبدأ: تنقل المعالج من وضع المستخدم إلى وضع النواة وتقفز إلى عنوان سجلته النواة، كما شرحنا بالتفصيل في [مقال استدعاءات النظام](https://arabroot.io/articles/%D9%81%D8%B6%D8%A7%D8%A1-%D8%A7%D9%84%D9%86%D9%88%D8%A7%D8%A9-%D9%88%D9%81%D8%B6%D8%A7%D8%A1-%D8%A7%D9%84%D9%85%D8%B3%D8%AA%D8%AE%D8%AF%D9%85-%D9%88%D8%A7%D8%B3%D8%AA%D8%AF%D8%B9%D8%A7%D8%A1%D8%A7%D8%AA-%D8%A7%D9%84%D9%86%D8%B8%D8%A7%D9%85/).
- **أرقام الطلبات مختلفة:** `write` هو 1 على x86-64 و64 على الأخريين، و`exit` هو 60 أو 93، فلو نسخت كود x86-64 حرفياً إلى ARM64 بعد تغيير أسماء المسجلات فقط، لطلبت من النواة الطلب رقم 1 وهو على ARM64 طلب مختلف تماماً اسمه `io_destroy`.
- **المسجل الذي يحمل رقم الطلب مختلف:** `rax` ثم `x8` ثم `a7`، والمعاملات في `rdi rsi rdx` أو `x0 x1 x2` أو `a0 a1 a2`، كما في جدول صفحة syscall(2).
- **التحميل الفوري لرقم صغير:** في x86-64 كتب المجمع `mov $1,%rax` بسبعة بايتات لأننا طلبنا مسجلاً كاملاً بحجم 64 بت، وفي RISC-V صارت `li a0,1` بايتين فقط بفضل الامتداد C. وفي الكود الذي ينتجه المترجم عادة سوف ترى `mov $1,%eax` بخمسة بايتات، لأن الكتابة في النصف الأدنى تصفر النصف الأعلى تلقائياً.
- **التحميل النسبي:** عنوان النص يحسب بالنسبة لمكان التعليمة نفسها في المعماريات الثلاث (`lea msg(%rip)` و`adr` و`auipc` مع `addi`)، حتى يعمل الكود في أي مكان يحمل فيه.

⚠️

في أول نسخة من ملف RISC-V كتبنا `la a1, msg` بدلاً من `lla`، فعمل البرنامج، ولكن `objdump` أظهر أن العنوان صار يقرأ من جدول GOT بتعليمة `ld` إضافية، لأن المترجم في Debian يبني كوداً مستقلاً عن الموضع PIC افتراضياً، و`la` في هذا الوضع تمر عبر الجدول. واستخدم `lla` عندما يكون الرمز داخل نفس الملف، فهي تحسب العنوان نسبياً بتعليمتين دون قراءة من الذاكرة.

## لماذا لا يعمل برنامج x86 على ARM؟

الآن نستطيع أن نجيب عن سؤال العنوان بدقة، والإجابة أن الملف يتوقف عند أول طبقة لا تطابق، والطبقات أربع من الأعلى إلى الأسفل:

1. **رأس الملف:** النواة تقرأ رقم المعمارية في رأس ELF، وإذا لم يطابق رقمها ولم يسجل محاكي لهذا النوع، ترفض الملف بالخطأ `Exec format error` قبل أي شيء آخر. وهذه هي الطبقة التي رأيناها في المختبر.
2. **بايتات التعليمات:** لو تجاوزنا الفحص الأول بطريقة ما، فإن البايتات نفسها لا معنى لها للمعالج الآخر، فالبايتات `48 85 f6` التي تعني `test %rsi,%rsi` على x86-64 لا تكون حتى تعليمة كاملة على ARM64 الذي يقرأ أربعة بايتات في كل مرة، وسوف يفسرها كتعليمة أخرى أو يرفع استثناء تعليمة غير معروفة.
3. **ال ABI وطلبات النواة:** لو ترجمنا التعليمات واحدة بواحدة، فإن أرقام الطلبات والمسجلات التي تحمل المعاملات مختلفة، وبعض الطلبات القديمة في x86-64 مثل `open` لا توجد أصلاً في الجدول المشترك لـ ARM64، الذي يحتوي فقط على `openat`.
4. **المكتبات والمحمل:** الملف الديناميكي يطلب محملاً بمسار معين، مثل `/lib64/ld-linux-x86-64.so.2` على x86-64 و`/lib/ld-linux-aarch64.so.1` على ARM64، ومكتبات مترجمة لنفس معماريته، وكل هذا غير موجود على النظام الآخر، وقد رأينا هذا الخطأ مع المحاكي في مقال [Hello World](https://arabroot.io/articles/%D8%B1%D8%AD%D9%84%D8%A9-hello-world-%D9%85%D9%86-%D9%84%D9%88%D8%AD%D8%A9-%D8%A7%D9%84%D9%85%D9%81%D8%A7%D8%AA%D9%8A%D8%AD-%D8%A7%D9%84%D9%89-%D8%A7%D9%84%D8%B4%D8%A7%D8%B4%D8%A9/#arch-mismatch).

وبالتالي لا يوجد «تحويل» بسيط لملف من معمارية إلى أخرى، والحلول الحقيقية ثلاثة: أن تترجم الكود المصدري من جديد للمعمارية الأخرى كما فعلنا هنا، وهذا الأفضل دائماً، أو أن تشغل الملف داخل محاك مثل QEMU يترجم كل تعليمة أثناء التشغيل ويقبل البطء، أو أن تستخدم ترجمة ثنائية Binary Translation مثل Rosetta 2 من Apple التي تترجم أغلب الملف مسبقاً.

📌

في يونيو 2020 [أعلنت Apple](https://www.apple.com/newsroom/2020/06/apple-announces-mac-transition-to-apple-silicon/?ref=arabroot.io) نقل أجهزة Mac من معالجات Intel إلى معالجات تصممها بنفسها بمعمارية ARM، وهي ثالث مرة تغير فيها Apple معمارية Mac بعد الانتقال من 68000 إلى PowerPC ثم من PowerPC إلى Intel. ولأن ملايين البرامج كانت مترجمة لـ x86-64، أعلنت معها عن Rosetta 2 لتشغيل هذه البرامج، وعن ملفات Universal 2 التي تحمل نسختين من نفس البرنامج في ملف واحد، نسخة لكل معمارية. والدرس هنا أن تغيير ال ISA ليس قراراً تقنياً فقط: هو انتقال يحتاج طبقة توافق لسنوات، وإعادة ترجمة لكل برنامج يريد أن يعمل بسرعته الكاملة.

## ماذا يحدث إذا بنيت لنفس المعمارية ولمستوى أعلى من معالجك؟

قد تظن أن المشكلة تنتهي إذا كانت المعمارية واحدة، ولكن ال ISA نفسها تكبر مع الزمن: كل جيل من المعالجات يضيف امتدادات Extensions، أي تعليمات جديدة، مثل SSE4.2 وAVX2 وAVX-512 في x86-64، أو امتدادات المتجهات في ARM64 وRISC-V. والبرنامج الذي يستخدم امتداداً لا يملكه معالجك يتجاوز فحص رأس الملف بنجاح، لأن رقم المعمارية واحد، ثم يتوقف عند أول تعليمة جديدة. ولكي لا تبقى قائمة الامتدادات بلا ترتيب، جمعت وثيقة [psABI لـ x86-64](https://gitlab.com/x86-psABIs/x86-64-ABI?ref=arabroot.io) الامتدادات في أربعة مستويات تبينها الصورة التالية، ويمكنك أن تطلب أياً منها من GCC بالخيار `-march` كما في [توثيق خيارات x86 في GCC](https://gcc.gnu.org/onlinedocs/gcc/x86-Options.html?ref=arabroot.io):

![أربع بطاقات لمستويات x86-64: المستوى الأساسي مع CMOV وSSE وSSE2، والمستوى v2 مع SSE3 وSSSE3 وSSE4.2 وPOPCNT وCX16، والمستوى v3 مع AVX وAVX2 وBMI2 وFMA وMOVBE، والثلاثة بعلامة خضراء تعمل على i7-7700K، والمستوى v4 مع امتدادات AVX-512 الخمسة بعلامة حمراء غير موجود في هذا المعالج، وتحتها مخرجان: تعليمة vaddps على مسجلات zmm، ورسالة Illegal instruction](https://arabroot.io/content/images/2026/11/isa-explained-06-levels.webp)

مستويات x86-64 وما يدعمه معالج جهاز التجارب

ولنجرب ذلك على الدالة التالية، وهي حلقة تجمع مصفوفتين من الأرقام العشرية، ونبنيها ثلاث مرات: للمستوى الأساسي، وللمستوى v3، وللمستوى v4:

```c
// add.c: the same loop, built for a CPU level we choose with -march
#include <stdio.h>
#include <stdlib.h>

__attribute__((noinline))
void add(float *c, const float *a, const float *b, int n)
{
    for (int i = 0; i < n; i++)
        c[i] = a[i] + b[i];
}

int main(int argc, char **argv)
{
    int n = argc > 1 ? atoi(argv[1]) : 1024;
    float *a = malloc(n * sizeof *a), *b = malloc(n * sizeof *b), *c = malloc(n * sizeof *c);
    for (int i = 0; i < n; i++) { a[i] = i; b[i] = 2 * i; }
    add(c, a, b, n);
    printf("c[%d] = %.0f\n", n - 1, c[n - 1]);
    return 0;
}
```

```bash
gcc -O3 add.c -o add-base
gcc -O3 -march=x86-64-v3 add.c -o add-v3
gcc -O3 -march=x86-64-v4 add.c -o add-v4
./add-base; ./add-v3; ./add-v4; echo "exit=$?"
grep -o -w -E 'avx512[a-z]*|avx2' /proc/cpuinfo | sort -u
```

والمخرج سوف يكون كما يلي:

```text
c[1023] = 3069
c[1023] = 3069
bash: line 12:    44 Illegal instruction     ./add-v4
exit=132
avx2
```

الملفان الأول والثاني عملا، والثالث توقف بالإشارة `SIGILL`، أي تعليمة غير قانونية Illegal Instruction، ورمز الخروج 132 هو 128 زائد رقم الإشارة 4\. والسطر الأخير يوضح السبب: المعالج يعلن عن `avx2` ولا يعلن عن أي امتداد يبدأ بـ `avx512`. ولنرى التعليمات التي اختارها المترجم في النسختين:

```bash
objdump -d --disassemble=add add-v4 | grep -m3 zmm
objdump -d --disassemble=add add-base | grep -m3 xmm
```

والمخرج سوف يكون كما يلي:

```text
    14c0:	62 f1 7c 48 10 04 02 	vmovups (%rdx,%rax,1),%zmm0
    14c7:	62 f1 7c 48 58 04 06 	vaddps (%rsi,%rax,1),%zmm0,%zmm0
    14ce:	62 f1 7c 48 11 04 07 	vmovups %zmm0,(%rdi,%rax,1)
    1380:	0f 10 04 06          	movups (%rsi,%rax,1),%xmm0
    1384:	0f 10 14 02          	movups (%rdx,%rax,1),%xmm2
    1388:	0f 58 c2             	addps  %xmm2,%xmm0
```

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

- النسخة v4 تجمع 16 رقماً عشرياً في تعليمة واحدة على مسجلات `zmm` بعرض 512 بت، والنسخة الأساسية تجمع 4 أرقام على مسجلات `xmm` بعرض 128 بت، وقد شرحنا فكرة SIMD في [مقال المعالج من الداخل](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%B9%D8%A7%D9%84%D8%AC-cpu-%D9%85%D9%86-%D8%A7%D9%84%D8%AF%D8%A7%D8%AE%D9%84/#simd).
- تعليمات AVX-512 تبدأ بالبايت `62`، وهو بادئة اسمها EVEX، بينما التعليمات القديمة تبدأ بـ `0f`. وهذا مثال على كيف كبرت x86-64 عبر السنين: كل امتداد جديد أضاف بادئة جديدة فوق الترميز القديم، ولذلك صار الطول المتغير أطول.
- المعالج لم يفشل عند التحميل، وإنما عند أول تعليمة `zmm`، أي بعد أن بدأ البرنامج يعمل، وفي برنامج حقيقي قد يحدث هذا بعد ساعات إذا كانت الدالة لا تستدعى إلا في حالة نادرة.

وكنا نتوقع أن ينقذنا المحاكي هنا، فشغلنا نفس الملف عبر محاكي x86-64 بأكبر مجموعة امتدادات يعرفها:

```bash
qemu-x86_64 -cpu max ./add-v4; echo "exit=$?"
```

فكانت النتيجة نفس الإشارة:

```text
qemu: uncaught target signal 4 (Illegal instruction) - core dumped
bash: line 15:    47 Illegal instruction     qemu-x86_64 -cpu max ./add-v4
exit=132
```

والسبب أن QEMU 10.0 لا يحاكي AVX-512 في وضع الترجمة البرمجية TCG، فهذا الملف لا يعمل على هذا الجهاز بأي طريقة، والحل الوحيد أن تعيد بناءه لمستوى أدنى أو أن تشغله على معالج فيه AVX-512\. وهناك مشكلة أخرى واجهناها في نفس التجربة تستحق الذكر: في النسخة الأولى من الملف كانت المصفوفات ثابتة الحجم والقيم داخل `main`، فحسب المترجم النتيجة كلها وقت الترجمة، ولم تظهر أي تعليمة `zmm` وعملت النسخة v4 بلا مشكلة. لذلك إذا أردت أن تختبر أثر خيار `-march`، فاجعل الحجم يأتي من وقت التشغيل وضع الحلقة في دالة منفصلة، وإلا فأنت تختبر المترجم وليس المعالج.

وكيف تتعامل التوزيعات مع هذا؟ مكتبة glibc تبحث عن نسخ من المكتبات مبنية لكل مستوى، وتختار أعلى مستوى يدعمه معالجك، كما يصف [دليل المحمل ld.so](https://man7.org/linux/man-pages/man8/ld.so.8.html?ref=arabroot.io)، وتستطيع أن تسأل المحمل عن المستويات التي يدعمها جهازك:

```bash
/lib64/ld-linux-x86-64.so.2 --help | grep -A4 Subdirectories
```

والمخرج سوف يكون كما يلي:

```text
Subdirectories of glibc-hwcaps directories, in priority order:
  x86-64-v4
  x86-64-v3 (supported, searched)
  x86-64-v2 (supported, searched)
```

والكلمتان `supported, searched` تظهران بجانب v3 وv2 فقط، أي أن هذا المعالج يقف عند المستوى v3، وهو ما رأيناه بالتجربة. وهذا الأمر أسرع طريقة لتعرف المستوى الذي يدعمه سيرفر قبل أن تشغل عليه ملفاً مبنياً لمستوى معين.

## ماذا يعني هذا لك عملياً؟

أول شيء أن تعرف أن لكل معمارية عدة أسماء بحسب من يتكلم، وهذا وحده سبب نصف الأخطاء في اختيار الملف الصحيح. والجدول التالي يجمع الأسماء التي سوف تراها:

| المعمارية | الأمر uname -m | Debian وUbuntu | منصة Docker   | أسماء أخرى في ملفات الإصدارات |
| --------- | -------------- | -------------- | ------------- | ----------------------------- |
| x86-64    | x86\_64        | amd64          | linux/amd64   | x64، x86\_64، intel           |
| ARM64     | aarch64        | arm64          | linux/arm64   | aarch64، armv8                |
| RISC-V 64 | riscv64        | riscv64        | linux/riscv64 | rv64، rv64gc                  |
| ARM 32 بت | armv7l         | armhf          | linux/arm/v7  | armv7                         |

والمهم في الجدول أن `amd64` لا تعني «لمعالجات AMD فقط»، وإنما هي اسم المعمارية x86-64 كلها، فالملف المسمى `amd64` هو ما تحتاجه على سيرفر فيه معالج Intel. وتجد قائمة المعماريات التي يدعمها Debian في [صفحة المنافذ Ports](https://www.debian.org/ports/?ref=arabroot.io).

وثاني شيء هو Docker، لأن أغلب الناس يصطدمون بهذا الموضوع فيه: ال Docker Image مبنية لمعمارية واحدة أو لعدة معماريات في قائمة واحدة Manifest List، وعندما تسحب Image فإن Docker يختار النسخة المناسبة لجهازك تلقائياً، أما عندما تبني على جهاز Mac بمعالج Apple فإن النتيجة الافتراضية `linux/arm64`، فإذا رفعتها إلى VPS بمعالج x86-64 ظهر الخطأ الذي رأيناه. والحل كما يشرح [توثيق البناء لعدة منصات في Docker](https://docs.docker.com/build/building/multi-platform/?ref=arabroot.io) أن تحدد المنصة عند البناء:

```bash
docker buildx build --platform linux/amd64,linux/arm64 -t registry.example.com/app:1.0 --push .
docker image inspect --format '{{.Os}}/{{.Architecture}}' registry.example.com/app:1.0
```

والأمر الثاني يخبرك بمعمارية Image موجودة عندك، كما في [توثيق docker image inspect](https://docs.docker.com/reference/cli/docker/image/inspect/?ref=arabroot.io)، فاجعله أول أمر عند أي خطأ `exec format error` داخل Container.

وثالث شيء هو اختيار السيرفر: سيرفرات ARM في السحابة أرخص غالباً لنفس الأداء في أعمال كثيرة، ولكن انتقالك إليها يعني أن كل ملف تنفيذي وكل Docker Image وكل مكتبة فيها كود مترجم يجب أن يكون لها نسخة ARM64\. فلغات مثل Python وJava وNode.js تنتقل بسهولة لأن المفسر نفسه متوفر للمعماريتين، كما شرحنا في مقال [المترجم والمفسر و JIT](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/)، أما الحزم التي فيها كود C أو برامج تجارية مغلقة لا توجد إلا لـ x86-64 فهي التي توقف الانتقال. وقبل أن تقرر افحص كل اعتماد في مشروعك، وسوف نناقش هذا القرار بالتفصيل في مقال ARM من الجوال إلى السيرفر.

## أخطاء شائعة

- الظن أن `amd64` لمعالجات AMD و`x86_64` لمعالجات Intel: الاسمان لنفس المعمارية، وكلاهما يعمل على معالجات الشركتين.
- الظن أن ARM شركة تصنع المعالجات: Arm تصمم المعمارية وتبيع رخصتها وتصاميم أنوية جاهزة، والشرائح تصنعها Apple وQualcomm وAmazon وغيرها، ولكل منها معماريتها الدقيقة.
- تشخيص `exec format error` على أنه مشكلة صلاحيات أو ملف تالف: أول أمر هو `file` على الملف و`uname -m` على الجهاز، فإذا اختلفت المعمارية فقد عرفت السبب. وانتبه أن نفس الرسالة تظهر أيضاً لسكربت يبدأ بسطر `#!` خاطئ أو بلا هذا السطر، فلا تفترض المعمارية قبل أن تنظر.
- الاعتماد على أن ملف ARM «عمل» على جهازك x86-64: قد يكون محاكي QEMU مسجلاً في binfmt\_misc، والبرنامج يعمل أبطأ بكثير، وسوف يفشل على سيرفر لا يوجد فيه محاك.
- بناء ملف بالخيار `-march=native` على جهاز التطوير ثم نشره على سيرفرات مختلفة: المترجم يستخدم كل امتدادات معالجك، والسيرفر الأقدم يتوقف بالإشارة `SIGILL`. وابن للمستوى الذي تضمنه في كل سيرفراتك، مثل `x86-64-v2` أو `x86-64-v3`.
- نسخ كود Assembly أو أرقام طلبات النواة من معمارية إلى أخرى: الأرقام والمسجلات تختلف كما رأينا، وطلبات مثل `open` غير موجودة على ARM64.
- الخلط بين ال ISA والأداء: معالجان بنفس ال ISA قد يختلفان في السرعة عدة أضعاف، والمقارنة الصحيحة بين شرائح محددة في عمل محدد، وليس بين معماريات.

## جدول قرار Decision Table: ما تراه وماذا تفعل

| ما تراه                                | الأمر الأول                   | ما تبحث عنه                             | الحل الغالب                                        |
| -------------------------------------- | ----------------------------- | --------------------------------------- | -------------------------------------------------- |
| exec format error عند تشغيل ملف        | file ./app وuname -m          | معمارية الملف مقابل معمارية الجهاز      | نزل أو ابن الملف للمعمارية الصحيحة                 |
| نفس الخطأ داخل Container               | docker image inspect          | قيمة Architecture                       | ابن بالخيار \--platform أو لعدة منصات              |
| ملف لمعمارية أخرى يعمل ولكنه بطيء جداً | ls /proc/sys/fs/binfmt\_misc/ | مدخل qemu-\* مسجل                       | استخدم نسخة أصلية للمعمارية، فالمحاكاة للتجربة فقط |
| Illegal instruction على نفس المعمارية  | grep flags /proc/cpuinfo      | امتداد يستخدمه الملف ولا يملكه المعالج  | ابن لمستوى أدنى من \-march                         |
| تحتاج مستوى المعالج قبل النشر          | ld.so --help                  | المستويات المكتوب بجانبها supported     | اختر أعلى مستوى مشترك بين سيرفراتك                 |
| تختار بين سيرفر x86-64 وARM64          | قائمة الاعتمادات وال Images   | حزم أو برامج لا توجد إلا لمعمارية واحدة | اختبر الخدمة كاملة على ARM64 قبل الانتقال          |

## قائمة تحقق Checklist قبل نشر ملف تنفيذي

- عرفت معمارية كل سيرفر بالأمر `uname -m`، ومستواه بالأمر `ld.so --help` إذا كان x86-64.
- كل ملف تنزله من صفحة إصدارات يطابق المعمارية بأي من أسمائها في الجدول السابق.
- ال Docker Images مبنية لكل منصة تعمل عليها خدماتك، ومعرفة بالأمر `docker image inspect`.
- لا يوجد `-march=native` في سكربت البناء الذي ينتج ملفات النشر.
- إذا كان في مشروعك كود Assembly أو أرقام طلبات نواة مكتوبة يدوياً، فلكل معمارية ملفها المختبر.
- لا تعتمد على محاكي QEMU في الإنتاج إلا وأنت تعرف كلفته، فهو مناسب للبناء والتجربة.

## تدريب عملي

1. أضف إلى `price.c` دالة تأخذ ثمانية معاملات، وترجمها للمعماريات الثلاث، ثم ابحث في `objdump` عن المعامل السابع: هل جاء في مسجل أم على ال Stack في كل معمارية؟ وقارن بما تقوله وثائق ال ABI الثلاث.
2. غير رقم الطلب في `hello-aarch64.S` من 64 إلى 1، كما في x86-64، وشغل الملف عبر `qemu-aarch64 -strace`، واقرأ اسم الطلب الذي وصل إلى النواة فعلاً.
3. على سيرفر Linux عندك نفذ `uname -m` و`ld.so --help`، واكتب المستوى الذي يدعمه، ثم قارنه بمستوى البناء في ال Docker Images التي تستخدمها.

## حذف المختبر Cleanup

كل ال Containers عملت بالخيار `--rm`، والملفات التنفيذية حذفها آخر سطر في سكربت المختبر، فيبقى فقط حذف ال Image:

```bash
docker rmi cs1-isa:1
```

## الخلاصة

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

- ال ISA عقد بين البرنامج والشريحة: التعليمات والمسجلات والعنونة والترميز ونموذج الذاكرة والصلاحيات، والمعمارية الدقيقة هي طريقة تنفيذ العقد داخل كل شريحة ولا يراها البرنامج إلا كسرعة.
- الحد الحقيقي بين العقود وليس بين الشركات: Intel وAMD في x86-64، وApple وQualcomm وAmazon وRaspberry Pi في ARM64.
- ال ABI عقد ثان فوق ال ISA: أي مسجل لكل معامل، وأين عنوان الرجوع، وأرقام طلبات النواة، وشكل الملف، ولذلك لا يعمل ملف Windows على Linux ولو كان المعالج واحداً.
- نفس البرنامج أنتج ثلاثة ملفات لا يتشابه فيها بايت واحد من التعليمات، والحلقة نفسها كانت أربع تعليمات في الثلاث، والفرق في التفاصيل: القراءة من الذاكرة، والأعلام، وبناء الأرقام الكبيرة، وطول التعليمة.
- النواة ترفض الملف من رأسه بالخطأ `Exec format error` إذا لم يطابق رقم المعمارية ولم يسجل محاك، والمحاكي QEMU يشغله أبطأ، والحل الدائم إعادة الترجمة.
- داخل نفس المعمارية تختلف المستويات، وملف مبني لـ `x86-64-v4` توقف بالإشارة `SIGILL` على معالج يقف عند v3، ولم ينقذه المحاكي.
- عملياً: اعرف أسماء المعماريات (`amd64` هي x86-64 كلها)، وابن ال Docker Images بالخيار `--platform`، ولا تنشر ملفات مبنية بـ `-march=native`.

وفي المقالات التالية من هذه المرحلة سوف نقارن فلسفة CISC وRISC بالأرقام، ونروي قصة x86 من 8086 إلى AMD64، ونقرأ أسماء معالجات Intel وAMD:

[![](https://arabroot.io/content/images/2026/11/cisc-vs-risc-cover-cover.webp)دليلCISC أم RISC: ما الفرق الحقيقي بين x86 وARM وRISC-V؟نقيس حجم الكود وعدد التعليمات المنفذة لنفس البرامج على x86-64 وARM64 وRISC-V، ونرى ما بقي من نقاش CISC وRISC وما لم يعد صحيحاً.](https://arabroot.io/articles/cisc-%D8%A7%D9%85-risc-%D8%A7%D9%84%D9%81%D8%B1%D9%82-%D8%A7%D9%84%D8%AD%D9%82%D9%8A%D9%82%D9%8A-%D8%A8%D9%8A%D9%86-x86-%D9%88-arm-%D9%88-risc-v/)[![](https://arabroot.io/content/images/2026/11/x86-history-cover-cover.webp)دليلقصة x86: من Intel 8086 إلى x86-64 الذي صممته AMDكيف وصلت معمارية معالج 16 بت من 1978 إلى أغلب سيرفرات اليوم، ولماذا ما زال معالجك يقلع كأنه 8086، مع قطاع إقلاع يصعد الأوضاع الثلاثة أمامك.](https://arabroot.io/articles/%D9%82%D8%B5%D8%A9-x86-%D9%85%D9%86-intel-8086-%D8%A7%D9%84%D9%89-x86-64-%D9%88-amd64/)[![](https://arabroot.io/content/images/2026/11/intel-amd-families-cover-cover.webp)دليلعائلات Intel وAMD: كيف تقرأ اسم المعالج وجيله؟نفك أسماء معالجات Intel وAMD من المصادر الرسمية، ثم نقرأ معالجاً حقيقياً بأدوات Windows وLinux ونفك هويته الرقمية التي لا تتغير مع الاسم.](https://arabroot.io/articles/%D8%B9%D8%A7%D8%A6%D9%84%D8%A7%D8%AA-intel-%D9%88-amd-%D9%83%D9%8A%D9%81-%D8%AA%D9%82%D8%B1%D8%A7-%D8%A7%D8%B3%D9%85-%D8%A7%D9%84%D9%85%D8%B9%D8%A7%D9%84%D8%AC-%D9%88%D8%AC%D9%8A%D9%84%D9%87/)[![](https://arabroot.io/content/images/2026/11/arm-everywhere-cover-cover.webp)دليلARM من الجوال إلى السيرفر: Apple Silicon وGravitonكيف تربح Arm من شرائح لا تصنعها، ولماذا صار في كل سحابة معالج ARM، مع مختبر يبني Image لـ arm64 ويقيس كلفة تشغيلها تحت المحاكاة.](https://arabroot.io/articles/arm-%D9%85%D9%86-%D8%A7%D9%84%D8%AC%D9%88%D8%A7%D9%84-%D8%A7%D9%84%D9%89-%D8%A7%D9%84%D8%B3%D9%8A%D8%B1%D9%81%D8%B1-apple-silicon-%D9%88-graviton/)[![](https://arabroot.io/content/images/2026/11/risc-v-cover-cover.webp)دليلRISC-V: المعمارية المفتوحة وهل تغير سوق المعالجات؟ما الذي يعنيه أن تكون معمارية المعالج مفتوحة، وكيف تقرأ امتدادات RISC-V وملفاتها التعريفية، مع مختبر يقلع Debian كاملاً على RISC-V داخل QEMU.](https://arabroot.io/articles/risc-v-%D8%A7%D9%84%D9%85%D8%B9%D9%85%D8%A7%D8%B1%D9%8A%D8%A9-%D8%A7%D9%84%D9%85%D9%81%D8%AA%D9%88%D8%AD%D8%A9-%D9%88%D9%87%D9%84-%D8%AA%D8%BA%D9%8A%D8%B1-%D8%B3%D9%88%D9%82-%D8%A7%D9%84%D9%85%D8%B9%D8%A7%D9%84%D8%AC%D8%A7%D8%AA/)[![](https://arabroot.io/content/images/2026/11/emulation-translation-cover-cover.webp)دليلالمحاكاة Emulation والترجمة الثنائية: QEMU وRosetta 2نفتح محاكي QEMU ونرى كيف تتحول تعليمات ARM إلى تعليمات x86 ونقيس كلفة كل خطوة، ثم نقارن ذلك بما تفعله Rosetta 2 وWindows Prism.](https://arabroot.io/articles/%D8%A7%D9%84%D9%85%D8%AD%D8%A7%D9%83%D8%A7%D8%A9-emulation-%D9%88%D8%A7%D9%84%D8%AA%D8%B1%D8%AC%D9%85%D8%A9-%D8%A7%D9%84%D8%AB%D9%86%D8%A7%D8%A6%D9%8A%D8%A9-qemu-%D9%88-rosetta-2/)[![](https://arabroot.io/content/images/2026/10/cpu-internals-cover-cover.webp)دليلكيف يعمل المعالج CPU من الداخل ولماذا يهمك ذلكنتابع تعليمة واحدة داخل نواة المعالج، ونرى لماذا يصبح نفس الكود أبطأ بعشر مرات عندما تغير ترتيب المرور على البيانات.](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%B9%D8%A7%D9%84%D8%AC-cpu-%D9%85%D9%86-%D8%A7%D9%84%D8%AF%D8%A7%D8%AE%D9%84/)

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

- 16 نوفمبر 2026: كتابة المقال، وتنفيذ التجارب داخل Container من Debian 13 (trixie) مع GCC 14.2 والمترجمين المتقاطعين لـ aarch64 وriscv64 وQEMU 10.0.13 في وضع المستخدم، على نواة Linux 5.15 (WSL2) ومعالج Intel Core i7-7700K، على Docker Engine 29.8.0.