Assembly Cheat Sheet: דף עזר מהיר
עודכן לאחרונה
מבנה התוכנית
תוכנית בלי ספריית C מתחילה בתווית שהמקשר מקבל עליה הודעה, בדרך כלל _start.
| רכיב | קוד |
|---|---|
| מקטע (section) לנתונים קבועים | section .data |
| מקטע לבאפרים מאופסים | section .bss |
| מקטע להוראות | section .text |
| הפיכת נקודת הכניסה לגלויה למקשר | global _start |
| תווית (כתובת עם שם) | _start: |
| הערה | ; everything after a semicolon |
| סיום התוכנית עם קוד יציאה 0 | mov rax, 60 → mov rdi, 0 → syscall |
אוגרים
שישה-עשר אוגרים כלליים של 64 ביט. לכל אחד יש שמות קצרים יותר ל-32, 16 ו-8 הביטים התחתונים שלו.
| האוגר והשימוש הנפוץ בו | שמות 64 / 32 / 16 / 8 ביט |
|---|---|
| צובר (accumulator), מספר קריאת המערכת, ערך החזרה | rax eax ax al |
| בסיס (base), נשמר לאורך קריאות לפונקציות | rbx ebx bx bl |
| מונה (counter), הארגומנט הרביעי של פונקציה | rcx ecx cx cl |
נתונים (data), הארגומנט השלישי, החצי העליון של mul ו-div | rdx edx dx dl |
| אינדקס מקור (source index), הארגומנט השני | rsi esi si sil |
| אינדקס יעד (destination index), הארגומנט הראשון | rdi edi di dil |
| מצביע המחסנית, ראש המחסנית | rsp esp sp spl |
| מצביע הבסיס, מסגרת המחסנית | rbp ebp bp bpl |
אוגרים נוספים, מוצגים עבור r8; r9 עד r15 הולכים לפי אותה תבנית | r8 r8d r8w r8b |
| מצביע ההוראות, הכתובת של ההוראה הבאה | rip |
דגלים ש-cmp, test ופעולות אריתמטיות קובעים | rflags |
הנחיות נתונים
הנחיות (directives) נקראות על ידי האסמבלר ושומרות זיכרון או נותנות לו שם; הן לא הוראות.
| משמעות | קוד |
|---|---|
| הגדרת בייטים: מחרוזת וירידת שורה | msg db "Hello", 10 |
| הגדרת word של 16 ביט | year dw 2026 |
| הגדרת doubleword של 32 ביט | count dd 1000 |
| הגדרת quadword של 64 ביט | big dq 123456789 |
שמירת 64 בייטים מאופסים (ב-.bss) | buffer resb 64 |
| שמירת 10 ערכי quadword | table resq 10 |
| מתן שם לקבוע | max equ 100 |
| האורך של הנתונים שממש מעל | len equ $ - msg |
| חזרה על הגדרה | zeros times 8 db 0 |
העברת נתונים
היעד בא קודם. סוגריים מרובעים פירושם הזיכרון בכתובת הזו.
| פעולה | קוד |
|---|---|
| מספר לתוך אוגר | mov rax, 42 |
| אוגר לתוך אוגר | mov rbx, rax |
| הכתובת של תווית לתוך אוגר | mov rsi, msg |
| קריאת 8 בייטים מהזיכרון | mov rax, [big] |
| כתיבת אוגר לזיכרון | mov [big], rax |
| כתיבת בייט אחד, עם גודל מפורש | mov byte [buffer], 10 |
| קריאת זיכרון בכתובת של אוגר ועוד היסט | mov al, [rsi + 1] |
| עם אינדקס: בסיס + אינדקס * קנה מידה + היסט | mov rax, [table + rcx * 8] |
| חישוב כתובת בלי לקרוא מהזיכרון | lea rax, [rsi + rcx * 2] |
| טעינת בייט ואיפוס שאר האוגר | movzx eax, byte [rsi] |
| החלפה בין שני אוגרים | xchg rax, rbx |
אריתמטיקה ולוגיקה
הוראות עם שני אופרנדים כותבות את התוצאה לאופרנד הראשון. mul, div ו-idiv משתמשות גם ב-rax וב-rdx באופן אוטומטי. ההשפעה על הדגלים משתנה: not לא משנה את הדגלים, ו-div ו-idiv משאירות אותם לא מוגדרים.
| פעולה | קוד |
|---|---|
| חיבור | add rax, rbx |
| חיסור | sub rax, 5 |
| הוספת 1 / הפחתת 1 | inc rcx / dec rcx |
| כפל עם סימן לתוך אוגר | imul rax, rbx |
כפל בלי סימן: rdx:rax = rax * rbx | mul rbx |
חילוק הערך בלי סימן שב-rax ב-rbx: קודם מאפסים את rdx; המנה ב-rax, השארית ב-rdx | xor rdx, rdx → div rbx |
חילוק עם סימן: קודם מרחיבים את הסימן של rax לתוך rdx | cqo → idiv rbx |
| היפוך סימן | neg rax |
| פעולות ביטים and, or, xor, not | and rax, 0xff / or rax, rbx / xor rax, rbx / not rax |
| איפוס אוגר (קצר ומהיר) | xor eax, eax |
| הזזה שמאלה (כפל ב-2 לכל ביט) | shl rax, 3 |
| הזזה ימינה: בלי סימן / עם סימן | shr rax, 1 / sar rax, 1 |
השוואה וקפיצה
cmp מחסרת בלי לשמור את התוצאה וקובעת את הדגלים; אחר כך קפיצה מותנית קוראת אותם.
| פעולה | קוד |
|---|---|
| השוואת שני ערכים | cmp rax, rbx |
| בדיקת ביטים (and בלי שמירה), לרוב כדי לבדוק אפס | test rax, rax |
| קפיצה תמיד | jmp done |
| קפיצה אם שווה / אפס | je done / jz done |
| קפיצה אם לא שווה / לא אפס | jne loop_start / jnz loop_start |
| עם סימן: גדול, גדול או שווה, קטן, קטן או שווה | jg / jge / jl / jle |
| בלי סימן: מעל, מעל או שווה, מתחת, מתחת או שווה | ja / jae / jb / jbe |
| לולאה של 10 פעמים עם מונה | mov rcx, 10 → again: → dec rcx → jnz again |
| העתקה רק אם התנאי מתקיים (בלי קפיצה) | cmovg rax, rbx |
מחסנית ופונקציות
המחסנית גדלה כלפי מטה: push מקטינה את rsp ב-8, ו-pop מגדילה אותו.
| פעולה | קוד |
|---|---|
| דחיפת אוגר / שליפתו בחזרה | push rbx / pop rbx |
| קריאה לפונקציה (דוחפת את כתובת החזרה) | call print_line |
| חזרה לקורא | ret |
| שמירת 32 בייטים של מקום מקומי | sub rsp, 32 |
| שחרור המקום | add rsp, 32 |
| הקמת מסגרת מחסנית | push rbp → mov rbp, rsp |
| פירוק המסגרת | mov rsp, rbp → pop rbp |
| ארגומנטים, לפי הסדר (System V, ב-Linux וב-macOS) | rdi rsi rdx rcx r8 r9 |
אוגרים שפונקציה חייבת לשחזר לפני ret | rbx rbp r12 r13 r14 r15 |
קריאות מערכת של Linux
שימו את המספר ב-rax ואת הארגומנטים ב-rdi, rsi, rdx, r10, r8, r9, ואז הריצו syscall. התוצאה חוזרת ב-rax; ערך שלילי הוא קוד שגיאה.
| קריאה | אוגרים |
|---|---|
read(fd, buffer, count) | rax = 0 rdi = fd rsi = buffer rdx = count |
write(fd, buffer, count) | rax = 1 rdi = fd rsi = buffer rdx = count |
open(path, flags, mode) | rax = 2 rdi = path rsi = flags rdx = mode |
close(fd) | rax = 3 rdi = fd |
exit(code) | rax = 60 rdi = code |
| קלט, פלט ושגיאה סטנדרטיים | fd 0 fd 1 fd 2 |
| אוגרים שהקרנל דורס | rcx r11 |
אסמבלי, הרצה ובדיקה
במחשב Linux שמותקנים בו NASM וכלי GNU.
| משימה | פקודה |
|---|---|
| אסמבלי לקובץ אובייקט | nasm -f elf64 main.asm -o main.o |
| קישור לתוכנית | ld main.o -o main |
| הרצה והצגת קוד היציאה | ./main; echo $? |
| דיסאסמבלי בתחביר Intel | objdump -d -M intel main |
| מעבר צעד אחר צעד בדיבאגר | gdb ./main |
| הצגת האסמבלי שקומפיילר C כותב | gcc -S -O2 -masm=intel file.c |
האוגרים, ההוראות וקריאות המערכת שהכי הרבה משתמשים בהם כשכותבים אסמבלי x86-64, בדף אחד. כל שורה כתובה בתחביר NASM (סדר האופרנדים של Intel, היעד קודם) עבור Linux של 64 ביט, אותה ערכת כלים שבה משתמשים העורך האונליין והקורס של Assembly ב-Coddy. חדשים באסמבלי? מה זו שפת אסמבלי עוברת על תוכנית שלמה שורה אחר שורה, ומה זה קוד מכונה מראה לאילו בייטים היא הופכת.
כל הוראה כאן עוברת אסמבלי עם nasm -f elf64. נסו כל אחת מהן בעורך האונליין של Assembly, שמבצע אסמבלי, קישור והרצה לתוכנית שלכם בדפדפן בלי להתקין כלום, או למדו אותן צעד אחר צעד בקורס Assembly החינמי.
שאלות נפוצות על ה-Assembly cheat sheet
האם ה-Assembly cheat sheet הזה בחינם?
כן. כל ה-cheat sheet חינמי לקריאה, בלי צורך בהרשמה. שמרו אותו במועדפים וחזרו אליו כשצריך שם של אוגר, הוראה או מספר של קריאת מערכת.
באיזו אסמבלי ה-cheat sheet הזה עוסק?
mov rax, rbx מעתיקה את rbx לתוך rax. תחביר AT&T, ברירת המחדל של האסמבלר של GNU, הופך את הסדר ומוסיף קידומות, וכותב movq %rbx, %rax. ל-ARM64 ול-RISC-V יש הוראות ואוגרים אחרים.מה ההבדל בין mov ל-lea?
mov rax, [rsi + 8] קוראת את 8 הבייטים שמאוחסנים בכתובת rsi + 8. lea rax, [rsi + 8] רק מחשבת את הכתובת ומכניסה את המספר ל-rax, בלי לגעת בזיכרון. מכיוון שהיא יכולה לחבר אוגרים ולהכפיל אותם בקנה מידה בצעד אחד, משתמשים ב-lea גם כמחשבון מהיר, למשל lea rax, [rbx + rbx * 4] כדי להכפיל את rbx ב-5.למה משתמשים ב-xor eax, eax כדי לאפס אוגר?
xor eax, eax באורך 2 בייטים, בעוד ש-mov rax, 0 תופסת 5 בייטים או יותר. כתיבה לאוגר של 32 ביט כמו eax מאפסת גם את החצי העליון של rax, כך שכל האוגר של 64 ביט הופך ל-0. המעבדים מזהים את ההוראה הזו ומטפלים בה בלי לחכות לערך הישן.בשביל מה יש שמות אוגרים של 64, 32, 16 ו-8 ביט?
rax הוא כל 64 הביטים, eax הוא 32 הביטים התחתונים, ax הוא 16 התחתונים ו-al הוא 8 הנמוכים ביותר. הם מאפשרים לעבוד עם בייטים ועם מספרים קטנים יותר, למשל mov al, [rsi] קוראת תו אחד ממחרוזת. כתיבה ל-eax מאפסת את 32 הביטים העליונים; כתיבה ל-ax או ל-al משאירה את השאר בלי שינוי.אפשר להריץ את ההוראות האלה אונליין?
כן. עורך האונליין של Assembly ב-Coddy מבצע אסמבלי ל-x86-64 NASM, מקשר ומריץ על Linux, ואז מציג את הפלט ואת השגיאות, אם יש. אפשר להדביק שורות מה-cheat sheet הזה לתוך תוכנית ולהריץ אותה בדפדפן.