דלגו לתוכן הראשי
גאמא קוד

מחשבון קרב - אסמבלי

פעולות בסיסיות

מושגי יסוד באסמבלי x86 ואוגרים, ומעקב אחרי ערכי אוגרים בפקודות mov, add, sub, inc ו-dec.

בחרו את הרמה שמתאימה לכם ואת הסט שתרצו לתרגל

חומר לימוד

פעולות בסיסיות: אסמבלי x86 מהאוגר ועד מעקב שורה אחר שורה

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

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

  • המושגים: ASM, x86, ARM, אוגר (Register), מצביע ההוראה (Instruction pointer) ומטמון (Cache).
  • ייצוג מספרים: עשרוני מול הקסדצימלי, ומה קורה לאוגר כשתוצאה חורגת מהטווח שלו.
  • שבע הפקודות הבסיסיות: mov, add, sub, inc, dec, cmp ו-jmp, כל אחת עם הכללים, הדגלים והשגיאות שלה, ואיך פונים לזיכרון.
  • שמונה מעקבים מלאים: טבלה שורה אחר שורה, באותה צורה שבה בנויות השאלות במבחן.
את דוגמאות האסמבלי הרצנו בפועל על מעבד x86 במצב 32 ביט, עם האסמבלר NASM, ואת הערכים בטבלאות המעקב השווינו למה שהמעבד נתן. בלוק שמופיע לצדו פלט מראה את מה שהאסמבלר או המהדר הדפיסו באמת, כולל הודעות שגיאה. בסוף כל פרק יש טעויות נפוצות ושאלות לבדיקה עצמית.

שפת אסמבלי (ASM): הצעד הראשון מעל קוד המכונה

מה זו שפת אסמבלי ולמה צריך אותה

נתחיל מחמישה בתים: B9 0C 00 00 00. עבור מעבד x86 זו פקודה שלמה, שמכניסה את המספר 12 לאוגר ECX, אבל אי אפשר לנחש את זה מהבתים עצמם.

בתים כאלה, רצפי ביטים שכל אחד מהם מקודד פקודה, הם כל מה שמעבד (CPU) מסוגל להריץ, וקוראים להם קוד מכונה. אסמבלי (Assembly, ובקיצור ASM) נותנת לכל פקודת מכונה שם קריא, ואת אותם חמישה בתים כותבים בה mov ecx, 12.

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

כשבשאלון הדיגיטלי מופיעה הקטגוריה ASM, היא מתייחסת לאסמבלי. אין לה קשר ל-Enterprise Service Management, שמתקצר באותן אותיות.

מי צריך לקרוא ולכתוב קוד כזה?

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

האסמבלר: מי שהופך טקסט לבתים

בואו נראה את התרגום קורה. NASM מקבל את הקובץ הזה, ולבקשתנו כותב לצדו קובץ רישום (listing) שמראה מה יצא מכל שורה:

Assembly
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, 12B9 0C 00 00 005 בתים
inc ecx41בית אחד
add ecx, 483 C1 043 בתים
dec edx4Aבית אחד

שימו לב לעמודת האורך: מבית אחד ועד חמישה. לזה נחזור בפרק על x86, כי זו תכונה שלה.

ועכשיו לשורה הראשונה, bits 32: מולה אין בתים בכלל. היא לא פקודה למעבד אלא הנחיה לאסמבלר, בדיוק כמו section ו-global שתפגשו בהמשך, ולכן היחס הוא "כמעט" אחד לאחד ולא בדיוק.

גם שמות של תוויות לא שורדים את התרגום: במקום כל תווית (label) האסמבלר שם את הכתובת המספרית שלה, ובקוד המכונה לא נשאר אף שם.

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

חזרה לתוכן העניינים

לכל מעבד שפת מכונה משלו: ISA

למה הבתים של add ecx, 4 הם דווקא 83 C1 04? כי כך קובעת טבלת הקידוד של x86. לטבלה כזו, ביחד עם רשימת כל הפקודות שהמעבד מבין, קוראים ארכיטקטורת סט פקודות (ISA, Instruction Set Architecture).

לכל משפחת מעבדים יש ISA משלה, ושל ARM שונה לגמרי משל x86. אותה כוונה, להוסיף 4 לאוגר הראשון, נראית כך בשתיהן:

היבטx86ARM
איך כותביםadd eax, 4add r0, r0, #4, בתחביר אחר עם שלושה אופרנדים
הבתים שנוצריםרצף אחד של בתיםרצף שונה לגמרי, בקידוד של ARM

נסו לתת למעבד ARM את הבתים 83 C0 04, שהאסמבלר יצר עבור add eax, 4. הוא יפרק אותם לפי הקידוד שלו, ויקבל משהו שאינו הפקודה שהתכוונתם אליה, או שאינו פקודה בכלל. מכאן שתוכנית x86 לא רצה על ARM.

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

חזרה לתוכן העניינים

אסמבלי מול שפה עילית

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

C
int apples, pears, plums, fruit;

void count_fruit(void)
{
    fruit = apples + pears + plums;   /* one line of C */
}

ביקשנו מ-gcc לעצור בשלב האסמבלי ולהדפיס את התוצאה, וסיננו את שורות ההנחיות כדי שיישארו רק הפקודות:

Bash
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 לכל משפחת הארכיטקטורות שצמחה מהם.

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

גרסהרוחבמה חשוב לזכור
808616 ביטהראשונה במשפחה
IA-3232 ביטהגרסה שעליה בנוי כל הפרק הזה
x86-6464 ביטאת ההרחבה ל-64 ביט פיתחה AMD, ולא Intel

"רוחב" כאן הוא מספר הביטים באוגר כללי. אין במשפחה גרסה של 8 ביט, ו-ARM64 איננה גרסה של x86 אלא ארכיטקטורה אחרת לגמרי.

את ההיסטוריה אפשר לקרוא מתוך השמות: AX של 16 ביט קיבל E מלפנים, מלשון Extended ("מורחב"), כשהורחב ל-32 ביט, ו-R כשהגיע ל-64:

רוחבאוגר כללי, לדוגמהמצביע ההוראה
16 ביטAXIP
32 ביטEAXEIP
64 ביטRAXRIP
חזרה לתוכן העניינים

CISC: הרבה פקודות, ואורכים שונים

חזרו לרישום של האסמבלר: inc ecx היא בית אחד, add ecx, 4 שלושה בתים, ו-mov ecx, 12 חמישה. ב-x86 אין אורך קבוע לפקודה, והטווח הוא מבית בודד ועד 15 בתים.

זה סימן ההיכר של ארכיטקטורת CISC (Complex Instruction Set Computer), ו-x86 שייכת לסוג הזה. יש בה מאגר פקודות עשיר, וחלק מהפקודות עושות כמה דברים בבת אחת: קוראות מהזיכרון, מחשבות וכותבות את התוצאה חזרה.

חזרה לתוכן העניינים

חישוב ישירות על הזיכרון

שתי השורות הבאות תקינות ב-x86, ובשתיהן אחד הצדדים הוא משתנה בזיכרון. בראשונה הוא היעד, ובשנייה הוא המקור:

Assembly
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. הסתכלו על הבתים שיצאו:

Assembly
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.

כתובת0x20000x20010x20020x2003
הבית שבה4D3C2B1A

ומה יקבל 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 במחשב השולחני ובשרת.

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

Load/Store: הזיכרון נגיש דרך LDR ו-STR בלבד

התחילו מהקוד. שלוש השורות האלה מעלות ב-1 מונה ביקורים ששמור בזיכרון, כש-R0 מחזיק את הכתובת שלו. זה קטע להמחשה בתחביר ARM, ולא הרצנו אותו, כי אין כאן מעבד ARM:

Assembly
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
R13SP (Stack Pointer)ראש המחסניתESP
R14LR (Link Register)הכתובת לחזור אליה בסוף פונקציהאין אוגר כזה: call שומרת אותה במחסנית
R15PC (Program Counter)הכתובת של ההוראה הבאהEIP

כדי לא להתבלבל, קראו את 13, 14, 15 כסיפור קצר: מחסנית, חזרה, ההוראה הבאה. כלומר SP, LR, PC.

חזרה לתוכן העניינים

x86 מול ARM בטבלה אחת

מאפייןx86ARM
סוג הארכיטקטורהCISCRISC
היקף סט הפקודותרחב ומסובךמצומצם ופשוט
אורך פקודהלא קבוע, בין 1 ל-15 בתיםקבוע, 32 ביט
פקודת חשבון על זיכרוןמותרת, למשל add [total], ecxלא קיימת: טוענים ב-LDR ושומרים ב-STR
אוגרים8 כלליים, ובנוסף EIP ו-EFLAGS16, מ-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 ביט, וזהו. אין בו זכר לחישוב שיצר את המספר, ואין לו קשר לאוגר שממנו אולי הועתק.

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

Assembly
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הבסיס של מסגרת המחסנית

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

Assembly
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.

חזרה לתוכן העניינים

מספרים באוגר: עשרוני, הקסדצימלי וגלישה

שתי דרכים לכתוב את אותו מספר

שתי השורות הבאות כתובות אחרת זו מזו. בדקו מה האסמבלר עשה מכל אחת:

Assembly
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. כמה זוגות שכדאי להכיר:

הקסדצימליהחישובעשרוני
0x0E1414
0x101×16 + 016
0x1C1×16 + 1228
0x303×1648
0x646×16 + 4100
0xFF15×16 + 15255

בספירה, הנקודות שמבלבלות הן אחרי 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 כלפי מטה.

בשפה מתמטית זה חשבון מודולו 2 בחזקת 32. בפועל זה אומר שלוש פעמים לא: לא נזרקת שגיאה, התוכנית לא נופלת, ובאוגר לעולם לא מופיע מספר שלילי.
חישובמה נשאר באוגר
0xFFFFFFFF + 10x00000000
0xFFFFFFFF + 30x00000002
0x00000000 - 10xFFFFFFFF
0x00000000 - 40xFFFFFFFC
0x00000002 - 90xFFFFFFF9

ובעשרוני: 4,294,967,295 ועוד 1 נותן 0, ו-0 פחות 1 נותן 4,294,967,295.

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

Python
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 bits
פלט
0x00000002
0xFFFFFFFC
0xFFFFFFF9
חזרה לתוכן העניינים

שיטה לחשב גלישה בהקסדצימלי

כשמחשבים ביד, יש שלושה מצבים שבהם התוצאה יוצאת מהטווח, ולכל אחד תיקון משלו:

המצבמה עושיםדוגמה
סכום שיצא בתשע ספרותמוחקים את הספרה השמאלית העודפת, שהיא תמיד 10xFFFFFFE0 + 0x30 = 0x100000010, ובאוגר 0x00000010
מחסרים מספר גדול ממספר קטןמוסיפים 0x100000000 למספר הקטן, ורק אז מחסרים0x4 - 0x9 הופך ל-0x100000004 - 0x9 = 0xFFFFFFFB
מחסרים ישר מ-0סופרים אחורה מ-0xFFFFFFFF0 פחות 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, שורת אסמבלי מורכבת מעד ארבעה חלקים. הנה שורה שיש בה את כולם:

Assembly
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, 9EDX=ערך כלשהוEDX=9
mov ecx, edxEDX=9, ECX=2EDX=9, ECX=9
mov esi, 0x1FESI=ערך כלשהוESI=0x0000001F, כלומר 31

בכל שורה, אחרי הפקודה היעד מחזיק את מה שהמקור מחזיק, והמקור עצמו לא זז. זה כל מה ש-mov dest, src עושה: העתקה. השם, קיצור של move, מטעה בעניין הזה.

בשורה השנייה ECX היה 2, והערך הזה פשוט נמחק. מה שהיה ביעד לא משתתף בשום חישוב, בניגוד למה שקורה ב-add וב-sub.

ומה קורה אחר כך? אם EDX ישתנה בשורה הבאה, ECX לא יידע על כך: mov לא יוצרת קשר בין האוגרים, רק עותק של רגע אחד. בנוסף, mov לא נוגעת בדגלים, כך ש-mov שנכנסת בין cmp לבין קפיצה מותנית לא משנה את ההכרעה של הקפיצה.

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

Assembly
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 operand
פלט
badmov.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, 0x2000EIP לא מקבל ערך דרך mov. את הזרימה משנים ב-jmp ובפקודות דומות לה.

שימו לב להודעה על השורה האחרונה: NASM אפילו לא מזהה את eip כשם של אוגר שמותר לכתוב בפקודה, ומחפש סמל בשם הזה. ל-mov עם זיכרון נחזור בפרק "גישה לזיכרון".

חזרה לתוכן העניינים

add: חיבור

פקודהלפניאחרי
add ecx, 6ECX=8ECX=14
add edx, ebxEDX=20, EBX=7EDX=27, EBX=7
add ebx, ebxEBX=9EBX=18
add edi, 0x0CEDI=0x30EDI=0x3C
add ecx, 3ECX=0xFFFFFFFEECX=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, 3ECX=15ECX=12
sub edx, ecxEDX=15, ECX=6EDX=9, ECX=6
sub ecx, edxECX=6, EDX=15ECX=0xFFFFFFF7, EDX=15
sub esi, 4ESI=2ESI=0xFFFFFFFE
sub ebx, ebxEBX=ערך כלשהו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 edxEDX=11EDX=12
inc ecxECX=0xFFFFFFFFECX=0, גלישה, ZF=1
inc esi פעמייםESI=9ESI=11

האופרנד היחיד חייב להיות משהו שאפשר לכתוב אליו. כך NASM מגיב לשתי הטעויות הנפוצות:

Assembly
bits 32
section .text
    inc edx, 4      ; two operands
    inc 3           ; a number cannot change
פלט
badinc.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 ebxEBX=20EBX=19
dec ecxECX=1ECX=0, ZF=1
dec ediEDI=0EDI=0xFFFFFFFF, גלישה

dec היא תמונת הראי של inc: אופרנד אחד, פחות 1, ובדיוק אותו ערך כמו sub dest, 1. גם היא לא משנה את CF ומעדכנת את ZF, כמו בשורה השנייה, שבה ECX הגיע ל-0.

בגלל שהן הפוכות, זוג של inc ו-dec על אותו אוגר מחזיר אותו לנקודת ההתחלה. למשל, dec edi ואחריה inc edi על EDI=0 עוברות דרך 0xFFFFFFFF וחוזרות ל-0.

חזרה לתוכן העניינים

cmp: השוואה שלא משנה כלום

הסתכלו קודם על התוצאות, ונסו לזהות מה משותף להן:

פקודהלפניאחרי
cmp ecx, 10ECX=10ECX=10, ZF=1: שווים
cmp ecx, 4ECX=10ECX=10, ZF=0: שונים
cmp ecx, 12ECX=10ECX=10, ZF=0, CF=1, כי 10 קטן מ-12
cmp edx, esiEDX=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, 88EDX מקבל 8
jmp NEXT8הביצוע עובר ל-NEXT
sub edx, 50לא בוצעהדילגנו עליה
NEXT: dec edx7ממשיכים מהתווית

מה קרה מאחורי הקלעים: jmp label כתבה ל-EIP את הכתובת של NEXT, והמעבד המשיך משם. שום אוגר כללי ושום דגל לא השתנו, ו-EDX ירד ל-7 רק בגלל ה-dec.

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

המילה "בלתי מותנית" אומרת ש-jmp קופצת בכל מצב, בלי לבדוק דגלים. את הקפיצות שכן בודקות, כמו jne, שמסתמכות על הדגלים ש-cmp קבעה, תלמדו בהמשך.

קפיצה יכולה גם ללכת אחורה. ברישום הזה הבתים EB FD פירושם "חזור 3 בתים", אל again, ומאחר שאין שום יציאה, הלולאה לא תיגמר לעולם:

Assembly
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

עוד דוגמה, הפעם הקפיצה מדלגת על שתי שורות:

Assembly
mov esi, 1
jmp DONE
mov esi, 99
add esi, 5
DONE:
inc esi

ESI מקבל 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 עשה מכל אחת:

Assembly
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 מסמן את נקודת הכניסה, השורה שבה הביצוע מתחיל:

Assembly
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, livesEAX מקבל את הכתובת של lives, מספר כמו 0x0804A000. הערך המדויק תלוי בתוכנית ובמקשר
mov [lives], eaxכתיבה לזיכרון: הערך של EAX נכנס לתוך המשתנה

הרוחב של הקריאה נקבע לפי האוגר שבצד השני. EAX הוא 32 ביט, ולכן mov eax, [lives] מושכת ארבעה בתים, את כל ה-dword.

וכל כיוון משנה רק את הצד שלו: בקריאה הזיכרון נשאר כמו שהיה, ובכתיבה mov [lives], eax המשתנה מתעדכן בזמן ש-EAX שומר על הערך שלו.

חזרה לתוכן העניינים

אוגר שמחזיק כתובת: [reg], [reg+n], [reg-n]

חזרו ל-costs מהרישום: שלושה dword ברצף, ולכן כל איבר מתחיל 4 בתים אחרי הקודם:

כתובתcostscosts+4costs+8
האיבר405570

נניח ש-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 אין אחד כזה, כי הצדדים הם זיכרון ומספר, ולכן צריך מילת גודל מפורשת:

מילת גודלבתיםביטים
byte18
word216
dword432
Assembly
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.

הגרסה החדשה של NASM שבדקנו כאן (3.01) לא עצרה, ובחרה גודל בעצמה: בית אחד בשורת mov כזו, ושני בתים בשורת add. זו בדיוק הסיבה לכתוב את הגודל תמיד, ובשאלות המבחן התשובה היא שהשורה שגויה.

ומה אם רוצים לקרוא לאוגר רק בית אחד מהזיכרון? לשם כך צריך אוגר ברוחב 8 ביט, ואלה תתי-האוגרים, שיש להם פרק משלהם.

חזרה לתוכן העניינים

אין זיכרון מול זיכרון

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

רוציםלא עובדעובד
להעתיק את price ל-backupmov [backup], [price]mov ecx, [price] ואחריה mov [backup], ecx
להוסיף ל-ECX את מה ששמור ב-price-add ecx, [price]
להוסיף ל-price את ECX-add [price], ecx
להעלות את price ב-1inc [price], בלי גודלinc dword [price]
לבדוק אם price שווה 100cmp [price], 100, בלי גודלcmp dword [price], 100
להוסיף את price ל-totaladd [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 אומרת לאסמבלר. ברישום רואים איפה מתחילה כל פקודה:

Assembly
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 אחריה
0x00403000mov ecx, 75 בתים0x00403005
0x00403005dec ecxבית אחד0x00403006

הצעד של EIP שווה לאורך ההוראה: חמישה בתים אחרי mov, בית אחד אחרי dec. ב-x86 האורכים משתנים, ולכן גם הצעדים, וההתקדמות קורית מעצמה אחרי כל הוראה.

שאלה נפוצה במבחן היא מה אין ב-EIP. כל אחד מהדברים שמתבלבלים איתו נמצא במקום אחר:

מה מחפשיםאיפה זה נמצא
הכתובת של ההוראה הבאהEIP
ההוראה שהסתיימה זה עתהלא ב-EIP: הוא כבר מצביע על זו שאחריה
תוצאה של חישובבדרך כלל ב-EAX, שגם מחזיק את מה שפונקציה מחזירה
הדגלים, כמו ZF ו-CFEFLAGS
ראש המחסניתESP
חזרה לתוכן העניינים

פקודות זרימה: הדרך לשנות את EIP

חזרו לרישום. השורה השלישית, jmp AHEAD, היא פקודה מסוג אחר: במקום לתת ל-EIP להתקדם, היא כותבת לתוכו כתובת חדשה. פקודות שעושות זאת נקראות פקודות זרימה, ובהן הקפיצות jmp, jne, jc ו-jnc, וגם call ו-ret, loop ו-int.

כך נראים שלושת הצעדים הבאים ברישום:

כתובתהוראהאורךEIP אחריה
0x00403006jmp AHEAD2 בתים0x0040300B, הכתובת של AHEAD
0x00403008sub ecx, 303 בתיםלא מתבצעת
0x0040300BAHEAD: add ecx, 23 בתים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 איננו ערך קבוע שלא משתנה: הוא זז אחרי כל הוראה, רק שהמעבד הוא שמזיז אותו, בהתקדמות רגילה או בפקודת זרימה. וגם mov עצמה עובדת מצוין עם אוגרים של 32 ביט.
טעויות נפוצות
  • 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 שמופיע מיד אחרי:

  1. פותחים טבלה עם עמודה ל-ECX ועמודה ל-EDX, כי רק הם מופיעים בקוד, ושורה לכל פקודה. ממלאים את השורות לפי סדר הקוד, אחת אחרי השנייה, בלי לקפוץ קדימה.
  2. בשורה add ecx, edx היעד הוא ECX, ולכן רק העמודה שלו מקבלת ערך חדש. את העמודה של EDX מעתיקים מהשורה הקודמת.
  3. כשמגיעים ל-add ecx, edx השנייה, לוקחים את EDX כפי שהוא עכשיו, אחרי ה-sub, ולא את הערך מתחילת הקוד. אותו עיקרון חל על mov: היא מעתיקה את הערך הנוכחי של המקור.
  4. אחרי כל add, sub, inc או dec בודקים אם התוצאה יצאה מהטווח, ומתקנים מודולו 2 בחזקת 32 באותה שורה. במעקב 1 זה לא קורה, במעקבים 3 ו-4 כן.
  5. לסיום מסתכלים על האפשרויות. אם הן בהקסדצימלי של שמונה ספרות, כותבים כך גם את התשובה; אם הן עשרוניות, ממירים.

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

חזרה לתוכן העניינים

מעקב 1: חיבור וחיסור עם הערך העדכני

תרחיש 1: חיבור וחיסור בין אוגרים
Assembly
mov ecx, 14
mov edx, 6
add ecx, edx
sub edx, 2
add ecx, edx
פקודהECXEDXהסבר
mov ecx, 1414-ECX מקבל 14
mov edx, 6146EDX מקבל 6
add ecx, edx20614 + 6. EDX לא זז
sub edx, 22046 - 2
add ecx, edx24420 + 4, עם הערך הנוכחי של EDX

מי שממשיך עם EDX=6 גם בשורה האחרונה מקבל 26. התשובה הנכונה: ECX=24.

חזרה לתוכן העניינים

מעקב 2: העתקה, לא קישור

תרחיש 2: mov יוצרת עותק עצמאי
Assembly
mov esi, 11
mov edi, esi
add esi, 9
sub edi, 4
add edi, esi
פקודהESIEDIהסבר
mov esi, 1111-ESI מקבל 11
mov edi, esi1111EDI מקבל עותק של 11
add esi, 92011רק ESI משתנה
sub edi, 420711 - 4
add edi, esi20277 + 20, עם ESI המעודכן

מי שמניח ש-EDI נגרר אחרי ESI, כאילו הם מחוברים, יגיע לתשובה אחרת. התשובה: EDI=27.

חזרה לתוכן העניינים

מעקב 3: שלוש גלישות בהקסדצימלי

תרחיש 3: גלישה למעלה, למטה ושוב למעלה
Assembly
mov eax, 0xFFFFFFFA
add eax, 0x0C
mov edx, eax
sub edx, 0x09
add edx, eax
פקודהEAXEDXהסבר
mov eax, 0xFFFFFFFA0xFFFFFFFA-שש פחות מהערך המקסימלי
add eax, 0x0C0x00000006-הסכום המלא 0x100000006. מוחקים את ה-1
mov edx, eax0x000000060x00000006מעתיקים את הערך שאחרי הגלישה
sub edx, 0x090x000000060xFFFFFFFD6 פחות 9 הוא מינוס 3: מחשבים 0x100000006 - 0x9
add edx, eax0x000000060x000000030xFFFFFFFD + 6 = 0x100000003. מוחקים את ה-1

בקוד אחד קצר יש גלישה למעלה, גלישה למטה ושוב גלישה למעלה. התשובה: EDX=0x00000003.

חזרה לתוכן העניינים

מעקב 4: inc ו-dec סביב האפס

תרחיש 4: ירידה מתחת ל-0 וחזרה
Assembly
mov ebx, 1
dec ebx
dec ebx
dec ebx
mov eax, ebx
inc eax
inc eax
inc eax
פקודהEBXEAXהסבר
mov ebx, 10x00000001-EBX מקבל 1
dec ebx0x00000000-הגענו ל-0, ולכן ZF=1
dec ebx0xFFFFFFFF-0 פחות 1 גולש למטה
dec ebx0xFFFFFFFE-עוד צעד אחד למטה
mov eax, ebx0xFFFFFFFE0xFFFFFFFEעותק
inc eax0xFFFFFFFE0xFFFFFFFFהערך המקסימלי
inc eax0xFFFFFFFE0x00000000גלישה למעלה, ZF=1
inc eax0xFFFFFFFE0x00000001EBX לא השתנה מאז ההעתקה

התשובה: EBX=0xFFFFFFFE ו-EAX=0x00000001.

חזרה לתוכן העניינים

מעקב 5: קריאה מהזיכרון וכתיבה אליו

תרחיש 5: משתנה שעובר דרך אוגר וחוזר
Assembly
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]
פקודהECXEDXstockהסבר
mov ecx, [stock]50-50טוענים את הערך מהזיכרון
sub ecx, 842-50החישוב באוגר. הזיכרון עוד לא השתנה
mov [stock], ecx42-42כותבים את ECX למשתנה
inc dword [stock]42-43פעולה ישירה על הזיכרון, עם מילת גודל
mov edx, [stock]424343קוראים את הערך החדש

התשובה: ECX=42, EDX=43, ובמשתנה stock שמור 43.

חזרה לתוכן העניינים

מעקב 6: cmp והדגל ZF

תרחיש 6: מתי ZF נדלק ומתי הוא כבה
Assembly
mov edx, 12
cmp edx, 12
mov ecx, edx
inc edx
cmp ecx, edx
dec edx
cmp edx, ecx
פקודהEDXECXZFהסבר
mov edx, 1212-?הקוד עוד לא קבע שום דגל
cmp edx, 1212-112 - 12 = 0, ולכן ZF=1. EDX לא משתנה
mov ecx, edx12121mov לא נוגעת בדגלים, ו-ZF נשאר 1
inc edx13120התוצאה 13 איננה 0
cmp ecx, edx1312012 - 13 איננו 0, ולכן ZF=0 (ו-CF=1, כי 12 קטן מ-13)
dec edx12120התוצאה 12 איננה 0, ולכן ZF=0, אף שעכשיו האוגרים שווים
cmp edx, ecx12121ההשוואה מוצאת ששניהם 12

בסוף: EDX=12, ECX=12, ZF=1. שימו לב לשורת ה-dec: ZF שם מתאר אם התוצאה של dec יצאה 0, ולא אם שני אוגרים שווים. רק cmp בודקת שוויון.

חזרה לתוכן העניינים

מעקב 7: מערך ומצביע

תרחיש 7: [reg+n], [reg-n] ומצביע שזז
Assembly
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]
פקודהESIEAXהסבר
mov esi, tempstemps-ESI מקבל את הכתובת של המערך, בלי סוגריים
mov eax, [esi+12]temps412 בתים הם שלושה איברים: מגיעים לאיבר הרביעי
add eax, [esi+4]temps194 + 15, האיבר השני
add esi, 8temps+819המצביע זז שני איברים קדימה
add eax, [esi]temps+84019 + 21, האיבר השלישי
add eax, [esi-8]temps+84740 + 7: שמונה בתים אחורה מגיעים לאיבר הראשון

התשובה: EAX=47, ו-ESI מצביע על האיבר השלישי, temps+8.

חזרה לתוכן העניינים

מעקב 8: jmp שמדלגת

תרחיש 8: קפיצה ותווית שעוברים דרכה
Assembly
mov ecx, 3
jmp SKIP
add ecx, 40
SKIP: add ecx, 2
MID: dec ecx
פקודהECXהסבר
mov ecx, 33ECX מקבל 3
jmp SKIP3הביצוע עובר ל-SKIP
add ecx, 403לא מתבצעת
SKIP: add ecx, 25ממשיכים מהתווית
MID: dec ecx4התווית 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, ושמונה אוגרים כלליים.
ARMRISC: במצב 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, ba מקבל עותק של ba בלבד, בלי דגלים
add a, ba = a + ba, ZF ו-CF
sub a, ba = a - ba, ZF ו-CF
inc aa = a + 1a ו-ZF, לא CF
dec aa = a - 1a ו-ZF, לא CF
cmp a, bמחשבת a - b וזורקת את התוצאההדגלים בלבד
jmp LEIP מקבל את הכתובת של LEIP בלבד
טעויות נפוצות
  • אפשר לפתור מעקב בראש, בלי טבלה. בלי טבלה קל לפספס אוגר שהשתנה, או להמשיך עם ערך ישן.
  • התשובה נכונה גם אם הפורמט שלה שונה מזה של האפשרויות. בדקו אם האפשרויות בעשרוני או בהקסדצימלי בן 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 כי ערך שווה לעצמו.