מחשבון קרב - אסמבלי
פעולות בסיסיות
מושגי יסוד באסמבלי x86 ואוגרים, ומעקב אחרי ערכי אוגרים בפקודות mov, add, sub, inc ו-dec.
בחרו את הרמה שמתאימה לכם ואת הסט שתרצו לתרגל
חומר לימוד
פעולות בסיסיות: אסמבלי x86 מהאוגר ועד מעקב שורה אחר שורה
הפרק בונה מהיסוד את כל מה שנשאל במבחנים על פעולות בסיסיות באסמבלי: מה זו השפה, על איזה מעבד היא רצה, איפה נשמרים הערכים, ואיך עוקבים אחרי קטע קוד עד הערך הסופי של כל אוגר.
במבחן מחשבון הקרב, בשלב הסדנא, כותבים בשפה מומצאת עבור מעבד דמיוני. הפקודות שם אחרות, אבל הרעיונות שכאן (אוגר, יעד ומקור, גלישה, קפיצה) עוברים לשם כמעט כמו שהם.
- המושגים: ASM, x86, ARM, אוגר (Register), מצביע ההוראה (Instruction pointer) ומטמון (Cache).
- ייצוג מספרים: עשרוני מול הקסדצימלי, ומה קורה לאוגר כשתוצאה חורגת מהטווח שלו.
- שבע הפקודות הבסיסיות: mov, add, sub, inc, dec, cmp ו-jmp, כל אחת עם הכללים, הדגלים והשגיאות שלה, ואיך פונים לזיכרון.
- שמונה מעקבים מלאים: טבלה שורה אחר שורה, באותה צורה שבה בנויות השאלות במבחן.
שפת אסמבלי (ASM): הצעד הראשון מעל קוד המכונה
מה זו שפת אסמבלי ולמה צריך אותה
נתחיל מחמישה בתים: B9 0C 00 00 00. עבור מעבד x86 זו פקודה שלמה, שמכניסה את המספר 12 לאוגר ECX, אבל אי אפשר לנחש את זה מהבתים עצמם.
בתים כאלה, רצפי ביטים שכל אחד מהם מקודד פקודה, הם כל מה שמעבד (CPU) מסוגל להריץ, וקוראים להם קוד מכונה. אסמבלי (Assembly, ובקיצור ASM) נותנת לכל פקודת מכונה שם קריא, ואת אותם חמישה בתים כותבים בה mov ecx, 12.
בגלל הצמידות הזו לחומרה אומרים שזו שפה ברמה נמוכה: כל שורה מתארת צעד בודד של המעבד, ולא משימה בשפה של בני אדם כמו "חשב את סכום ההזמנה". השורות מתבצעות אחת אחרי השנייה לפי סדר הכתיבה, אלא אם פקודה מפנה את הביצוע למקום אחר.
מי צריך לקרוא ולכתוב קוד כזה?
- מי שמנתח תוכנה בלי קוד מקור: בהנדסה לאחור ובאבטחת מידע יש בידיים רק קובץ הרצה, והדרך לקרוא אותו עוברת דרך האסמבלי שלו.
- מי שכותב למערכות משובצות, או קטע קוד שבו כל בית וכל מחזור שעון חשובים, ורוצה שליטה מלאה במה שהמעבד עושה.
- כל מי שרוצה להבין מה המחשב עושה באמת, צעד אחר צעד, בלי השכבות שהשפות העיליות מוסיפות מעל.
האסמבלר: מי שהופך טקסט לבתים
בואו נראה את התרגום קורה. NASM מקבל את הקובץ הזה, ולבקשתנו כותב לצדו קובץ רישום (listing) שמראה מה יצא מכל שורה:
bits 32
mov ecx, 12 ; put 12 in ECX
inc ecx ; ECX + 1
add ecx, 4 ; ECX + 4
dec edx ; EDX - 1 1 bits 32
2 00000000 B90C000000 mov ecx, 12 ; put 12 in ECX
3 00000005 41 inc ecx ; ECX + 1
4 00000006 83C104 add ecx, 4 ; ECX + 4
5 00000009 4A dec edx ; EDX - 1קראו את הרישום משמאל לימין: מספר השורה בקובץ, ה-offset שבו הפקודה מתחילה, הבתים שנוצרו, ורק אז הטקסט שכתבתם. ארבע שורות של פקודות הפכו לארבע פקודות מכונה, וזה היחס הרגיל באסמבלי.
הבתים האלה הם האופקודים (opcodes), הקודים הבינאריים שהמעבד מריץ. מי שייצר אותם הוא האסמבלר (assembler), התוכנה שהופכת אסמבלי לקוד מכונה.
ומתי זה קורה? לפני הריצה, ופעם אחת בלבד: כשהתוכנית רצה, הטקסט כבר לא קיים מבחינת המעבד, והוא קורא רק את הבתים שבקובץ. זה ההבדל משפה מפורשת (interpreted), שמתורגמת תוך כדי ריצה, ואסמבלי איננה כזו.
| שורת אסמבלי | הבתים שנוצרו | אורך |
|---|---|---|
mov ecx, 12 | B9 0C 00 00 00 | 5 בתים |
inc ecx | 41 | בית אחד |
add ecx, 4 | 83 C1 04 | 3 בתים |
dec edx | 4A | בית אחד |
שימו לב לעמודת האורך: מבית אחד ועד חמישה. לזה נחזור בפרק על x86, כי זו תכונה שלה.
ועכשיו לשורה הראשונה, bits 32: מולה אין בתים בכלל. היא לא פקודה למעבד אלא הנחיה לאסמבלר, בדיוק כמו section ו-global שתפגשו בהמשך, ולכן היחס הוא "כמעט" אחד לאחד ולא בדיוק.
גם שמות של תוויות לא שורדים את התרגום: במקום כל תווית (label) האסמבלר שם את הכתובת המספרית שלה, ובקוד המכונה לא נשאר אף שם.
כל זה קורה בכיוון אחד, מטקסט קריא אל בתים. אסמבלר לא מייצר קוד C או שפה עילית אחרת, והוא גם לא מריץ את התוכנית: את זה עושה המעבד, אחר כך.
חזרה לתוכן הענייניםלכל מעבד שפת מכונה משלו: ISA
למה הבתים של add ecx, 4 הם דווקא 83 C1 04? כי כך קובעת טבלת הקידוד של x86. לטבלה כזו, ביחד עם רשימת כל הפקודות שהמעבד מבין, קוראים ארכיטקטורת סט פקודות (ISA, Instruction Set Architecture).
לכל משפחת מעבדים יש ISA משלה, ושל ARM שונה לגמרי משל x86. אותה כוונה, להוסיף 4 לאוגר הראשון, נראית כך בשתיהן:
| היבט | x86 | ARM |
|---|---|---|
| איך כותבים | add eax, 4 | add r0, r0, #4, בתחביר אחר עם שלושה אופרנדים |
| הבתים שנוצרים | רצף אחד של בתים | רצף שונה לגמרי, בקידוד של ARM |
נסו לתת למעבד ARM את הבתים 83 C0 04, שהאסמבלר יצר עבור add eax, 4. הוא יפרק אותם לפי הקידוד שלו, ויקבל משהו שאינו הפקודה שהתכוונתם אליה, או שאינו פקודה בכלל. מכאן שתוכנית x86 לא רצה על ARM.
שימו לב מה לא הסיבה. לשני המעבדים יש אוגרים ופקודות חשבון, ושום שלב קומפילציה נוסף לא יתקן בתים שכבר נוצרו. כל העניין הוא שה-ISA של האחד שונה מזו של השני.
חזרה לתוכן הענייניםאסמבלי מול שפה עילית
בשפה עילית התמונה שונה. קחו פונקציית C עם שורה אחת בלבד, שמחברת שלושה משתנים גלובליים, ובדקו כמה פקודות מכונה היא מייצרת:
int apples, pears, plums, fruit;
void count_fruit(void)
{
fruit = apples + pears + plums; /* one line of C */
}ביקשנו מ-gcc לעצור בשלב האסמבלי ולהדפיס את התוצאה, וסיננו את שורות ההנחיות כדי שיישארו רק הפקודות:
gcc -O1 -masm=intel -S fruit.c -o - | grep -vE '^\s*\.|:$' mov eax, DWORD PTR "pears"[rip]
add eax, DWORD PTR "apples"[rip]
add eax, DWORD PTR "plums"[rip]
mov DWORD PTR "fruit"[rip], eax
retשורת C אחת נהפכה לארבע פקודות: טעינה, שני חיבורים ושמירה. ה-ret בסוף הוא היציאה מהפונקציה.
gcc כותב בניב מעט שונה מזה של הפרק: DWORD PTR מקביל ל-dword, ו-[rip] היא הדרך של מצב 64 ביט לפנות למשתנה גלובלי. הוא גם מקיף כאן את שמות המשתנים במירכאות, כמו "pears"; אלה סתם שמות, ואפשר להתעלם מהמירכאות.
השוו את זה לקובץ אסמבלי: שם אתם כותבים בעצמכם כל אחת מהפקודות האלה, ולכן כל שורה שלכם היא בערך פקודת מכונה אחת.
ויש לזה מחיר. מאותו fruit.c אפשר לקבל גרסה ל-ARM פשוט בהרצה של מהדר ל-ARM, אבל ארבע הפקודות שלמעלה הן x86 בלבד, ובשביל ARM צריך לכתוב אותן מחדש בפקודות שלו.
טעויות נפוצות
- ASM בשאלון היא קטגוריה של ניהול שירותים בארגון (Enterprise Service Management). ASM שם היא Assembly, שפת האסמבלי.
- האסמבלר מתרגם קוד אסמבלי לשפה עילית כמו C. הכיוון הפוך: מטקסט אסמבלי אל קוד מכונה בינארי.
- קוד אסמבלי רץ על המעבד כמו שהוא, או שמפרשים אותו שורה אחר שורה בזמן הריצה. האסמבלר מתרגם אותו מראש, והמעבד מריץ רק את הבתים שנוצרו.
- כל פקודת אסמבלי מתפרקת להרבה פקודות מכונה. זה מה שקורה לשורה בשפה עילית. שורת אסמבלי היא בדרך כלל פקודת מכונה אחת.
- קוד אסמבלי רץ בלי שינוי על כל מעבד. הוא כתוב בפקודות של ISA אחת, ומעבד ממשפחה אחרת מפענח את הבתים לפי ISA אחרת.
- x86 לא מריץ קוד של ARM כי ל-ARM אין אוגרים. יש ל-ARM שישה עשר אוגרים. ההבדל הוא סט הפקודות והקידוד שלו.
בדקו את עצמכם
לכמה פקודות מכונה יתרגם האסמבלר את השורה inc ecx?
לאחת. ברישום של NASM ראיתם שהיא נהפכת לבית יחיד, 41.
קובץ הרצה נבנה עבור מחשב נייד עם מעבד x86. האם הוא ירוץ כמו שהוא על טאבלט עם מעבד ARM?
לא. הקובץ מכיל קוד מכונה של x86, ומעבד ARM מפענח בתים לפי סט פקודות אחר. צריך לבנות אותו מחדש עבור ARM מקוד המקור, או לכתוב את האסמבלי מחדש.
מה התפקיד של האסמבלר, ומה שני דברים שהוא לא עושה?
הוא מתרגם קוד אסמבלי לקוד מכונה בינארי, לפני הריצה. הוא לא מריץ את התוכנית, ולא מתרגם אותה לשפה עילית.
אילו שורות בקובץ אסמבלי לא נהפכות לפקודת מכונה?
הנחיות לאסמבלר, כמו section, global ו-bits. גם שם של תווית לא נהפך לפקודה: האסמבלר מחליף אותו בכתובת.
ארכיטקטורת x86: CISC, סדר בתים ושמונה אוגרים
המשפחה x86 והגרסאות שלה
8086, 80286, 80386: השמות של המעבדים הראשונים של Intel בסדרה הזו נגמרו כולם ב-86, ומכאן השם x86 לכל משפחת הארכיטקטורות שצמחה מהם.
לאורך השנים המשפחה התרחבה פעמיים, ולכן מדברים על שלוש גרסאות עיקריות, מהוותיקה לחדשה:
| גרסה | רוחב | מה חשוב לזכור |
|---|---|---|
| 8086 | 16 ביט | הראשונה במשפחה |
| IA-32 | 32 ביט | הגרסה שעליה בנוי כל הפרק הזה |
| x86-64 | 64 ביט | את ההרחבה ל-64 ביט פיתחה AMD, ולא Intel |
"רוחב" כאן הוא מספר הביטים באוגר כללי. אין במשפחה גרסה של 8 ביט, ו-ARM64 איננה גרסה של x86 אלא ארכיטקטורה אחרת לגמרי.
את ההיסטוריה אפשר לקרוא מתוך השמות: AX של 16 ביט קיבל E מלפנים, מלשון Extended ("מורחב"), כשהורחב ל-32 ביט, ו-R כשהגיע ל-64:
| רוחב | אוגר כללי, לדוגמה | מצביע ההוראה |
|---|---|---|
| 16 ביט | AX | IP |
| 32 ביט | EAX | EIP |
| 64 ביט | RAX | RIP |
CISC: הרבה פקודות, ואורכים שונים
חזרו לרישום של האסמבלר: inc ecx היא בית אחד, add ecx, 4 שלושה בתים, ו-mov ecx, 12 חמישה. ב-x86 אין אורך קבוע לפקודה, והטווח הוא מבית בודד ועד 15 בתים.
זה סימן ההיכר של ארכיטקטורת CISC (Complex Instruction Set Computer), ו-x86 שייכת לסוג הזה. יש בה מאגר פקודות עשיר, וחלק מהפקודות עושות כמה דברים בבת אחת: קוראות מהזיכרון, מחשבות וכותבות את התוצאה חזרה.
חזרה לתוכן הענייניםחישוב ישירות על הזיכרון
שתי השורות הבאות תקינות ב-x86, ובשתיהן אחד הצדדים הוא משתנה בזיכרון. בראשונה הוא היעד, ובשנייה הוא המקור:
add [total], ecx ; total = total + ECX: read, add and write back in one instruction
add ecx, [total] ; ECX = ECX + totalב-ARM אף אחת מהן לא קיימת, כפי שתראו בפרק הבא, כי שם חישוב נעשה רק בין אוגרים. הפרטים של פנייה לזיכרון, כמו סוגריים וגדלים, מחכים בפרק "גישה לזיכרון".
חזרה לתוכן הענייניםLittle-endian: הבית הקטן קודם
ברישום הבא NASM שומר מספר אחד בגודל 4 בתים, החל מכתובת 0x2000. הסתכלו על הבתים שיצאו:
bits 32
org 0x2000
limit dd 0x1A2B3C4D ; one 4-byte number 1 bits 32
2 org 0x2000
3 00000000 4D3C2B1A limit dd 0x1A2B3C4D ; one 4-byte numberבקוד כתוב 0x1A2B3C4D, אבל בזיכרון מופיע 4D 3C 2B 1A, בסדר הפוך. 4D, הקצה הימני והפחות משמעותי של המספר, נכתב ראשון, בכתובת הנמוכה, ו-1A, המשמעותי ביותר, נכתב אחרון. לסדר הזה קוראים little-endian, וזה הסדר של x86.
| כתובת | 0x2000 | 0x2001 | 0x2002 | 0x2003 |
|---|---|---|---|---|
| הבית שבה | 4D | 3C | 2B | 1A |
ומה יקבל EAX אחרי mov eax, [limit]? את 0x1A2B3C4D הרגיל, כי הקריאה מרכיבה את ארבעת הבתים בחזרה. ההיפוך הוא עניין של זיכרון בלבד: אוגר מחזיק מספר, ואין לו סדר בתים בכלל.
שמונה אוגרים כלליים
כמה אוגרים כלליים יש ב-IA-32? שמונה, כל אחד ברוחב 32 ביט, ארבעה בתים, ונוח לזכור אותם בשלוש קבוצות:
- ארבעה אוגרי נתונים:
EAX,EBX,ECX,EDX. - שני אוגרי מצביעים:
ESIו-EDI. - שני אוגרים שמשמשים את המחסנית:
ESPו-EBP.
שני שמות שלא תמצאו כאן הם EIP ו-EFLAGS. הם אוגרים מסוג אחר, מיוחדים, ופרק "אוגר" מפרט אותם.
טעויות נפוצות
- 8086 היא גרסת 32 ביט, ו-IA-32 היא גרסת 64 ביט. הסדר הוא 8086 ב-16 ביט, IA-32 ב-32 ביט, ו-x86-64 ב-64 ביט.
- Intel פיתחה את x86-64. את ההרחבה ל-64 ביט פיתחה AMD.
- הגרסה הראשונה של x86 הייתה של 8 ביט, ו-ARM64 היא הגרסה האחרונה במשפחה. הראשונה, 8086, היא 16 ביט. ARM היא ארכיטקטורה נפרדת ולא חלק מ-x86.
- x86 היא RISC, עם פקודות באורך קבוע. x86 היא CISC, והאורך של פקודה בה נע בין בית אחד ל-15 בתים.
- ב-x86 חישוב חייב להתבצע בין אוגרים בלבד. ב-x86 פקודת חשבון יכולה לעבוד ישירות על הזיכרון. המגבלה הזו שייכת ל-ARM.
- המספר
0x1A2B3C4Dנשמר בזיכרון כ-1A 2B 3C 4D. ב-little-endian הבית הנמוך ראשון:4D 3C 2B 1A. - יש ל-x86 שישה אוגרים כלליים, כולל EIP ו-EFLAGS, או שישה עשר בשם R0 עד R15. יש שמונה: ארבעת אוגרי הנתונים EAX עד EDX, הזוג ESI ו-EDI, והזוג ESP ו-EBP. השמות R0 עד R15 שייכים ל-ARM, ו-EIP ו-EFLAGS הם אוגרים מיוחדים.
בדקו את עצמכם
איזה בית יישב בכתובת הנמוכה ביותר אחרי dd 0x11223344, ומה סדר כל הבתים?
0x44, כי ב-little-endian הבית הפחות משמעותי בא ראשון. בזיכרון: 44 33 22 11.
ב-IA-32: כמה אוגרים כלליים יש, ומה הגודל של כל אחד?
שמונה, ובכל אחד 32 ביט, כלומר 4 בתים.
מה הרוחב של 8086, ואיזו חברה פיתחה את x86-64?
8086 היא 16 ביט. את x86-64, גרסת 64 ביט, פיתחה AMD.
ארכיטקטורת ARM: RISC ומודל Load/Store
RISC: מעט פקודות, אורך אחיד
ב-ARM התמונה הפוכה. כל פקודה תופסת בדיוק 32 ביט, ארבעה בתים, במצב העבודה הרגיל שנקרא מצב ARM, ומאגר הפקודות קטן ופשוט. זו ארכיטקטורת RISC (Reduced Instruction Set Computer).
מה מרוויחים מזה? מפענח פשוט, שיודע מראש איפה נגמרת כל פקודה, ומעבד שצורך מעט חשמל. לכן תמצאו ARM בטלפון ובמכשירים משובצים, ואת x86 במחשב השולחני ובשרת.
Load/Store: הזיכרון נגיש דרך LDR ו-STR בלבד
התחילו מהקוד. שלוש השורות האלה מעלות ב-1 מונה ביקורים ששמור בזיכרון, כש-R0 מחזיק את הכתובת שלו. זה קטע להמחשה בתחביר ARM, ולא הרצנו אותו, כי אין כאן מעבד ARM:
ldr r1, [r0] @ load the counter from memory into R1
add r1, r1, #1 @ add 1, registers only
str r1, [r0] @ store R1 back to memoryרק השורה האמצעית מחשבת, והיא עובדת על אוגרים בלבד. השורה הראשונה, LDR (Load, טעינה), מביאה את הערך מהזיכרון לאוגר, והאחרונה, STR (Store, שמירה), מחזירה אותו מהאוגר לזיכרון.
זה כל מודל Load/Store: פקודות החשבון של ARM לא נוגעות בזיכרון, והפקודות היחידות שנוגעות בו הן LDR ו-STR. ב-x86 אותה עבודה היא שורה אחת, add dword [visits], 1, כי שם פקודת חשבון רשאית לפעול ישר על הזיכרון. ומה שהשם לא אומר: המטמון לא קשור לכאן, וגם לא הטעינה של התוכנית מהדיסק.
שישה עשר האוגרים של ARM
ב-x86 יש שמונה אוגרים כלליים בשמות שונים, ו-EIP עומד בנפרד. ב-ARM של 32 ביט כולם חלק מסדרה אחת: R0, R1 וכן הלאה עד R15, שישה עשר בסך הכול.
גם התפקידים המיוחדים יושבים בתוך הסדרה. שלושת האחרונים שמורים לשימוש קבוע, ואחד מהם הוא המקביל של EIP:
| אוגר | כינוי | תפקיד | המקביל ב-x86 |
|---|---|---|---|
| R13 | SP (Stack Pointer) | ראש המחסנית | ESP |
| R14 | LR (Link Register) | הכתובת לחזור אליה בסוף פונקציה | אין אוגר כזה: call שומרת אותה במחסנית |
| R15 | PC (Program Counter) | הכתובת של ההוראה הבאה | EIP |
כדי לא להתבלבל, קראו את 13, 14, 15 כסיפור קצר: מחסנית, חזרה, ההוראה הבאה. כלומר SP, LR, PC.
חזרה לתוכן הענייניםx86 מול ARM בטבלה אחת
| מאפיין | x86 | ARM |
|---|---|---|
| סוג הארכיטקטורה | CISC | RISC |
| היקף סט הפקודות | רחב ומסובך | מצומצם ופשוט |
| אורך פקודה | לא קבוע, בין 1 ל-15 בתים | קבוע, 32 ביט |
| פקודת חשבון על זיכרון | מותרת, למשל add [total], ecx | לא קיימת: טוענים ב-LDR ושומרים ב-STR |
| אוגרים | 8 כלליים, ובנוסף EIP ו-EFLAGS | 16, מ-R0 עד R15 |
| איפה פוגשים אותה | מחשבים אישיים ושרתים | טלפונים ומערכות משובצות |
טעויות נפוצות
- פקודות באורך משתנה וחישוב על הזיכרון הם מאפיינים של ARM. שניהם של x86. ל-ARM אורך קבוע ומודל Load/Store.
- ל-ARM אין אוגרים כלליים לחישובים. יש לו 16 אוגרים, R0 עד R15, והחישובים נעשים עליהם.
- ההבדל היחיד בין x86 ל-ARM הוא מספר האוגרים. הן שונות גם בסוג (CISC מול RISC), באורך הפקודות, בגישה לזיכרון ובסט הפקודות כולו.
- תפקידן של LDR ו-STR הוא לנהל את המטמון. הן טוענות מהזיכרון לאוגר ושומרות מאוגר לזיכרון.
- R13 הוא מונה התוכנית. המונה הוא R15 (PC). R13 הוא SP, ו-R14 הוא LR.
- SP ו-PC הם שני שמות לאותו אוגר. SP מצביע על ראש המחסנית, ו-PC מצביע על ההוראה הבאה שתתבצע.
בדקו את עצמכם
למה ב-ARM אי אפשר להגדיל משתנה בזיכרון בפקודה אחת, ומה עושים במקום?
בגלל מודל Load/Store: פקודות חשבון עובדות רק על אוגרים. טוענים את הערך לאוגר ב-LDR, מחשבים, ומחזירים אותו לזיכרון ב-STR.
כמה בתים תופסת פקודה ב-ARM, וכמה ב-x86?
במצב ARM הרגיל, 4 בתים (32 ביט) לכל פקודה. ב-x86 זה משתנה, מבית אחד ועד 15.
איזה אוגר ב-ARM שומר את הכתובת שאליה חוזרים בסוף פונקציה, ואיזה מצביע על ההוראה שתתבצע אחר כך?
R14 (LR) שומר את כתובת החזרה. R15 (PC) מצביע על ההוראה הבאה.
אוגר (Register): המקום שבו המעבד עובד
מה זה אוגר
תחשבו על טבח במסעדה. מה שבידיים ועל קרש החיתוך זמין מיד, המקרר שמאחוריו דורש כמה צעדים, והמחסן בקומה למטה דורש יציאה מהמטבח.
האוגרים הם הידיים של המעבד: תאי אחסון זעירים בתוך המעבד עצמו, מהירים יותר מכל דבר אחר במחשב, כולל המטמון, ה-RAM (המקרר) והדיסק (המחסן).
מכאן שתי תכונות. בגלל המהירות, המעבד מעדיף לבצע את החישובים על אוגרים; ובגלל שיש מעט מהם, הקוד צריך לבחור מה להחזיק בהם ומתי לפנות מקום.
ומה בדיוק יש בתוך אוגר? מספר אחד בן 32 ביט, וזהו. אין בו זכר לחישוב שיצר את המספר, ואין לו קשר לאוגר שממנו אולי הועתק.
עוד פרט שימושי: לאסמבלר לא אכפת אם כותבים באותיות גדולות או קטנות, לא בשמות אוגרים ולא בשמות פקודות. שלוש השורות הבאות יצאו זהות:
bits 32
mov edx, 32 ; lowercase
MOV EDX, 32 ; uppercase
Mov Edx, 32 ; mixed 1 bits 32
2 00000000 BA20000000 mov edx, 32 ; lowercase
3 00000005 BA20000000 MOV EDX, 32 ; uppercase
4 0000000A BA20000000 Mov Edx, 32 ; mixedשמונת הכלליים והתפקיד המקובל של כל אחד
| אוגר | שימוש נפוץ |
|---|---|
| EAX | חישובים, והערך שפונקציה מחזירה |
| EBX | כתובת בסיס |
| ECX | מונה, ובו משתמשת הפקודה loop |
| EDX | נתונים |
| ESI | מצביע אל המקור (source) |
| EDI | מצביע אל היעד (destination) |
| ESP | ראש המחסנית |
| EBP | הבסיס של מסגרת המחסנית |
הטבלה מתארת הרגלים של מתכנתים, לא הגבלה של המעבד. האסמבלר מקבל בלי היסוס חישוב באוגרים שה"תפקיד" שלהם אחר לגמרי:
bits 32
add ebx, 9 ; arithmetic in EBX
add edi, 9 ; the same in EDI
mov ebp, 40 ; a value in EBP
sub ebp, ebx ; EBP = EBP - EBX 1 bits 32
2 00000000 83C309 add ebx, 9 ; arithmetic in EBX
3 00000003 83C709 add edi, 9 ; the same in EDI
4 00000006 BD28000000 mov ebp, 40 ; a value in EBP
5 0000000B 29DD sub ebp, ebx ; EBP = EBP - EBXשני יוצאים מן הכלל קשורים לפקודות מסוימות, ולא לבחירה שלכם: loop סופרת תמיד על ECX, ו-push ו-pop עובדות תמיד דרך ESP. וגם עם התפקיד המיוחד במחסנית, ESP ו-EBP נספרים בין שמונת הכלליים.
שני אוגרים מיוחדים: EIP ו-EFLAGS
שניים נשארו מחוץ לרשימה: EIP, שמצביע על ההוראה, ו-EFLAGS, שמחזיק את הדגלים, ביטים בודדים שמתעדכנים אחרי חישוב. בפרק תפגשו שניים מהם, ZF (דגל האפס) ו-CF (דגל הנשיאה).
מה שמייחד את שניהם: הם לא נספרים בשמונה, ולא כותבים אותם כאופרנד רגיל של mov, add וחברותיהן. בפרק הפקודות תראו מה NASM עונה על ניסיון כזה.
חזרה לתוכן הענייניםהטווח של אוגר בן 32 ביט
כמה מספרים שונים אפשר לשים באוגר? כל ביט הוא 0 או 1, ולכן ל-32 ביטים יש 2 בחזקת 32 מצבים: 4,294,967,296.
המצב שכולו אפסים הוא 0, והמצב שכולו אחדים הוא 0xFFFFFFFF, כלומר 4,294,967,295. המקסימום קטן באחד ממספר המצבים, כי 0 תופס אחד מהם.
שמונה ספרות הקסדצימליות מכסות בדיוק 32 ביט, ולכן ערכי אוגר נכתבים בשמונה ספרות, ואפסים מובילים לא משנים את הערך. מה קורה כשחישוב מנסה לצאת מהטווח, למעלה או למטה, מוסבר בפרק הבא.
טעויות נפוצות
- EIP ו-EFLAGS הם חלק מהאוגרים הכלליים. הם אוגרים מיוחדים. הכלליים הם שמונה, מ-EAX ועד EDX, ואחריהם ESI, EDI, ESP ו-EBP.
- מותר להשתמש בכל אוגר רק לתפקיד המקובל שלו. התפקידים הם מוסכמה. רק loop קשורה ל-ECX, ו-push ו-pop קשורות ל-ESP.
- אוגר זוכר את הביטוי שחושב בו, או נשאר קשור לאוגר שממנו קיבל את הערך. אוגר מחזיק מספר אחד ותו לא. מה שקרה לפני כן לא נשמר בו.
- אוגר איטי יותר מ-RAM. אוגרים הם האחסון המהיר ביותר במחשב, מהירים אפילו מהמטמון.
בדקו את עצמכם
כמה ביטים יש ב-ECX, ומה הערך הגדול ביותר שהוא יכול להחזיק, בעשרוני ובהקסדצימלי?
32 ביט. הערך הגדול ביותר הוא 4,294,967,295, שהוא 0xFFFFFFFF.
האם EBP נחשב אוגר כללי? והאם EFLAGS?
EBP כן: הוא אחד מהשמונה, גם אם משתמשים בו כבסיס של מסגרת המחסנית. EFLAGS לא: הוא אוגר מיוחד שמחזיק את הדגלים.
על איזה אוגר הפקודה loop סופרת?
על ECX.
מספרים באוגר: עשרוני, הקסדצימלי וגלישה
שתי דרכים לכתוב את אותו מספר
שתי השורות הבאות כתובות אחרת זו מזו. בדקו מה האסמבלר עשה מכל אחת:
bits 32
mov edx, 32 ; decimal
mov edx, 0x20 ; hexadecimal 1 bits 32
2 00000000 BA20000000 mov edx, 32 ; decimal
3 00000005 BA20000000 mov edx, 0x20 ; hexadecimalשתיהן הפכו לאותם חמישה בתים, BA 20 00 00 00: לא משנה אם כותבים בעשרוני 32 או בהקסדצימלי 0x20, המעבד מקבל אותו ערך. הסימון 0x אומר לאסמבלר שהמספר כתוב בבסיס 16.
| מה | מה צריך לדעת |
|---|---|
| הספרות | 0 עד 9, ואחריהן A=10, B=11, C=12, D=13, E=14, F=15 |
| ספרה אחת | 4 ביטים, ולכן 8 ספרות ממלאות אוגר של 32 ביט |
| אפסים מובילים | לא משנים את הערך: 0x7 זהה ל-0x00000007. במבחנים רגילים לראות את כל שמונה הספרות |
המרה לעשרוני היא סכום: הספרה הימנית שווה לעצמה, זו שמשמאלה שווה פי 16, זו שאחריה פי 256, וכן הלאה. למשל 0x1C הוא 1×16 ועוד 12, כלומר 28. כמה זוגות שכדאי להכיר:
| הקסדצימלי | החישוב | עשרוני |
|---|---|---|
0x0E | 14 | 14 |
0x10 | 1×16 + 0 | 16 |
0x1C | 1×16 + 12 | 28 |
0x30 | 3×16 | 48 |
0x64 | 6×16 + 4 | 100 |
0xFF | 15×16 + 15 | 255 |
בספירה, הנקודות שמבלבלות הן אחרי 9 ואחרי F. 0x39 + 1 נותן 0x3A, כי אחרי 9 באה A; רק 0x2F + 1 מגלגל נשיאה לספרה השמאלית ונותן 0x30. וכמובן 0x0E + 1 = 0x0F.
גלישה: כשהתוצאה לא נכנסת ב-32 ביט
שעון מחוגים יודע להראות רק 12 שעות: שלוש שעות אחרי 11 הוא מראה 2, ושעתיים לפני 1 הוא מראה 11. אוגר של 32 ביט עובד באותה צורה, רק שבמקום 12 מצבים יש לו 4,294,967,296.
לכן חיבור שעובר את 0xFFFFFFFF ממשיך מ-0: הביט ה-33 של התוצאה לא נכנס לאוגר ופשוט אובד. וחיסור שיורד מתחת ל-0 ממשיך מ-0xFFFFFFFF כלפי מטה.
| חישוב | מה נשאר באוגר |
|---|---|
0xFFFFFFFF + 1 | 0x00000000 |
0xFFFFFFFF + 3 | 0x00000002 |
0x00000000 - 1 | 0xFFFFFFFF |
0x00000000 - 4 | 0xFFFFFFFC |
0x00000002 - 9 | 0xFFFFFFF9 |
ובעשרוני: 4,294,967,295 ועוד 1 נותן 0, ו-0 פחות 1 נותן 4,294,967,295.
את החשבון הזה אפשר לבדוק גם בלי אסמבלי. שארית החלוקה ב-2 בחזקת 32, בפייתון, נותנת את אותן תוצאות כמו בטבלה:
M = 2 ** 32 # how many values a 32-bit register can hold
for a, b in [(0xFFFFFFFF, 3), (0, -4), (2, -9)]:
print("0x" + format((a + b) % M, "08X")) # keep only the low 32 bits0x00000002
0xFFFFFFFC
0xFFFFFFF9שיטה לחשב גלישה בהקסדצימלי
כשמחשבים ביד, יש שלושה מצבים שבהם התוצאה יוצאת מהטווח, ולכל אחד תיקון משלו:
| המצב | מה עושים | דוגמה |
|---|---|---|
| סכום שיצא בתשע ספרות | מוחקים את הספרה השמאלית העודפת, שהיא תמיד 1 | 0xFFFFFFE0 + 0x30 = 0x100000010, ובאוגר 0x00000010 |
| מחסרים מספר גדול ממספר קטן | מוסיפים 0x100000000 למספר הקטן, ורק אז מחסרים | 0x4 - 0x9 הופך ל-0x100000004 - 0x9 = 0xFFFFFFFB |
| מחסרים ישר מ-0 | סופרים אחורה מ-0xFFFFFFFF | 0 פחות 4: FFFFFFFF, FFFFFFFE, FFFFFFFD, FFFFFFFC |
השיטה מבטיחה שבכל רגע אתם מחזיקים את מה שהמעבד מחזיק. אחרי כל פקודה שגלשה, האוגר כבר מכיל את הערך המתוקן, והפקודה הבאה, וגם mov, cmp והדגלים, עובדים עם הערך הזה ולא עם התוצאה המתמטית.
טעויות נפוצות
0xFFFFFFE0 + 0x30משאיר באוגר0x100000010, ו-0 פחות 1 משאיר -1. האוגר שומר 32 ביט בלבד ואין בו שליליים: מתקבל0x00000010, ו-0 פחות 1 הוא0xFFFFFFFF.decעל אוגר שערכו 0 משאירה אותו 0. היא גולשת למטה, והאוגר מקבל0xFFFFFFFF.- חיבור שעובר את הקצה חוזר לסביבת
0xFFFFFFFF, וחיסור מתחת ל-0 חוזר לסביבת 0. זה הפוך. חיבור מעל0xFFFFFFFFממשיך מ-0 והלאה, וחיסור מתחת ל-0 ממשיך מ-0xFFFFFFFFומטה. 0x39 + 1 = 0x40. אחרי 9 מגיעה A, ולכן0x3A. נשיאה לספרה הבאה קורית רק אחרי F.- באמצע הקוד האוגר יכול להחזיק מספר שלילי או מספר בן תשע ספרות, ומתקנים רק בסוף. כבר אחרי הפקודה שגלשה האוגר מחזיק את הערך המתוקן בן 32 הביטים. זה הערך שהפקודה הבאה, ההעתקה וההשוואה מקבלות.
בדקו את עצמכם
מה מתקבל באוגר של 32 ביט אחרי 0x00FFFFFF + 1?
0x01000000. התוצאה רחוקה מהקצה של 32 ביט, ולכן אין גלישה.
מה מתקבל אחרי 0x00000003 - 0x00000007?
מחשבים 0x100000003 - 7 ומקבלים 0xFFFFFFFC.
מה מתקבל אחרי 0xFFFFFFFC + 0x0A?
הסכום המלא הוא 0x100000006. מוחקים את ה-1 העודף, ובאוגר נשאר 0x00000006.
מה הערך העשרוני של 0x3C?
3×16 + 12 = 60.
הפקודות הבסיסיות: mov, add, sub, inc, dec, cmp, jmp
האנטומיה של שורת קוד
בתחביר של Intel, שבו כותבים ב-NASM, שורת אסמבלי מורכבת מעד ארבעה חלקים. הנה שורה שיש בה את כולם:
next: add ecx, 4 ; ECX = ECX + 4- תווית (label), כאן
next:: שם לכתובת של השורה, שפקודות קפיצה משתמשות בו. היא לא חובה, והיא לא מבצעת שום פעולה. - שם הפקודה (mnemonic), כאן
add. - האופרנדים, הנתונים שהפקודה עובדת איתם: קודם היעד (destination), אחריו פסיק, ואז המקור (source).
- הערה: כל מה שבא אחרי
;עד סוף השורה. האסמבלר מדלג עליה, והיא לא מגיעה למעבד.
ב-add וב-sub נוח לתרגם את השורה לנוסחה שבה היעד מופיע משני צדי השוויון: sub edx, ecx היא edx = edx - ecx.
אופרנד יכול להיות מאחד משלושה סוגים:
| סוג אופרנד | איך הוא נראה | מה הפקודה מקבלת |
|---|---|---|
| אוגר | ecx | המספר שנמצא כרגע באוגר |
| קבוע (immediate) | 12, 0x2D | מספר שכתוב בתוך הפקודה עצמה |
| זיכרון | [total], [esi+8] | המספר ששמור בכתובת שבתוך הסוגריים |
לא כל צירוף של יעד ומקור מותר. בפקודות עם שני אופרנדים (mov, add, sub, cmp) אלה הכללים:
| יעד, מקור | מותר? | דוגמה |
|---|---|---|
| אוגר, אוגר | כן | sub edx, ecx |
| אוגר, קבוע | כן | add esi, 7 |
| אוגר, זיכרון | כן | mov ecx, [total] |
| זיכרון, אוגר | כן | mov [total], ecx |
| זיכרון, קבוע | כן, אם כותבים את הגודל | mov dword [total], 0 |
| זיכרון, זיכרון | לא | mov [total], [bonus] |
| קבוע בתור יעד | לא | mov 7, ecx |
ועוד כלל אחד לכל הצירופים: שני הצדדים באותו רוחב. mov ecx, edx עוברת, אבל mov ax, ecx נכשלת, כי AX רחב 16 ביט ו-ECX רחב 32; על תתי-אוגרים כמו AX יש פרק נפרד.
בסוף כל פקודה הביצוע ממשיך לשורה הבאה בקובץ. את הסדר הזה שוברות רק פקודות זרימה, כמו jmp.
חזרה לתוכן הענייניםmov: העתקה
| פקודה | לפני | אחרי |
|---|---|---|
mov edx, 9 | EDX=ערך כלשהו | EDX=9 |
mov ecx, edx | EDX=9, ECX=2 | EDX=9, ECX=9 |
mov esi, 0x1F | ESI=ערך כלשהו | ESI=0x0000001F, כלומר 31 |
בכל שורה, אחרי הפקודה היעד מחזיק את מה שהמקור מחזיק, והמקור עצמו לא זז. זה כל מה ש-mov dest, src עושה: העתקה. השם, קיצור של move, מטעה בעניין הזה.
בשורה השנייה ECX היה 2, והערך הזה פשוט נמחק. מה שהיה ביעד לא משתתף בשום חישוב, בניגוד למה שקורה ב-add וב-sub.
ומה קורה אחר כך? אם EDX ישתנה בשורה הבאה, ECX לא יידע על כך: mov לא יוצרת קשר בין האוגרים, רק עותק של רגע אחד. בנוסף, mov לא נוגעת בדגלים, כך ש-mov שנכנסת בין cmp לבין קפיצה מותנית לא משנה את ההכרעה של הקפיצה.
כדי לראות מה אסור, הרצנו את NASM על קובץ עם ארבע שורות שגויות:
bits 32
section .data
score dd 40
bonus dd 2
section .text
mov [score], [bonus] ; memory to memory
mov 7, ecx ; a number as the destination
mov ax, ecx ; 16 bits and 32 bits
mov eip, 0x2000 ; EIP as an operandbadmov.asm:6: error: invalid combination of opcode and operands
badmov.asm:7: error: invalid combination of opcode and operands
badmov.asm:8: error: invalid combination of opcode and operands
badmov.asm:9: error: symbol `eip' not defined| השורה | למה היא נדחית |
|---|---|
mov [score], [bonus] | אין העתקה ישירה מזיכרון לזיכרון. צריך לעבור דרך אוגר. |
mov 7, ecx | מספר קבוע לא יכול לשמש יעד. |
mov ax, ecx | הגדלים שונים: 16 ביט מול 32 ביט. |
mov eip, 0x2000 | EIP לא מקבל ערך דרך mov. את הזרימה משנים ב-jmp ובפקודות דומות לה. |
שימו לב להודעה על השורה האחרונה: NASM אפילו לא מזהה את eip כשם של אוגר שמותר לכתוב בפקודה, ומחפש סמל בשם הזה. ל-mov עם זיכרון נחזור בפרק "גישה לזיכרון".
add: חיבור
| פקודה | לפני | אחרי |
|---|---|---|
add ecx, 6 | ECX=8 | ECX=14 |
add edx, ebx | EDX=20, EBX=7 | EDX=27, EBX=7 |
add ebx, ebx | EBX=9 | EBX=18 |
add edi, 0x0C | EDI=0x30 | EDI=0x3C |
add ecx, 3 | ECX=0xFFFFFFFE | ECX=1, אחרי גלישה |
בכל שורה, היעד קיבל את הסכום של עצמו ושל המקור, והמקור נשאר: EBX הוא עדיין 7 אחרי add edx, ebx. זו כל ההגדרה של add dest, src, כלומר dest = dest + src.
השורה האחרונה מראה שגם כאן הסכום נחתך ל-32 ביט: 0xFFFFFFFE ועוד 3 נותן 1. ובאותו אופן add esi, edi הייתה משנה את ESI בלבד, בלי לגעת ב-EDI.
שני דברים נשארים כמו ב-mov: אין add בין שני אופרנדים בזיכרון, והיעד לא יכול להיות קבוע. אבל בניגוד ל-mov, add כן משנה דגלים: ZF מקבל 1 אם הסכום יצא 0, ו-CF מסמן נשיאה שלא נכנסה ל-32 הביטים, ועל שניהם יש פרק נפרד.
חזרה לתוכן הענייניםsub: חיסור
| פקודה | לפני | אחרי |
|---|---|---|
sub ecx, 3 | ECX=15 | ECX=12 |
sub edx, ecx | EDX=15, ECX=6 | EDX=9, ECX=6 |
sub ecx, edx | ECX=6, EDX=15 | ECX=0xFFFFFFF7, EDX=15 |
sub esi, 4 | ESI=2 | ESI=0xFFFFFFFE |
sub ebx, ebx | EBX=ערך כלשהו | EBX=0, ZF=1 |
ההגדרה היא של add עם סימן הפוך: sub dest, src היא dest = dest - src. השוו את השורות השנייה והשלישית: אותם שני אוגרים בסדר הפוך, ותוצאות שונות לגמרי, כי רק האוגר שכתוב ראשון מקבל את ההפרש.
בשורה השלישית ההפרש האמיתי שלילי, מינוס 9. מה שהאוגר מקבל הוא 4,294,967,296 פחות 9, ובהקסדצימלי 0xFFFFFFF7.
מבחינת דגלים, sub דומה ל-add: ZF נדלק כשההפרש 0, כמו בשורה האחרונה. ו-CF נדלק בדיוק כשהחיסור גלש, כלומר כשהמספר שמחסרים גדול מזה שהיה ביעד, כמו בשורות השלישית והרביעית.
חזרה לתוכן הענייניםinc: הוספת 1
inc dest היא קיצור לחיבור של 1. יש לה רק אופרנד אחד, שממנו היא קוראת ואליו היא כותבת, ומבחינת הערך inc edx ו-add edx, 1 זהות לגמרי.
ההבדל ביניהן הוא בדגלים בלבד. inc משאירה את CF כמו שהיה, אבל מעדכנת את ZF, ולכן ZF=1 כשהגלישה מביאה את האוגר ל-0, כמו בשורה השנייה בטבלה:
| פקודה | לפני | אחרי |
|---|---|---|
inc edx | EDX=11 | EDX=12 |
inc ecx | ECX=0xFFFFFFFF | ECX=0, גלישה, ZF=1 |
inc esi פעמיים | ESI=9 | ESI=11 |
האופרנד היחיד חייב להיות משהו שאפשר לכתוב אליו. כך NASM מגיב לשתי הטעויות הנפוצות:
bits 32
section .text
inc edx, 4 ; two operands
inc 3 ; a number cannot changebadinc.asm:3: error: invalid combination of opcode and operands
badinc.asm:4: error: invalid combination of opcode and operandsואם רוצים להוסיף 4? או add edx, 4, או ארבע פעמים inc edx, אחת מתחת לשנייה.
dec: הפחתת 1
| פקודה | לפני | אחרי |
|---|---|---|
dec ebx | EBX=20 | EBX=19 |
dec ecx | ECX=1 | ECX=0, ZF=1 |
dec edi | EDI=0 | EDI=0xFFFFFFFF, גלישה |
dec היא תמונת הראי של inc: אופרנד אחד, פחות 1, ובדיוק אותו ערך כמו sub dest, 1. גם היא לא משנה את CF ומעדכנת את ZF, כמו בשורה השנייה, שבה ECX הגיע ל-0.
בגלל שהן הפוכות, זוג של inc ו-dec על אותו אוגר מחזיר אותו לנקודת ההתחלה. למשל, dec edi ואחריה inc edi על EDI=0 עוברות דרך 0xFFFFFFFF וחוזרות ל-0.
cmp: השוואה שלא משנה כלום
הסתכלו קודם על התוצאות, ונסו לזהות מה משותף להן:
| פקודה | לפני | אחרי |
|---|---|---|
cmp ecx, 10 | ECX=10 | ECX=10, ZF=1: שווים |
cmp ecx, 4 | ECX=10 | ECX=10, ZF=0: שונים |
cmp ecx, 12 | ECX=10 | ECX=10, ZF=0, CF=1, כי 10 קטן מ-12 |
cmp edx, esi | EDX=3, ESI=3 | שניהם נשארים 3, ZF=1 |
בכל השורות האופרנדים לא השתנו. cmp a, b מחשבת את a - b רק כדי לקבוע דגלים, ואת ההפרש עצמו זורקת.
ZF=1 מופיע בדיוק כשהערכים שווים, כי אז ההפרש הוא 0. CF=1 מופיע כש-a קטן מ-b, כשקוראים את שניהם כמספרים בלי סימן.
בשביל מה זה טוב? כדי להשוות בלי לאבד אף ערך. אחרי cmp מגיעה בדרך כלל קפיצה מותנית, למשל jne, שמחליטה לפי הדגלים; את אלה תלמדו בפרק התנאים.
האופרנדים של cmp כפופים לכללים של sub: אין שני אופרנדים בזיכרון, והראשון לא יכול להיות מספר קבוע. והדגלים שהיא קבעה נשארים בתוקף עד הפקודה הבאה שמעדכנת דגלים. מי מעדכן ומי לא:
| פקודה | השפעה על הדגלים |
|---|---|
| mov | אין |
| add, sub, cmp | מעדכנות את ZF ואת CF |
| inc, dec | מעדכנות את ZF, ו-CF נשאר כמו שהיה |
| jmp | אין |
jmp: קפיצה שמתבצעת תמיד
הנה הדוגמה הפשוטה ביותר. EDX מקבל 8, הקפיצה מעבירה את הביצוע ל-NEXT, והשורה שבאמצע לא מתבצעת:
| שורה | EDX אחריה | מה קרה |
|---|---|---|
mov edx, 8 | 8 | EDX מקבל 8 |
jmp NEXT | 8 | הביצוע עובר ל-NEXT |
sub edx, 50 | לא בוצעה | דילגנו עליה |
NEXT: dec edx | 7 | ממשיכים מהתווית |
מה קרה מאחורי הקלעים: jmp label כתבה ל-EIP את הכתובת של NEXT, והמעבד המשיך משם. שום אוגר כללי ושום דגל לא השתנו, ו-EDX ירד ל-7 רק בגלל ה-dec.
התווית NEXT: היא שם ונקודתיים, לא פקודה. כשהביצוע מגיע אליה בזרימה רגילה, בלי קפיצה, הוא פשוט עובר הלאה, וכל מה שבין jmp לתווית מדולג, אלא אם קפיצה אחרת מביאה אליו.
המילה "בלתי מותנית" אומרת ש-jmp קופצת בכל מצב, בלי לבדוק דגלים. את הקפיצות שכן בודקות, כמו jne, שמסתמכות על הדגלים ש-cmp קבעה, תלמדו בהמשך.
קפיצה יכולה גם ללכת אחורה. ברישום הזה הבתים EB FD פירושם "חזור 3 בתים", אל again, ומאחר שאין שום יציאה, הלולאה לא תיגמר לעולם:
bits 32
again:
inc ecx ; ECX + 1
jmp again ; back up, forever 1 bits 32
2 again:
3 00000000 41 inc ecx ; ECX + 1
4 00000001 EBFD jmp again ; back up, foreverעוד דוגמה, הפעם הקפיצה מדלגת על שתי שורות:
mov esi, 1
jmp DONE
mov esi, 99
add esi, 5
DONE:
inc esiESI מקבל 1, והקפיצה עוברת ישר ל-DONE, ולכן mov esi, 99 ו-add esi, 5 לא קורות. אחרי inc esi הערך הוא 2.
טעויות נפוצות
- mov מזיזה את הערך, והמקור מתרוקן. היא מעתיקה. המקור נשאר עם הערך שלו.
sub edx, 6משנה את המספר 6. רק היעד, EDX, משתנה. 6 הוא קבוע שכתוב בפקודה.- באמצע רצף פקודות אפשר להמשיך עם הערך שהיה לאוגר בהתחלה. כל פקודה עובדת על הערך הנוכחי, אחרי כל השינויים שקדמו לה. וגם אסור לשכוח את הפקודה האחרונה ברצף.
- שתי פקודות inc ופקודת dec אחת מגדילות ב-3. הן מגדילות ב-1 נטו: ועוד 1, ועוד 1, פחות 1.
- cmp שומרת את ההפרש באופרנד הראשון. היא לא כותבת לשום אופרנד. רק הדגלים משתנים.
- jmp קופצת רק כשתנאי מתקיים. jmp קופצת תמיד. הקפיצות המותנות הן פקודות אחרות, כמו jne.
- mov מאפסת או מעדכנת את ZF. mov לא נוגעת בדגלים בכלל.
mov [a], [b]ו-mov ax, ecxהן פקודות תקינות. אין mov מזיכרון לזיכרון, ושני האופרנדים חייבים להיות באותו גודל.- אפשר לכתוב
inc ecx, 3כדי להוסיף 3. ל-inc יש אופרנד אחד בלבד. כדי להוסיף 3 כותביםadd ecx, 3.
בדקו את עצמכם
EBX=2 ו-ECX=9. מה יהיו הערכים אחרי sub ebx, ecx?
EBX=0xFFFFFFF9, כי 2 פחות 9 הוא מינוס 7 והאוגר גולש. ECX נשאר 9.
אחרי mov ecx, 15, mov edx, ecx, dec ecx, מה הערך של EDX?
15. ההעתקה קרתה לפני ה-dec, ו-EDX לא קשור ל-ECX. ECX עצמו הוא 14.
EDX=0x20. מה יהיו EDX ו-ZF אחרי cmp edx, 0x20?
EDX נשאר 0x20, ו-ZF=1 כי הערכים שווים.
במה שונות dec ebx ו-sub ebx, 1?
הערך שנשאר ב-EBX זהה. ההבדל היחיד הוא ש-dec לא משנה את CF, ו-sub כן.
כתבו קוד שמעתיק את המשתנה src אל המשתנה dst, כששניהם dword בזיכרון.
שתי פקודות דרך אוגר: mov ecx, [src] ואחריה mov [dst], ecx. פקודה אחת מזיכרון לזיכרון לא קיימת.
גישה לזיכרון: כתובות, סוגריים וגדלים
כתובות, קטעים והגדרת משתנים
אפשר לדמיין את ה-RAM כרחוב ארוך מאוד שבו כל בית הוא דירה, ולכל דירה יש מספר. המספר הזה הוא הכתובת של הבית.
קובץ אסמבלי מחולק לקטעים (sections), ולכל קטע תפקיד משלו:
| קטע | מה שמים בו |
|---|---|
section .text | הפקודות עצמן, כלומר הקוד |
section .data | משתנים שיש להם ערך התחלתי |
section .bss | משתנים בלי ערך התחלתי: רק שמירת מקום |
כך נראות הגדרות של משתנים בשני קטעי הנתונים, ולידן מה ש-NASM עשה מכל אחת:
bits 32
section .data
level db 3 ; 1 byte
year dw 2026 ; 2 bytes
lives dd 3 ; 4 bytes
costs dd 40, 55, 70 ; three dwords in a row
section .bss
scores resd 6 ; room for 6 dwords
nick resb 16 ; room for 16 bytes 1 bits 32
2 section .data
3 00000000 03 level db 3 ; 1 byte
4 00000001 EA07 year dw 2026 ; 2 bytes
5 00000003 03000000 lives dd 3 ; 4 bytes
6 00000007 280000003700000046- costs dd 40, 55, 70 ; three dwords in a row
6 00000010 000000
7 section .bss
8 00000000 <res 18h> scores resd 6 ; room for 6 dwords
9 00000018 <res 10h> nick resb 16 ; room for 16 bytesבכל שורה יש שם, מילת גודל וערך. ב-.data, המילה db הקצתה ל-level בית אחד (8 ביט), dw נתנה ל-year שני בתים (word), ו-dd נתנה ארבעה בתים (dword) לכל ערך של lives ושל costs, ולכן costs, עם שלושה ערכים, תפסה 12 בתים.
year מדגים שוב little-endian: 2026 הוא 0x07EA, והוא נשמר כ-EA 07.
ב-.bss אין ערכים, ולכן אין ברישום בתים, רק <res ...>, מקום שמור. resd 6 שמרה שישה dword, 18h בתים, כלומר 24, ו-resb 16 שמרה 16 בתים בודדים (10h); המילה השלישית מאותה משפחה, resw, שומרת word.
בתוכנית שלמה הקוד יושב ב-.text, ו-_start מסמן את נקודת הכניסה, השורה שבה הביצוע מתחיל:
section .data
lives dd 3 ; 4-byte variable, starts at 3
section .text
global _start ; make the entry point visible to the linker
_start:
mov eax, [lives] ; EAX = 3מה בעצם מייצג השם lives בתוך הקוד? מספר: הכתובת של הבית הראשון של המשתנה. הסוגריים בשורה האחרונה הם שהופכים אותו לערך, ועל זה הסעיף הבא.
סוגריים מרובעים: כתובת מול תוכן
כשכותבים כתובת בתוך [ ], הפקודה עובדת עם מה ששמור בכתובת הזו. בלי הסוגריים, היא עובדת עם הכתובת עצמה, כמספר.
| פקודה | מה קורה |
|---|---|
mov eax, [lives] | קריאה מהזיכרון: EAX מקבל 3, הערך ששמור במשתנה |
mov eax, lives | EAX מקבל את הכתובת של lives, מספר כמו 0x0804A000. הערך המדויק תלוי בתוכנית ובמקשר |
mov [lives], eax | כתיבה לזיכרון: הערך של EAX נכנס לתוך המשתנה |
הרוחב של הקריאה נקבע לפי האוגר שבצד השני. EAX הוא 32 ביט, ולכן mov eax, [lives] מושכת ארבעה בתים, את כל ה-dword.
וכל כיוון משנה רק את הצד שלו: בקריאה הזיכרון נשאר כמו שהיה, ובכתיבה mov [lives], eax המשתנה מתעדכן בזמן ש-EAX שומר על הערך שלו.
אוגר שמחזיק כתובת: [reg], [reg+n], [reg-n]
חזרו ל-costs מהרישום: שלושה dword ברצף, ולכן כל איבר מתחיל 4 בתים אחרי הקודם:
| כתובת | costs | costs+4 | costs+8 |
|---|---|---|---|
| האיבר | 40 | 55 | 70 |
נניח ש-EBX מחזיק את הכתובת של costs, אחרי mov ebx, costs. אז אפשר לפנות לכל איבר דרך EBX: [ebx] נותן 40, [ebx+4] נותן 55, ו-[ebx+8] נותן 70. אוגר שמשמש כך נקרא מצביע.
המספר שבתוך הסוגריים הוא תמיד מרחק בבתים, לא מספר סידורי של איבר. לכן האיבר השלישי הוא +8 ולא +2, וגם אפשר להחסיר: [ebx-4] הוא הערך שיושב 4 בתים לפני הכתובת שב-EBX.
אפשר גם להזיז את המצביע עצמו במקום לשנות את המרחק. אחרי add ebx, 4 המצביע עומד על 55: הביטוי [ebx] נותן 55, ו-[ebx-4] חוזר ל-40.
byte, word, dword: כמה בתים לכתוב
האסמבלר מסיק את הגודל מהאוגר, אם יש אוגר בפקודה. בפקודה כמו mov [total], 0 אין אחד כזה, כי הצדדים הם זיכרון ומספר, ולכן צריך מילת גודל מפורשת:
| מילת גודל | בתים | ביטים |
|---|---|---|
| byte | 1 | 8 |
| word | 2 | 16 |
| dword | 4 | 32 |
mov dword [total], 0 ; write 4 bytes
sub dword [total], 2 ; subtract 2 from a 4-byte value
mov byte [level], 9 ; write a single byte
mov [total], 0 ; wrong: how many bytes?המספר 0 נכנס בבית אחד וגם בארבעה, ולכן השורה האחרונה דו-משמעית. גרסאות 2 של NASM, שבהן משתמשים רוב המדריכים, עוצרות עליה עם השגיאה operation size not specified.
ומה אם רוצים לקרוא לאוגר רק בית אחד מהזיכרון? לשם כך צריך אוגר ברוחב 8 ביט, ואלה תתי-האוגרים, שיש להם פרק משלהם.
חזרה לתוכן הענייניםאין זיכרון מול זיכרון
הכלל שמאחד את הפרק: בכל פקודה יש לכל היותר אופרנד אחד בזיכרון, וכשאין אוגר בכלל, חובה לכתוב גודל. הטבלה מראה מה יוצא מזה:
| רוצים | לא עובד | עובד |
|---|---|---|
| להעתיק את price ל-backup | mov [backup], [price] | mov ecx, [price] ואחריה mov [backup], ecx |
| להוסיף ל-ECX את מה ששמור ב-price | - | add ecx, [price] |
| להוסיף ל-price את ECX | - | add [price], ecx |
| להעלות את price ב-1 | inc [price], בלי גודל | inc dword [price] |
| לבדוק אם price שווה 100 | cmp [price], 100, בלי גודל | cmp dword [price], 100 |
| להוסיף את price ל-total | add [total], [price] | mov ecx, [price] ואחריה add [total], ecx |
השורות השנייה והשלישית הן בדיוק מה ש-ARM לא מאפשרת: ב-x86 פקודת חשבון יכולה לקרוא מהזיכרון ולכתוב אליו, וב-ARM כל עבודה כזו עוברת דרך LDR בהתחלה ו-STR בסוף.
טעויות נפוצות
[lives]ו-livesהם אותו דבר.[lives]הוא הערך שבמשתנה, ו-livesהוא הכתובת שלו.mov [price], [backup]מעתיקה בין משתנים. פקודה כזו לא קיימת. עוברים דרך אוגר, בשתי פקודות.mov [total], 5מספיקה. אין אוגר שממנו אפשר להסיק גודל, ולכן כותביםmov dword [total], 5.[esi+2]הוא האיבר השלישי במערך dword. ההיסט בבתים. האיבר השלישי נמצא ב-[esi+8], ו-[esi+2]נופל באמצע האיבר הראשון.- בכתובת הנמוכה של dword בזיכרון יושב הבית המשמעותי ביותר. ב-little-endian ההפך: בכתובת הנמוכה יושב הבית הפחות משמעותי.
mov ecx, [price]משנה את price. זו קריאה בלבד. הזיכרון משתנה רק כשהוא היעד.
בדקו את עצמכם
count dd 12. מה יהיה ב-EDX אחרי mov edx, [count], ומה אחרי mov edx, count?
אחרי הראשונה EDX=12, הערך שבמשתנה. אחרי השנייה EDX מחזיק את הכתובת של count.
מה הבעיה ב-sub [count], 1, ואיך מתקנים?
אין בה אוגר, ולכן לא ברור כמה בתים לשנות. מתקנים ל-sub dword [count], 1.
vals dd 9, 8, 7, 6, ו-ESI מחזיק את הכתובת של vals. מה יהיה ב-EAX אחרי mov eax, [esi+12]?
6. היסט של 12 בתים הוא שלושה איברים של 4 בתים, ולכן מגיעים לאיבר הרביעי.
מצביע ההוראה (Instruction pointer): EIP
על מה EIP מצביע
הקוד הבא הונח בזיכרון החל מכתובת 0x00403000, וזה מה שהשורה org אומרת לאסמבלר. ברישום רואים איפה מתחילה כל פקודה:
bits 32
org 0x00403000
mov ecx, 7 ; 5 bytes
dec ecx ; 1 byte
jmp AHEAD ; 2 bytes
sub ecx, 30 ; skipped
AHEAD:
add ecx, 2 ; 3 bytes 1 bits 32
2 org 0x00403000
3 00000000 B907000000 mov ecx, 7 ; 5 bytes
4 00000005 49 dec ecx ; 1 byte
5 00000006 EB03 jmp AHEAD ; 2 bytes
6 00000008 83E91E sub ecx, 30 ; skipped
7 AHEAD:
8 0000000B 83C102 add ecx, 2 ; 3 bytesכל פקודה יושבת בכתובת משלה: הכתובת ההתחלתית ועוד ה-offset שברישום. כדי להריץ את הרצף, המעבד צריך לדעת בכל רגע איפה הוא נמצא בו, ולשם כך יש אוגר מיוחד, מצביע ההוראה.
ב-x86 של 32 ביט קוראים לו EIP, והוא מחזיק את הכתובת של ההוראה הבאה שתתבצע. כשהמעבד מסיים את mov ecx, 7, EIP כבר מראה 0x00403005, הכתובת של dec ecx.
ב-16 ביט שמו IP, וב-64 ביט RIP; ב-ARM את המשימה הזו ממלא R15, ה-PC.
| כתובת | הוראה | אורך | EIP אחריה |
|---|---|---|---|
| 0x00403000 | mov ecx, 7 | 5 בתים | 0x00403005 |
| 0x00403005 | dec ecx | בית אחד | 0x00403006 |
הצעד של EIP שווה לאורך ההוראה: חמישה בתים אחרי mov, בית אחד אחרי dec. ב-x86 האורכים משתנים, ולכן גם הצעדים, וההתקדמות קורית מעצמה אחרי כל הוראה.
שאלה נפוצה במבחן היא מה אין ב-EIP. כל אחד מהדברים שמתבלבלים איתו נמצא במקום אחר:
| מה מחפשים | איפה זה נמצא |
|---|---|
| הכתובת של ההוראה הבאה | EIP |
| ההוראה שהסתיימה זה עתה | לא ב-EIP: הוא כבר מצביע על זו שאחריה |
| תוצאה של חישוב | בדרך כלל ב-EAX, שגם מחזיק את מה שפונקציה מחזירה |
| הדגלים, כמו ZF ו-CF | EFLAGS |
| ראש המחסנית | ESP |
פקודות זרימה: הדרך לשנות את EIP
חזרו לרישום. השורה השלישית, jmp AHEAD, היא פקודה מסוג אחר: במקום לתת ל-EIP להתקדם, היא כותבת לתוכו כתובת חדשה. פקודות שעושות זאת נקראות פקודות זרימה, ובהן הקפיצות jmp, jne, jc ו-jnc, וגם call ו-ret, loop ו-int.
כך נראים שלושת הצעדים הבאים ברישום:
| כתובת | הוראה | אורך | EIP אחריה |
|---|---|---|---|
| 0x00403006 | jmp AHEAD | 2 בתים | 0x0040300B, הכתובת של AHEAD |
| 0x00403008 | sub ecx, 30 | 3 בתים | לא מתבצעת |
| 0x0040300B | AHEAD: add ecx, 2 | 3 בתים | 0x0040300E |
גם בבתים של הקפיצה רואים את זה. EB 03 פירושו "דלג 3 בתים קדימה" מהכתובת שאחרי הקפיצה, 0x00403008, ומשם מגיעים ל-0x0040300B.
שתיים מהרשימה עובדות בזוג. call קופצת לפונקציה, אבל קודם דוחפת למחסנית את הכתובת שאחריה; ret, בסוף הפונקציה, שולפת את הכתובת הזו ומחזירה אותה ל-EIP. הפירוט בפרק התוויות.
למה mov eip, 0x2000 לא עובדת
נניח שרוצים לשלוח את הביצוע לכתובת 0x2000. הניסיון mov eip, 0x2000 לא יעבור: EIP פשוט לא נמצא ברשימת האופרנדים של mov, של add או של כל פקודה רגילה אחרת.
ראיתם את זה בתגובה של NASM בפרק הפקודות: הוא לא זיהה את eip כאוגר שאפשר לכתוב בפקודה, ודיווח על סמל שלא הוגדר.
את מה ש-mov לא מסוגלת לעשות, jmp עושה: jmp 0x2000 מעבירה את הביצוע לכתובת הזו, ובקוד אמיתי כותבים בדרך כלל jmp לתווית ולא לכתובת מספרית.
טעויות נפוצות
- EIP מחזיק את ההוראה שרק הסתיימה, את הדגלים או את ראש המחסנית. EIP מצביע על ההוראה שתבוא אחר כך. הדגלים נמצאים ב-EFLAGS, וראש המחסנית ב-ESP.
- אפשר לכוון את EIP בפקודת mov. mov לא מקבלת את EIP. משנים אותו רק בפקודות זרימה.
- EIP משתנה רק כשיש קפיצה או פסיקה. הוא מתקדם אחרי כל הוראה, גם בלי שום קפיצה.
mov eip, ...נכשלת כי mov לא תומכת ב-32 ביט, או כי ערכו של EIP קבוע. mov עובדת מצוין עם 32 ביט, ו-EIP משתנה כל הזמן. הוא פשוט לא אופרנד של mov.- EIP עולה תמיד ב-1 אחרי כל הוראה. הוא עולה באורך ההוראה, שב-x86 יכול להיות בין בית אחד ל-15 בתים.
בדקו את עצמכם
EIP=0x00403010, ובכתובת הזו יושבת mov ecx, 7 באורך 5 בתים. מה יהיה EIP אחרי שהיא תתבצע?
0x00403015, הכתובת שמיד אחרי ההוראה.
מבין sub, ret, inc ו-jmp, אילו שולחות את EIP למקום שאינו ההוראה הבאה בתור?
ret ו-jmp. שתי האחרות, sub ו-inc, רק מתקדמות להוראה הבאה.
אם mov eip, ... אסורה, איך מעבירים את הביצוע לכתובת אחרת?
בפקודת זרימה, למשל jmp לתווית.
מטמון (Cache): זיכרון קטן ומהיר ליד המעבד
למה צריך מטמון
דמיינו ספרייה: הספרים של השבוע מונחים על השולחן ליד הכיסא, וכל השאר על המדפים בקומה אחרת. לקום אל המדפים לכל ספר היה מבזבז את רוב הזמן.
המעבד נמצא באותו מצב מול ה-RAM, שאיטי ממנו בהרבה. לכן יש לו שולחן משלו, המטמון (Cache): זיכרון קטן ומהיר שממוקם בדרך שבין המעבד ל-RAM, ובו עותקים של נתונים שנקראו לאחרונה.
השולחן הזה מסתדר מעצמו. החומרה מחליטה מה מונח עליו, והתוכנית לא כותבת אליו כתובות ולא נותנת לו פקודות.
וכדי לסגור שני בלבולים נפוצים: המטמון איננו אוגר, ואיננו חלק בדיסק שנועד לגיבוי או לאחסון קבוע.
חזרה לתוכן הענייניםשלוש רמות, וההיררכיה כולה
למטמון יש בדרך כלל שלוש רמות, וכדי לראות איפה הן יושבות כדאי לשים אותן בתוך כל ההיררכיה של האחסון. בטבלה, כל שורה רחוקה יותר מהמעבד מזו שמעליה, ולכן גם איטית יותר וגם גדולה יותר:
| שלב | מיקום | מה לזכור |
|---|---|---|
| אוגרים | בתוך המעבד | המהירים מכולם. הם קודמים למטמון ואינם חלק ממנו |
| L1 | צמודה לליבה | רמת המטמון הקטנה והמהירה ביותר |
| L2 | בין L1 ל-L3 | גדולה מ-L1 ואיטית ממנה |
| L3 | לרוב משותפת לכל הליבות | רמת המטמון הגדולה והאיטית ביותר |
| RAM | מחוץ למעבד | הזיכרון הראשי, שהמטמון מחזיק עותקים ממנו |
| דיסק | התקן אחסון | האיטי והגדול ביותר |
Cache hit ו-Cache miss
עקבו אחרי לולאה שקוראת מערך של מאה איברי dword מההתחלה לסוף. בקריאה הראשונה הנתון עוד לא במטמון, וזה Cache miss: המעבד מחכה שהנתון יגיע מה-RAM, החלק האיטי, ושומר עותק במטמון.
אבל מה-RAM לא מגיע איבר בודד. המטמון מקבל בלוק שלם בגודל קבוע, cache line, שבדרך כלל הוא 64 בתים, כלומר 16 איברים של 4 בתים.
לכן בקריאה השנייה, השלישית ועד השש עשרה, הנתון כבר שם, וזה Cache hit: קריאה מהירה ישר מהמטמון. באיבר ה-17 מתחילה שורה חדשה, ושוב miss אחד ואחריו סדרה של hit.
כל זה קורה בכל רמה בנפרד. החיפוש מתחיל ב-L1; miss שם שולח את הבקשה ל-L2, משם ל-L3, ורק אם גם שם הנתון חסר, ל-RAM.
חזרה לתוכן הענייניםמקומיות: למה המטמון עובד
למה הניחוש של המטמון, להחזיק את מה שנקרא לאחרונה ואת מה שלידו, מצליח כל כך? כי תוכניות חוזרות שוב ושוב על שני הרגלים, שנקראים מקומיות (locality):
| סוג | הרעיון | דוגמה |
|---|---|---|
| מקומיות זמנית | מה שנקרא לאחרונה ייקרא שוב בקרוב | סכום מצטבר בזיכרון שמתעדכן בכל סיבוב של לולאה |
| מקומיות מרחבית | אחרי גישה לכתובת, ניגשים גם לכתובות שלידה | קריאה של תווי מחרוזת אחד אחרי השני |
הלולאה מהסעיף הקודם נהנתה ממקומיות מרחבית: היא קראה כתובות צמודות, ולכן כל miss הביא איתו את 15 האיברים הבאים, וכמעט כל שאר הקריאות היו hit.
לו הייתה קופצת על המערך בצעדים גדולים, כל קריאה הייתה נוחתת בשורה אחרת, והרווח מהמטמון היה קטן בהרבה.
טעויות נפוצות
- hit פירושו שהנתון לא נמצא במטמון. הפוך: ב-hit הוא נמצא שם, וב-miss לא.
- אחרי hit המטמון זורק את הנתון, ורק miss משאיר אותו שם לפעם הבאה. ב-hit קוראים את הנתון מהר והוא נשאר. ב-miss מושכים אותו מה-RAM, משתמשים בו, ושומרים עותק במטמון.
- hit ו-miss מתארים גישה לדיסק, או שהם קיימים רק ברמה אחת. הם מתארים חיפוש במטמון, ונכונים בכל רמה: L1, L2 ו-L3.
- L3 היא הקטנה והמהירה, ו-L1 הגדולה. L1 היא הקטנה והמהירה ביותר, ו-L3 הגדולה והאיטית.
- מקומיות זמנית היא גישה לכתובות סמוכות. זו מרחבית. זמנית היא חזרה לאותו נתון שוב.
- האוגרים הם הרמה הראשונה של המטמון. הם נפרדים ממנו, ומהירים ממנו.
- המטמון שומר את הקבצים של המחשב לאורך זמן, ולכן הוא הרכיב הגדול בהיררכיה. הוא דווקא קטן ומהיר, והתוכן שלו זמני: עותקים של נתונים מה-RAM.
בדקו את עצמכם
איזו רמת מטמון היא הגדולה ביותר, ולרוב משותפת לכל הליבות?
L3. היא גם האיטית מבין שלוש הרמות.
פונקציה בודקת את אותו דגל בזיכרון אלפי פעמים ברצף. איזו מקומיות היא מנצלת?
זמנית: חוזרים שוב ושוב לאותו נתון.
כמה איברי word (2 בתים) נכנסים ב-cache line של 64 בתים, וכמה איברי dword?
32 איברי word ו-16 איברי dword, כי 64 חלקי 2 הוא 32, ו-64 חלקי 4 הוא 16.
האם אוגרים הם חלק מהמטמון?
לא. הם קודמים ל-L1 בהיררכיה ומהירים ממנה.
מעקבים מלאים: שורה אחר שורה
שיטת העבודה בשאלת מעקב
שאלת מעקב נותנת כמה שורות קוד ושואלת מה יהיה ערכו של אוגר אחד בסוף. כך עובדים, על הקוד של מעקב 1 שמופיע מיד אחרי:
- פותחים טבלה עם עמודה ל-ECX ועמודה ל-EDX, כי רק הם מופיעים בקוד, ושורה לכל פקודה. ממלאים את השורות לפי סדר הקוד, אחת אחרי השנייה, בלי לקפוץ קדימה.
- בשורה
add ecx, edxהיעד הוא ECX, ולכן רק העמודה שלו מקבלת ערך חדש. את העמודה של EDX מעתיקים מהשורה הקודמת. - כשמגיעים ל-
add ecx, edxהשנייה, לוקחים את EDX כפי שהוא עכשיו, אחרי ה-sub, ולא את הערך מתחילת הקוד. אותו עיקרון חל על mov: היא מעתיקה את הערך הנוכחי של המקור. - אחרי כל add, sub, inc או dec בודקים אם התוצאה יצאה מהטווח, ומתקנים מודולו 2 בחזקת 32 באותה שורה. במעקב 1 זה לא קורה, במעקבים 3 ו-4 כן.
- לסיום מסתכלים על האפשרויות. אם הן בהקסדצימלי של שמונה ספרות, כותבים כך גם את התשובה; אם הן עשרוניות, ממירים.
בכל הטבלאות שלמטה, הערך שנכתב בשורה מסוימת מופיע בהדגשה. הערכים עצמם לא חושבו רק ביד: הרצנו כל קטע על מעבד x86 והשווינו.
חזרה לתוכן הענייניםמעקב 1: חיבור וחיסור עם הערך העדכני
תרחיש 1: חיבור וחיסור בין אוגרים
mov ecx, 14
mov edx, 6
add ecx, edx
sub edx, 2
add ecx, edx| פקודה | ECX | EDX | הסבר |
|---|---|---|---|
mov ecx, 14 | 14 | - | ECX מקבל 14 |
mov edx, 6 | 14 | 6 | EDX מקבל 6 |
add ecx, edx | 20 | 6 | 14 + 6. EDX לא זז |
sub edx, 2 | 20 | 4 | 6 - 2 |
add ecx, edx | 24 | 4 | 20 + 4, עם הערך הנוכחי של EDX |
מי שממשיך עם EDX=6 גם בשורה האחרונה מקבל 26. התשובה הנכונה: ECX=24.
מעקב 2: העתקה, לא קישור
תרחיש 2: mov יוצרת עותק עצמאי
mov esi, 11
mov edi, esi
add esi, 9
sub edi, 4
add edi, esi| פקודה | ESI | EDI | הסבר |
|---|---|---|---|
mov esi, 11 | 11 | - | ESI מקבל 11 |
mov edi, esi | 11 | 11 | EDI מקבל עותק של 11 |
add esi, 9 | 20 | 11 | רק ESI משתנה |
sub edi, 4 | 20 | 7 | 11 - 4 |
add edi, esi | 20 | 27 | 7 + 20, עם ESI המעודכן |
מי שמניח ש-EDI נגרר אחרי ESI, כאילו הם מחוברים, יגיע לתשובה אחרת. התשובה: EDI=27.
מעקב 3: שלוש גלישות בהקסדצימלי
תרחיש 3: גלישה למעלה, למטה ושוב למעלה
mov eax, 0xFFFFFFFA
add eax, 0x0C
mov edx, eax
sub edx, 0x09
add edx, eax| פקודה | EAX | EDX | הסבר |
|---|---|---|---|
mov eax, 0xFFFFFFFA | 0xFFFFFFFA | - | שש פחות מהערך המקסימלי |
add eax, 0x0C | 0x00000006 | - | הסכום המלא 0x100000006. מוחקים את ה-1 |
mov edx, eax | 0x00000006 | 0x00000006 | מעתיקים את הערך שאחרי הגלישה |
sub edx, 0x09 | 0x00000006 | 0xFFFFFFFD | 6 פחות 9 הוא מינוס 3: מחשבים 0x100000006 - 0x9 |
add edx, eax | 0x00000006 | 0x00000003 | 0xFFFFFFFD + 6 = 0x100000003. מוחקים את ה-1 |
בקוד אחד קצר יש גלישה למעלה, גלישה למטה ושוב גלישה למעלה. התשובה: EDX=0x00000003.
מעקב 4: inc ו-dec סביב האפס
תרחיש 4: ירידה מתחת ל-0 וחזרה
mov ebx, 1
dec ebx
dec ebx
dec ebx
mov eax, ebx
inc eax
inc eax
inc eax| פקודה | EBX | EAX | הסבר |
|---|---|---|---|
mov ebx, 1 | 0x00000001 | - | EBX מקבל 1 |
dec ebx | 0x00000000 | - | הגענו ל-0, ולכן ZF=1 |
dec ebx | 0xFFFFFFFF | - | 0 פחות 1 גולש למטה |
dec ebx | 0xFFFFFFFE | - | עוד צעד אחד למטה |
mov eax, ebx | 0xFFFFFFFE | 0xFFFFFFFE | עותק |
inc eax | 0xFFFFFFFE | 0xFFFFFFFF | הערך המקסימלי |
inc eax | 0xFFFFFFFE | 0x00000000 | גלישה למעלה, ZF=1 |
inc eax | 0xFFFFFFFE | 0x00000001 | EBX לא השתנה מאז ההעתקה |
התשובה: EBX=0xFFFFFFFE ו-EAX=0x00000001.
מעקב 5: קריאה מהזיכרון וכתיבה אליו
תרחיש 5: משתנה שעובר דרך אוגר וחוזר
section .data
stock dd 50
section .text
global _start
_start:
mov ecx, [stock]
sub ecx, 8
mov [stock], ecx
inc dword [stock]
mov edx, [stock]| פקודה | ECX | EDX | stock | הסבר |
|---|---|---|---|---|
mov ecx, [stock] | 50 | - | 50 | טוענים את הערך מהזיכרון |
sub ecx, 8 | 42 | - | 50 | החישוב באוגר. הזיכרון עוד לא השתנה |
mov [stock], ecx | 42 | - | 42 | כותבים את ECX למשתנה |
inc dword [stock] | 42 | - | 43 | פעולה ישירה על הזיכרון, עם מילת גודל |
mov edx, [stock] | 42 | 43 | 43 | קוראים את הערך החדש |
התשובה: ECX=42, EDX=43, ובמשתנה stock שמור 43.
מעקב 6: cmp והדגל ZF
תרחיש 6: מתי ZF נדלק ומתי הוא כבה
mov edx, 12
cmp edx, 12
mov ecx, edx
inc edx
cmp ecx, edx
dec edx
cmp edx, ecx| פקודה | EDX | ECX | ZF | הסבר |
|---|---|---|---|---|
mov edx, 12 | 12 | - | ? | הקוד עוד לא קבע שום דגל |
cmp edx, 12 | 12 | - | 1 | 12 - 12 = 0, ולכן ZF=1. EDX לא משתנה |
mov ecx, edx | 12 | 12 | 1 | mov לא נוגעת בדגלים, ו-ZF נשאר 1 |
inc edx | 13 | 12 | 0 | התוצאה 13 איננה 0 |
cmp ecx, edx | 13 | 12 | 0 | 12 - 13 איננו 0, ולכן ZF=0 (ו-CF=1, כי 12 קטן מ-13) |
dec edx | 12 | 12 | 0 | התוצאה 12 איננה 0, ולכן ZF=0, אף שעכשיו האוגרים שווים |
cmp edx, ecx | 12 | 12 | 1 | ההשוואה מוצאת ששניהם 12 |
בסוף: EDX=12, ECX=12, ZF=1. שימו לב לשורת ה-dec: ZF שם מתאר אם התוצאה של dec יצאה 0, ולא אם שני אוגרים שווים. רק cmp בודקת שוויון.
מעקב 7: מערך ומצביע
תרחיש 7: [reg+n], [reg-n] ומצביע שזז
section .data
temps dd 7, 15, 21, 4
section .text
global _start
_start:
mov esi, temps
mov eax, [esi+12]
add eax, [esi+4]
add esi, 8
add eax, [esi]
add eax, [esi-8]| פקודה | ESI | EAX | הסבר |
|---|---|---|---|
mov esi, temps | temps | - | ESI מקבל את הכתובת של המערך, בלי סוגריים |
mov eax, [esi+12] | temps | 4 | 12 בתים הם שלושה איברים: מגיעים לאיבר הרביעי |
add eax, [esi+4] | temps | 19 | 4 + 15, האיבר השני |
add esi, 8 | temps+8 | 19 | המצביע זז שני איברים קדימה |
add eax, [esi] | temps+8 | 40 | 19 + 21, האיבר השלישי |
add eax, [esi-8] | temps+8 | 47 | 40 + 7: שמונה בתים אחורה מגיעים לאיבר הראשון |
התשובה: EAX=47, ו-ESI מצביע על האיבר השלישי, temps+8.
מעקב 8: jmp שמדלגת
תרחיש 8: קפיצה ותווית שעוברים דרכה
mov ecx, 3
jmp SKIP
add ecx, 40
SKIP: add ecx, 2
MID: dec ecx| פקודה | ECX | הסבר |
|---|---|---|
mov ecx, 3 | 3 | ECX מקבל 3 |
jmp SKIP | 3 | הביצוע עובר ל-SKIP |
add ecx, 40 | 3 | לא מתבצעת |
SKIP: add ecx, 2 | 5 | ממשיכים מהתווית |
MID: dec ecx | 4 | התווית MID לא עוצרת כלום: מגיעים אליה בזרימה רגילה וממשיכים |
את add ecx, 40 השארנו בטבלה עם הערך הקודם, כסימון לשורה שלא בוצעה. התשובה: ECX=4.
טעויות נפוצות
- אפשר להשתמש בערך של אוגר כפי שהיה לפני כמה שורות. צריך את הערך הנוכחי, אחרי כל שינוי שעבר עליו בדרך.
- פקודה אחת פחות או יותר לא משנה הרבה. דילוג על השורה האחרונה, או ספירה שגויה של inc ו-dec, מובילים ישר לאחת התשובות השגויות.
- את הגלישה מתקנים פעם אחת, בסוף. האוגר מחזיק את הערך הגלוש כבר אחרי הפקודה שגרמה לגלישה, וזה מה שהשורה הבאה, ההעתקה וההשוואה רואות.
- אחרי
mov edi, esiכל שינוי ב-ESI מופיע גם ב-EDI. mov יוצרת עותק חד-פעמי. שינוי מאוחר באחד לא נוגע בשני. - שורות ש-jmp דילגה עליהן נכנסות לחישוב. הן לא בוצעו, ולכן לא משפיעות על אף ערך. אם הן מופיעות בטבלה, זה רק כדי לסמן שדילגו עליהן.
mov esi, tempsטוענת את האיבר הראשון במערך. בלי סוגריים זו הכתובת של המערך. את האיבר הראשון קוראים עםmov eax, [temps].
בדקו את עצמכם
מה הערך של EAX בסוף: mov edx, 4, mov eax, edx, add eax, eax, add eax, edx, sub eax, edx?
EAX=8. הערכים בדרך: 4, אחרי ההכפלה 8, אחרי החיבור 12, ואחרי החיסור שוב 8.
מה הערך של ECX בסוף: mov ecx, 2, dec ecx, dec ecx, dec ecx, inc ecx?
ECX=0. הערכים: 2, 1, 0, 0xFFFFFFFF, ושוב 0x00000000 אחרי גלישה למעלה.
מה הערך של EBX בסוף: mov ebx, 0x20, sub ebx, 0x23, add ebx, 5?
EBX=0x00000002. החיסור נותן 0xFFFFFFFD, והחיבור נותן 0x100000002, שגולש ל-2.
סיכום
אלה העובדות שכדאי לקחת מהפרק כולו:
| נושא | מה לזכור |
|---|---|
| ASM | שפה ברמה נמוכה. האסמבלר מתרגם אותה מראש לקוד מכונה, בערך פקודה אחת לכל שורה, והקוד מתאים לארכיטקטורה אחת בלבד. |
| x86 | התחילה ב-Intel. 8086 ב-16 ביט, IA-32 ב-32 ביט, x86-64 ב-64 ביט (של AMD). CISC: אורך פקודה משתנה, וחישוב מותר על הזיכרון. little-endian, ושמונה אוגרים כלליים. |
| ARM | RISC: במצב ARM הרגיל כל פקודה 32 ביט, ומודל Load/Store עם LDR ו-STR. שישה עשר אוגרים, ובהם R13=SP, R14=LR, R15=PC. |
| אוגר | אחסון זעיר ומהיר בתוך המעבד, 32 ביט. כל חישוב גולש מודולו 2 בחזקת 32. EIP ו-EFLAGS הם אוגרים מיוחדים. |
| מצביע ההוראה | EIP שומר את הכתובת של ההוראה הבאה, מתקדם אחרי כל הוראה, ומשנה כיוון רק בפקודות זרימה, לעולם לא ב-mov. |
| מטמון | זיכרון קטן ומהיר בין המעבד ל-RAM. L1 הקטנה והמהירה, L3 הגדולה. hit: הנתון שם. miss: מביאים מ-RAM. עובד בזכות מקומיות זמנית ומרחבית. |
| פקודה | מה היא עושה | מה משתנה |
|---|---|---|
mov a, b | a מקבל עותק של b | a בלבד, בלי דגלים |
add a, b | a = a + b | a, ZF ו-CF |
sub a, b | a = a - b | a, ZF ו-CF |
inc a | a = a + 1 | a ו-ZF, לא CF |
dec a | a = a - 1 | a ו-ZF, לא CF |
cmp a, b | מחשבת a - b וזורקת את התוצאה | הדגלים בלבד |
jmp L | EIP מקבל את הכתובת של L | EIP בלבד |
טעויות נפוצות
- אפשר לפתור מעקב בראש, בלי טבלה. בלי טבלה קל לפספס אוגר שהשתנה, או להמשיך עם ערך ישן.
- התשובה נכונה גם אם הפורמט שלה שונה מזה של האפשרויות. בדקו אם האפשרויות בעשרוני או בהקסדצימלי בן 8 ספרות, וכתבו את התוצאה באותה צורה.
- x86 ו-ARM נבדלות רק בפרט אחד. הן שונות בסוג, באורך פקודה, בגישה לזיכרון ובמספר האוגרים. כדאי לזכור את טבלת ההשוואה כולה.
בדקו את עצמכם
מה ההבדל בין mov edx, ecx לבין add edx, ecx?
mov מעתיקה: EDX מקבל את הערך של ECX. add מחברת: EDX מקבל את הסכום של שניהם.
למה תוכנית שנבנתה ל-ARM לא תרוץ על x86, ומה האורך של פקודת ARM?
לשתי הארכיטקטורות סט פקודות שונה. במצב ARM הרגיל, כל פקודה היא 32 ביט.
באיזה אוגר שמורה ב-x86 הכתובת של ההוראה הבאה, ובאיזה ב-ARM?
ב-x86 זה EIP, וב-ARM זה R15, שנקרא PC.
מה קורה לאוגר ולדגל ZF אחרי cmp ebx, ebx?
EBX לא משתנה, ו-ZF=1 כי ערך שווה לעצמו.