Menu
CoddyTech

מה זה שפת מכונה (קוד מכונה)?

קוד מכונה, שנקרא גם שפת מכונה, הוא ההוראות הבינאריות שהמעבד מבצע ישירות. כל הוראה היא רצף קצר של בייטים, כמו b8 01 00 00 00, שאומר למעבד להעביר, לחבר, להשוות או לקפוץ, ולכל משפחת מעבדים יש ערכת הוראות משלה.

מאת Kevin Spektor, מייסד שותף ו-CTO

עודכן ב-16 בנובמבר 2026

התוכנית הזו מסתכלת על שלוש מההוראות של עצמה, אלה שמתחת ל-sample:, ומדפיסה את הבייטים שהמעבד רואה. לחצו על הרצה:

b8 01 00 00 00 bf 01 00 00 00 0f 05

שנים-עשר הבייטים האלה הם קוד המכונה של שלוש השורות שמתחת ל-sample:, כתובים בהקסדצימלי, שתי ספרות לכל בייט. בזיכרון הם ביטים: b8 הוא 10111000. התוכנית אף פעם לא מריצה אותם. היא קוראת אותם כמו שהייתה קוראת כל נתון אחר, כי מבחינת המחשב, הוראות הן פשוט בייטים בזיכרון.

קוראים את הבייטים

בייטיםאסמבלימה המעבד עושה
b8 01 00 00 00mov rax, 1מכניס את המספר 1 בגודל 32 ביט ל-eax, מה שמאפס גם את החצי העליון של rax
bf 01 00 00 00mov rdi, 1אותו דבר, ל-edi
0f 05syscallקורא למערכת ההפעלה

בשתי ההוראות הראשונות, הבייט הראשון הוא ה-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). הוא חוזר על שלושה שלבים מיליארדי פעמים בשנייה:

  1. הבאה (fetch). קריאת הבייטים בכתובת שב-rip.
  2. פענוח (decode). זיהוי איזו הוראה זו ומה האורך שלה. הוראות x86-64 הן באורך 1 עד 15 בייטים, ולכן המעבד צריך לקרוא את הבייטים הראשונים כדי לדעת איפה ההוראה נגמרת. הוראות ARM64 הן תמיד באורך 4 בייטים.
  3. ביצוע (execute). ביצוע ההוראה, ואז העברת rip להוראה הבאה, או לכתובת אחרת אם ההוראה הייתה קפיצה.

שום דבר לא אומר למעבד אם הבייטים ב-rip נועדו להיות הוראות. אם באג שולח אותו לכתובת מלאה בטקסט, הוא מפענח את הטקסט כהוראות ומריץ אותן, או נעצר עם שגיאת illegal instruction. מערכות הפעלה מודרניות מסמנות את זיכרון הנתונים כלא ניתן להרצה, ולכן קפיצה אליו מסיימת את התוכנית; ב-Linux זה מדווח כ-segmentation fault.

קוד מכונה מול שפת אסמבלי

שפת אסמבלי היא הצורה הטקסטואלית של קוד מכונה. השתיים ממופות כמעט אחד לאחד, אבל הן לא אותו דבר:

קוד מכונהשפת אסמבלי
מה זהבייטים שהמעבד מבצעטקסט שאדם כותב
דוגמהbf 01 00 00 00mov 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 מקריאת המערכת הראשונה. כדי להבין איך ביטים ובייטים מאחסנים את כל השאר, ראו את הדף על בייט.

שאלות נפוצות

האם קוד מכונה הוא רק אפסים ואחדות?
כן. בזיכרון, כל הוראה היא תבנית של ביטים, והמעגלים של המעבד מגיבים לביטים האלה ישירות. אבל כמעט אף פעם לא כותבים אותו באפסים ואחדות: הקסדצימלי קצר יותר וקל יותר לקריאה, ולכן ההוראה 10111000 00000001 00000000 00000000 00000000 נכתבת b8 01 00 00 00.
מה ההבדל בין קוד מכונה לשפת אסמבלי?
קוד מכונה הוא הבייטים שהמעבד מריץ. שפת אסמבלי היא צורה טקסטואלית של אותן הוראות, עם שמות כמו mov במקום מספרים כמו b8, ובנוסף תוויות והערות בשביל בני אדם. אסמבלר מתרגם אסמבלי לקוד מכונה, ודיסאסמבלר מתרגם בחזרה, אם כי התוויות וההערות הולכות לאיבוד בדרך.
האם קוד מכונה זהה בכל מחשב?
לא. לכל משפחת מעבדים יש ערכת הוראות משלה: הבייטים 0f 05 פירושם syscall ב-x86-64, בעוד ששבב ARM64 קורא הוראות של 4 בייטים בכל פעם ולא נותן לבייטים האלה משמעות כזו. גם על אותו מעבד, Windows, macOS ו-Linux אורזות תוכניות בפורמטים שונים של קבצים ומציעות קריאות מערכת שונות, ולכן תוכנית נבנית למעבד אחד ולמערכת הפעלה אחת.
מה ההבדל בין קוד מכונה ל-bytecode?
קוד מכונה רץ על מעבד פיזי. Bytecode הוא סט הוראות למכונה וירטואלית, כלומר לתוכנית שקוראת ומבצעת כל הוראה. קובצי .class של Java וקובצי .pyc של Python מכילים bytecode, שרץ על כל מחשב שיש בו את המכונה הווירטואלית, וקומפיילר JIT יכול להפוך את החלקים שרצים הכי הרבה לקוד מכונה בזמן שהתוכנית רצה.
האם בני אדם יכולים לכתוב קוד מכונה?

כן, והמתכנתים הראשונים עשו את זה, כשהזינו מספרים ביד בעזרת מתגים או כרטיסים מנוקבים. זה איטי וקל לטעות בזה, כי צריך לחשב ביד כל כתובת, ולכן שפות אסמבלי הופיעו כבר בסוף שנות ה-40. היום אנשים קוראים קוד מכונה בדיבאגר הרבה יותר משהם כותבים אותו.

איור של שפות התכנות ב-Coddy

ללמוד תכנות עם Coddy

להתחיל