Menu
CoddyTech

מה זה שפת אסמבלי (Assembly)?

שפת אסמבלי (Assembly) היא שפת תכנות ברמה נמוכה שבה ההוראות של מעבד נכתבות הוראה אחת בכל שורה, בשמות קצרים כמו mov ו-add במקום מספרים בינאריים. תוכנית שנקראת אסמבלר (assembler) מתרגמת אותה לקוד המכונה שהמעבד מריץ.

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

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

התוכנית הזו מדפיסה שורה אחת. לחצו על הרצה: האסמבלר NASM מתרגם אותה, היא מקושרת לתוכנית Linux ורצה. היא מדברת עם Linux ישירות דרך קריאות מערכת (system calls), בלי ספריית C.

Hello from assembly!

כל שורה מתחת ל-_start היא הוראה אחת למעבד x86-64, הסוג שנמצא ברוב מחשבי ה-PC עם Windows ו-Linux. אין פונקציית print. התוכנית מכניסה ארבעה מספרים לאוגרים (registers) של המעבד ומבקשת מהקרנל של Linux לכתוב את הבייטים.

קוראים את התוכנית שורה אחר שורה

section .data פותח את החלק בתוכנית שמחזיק נתונים קבועים. msg db "Hello from assembly!", 10 שומר בייטים לטקסט, ו-db פירושו "define bytes" (הגדר בייטים). ה-10 בסוף הוא קוד התו של ירידת שורה.

len equ $ - msg מחושב על ידי האסמבלר, לא על ידי המעבד: $ הוא המיקום הנוכחי, ולכן ההפרש הוא אורך ההודעה, 21 בייטים.

section .text מחזיק את ההוראות. global _start הופך את התווית _start לגלויה למקשר (linker), שמסמן אותה כמקום שבו התוכנית מתחילה.

mov rax, 1 מעתיק את המספר 1 לאוגר rax. אוגר הוא תא אחסון קטן בתוך המעבד עצמו, ברוחב 64 ביט ב-x86-64, ורוב החישובים מתבצעים באוגרים. שלוש שורות ה-mov הבאות ממלאות באותו אופן את rdi, את rsi ואת rdx.

syscall מעביר את השליטה למערכת ההפעלה. Linux בודקת את rax כדי לדעת איזה שירות התבקש (1 הוא write), ואת rdi, את rsi ואת rdx כדי לקבל את הארגומנטים שלו: לאן לכתוב, הכתובת של הבייטים, וכמה בייטים. ה-syscall השני, עם 60 ב-rax, מסיים את התוכנית עם קוד יציאה 0.

המילים שאחרי ; הן הערות. האסמבלר מתעלם מהן, ובאסמבלי הן חשובות יותר מאשר ברוב השפות, כי ההוראות אומרות מה קורה אבל לא למה.

איך אסמבלי הופכת לתוכנית

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

  1. האסמבלר (nasm -f elf64 hello.asm -o hello.o) מתרגם כל הוראה לבייטים שלה וכותב קובץ אובייקט.
  2. המקשר (ld hello.o -o hello) ממלא את כתובות הזיכרון הסופיות, למשל איפה msg יהיה, וכותב את קובץ ההרצה.
  3. הרצת ./hello גורמת לקרנל לטעון את הבייטים האלה לזיכרון ולהתחיל את המעבד ב-_start.

דיסאסמבלר מראה מה האסמבלר יצר. הנה הפלט של objdump -d -M intel hello.o, מקוצר לשלוש ההוראות הראשונות:

0000000000000000 <_start>:
   0:   b8 01 00 00 00          mov    eax,0x1
   5:   bf 01 00 00 00          mov    edi,0x1
   a:   48 be 00 00 00 00 00    movabs rsi,0x0
  11:   00 00 00

כל שורת אסמבלי הפכה להוראה אחת באורך 2 עד 10 בייטים. שני פרטים מראים שהאסמבלר עושה יותר מהעתקה: NASM בחר קידוד קצר יותר ל-mov rax, 1, כי כתיבה ל-eax מאפסת גם את החצי העליון של rax, והכתובת של msg עדיין כולה אפסים, כי רק המקשר יודע אותה. הדף על קוד מכונה קורא את הבייטים האלה אחד אחד.

זה ההבדל מקומפיילר. קומפיילר מתחיל משפה כמו C, שבה שורה אחת יכולה להפוך להרבה הוראות, ובוחר את ההוראות האלה בעצמו. באסמבלי, אתם בוחרים כל הוראה.

האוגרים עושים את העבודה

באסמבלי אין משתנים מוצהרים עם טיפוסים, כמו ב-Python או ב-C. אתם מחליטים איפה כל ערך נמצא: באוגר בזמן שהמעבד עובד עליו, או בזיכרון, שבו תווית כמו digit נותנת שם לכתובת. התוכנית הזו מחברת שני מספרים ומדפיסה את התוצאה:

7

הסכום הוא המספר 7, אבל המסך מציג תווים, ולכן התוכנית מוסיפה 48, הקוד של התו 0, לפני שהיא כותבת אותו. al הוא הבייט הנמוך ביותר של rax, ו-[digit] עם סוגריים מרובעים פירושו "הזיכרון בכתובת digit". שנו את ה-5 ל-15 והפלט יהיה A, התו שהקוד שלו 65: הדפסת מספר דו-ספרתי דורשת לולאה שמחלקת ב-10. זו הפשרה של אסמבלי בדוגמה אחת. אתם שולטים בכל צעד, ואתם צריכים לכתוב כל צעד.

שפת אסמבלי לכל משפחת מעבדים

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

x86-64 (NASM):  mov rdi, 1
ARM64:          mov x0, #1
RISC-V:         li a0, 1
  • x86-64 מריצה את רוב מחשבי ה-PC והשרתים עם Windows ו-Linux, על מעבדי Intel ו-AMD. שני התחבירים שלה כותבים את האופרנדים בסדר הפוך: תחביר Intel כותב mov rax, 1, ותחביר AT&T, ברירת המחדל של כלי GNU, כותב movq $1, %rax.
  • ARM64, שנקראת גם AArch64, מריצה כמעט כל טלפון, מחשבי Mac עם Apple silicon, ונתח הולך וגדל משרתי הענן.
  • RISC-V היא ערכת הוראות פתוחה, נפוצה במיקרו-בקרים ובהוראה.

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

למה משתמשים בשפת אסמבלי

  • מערכות הפעלה. הקוד שמאתחל את המעבד, מטפל בפסיקות (interrupts) ועובר בין תוכניות כתוב בחלקו באסמבלי. הקרנל של Linux שומר אותו בתיקייה נפרדת לכל משפחת מעבדים.
  • לולאות שהמהירות תלויה בהן. מפענחי וידאו כמו dav1d וכלי מדיה כמו FFmpeg משתמשים באסמבלי שנכתב ביד בלולאות הספורות שבהן הם מבלים את רוב הזמן.
  • מערכות משובצות. שבבים קטנים מאוד, עם כמה קילובייטים של זיכרון, צריכים לפעמים קוד שבו כל בייט נבחר.
  • לקרוא מה הקומפיילר יצר. gcc -S ואתרים כמו Compiler Explorer מראים את האסמבלי שמאחורי קוד C, C++ או Rust, וכך אנשים בודקים אופטימיזציות.
  • אבטחה והנדסה לאחור. אפשר לבצע דיסאסמבלי לתוכנית גם בלי קוד המקור שלה, וכך חוקרי נוזקות ומפתחי אקספלויטים קוראים אותה.
  • ללמוד איך מחשבים עובדים. segmentation fault, גלישת מחסנית (stack overflow) או מצביע נהיים הגיוניים הרבה יותר אחרי שכותבים את ההוראות שמאחוריהם.

מיתוסים נפוצים על אסמבלי

  • "אסמבלי זה קוד מכונה." זה טקסט שממופה מקרוב לקוד מכונה. תוויות, הערות, db ו-equ קיימים רק בשביל האסמבלר, והוא בוחר קידודים בשבילכם, כפי ש-mov rax, 1 הראה.
  • "אסמבלי תמיד מהירה יותר." קוד מהיר רק כמו ההוראות שנבחרו, וקומפיילרים מודרניים בוחרים טוב מאוד. אסמבלי שנכתב ביד מנצח במקרים צרים, בדרך כלל לולאות שמשתמשות בהוראות מיוחדות, ומי שכותבים אותו מודדים קודם.
  • "צריך ללמוד אסמבלי לפני כל שפה אחרת." לא צריך. זו שפה שנייה או שלישית טובה: כשכבר יודעים מה זה משתנה ומה זו לולאה, קל יותר לראות איך המעבד מבצע אותם.

לאן ממשיכים מכאן

נסו לשנות את התוכניות שלמעלה בעורך האונליין של Assembly, שמריץ את אותה ערכת כלים של x86-64 NASM. הAssembly cheat sheet מרכז את האוגרים, ההוראות וקריאות המערכת של Linux בדף אחד. כדי לראות בפירוט מה האסמבלר מייצר, קראו מה זה קוד מכונה, וכדי לתרגל צעד אחר צעד אוגרים, זיכרון, קריאות מערכת, אריתמטיקה ולולאות, היכנסו לקורס Assembly החינמי.

שאלות נפוצות

האם עדיין משתמשים בשפת אסמבלי היום?

כן, אבל במקומות קטנים ומוגדרים. ליבות של מערכות הפעלה משתמשות בה לקוד שמאתחל את המעבד ועובר בין תוכניות, קושחה (firmware) של שבבים זעירים משתמשת בה במקומות שבהם כל בייט חשוב, ומפענחי וידאו כמו dav1d משתמשים באסמבלי שנכתב ביד בלולאות שצורכות את רוב זמן העיבוד שלהם. מפתחים רבים שאף פעם לא כותבים אסמבלי עדיין קוראים אותו, כשמדבגים קריסה, כשבודקים מה הקומפיילר יצר, או כשמנתחים נוזקה.

האם אסמבלי קשה יותר מ-C++?
השפה עצמה קטנה יותר: כמה עשרות הוראות נפוצות, אוגרים וזיכרון. כתיבת תוכנית שלמה קשה יותר, כי אתם מנהלים בעצמכם את האוגרים, הזיכרון וזרימת הבקרה. אין טיפוסים, אין פקודות לולאה ואין print, כך ששורה אחת של C++ יכולה לדרוש עשר שורות אסמבלי.
מה ההבדל בין שפת אסמבלי לאסמבלר?
אסמבלי היא השפה: הטקסט שאתם כותבים, כמו mov rax, 1. אסמבלר הוא התוכנית שמתרגמת את הטקסט הזה לקוד מכונה, כמו NASM, האסמבלר as של GNU, או MASM של Microsoft. אנשים קוראים לעתים קרובות גם לשפה עצמה "assembler", במיוחד בגרמנית, ברוסית ובפולנית, שבהן זה השם המקובל.
האם C++ היא שפת אסמבלי?
לא. C++ היא שפה עילית: קומפיילר מתרגם אותה, ושורה אחת יכולה להפוך להרבה הוראות מכונה, והקומפיילר יכול לייצר אותן לכל משפחת מעבדים שהוא תומך בה. אסמבלי קשורה למשפחת מעבדים אחת, וכל שורה בה היא הוראה אחת. קומפיילרים כמו GCC יכולים להראות לכם את האסמבלי שהם מייצרים עבור קוד ה-C++ שלכם עם הדגל -S.
כמה שפות אסמבלי יש?

אחת לכל משפחת מעבדים, ועוד תחבירים שונים לחלק מהן. הנפוצות היום הן x86-64 למחשבי PC של Intel ו-AMD, ARM64 לטלפונים ולמחשבי Mac עם Apple silicon, ו-RISC-V. רק ל-x86-64 יש שני תחבירים: Intel (שבו משתמשים NASM ו-MASM) ו-AT&T (ברירת המחדל של האסמבלר של GNU).

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

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

להתחיל