מה זה שפת מכונה (קוד מכונה)?
קוד מכונה, שנקרא גם שפת מכונה, הוא ההוראות הבינאריות שהמעבד מבצע ישירות. כל הוראה היא רצף קצר של בייטים, כמו b8 01 00 00 00, שאומר למעבד להעביר, לחבר, להשוות או לקפוץ, ולכל משפחת מעבדים יש ערכת הוראות משלה.
עודכן ב-16 בנובמבר 2026
התוכנית הזו מסתכלת על שלוש מההוראות של עצמה, אלה שמתחת ל-sample:, ומדפיסה את הבייטים שהמעבד רואה. לחצו על הרצה:
b8 01 00 00 00 bf 01 00 00 00 0f 05
שנים-עשר הבייטים האלה הם קוד המכונה של שלוש השורות שמתחת ל-sample:, כתובים בהקסדצימלי, שתי ספרות לכל בייט. בזיכרון הם ביטים: b8 הוא 10111000. התוכנית אף פעם לא מריצה אותם. היא קוראת אותם כמו שהייתה קוראת כל נתון אחר, כי מבחינת המחשב, הוראות הן פשוט בייטים בזיכרון.
קוראים את הבייטים
| בייטים | אסמבלי | מה המעבד עושה |
|---|---|---|
b8 01 00 00 00 | mov rax, 1 | מכניס את המספר 1 בגודל 32 ביט ל-eax, מה שמאפס גם את החצי העליון של rax |
bf 01 00 00 00 | mov rdi, 1 | אותו דבר, ל-edi |
0f 05 | syscall | קורא למערכת ההפעלה |
בשתי ההוראות הראשונות, הבייט הראשון הוא ה-opcode, החלק שאומר מה לעשות. כאן, כל הבייטים מ-b8 עד bf פירושם "הכנס את 4 הבייטים הבאים לאוגר", והאוגר נבחר לפי המרחק של ה-opcode מ-b8: eax הוא אוגר 0, ולכן ה-opcode שלו הוא b8, ו-edi הוא אוגר 7, ולכן ה-opcode שלו הוא b8 + 7, כלומר bf. לא כל הוראת x86-64 בנויה בצורה פשוטה כל כך: חלק מההוראות מתחילות בבייט קידומת (prefix), כמו ה-48 שמופיע לפני הרבה הוראות של 64 ביט, ויש opcodes שתופסים שני בייטים, כמו 0f 05.
4 הבייטים שאחריו מחזיקים את המספר 1, אבל הפוך: 01 00 00 00. x86-64 היא little-endian, כלומר מספר של כמה בייטים נשמר כשהבייט הנמוך ביותר שלו ראשון. המספר 258 היה נשמר כ-02 01 00 00.
גם האסמבלר עשה כאן בחירה. קוד המקור אמר mov rax, 1, אוגר של 64 ביט, אבל NASM כתב את ההוראה בת 5 הבייטים עבור eax, כי כתיבה לאוגר של 32 ביט מאפסת את 32 הביטים העליונים והתוצאה זהה. הצורה הארוכה, 48 c7 c0 01 00 00 00, הייתה תופסת 7 בייטים.
איך המעבד מריץ קוד מכונה
המעבד שומר את הכתובת של ההוראה הבאה באוגר מיוחד, rip ב-x86-64, שנקרא מצביע ההוראות (instruction pointer) או מונה התוכנית (program counter). הוא חוזר על שלושה שלבים מיליארדי פעמים בשנייה:
- הבאה (fetch). קריאת הבייטים בכתובת שב-
rip. - פענוח (decode). זיהוי איזו הוראה זו ומה האורך שלה. הוראות x86-64 הן באורך 1 עד 15 בייטים, ולכן המעבד צריך לקרוא את הבייטים הראשונים כדי לדעת איפה ההוראה נגמרת. הוראות ARM64 הן תמיד באורך 4 בייטים.
- ביצוע (execute). ביצוע ההוראה, ואז העברת
ripלהוראה הבאה, או לכתובת אחרת אם ההוראה הייתה קפיצה.
שום דבר לא אומר למעבד אם הבייטים ב-rip נועדו להיות הוראות. אם באג שולח אותו לכתובת מלאה בטקסט, הוא מפענח את הטקסט כהוראות ומריץ אותן, או נעצר עם שגיאת illegal instruction. מערכות הפעלה מודרניות מסמנות את זיכרון הנתונים כלא ניתן להרצה, ולכן קפיצה אליו מסיימת את התוכנית; ב-Linux זה מדווח כ-segmentation fault.
קוד מכונה מול שפת אסמבלי
שפת אסמבלי היא הצורה הטקסטואלית של קוד מכונה. השתיים ממופות כמעט אחד לאחד, אבל הן לא אותו דבר:
| קוד מכונה | שפת אסמבלי | |
|---|---|---|
| מה זה | בייטים שהמעבד מבצע | טקסט שאדם כותב |
| דוגמה | bf 01 00 00 00 | mov rdi, 1 |
| מי קורא אותו | המעבד | אסמבלר, כמו NASM |
| תוויות והערות | אין, רק כתובות | _start:, ; comment |
| נתונים בקוד המקור | עוד בייטים וזהו | הנחיות כמו db "Hello" |
| קשור למשפחת מעבדים אחת | כן | כן |
אסמבלר עובר מעמודת האסמבלי לעמודת קוד המכונה. דיסאסמבלר, כמו objdump -d, עובר בכיוון ההפוך: הוא הופך בייטים לאסמבלי. הערות אף פעם לא נשמרות בקוד מכונה, ולכן הן אובדות. שמות של תוויות נשמרים רק בטבלת הסמלים (symbol table) של הקובץ: בתוכנית שלמעלה, objdump מציג את ה-jnz של הלולאה כ-jne 401019 <next_byte> (שני שמות לאותה הוראה), ואחרי ש-strip מסיר את הסמלים, רק jne 0x401019. כך אנשים קוראים תוכניות שאין להם את קוד המקור שלהן.
קוד מכונה מול bytecode
לא כל תוכנית מקומפלת היא קוד מכונה. קומפיילר של C, C++, Go או Rust מייצר קוד מכונה למעבד אחד. Java מתקמפלת ל-bytecode בקובצי .class, ו-Python מקמפלת את הקוד שלכם ל-bytecode לפני שה-interpreter שלה מריץ אותו. ל-bytecode יש הוראות גם כן, אבל הן מיועדות למכונה וירטואלית, כלומר לתוכנית, ולא לשבב פיזי.
לכן קובץ .class אחד רץ על כל מחשב שיש בו סביבת ריצה של Java, בעוד שתוכנית C מקומפלת צריכה להיבנות מחדש לכל מעבד ומערכת הפעלה. השניים נפגשים בקומפיילרי JIT (just-in-time): ה-JVM ומנועי JavaScript כמו V8 הופכים את ה-bytecode הנפוץ ביותר לקוד מכונה בזמן שהתוכנית רצה.
למה קוד מכונה רץ רק על סוג אחד של מחשב
שלושה דברים צריכים להתאים כדי שקוד המכונה של תוכנית ירוץ:
- ערכת ההוראות. x86-64 ו-ARM64 משתמשות בבייטים שונים לפעולות שונות. Rosetta 2 של Apple מאפשר למחשבי Mac עם Apple silicon להריץ תוכניות x86-64 על ידי תרגום קוד המכונה שלהן לקוד מכונה של ARM64.
- פורמט הקובץ. Linux משתמשת בקובצי ELF, Windows ב-PE (
.exe) ו-macOS ב-Mach-O. כל אחד מהם אומר למערכת ההפעלה איפה הקוד והנתונים ומאיפה להתחיל. - קריאות המערכת. הדוגמה שלמעלה מבקשת מ-Linux את קריאת המערכת 1, write. Windows ו-macOS ממספרות את השירותים שלהן אחרת, ולכן אותם בייטים יבקשו משהו אחר, או כלום.
לאן ממשיכים מכאן
שנו את ההוראות שמתחת ל-sample: בעורך האונליין של Assembly והריצו את התוכנית שוב כדי לראות את הבייטים שלהן: נסו add rax, rbx או ret. הדף על שפת אסמבלי מסביר את השפה שבה ההוראות האלה כתובות, הAssembly cheat sheet מרכז את ההוראות הנפוצות, וקורס Assembly החינמי מלמד x86-64 מקריאת המערכת הראשונה. כדי להבין איך ביטים ובייטים מאחסנים את כל השאר, ראו את הדף על בייט.
שאלות נפוצות
האם קוד מכונה הוא רק אפסים ואחדות?
b8 01 00 00 00.מה ההבדל בין קוד מכונה לשפת אסמבלי?
mov במקום מספרים כמו b8, ובנוסף תוויות והערות בשביל בני אדם. אסמבלר מתרגם אסמבלי לקוד מכונה, ודיסאסמבלר מתרגם בחזרה, אם כי התוויות וההערות הולכות לאיבוד בדרך.האם קוד מכונה זהה בכל מחשב?
0f 05 פירושם syscall ב-x86-64, בעוד ששבב ARM64 קורא הוראות של 4 בייטים בכל פעם ולא נותן לבייטים האלה משמעות כזו. גם על אותו מעבד, Windows, macOS ו-Linux אורזות תוכניות בפורמטים שונים של קבצים ומציעות קריאות מערכת שונות, ולכן תוכנית נבנית למעבד אחד ולמערכת הפעלה אחת.מה ההבדל בין קוד מכונה ל-bytecode?
.class של Java וקובצי .pyc של Python מכילים bytecode, שרץ על כל מחשב שיש בו את המכונה הווירטואלית, וקומפיילר JIT יכול להפוך את החלקים שרצים הכי הרבה לקוד מכונה בזמן שהתוכנית רצה.האם בני אדם יכולים לכתוב קוד מכונה?
כן, והמתכנתים הראשונים עשו את זה, כשהזינו מספרים ביד בעזרת מתגים או כרטיסים מנוקבים. זה איטי וקל לטעות בזה, כי צריך לחשב ביד כל כתובת, ולכן שפות אסמבלי הופיעו כבר בסוף שנות ה-40. היום אנשים קוראים קוד מכונה בדיבאגר הרבה יותר משהם כותבים אותו.