Menu
CoddyTech

Assembly Cheat Sheet: דף עזר מהיר

עודכן לאחרונה

מבנה התוכנית

תוכנית בלי ספריית C מתחילה בתווית שהמקשר מקבל עליה הודעה, בדרך כלל _start.

רכיבקוד
מקטע (section) לנתונים קבועיםsection .data
מקטע לבאפרים מאופסיםsection .bss
מקטע להוראותsection .text
הפיכת נקודת הכניסה לגלויה למקשרglobal _start
תווית (כתובת עם שם)_start:
הערה; everything after a semicolon
סיום התוכנית עם קוד יציאה 0mov 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 ו-divrdx 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 ערכי quadwordtable 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 / הפחתת 1inc rcx / dec rcx
כפל עם סימן לתוך אוגרimul rax, rbx
כפל בלי סימן: rdx:rax = rax * rbxmul rbx
חילוק הערך בלי סימן שב-rax ב-rbx: קודם מאפסים את rdx; המנה ב-rax, השארית ב-rdxxor rdx, rdx → div rbx
חילוק עם סימן: קודם מרחיבים את הסימן של rax לתוך rdxcqo → idiv rbx
היפוך סימןneg rax
פעולות ביטים and, or, xor, notand 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
אוגרים שפונקציה חייבת לשחזר לפני retrbx 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 $?
דיסאסמבלי בתחביר Intelobjdump -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 הזה עוסק?
x86-64, ערכת ההוראות של 64 ביט במעבדי Intel ו-AMD, בתחביר NASM על Linux. NASM משתמש בסדר האופרנדים של Intel, כך ש-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 עם עצמו נותן 0, ו-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 הזה לתוך תוכנית ולהריץ אותה בדפדפן.

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

ללמוד Assembly עם Coddy

להתחיל