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

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

דגלים (flags)

דגלי המעבד כמו Carry וקפיצות jc ו-jnc לפי תוצאות פעולות add, sub, cmp ו-bt.

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

חומר לימוד

דגלים (flags): דגל הנשיאה CF, מי כותב אותו ומי רק קורא

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

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

  • היסודות: האוגר EFLAGS, דגל הנשיאה Carry flag (CF) ודגל האפס ZF, ולמה צריך אותם.
  • גבולות האוגר: 8, 16 ו-32 ביט, תתי-אוגרים כמו DL ו-DX, ואיך גלישה מתורגמת ל-CF.
  • הפקודות שכותבות ל-CF: add, sub, cmp, bt, stc ו-clc, כל אחת עם הכלל שלה.
  • הפקודות שלא נוגעות בו: mov, inc, dec, וגם jc ו-jnc, שרק קוראות אותו כדי להחליט.
  • הכלל שמכריע: הכותבת האחרונה של CF לפני הקפיצה, לפי הסדר שבו הקוד רץ באמת.
  • תרגול: תשעה מעקבים פתורים ורשימת בדיקה לסיום.
קטעי הקוד בפרק הם קטעים קצרים של אסמבלי x86 בתחביר NASM, ולא תוכניות שמדפיסות משהו, ולכן לרובם אין פלט. ההערות בתוך הקוד ובטבלאות המעקב הן מעקב של ערכי האוגרים ו-CF, וכל הערכים האלה נבדקו בהרצה של אותן פקודות על מעבד x86 אמיתי. הפלט היחיד שמוצג הוא הודעות שגיאה אמיתיות של האסמבלר.

מהו דגל, ומהו Carry flag (CF)

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

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

הנוריות של המעבד יושבות באוגר שנקרא EFLAGS. כל ביט בו הוא נורית כזו, דגל שערכו 0 או 1, ופקודת חשבון או השוואה מעדכנת אותו כדי לתעד משהו על מה שיצא לה. הקפיצה שבאה אחריה רק מסתכלת על הנורית.

את EFLAGS לא ממלאים ביד כמו את EAX או את EDX, ו-mov אינה יכולה לכתוב אליו. הדגלים מתעדכנים מעצמם, כחלק מהעבודה של פקודות מסוימות, ובפרק הזה תכירו את המעטות שמשנות את CF.

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

Carry flag: מה הוא מסמן ומי כותב אותו

CF, דגל הנשיאה, הוא ביט יחיד ב-EFLAGS. ארבע קבוצות של פקודות כותבות אליו:

פקודהמתי CF=1
addהחיבור יצא גדול מהקיבולת של האוגר: יש נשיאה החוצה מהביט העליון
sub, cmpהיה צריך לשאול (לווה) מעבר לביט העליון, כלומר המספר שמחסירים גדול מהמספר שממנו מחסירים
btהביט שנבחר באופרנד הוא 1 (CF מקבל עותק שלו)
stc, clcstc תמיד מציבה 1, ו-clc תמיד מציבה 0

שני מקרים ב-DL, שמחזיק 0 עד 255, מראים שחיבור וחיסור נשלטים כאן באותו עיקרון. 250 ועוד 9 צריכים לתת 259, ו-3 פחות 4 צריכים לתת מינוס 1: בשניהם התשובה המתמטית לא קיימת על הסרגל של 0 עד 255, ולכן CF=1.

לעומת זאת 250 ועוד 5 נותנים 255, ו-4 פחות 3 נותנים 1, ושתי התוצאות נוחתות על הסרגל, ולכן CF=0. השאלה היא תמיד אחת: האם התוצאה האמיתית נשארה בתחום של האוגר?

בכל הפרק, "מספר" פירושו מספר לא מסומן: אין שליליים, והתחום מתחיל ב-0. גלישה במובן של מספרים מסומנים נרשמת בדגל אחר (OF), ואינה מעניינת אותנו כאן.
חזרה לתוכן העניינים

שלושה עקרונות שילוו אתכם לאורך כל הפרק

  1. לא כל פקודה כותבת ל-CF. מבין הפקודות שבפרק, אלה שכותבות הן add, sub, cmp, bt, stc ו-clc, וזו כל הרשימה.
  2. ערך הדגל נשמר עד שמישהו כותב עליו. mov, inc, dec וכל הקפיצות עוברות לידו ולא משנות אותו.
  3. גודל הפעולה משנה את התשובה. אותו חיבור בדיוק יכול לתת CF=1 על DL (8 ביט) ו-CF=0 על DX (16 ביט) או על EDX (32 ביט).
חזרה לתוכן העניינים

ZF, דגל האפס, ומה מבדיל אותו מ-CF

קל לבלבל בין CF לבין שכן שלו ב-EFLAGS, ZF (דגל האפס). ZF עונה על השאלה "האם יצא 0": הוא נדלק כשהתוצאה האחרונה היא אפס, ובהשוואה של שני ערכים שווים, ו-jne קופצת כשהוא כבוי. CF עונה על שאלה אחרת, "האם יצאנו מהתחום", ושתי השאלות לא תלויות זו בזו:

Assembly
mov dl, 0x3C
sub dl, dl        ; DL = 0x00, ZF = 1, CF = 0  (no borrow: equal values)
mov bl, 0xFF
add bl, 1         ; BL = 0x00, ZF = 1, CF = 1  (255 + 1 does not fit in 8 bits)

בשתיהן האוגר מגיע ל-0 ו-ZF נדלק, אבל רק בשנייה התוצאה האמיתית חרגה מהתחום, ולכן רק שם CF=1.

טעויות נפוצות
  • הדגלים הם חלק מהאוגר, ולכן ערך חדש שנכתב לאוגר מוחק גם אותם. הדגלים יושבים ב-EFLAGS, בנפרד מכל אוגר כללי. רק פקודה שמעדכנת דגלים משנה אותם, וכתיבה לאוגר אינה כזו.
  • אם אוגר הגיע ל-0 במהלך הריצה, CF בוודאי נדלק. הגעה ל-0 קשורה ל-ZF. CF מסמן רק יציאה מהתחום, ו-sub dl, dl למשל נותנת 0 עם CF=0.
  • CF יכול להחזיק את הנשיאה עצמה, למשל 3 או 0xFF. CF הוא ביט אחד. הערכים היחידים שלו הם 0 ו-1.
בדקו את עצמכם
CF=1. מה יהיה CF אחרי mov ebx, 0?

עדיין 1. mov לא משנה אף דגל, גם כשהיא מציבה 0.

מה ההבדל בין EDX לבין CF מבחינת מי יכול לכתוב אליהם?

EDX הוא אוגר כללי של 32 ביט, וכל פקודה שמקבלת אותו כיעד כותבת אליו. CF הוא ביט יחיד בתוך EFLAGS, ורק קבוצה קטנה של פקודות מעדכנת אותו.

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

גדלי אוגרים, גלישה ותתי-אוגרים

כמה מספרים נכנסים בכל גודל

כדי לדעת מתי CF נדלק צריך לדעת איפה נגמר האוגר. לכל גודל יש ערך עליון משלו:

גודלאוגרים לדוגמהתחום (לא מסומן)הערך העליון בהקסה
8 ביטAL, AH, BL, BH, CL, CH, DL, DH0 עד 2550xFF
16 ביטAX, BX, CX, DX0 עד 65,5350xFFFF
32 ביטEAX, EBX, ECX, EDX0 עד 4,294,967,2950xFFFFFFFF

מאיפה באים המספרים האלה? כל ביט נוסף מכפיל את מספר הצירופים, כך ש-8 ביטים נותנים 2 בחזקת 8, כלומר 256 צירופים, ו-32 ביטים נותנים יותר מארבעה מיליארד. מכיוון שהספירה מתחילה ב-0, הערך הגבוה ביותר קטן ב-1 ממספר הצירופים: 255, 65,535 ו-4,294,967,295.

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

גלישה: מה קורה לתוצאה שלא נכנסת

נתחיל מחיבור אחד ב-AL, ונראה מה נשאר ממנו:

Text
  11001000     0xC8 = 200
+ 01000000     0x40 = 64
----------
1 00001000     the real sum is 264: it needs 9 bits
^              the ninth bit has no room in AL: it becomes CF = 1
  00001000     AL keeps only the low 8 bits: AL = 0x08

הביט התשיעי פשוט נחתך, והאוגר מחזיק את מה שנשאר, 8. כך מתנהג מונה קילומטרים בן שלוש ספרות שעובר את 999 ומראה שוב 000: ב-8 ביט 0xFF ועוד 1 מראה 0x00, ובכיוון ההפוך 0x00 פחות 1 מראה 0xFF.

לחשבון כזה קוראים מודולו 2 בחזקת n. מה שהאוגר מאבד בחיתוך לא הולך לגמרי לאיבוד: CF שומר את העובדה שהייתה גלישה.

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

תתי-אוגרים: DL, DH, DX ו-EDX

אוגר של 32 ביט מתחלק לחלקים שלכל אחד מהם יש שם. כך זה נראה ב-EDX:

Text
 bits 31..16          bits 15..8    bits 7..0
+--------------------+-------------+-------------+
| high word, no name |     DH      |     DL      |
+--------------------+-------------+-------------+
                     |<-------- DX (16) -------->|
|<------------------- EDX (32) ----------------->|
  • DL הוא ביטים 0 עד 7, DH הוא ביטים 8 עד 15, ו-DX הוא שניהם יחד, 16 הביטים התחתונים.
  • אותו מבנה בדיוק קיים ב-EAX (AX, AH, AL), ב-EBX (BX, BH, BL) וב-ECX (CX, CH, CL).
  • ל-16 הביטים העליונים של האוגר אין שם, ואי אפשר לפנות אליהם לבד.

השם שכתוב בפקודה הוא גם הגבול שלה. פקודה על DL רואה 8 ביטים בלבד, על DX 16, ועל EDX את כולם, וכל מה שמחוץ לגבול הזה לא זז: mov dl, 9 משאירה את DH ואת החצי העליון בדיוק כמו שהיו.

אותו גבול חל גם על הנשיאה. כש-DL גולש, הביט העודף לא נכנס ל-DH אלא נרשם ב-CF, ו-DL עצמו ממשיך מ-0.

Assembly
mov edx, 0x5A6B90FF   ; DH = 0x90, DL = 0xFF
add dl, 1             ; DL wraps to 0x00, CF = 1
                      ; EDX = 0x5A6B9000: DH is still 0x90, the high word still 0x5A6B
חזרה לתוכן העניינים

שני האופרנדים באותו גודל

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

פקודהמותר?הסיבה
mov dl, ahכן8 ביט מול 8 ביט
mov cx, dxכן16 ביט מול 16 ביט
mov ecx, dlלא32 ביט מול 8 ביט
add bx, alלא16 ביט מול 8 ביט
add ecx, 9כןהקבוע 9 נכתב בגודל של ECX
חזרה לתוכן העניינים

מהקסדצימלי לבינארי, ספרה אחרי ספרה

כל ספרה הקסדצימלית מתאימה בדיוק לארבעה ביטים. לכן לא צריך לחשב: מתרגמים כל ספרה בנפרד ומצמידים. למשל 0x9E הוא 1001 ואחריו 1110, כלומר 10011110.

hexbinhexbinhexbinhexbin
000004010081000C1100
100015010191001D1101
2001060110A1010E1110
3001170111B1011F1111
טעויות נפוצות
  • כש-DL=0xFF ומבצעים add dl, 1, הנשיאה מוסיפה 1 ל-DH. DH נשאר כפי שהיה. הנשיאה מ-DL נרשמת רק ב-CF.
  • DX=0x00FF ו-add dx, 1 נותנת CF=1, בדיוק כמו add dl, 1 על DL=0xFF. החיבור כאן נעשה ב-16 ביט. התוצאה 0x0100 נכנסת בלי בעיה, ולכן CF=0.
  • mov dl, 9 כותבת 9 לכל EDX, כלומר EDX=9 אחריה. רק 8 הביטים התחתונים מוחלפים. DH והחצי העליון שומרים על מה שהיה בהם.
  • mov cx, dl מעתיקה את DL אל CX ומשלימה אפסים. האסמבלר מסרב לפקודה: 16 ביט מול 8 ביט.
בדקו את עצמכם
CL=0xE0. מה CL ומה CF אחרי add cl, 0x20?

0xE0 ועוד 0x20 הם 0x100, מספר של 9 ביטים. CL=0x00 ו-CF=1.

CX=0x00E0. מה CX ומה CF אחרי add cx, 0x20?

CX=0x0100 ו-CF=0, כי ב-16 ביט אין חריגה.

EBX=0xA1B2C3D4. מה EBX אחרי mov bh, 0x77?

BH הוא ביטים 8 עד 15, והיה בו 0xC3. הוא מוחלף ב-0x77, ושאר הביטים נשארים: EBX=0xA1B277D4.

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

הפקודה mov: העתקה שלא נוגעת בדגלים

איך קוראים את הפקודה

Assembly
mov dest, src      ; dest gets a copy of src, src stays as it was

קראו את השורה מימין לשמאל, כמו חץ: הערך עובר מ-src אל dest. זה הסדר בכל פקודה בתחביר Intel שבו כותבים ב-NASM, op dest, src, והתו ; פותח הערה עד סוף השורה.

אחרי mov יש שני עותקים של אותו ערך: src נשאר כמו שהיה, ו-dest איבד את מה שהחזיק קודם. ב-EFLAGS לא קורה כלום, כך שגם CF יוצא ממנה בלי שינוי.

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

אילו צירופים האסמבלר מקבל

צורהדוגמהמותר?
אוגר ← קבועmov ecx, 0x1Fכן
אוגר ← אוגרmov edx, ecxכן
אוגר ← זיכרוןmov ecx, [count]כן
זיכרון ← אוגרmov [count], ecxכן
זיכרון ← קבוע, עם גודלmov dword [count], 12כן
זיכרון ← זיכרוןmov [count], [limit]לא: mov לא מעבירה ישירות בין שני מקומות בזיכרון
גדלים שוניםmov cx, dlלא: חייבים להיות באותו גודל
קבוע כיעדmov 7, ecxלא: למספר אין מקום שאפשר לכתוב אליו
EIP כיעדmov eip, 7לא: את מצביע ההוראה משנות רק פקודות של זרימת ביצוע

כך נראות השגיאות כשמעבירים את השורות האסורות לאסמבלר (NASM 3.01, קובץ בשם bad.asm):

Assembly
section .data
count: dd 0
limit: dd 0
section .text
mov ecx, [count]       ; memory to register: fine
mov [count], [limit]   ; memory to memory
mov cx, dl             ; 16-bit target, 8-bit source
mov 7, ecx             ; a number as the target
mov eip, 7             ; write the instruction pointer
פלט
bad.asm:6: error: invalid combination of opcode and operands
bad.asm:7: error: invalid combination of opcode and operands
bad.asm:8: error: invalid combination of opcode and operands
bad.asm:9: error: symbol `eip' not defined

בשורה 9 NASM אפילו לא מכיר את EIP כשם של אוגר שאפשר לכתוב בפקודה, ולכן הוא מחפש סמל בשם הזה.

כשאף אחד מהאופרנדים אינו אוגר, אין ממה להסיק את הגודל, ולכן כותבים אותו: byte ל-8 ביט, word ל-16 ו-dword ל-32. אל תסמכו על האסמבלר שינחש: יש גרסאות שמסרבות, ויש שבוחרות גודל בעצמן, ואז החישוב ו-CF נקבעים בגודל שלא התכוונתם אליו.

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

לפני ואחרי: מה בדיוק מוחלף

מצב התחלתיפקודהאחרי
ECX=9mov ecx, 0x1FECX=0x1F
ECX=0x1F, EDX=4mov edx, ecxEDX=0x1F, ECX=0x1F (המקור לא השתנה)
EBX=0xCAFE1234mov bl, 0x00EBX=0xCAFE1200
EBX=0xCAFE1234mov bx, 0x0042EBX=0xCAFE0042
חזרה לתוכן העניינים

mov ו-CF: הדגל נשאר במקומו

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

Assembly
mov bl, 0xF0
add bl, 0x20       ; 240 + 32 = 272: BL = 0x10, CF = 1
mov ebx, 0x99      ; EBX = 0x00000099, and CF is still 1

לא. ה-mov החליפה את כל 32 הביטים של EBX, ובכל זאת CF נשאר 1, כי הוא לא שמור באוגר אלא ב-EFLAGS. רק add, sub, cmp, bt, stc או clc יוכלו לשנות אותו מכאן.

טעויות נפוצות
  • mov מאפסת את CF, כי היא כותבת ערך חדש. mov לא נוגעת בשום דגל, וערך CF אחריה זהה לערך שלפניה.
  • אם דורסים את האוגר שגרם לנשיאה, הנשיאה נמחקת יחד איתו. הדגל נשמר בנפרד, ב-EFLAGS. אין לו קשר לתוכן הנוכחי של האוגר.
  • כשנשאלים על ערך של אוגר, אפשר לענות לפי הערך שהוצב בו בתחילת הקוד. התשובה היא הערך שנמצא באוגר שעליו נשאלתם ברגע שהקוד הסתיים, אחרי כל ההצבות.
בדקו את עצמכם
stc ואחריה mov edx, 0. מה CF?

CF=1. ה-mov לא משנה דגלים, ולכן מה שה-stc הציבה נשאר.

איזו מהשלוש תעבור הרכבה: mov [count], [limit], mov cx, dl, mov ah, bl?

רק mov ah, bl, ששני האופרנדים שלה בני 8 ביט. הראשונה מעבירה מזיכרון לזיכרון, והשנייה מערבבת 16 ביט עם 8 ביט.

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

הפקודה add: חיבור, ומתי CF נדלק

איך add כתובה ומה מותר בה

Assembly
add dest, src      ; dest = dest + src
פקודהמותר?
add ecx, 7כן
add dl, bhכן
add [total], ecxכן: היעד בזיכרון, המקור אוגר
add dword [total], 1כן: הגודל צוין במפורש
add [total], [step]לא: שני אופרנדים בזיכרון
add bx, alלא: 16 ביט מול 8 ביט

הטבלה מראה ש-add משחקת לפי אותם חוקים של mov. אופרנד אחד מותר בזיכרון, כמו [total] בשורה השלישית, ושניים לא, הגדלים חייבים להתאים, ומספר לא יכול להיות יעד.

את הסכום add כותבת לאופרנד הראשון, ובאותה הזדמנות היא מעדכנת את הדגלים, ובהם CF ו-ZF. בזה היא שונה מ-mov, שלא נוגעת בהם.

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

הכלל: CF אחרי חיבור

כדי לדעת מה add תשאיר ב-CF, חשבו את הסכום כמו במחשבון, בלי שום גבול, והשוו אותו לתקרה של האוגר שבפקודה. מי שעבר את התקרה (255, 65,535 או 4,294,967,295) מקבל CF=1, וכל השאר, כולל סכום שנוגע בתקרה בדיוק, מקבלים CF=0.

מי שמעדיף ביטים יכול לבדוק אם נוצרה נשיאה מהעמודה השמאלית ביותר, וזו אותה בדיקה בדיוק. היזהרו ממספרים שנראים ענקיים: 0x80000000 + 0x7FFFFFFF הם 4,294,967,295, בדיוק על התקרה של 32 ביט, ולכן CF=0, ואילו 0x80000000 + 0x80000000 כבר עוברים אותה ונותנים CF=1.

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

חיבורים ב-8 ביט, ביט אחרי ביט

מקרה ראשון: AL=0xFE ומבצעים add al, 0x03.

Text
  11111110   254
+ 00000011     3
----------
1 00000001   257 > 255  -> CF = 1, AL = 0x01

מקרה שני: AL=0xC0 ומבצעים add al, 0x40.

Text
  11000000   192
+ 01000000    64
----------
1 00000000   256 > 255  -> CF = 1, AL = 0x00

מקרה שלישי: AL=0x3F ומבצעים add al, 0x41. כאן הביט העליון של התוצאה נדלק, אבל שום ביט לא יוצא החוצה.

Text
  00111111    63
+ 01000001    65
----------
0 10000000   128 <= 255 -> CF = 0, AL = 0x80

מקרה רביעי, בלי ציור: AL=0xA5 ומבצעים add al, 0x5B. 165 ועוד 91 נותנים 256, אחד יותר מהתקרה, כך שהתוצאה AL=0x00 עם CF=1.

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

אותו חיבור בשלושה גדלים

255 ועוד 1 תמיד שווים 256. ב-8 ביט זה כבר מחוץ לתחום, וב-16 או ב-32 ביט יש עוד הרבה מקום.

פקודהלפניאחריCF
add bl, 1BL=0xFFBL=0x001
add bx, 1BX=0x00FFBX=0x01000
add bx, 1BX=0xFFFFBX=0x00001
add ebx, 1EBX=0x000000FFEBX=0x000001000
add ebx, 1EBX=0xFFFFFFFFEBX=0x000000001
add ebx, 0x7FFFFFFFEBX=0x7FFFFFFFEBX=0xFFFFFFFE0
add ebx, 0x10EBX=0xFFFFFFF8EBX=0x000000081

בשורה האחרונה הסכום האמיתי הוא 0x1_00000008, מספר של 33 ביטים. הביט ה-33 עובר ל-CF, ו-EBX מקבל את 32 הביטים התחתונים, 0x00000008.

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

תוצאה אפס, וחיבור של אפס

  • תוצאה 0 לבדה לא מדליקה את CF: add dl, 0 כש-DL=0 משאירה 0 ונותנת CF=0.
  • add כותבת ל-CF בכל הפעלה, ולכן כשאין נשיאה היא מורידה אותו ל-0: אחרי stc, הפקודה add ecx, 2 על ECX=3 נותנת 5 ו-CF=0.
טעויות נפוצות
  • ברגע שחיבור הדליק את CF, הוא נשאר דולק גם אחרי החיבורים הבאים. כל add מחליטה מחדש: 1 אם יצאה נשיאה, 0 אם לא. הערך הקודם לא משנה.
  • add dl, 1 ו-add dx, 1 תמיד נותנות אותו CF, כי DL הוא חלק מ-DX. כל פקודה בודקת חריגה בגודל שלה. כש-DX=0x00FF, החיבור ל-DL גולש ונותן CF=1, והחיבור ל-DX נותן 0x0100 ו-CF=0.
  • 0x7FFFFFFF + 0x7FFFFFFF הוא סכום ענק, ולכן CF=1. הסכום הוא 0xFFFFFFFE, והוא עדיין נכנס ב-32 ביט. CF=0.
  • כשהשאלה שואלת על ECX, אפשר לענות לפי האוגר שהשתתף בחיבור. בדקו על איזה אוגר נשאלתם. לעתים קרובות החיבור רק קובע את CF, והאוגר המבוקש מקבל את ערכו בענף שנבחר אחר כך.
בדקו את עצמכם
DL=0xF0 (240). מה DL ומה CF אחרי add dl, 15?

240 ועוד 15 הם 255, בדיוק הערך העליון של 8 ביט. DL=0xFF ו-CF=0.

EBX=0xFFFFFFFD. מבצעים add ebx, 1 שלוש פעמים. מה המצב אחרי כל אחת?

אחרי הראשונה EBX=0xFFFFFFFE ו-CF=0, אחרי השנייה EBX=0xFFFFFFFF ו-CF=0, ורק השלישית גולשת: EBX=0x00000000 ו-CF=1.

stc ואחריה add ebx, 0. מה CF?

CF=0. add כותבת תמיד ל-CF, וחיבור של 0 אינו יכול לצאת מהתחום.

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

הפקודות sub ו-cmp: חיסור, השוואה ולווה

sub: חיסור ששומר את התוצאה

Assembly
sub dest, src      ; dest = dest - src

הנה ניסוי קטן שמבהיר את ההבדל: ECX=10, ופעם אחת מריצים sub ecx, 4 ופעם אחרת cmp ecx, 4. אחרי sub ב-ECX יש 6, וגם ZF ו-CF עודכנו לפי החיסור. חוקי האופרנדים הם של add: גדלים תואמים, ולכל היותר אופרנד אחד בזיכרון.

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

cmp: חיסור שנזרק

Assembly
cmp a, b           ; works out a - b, keeps nothing, only sets the flags

אחרי cmp ecx, 4 ב-ECX עדיין יש 10. המעבד חישב את אותו 10 פחות 4, השאיר בדגלים את מה ש-sub הייתה משאירה, ושכח את ההפרש, וזו כל המטרה: להכין את הדגלים לקפיצה שבאה מיד אחר כך.

השוואה של מקום בזיכרון לקבוע צריכה מילת גודל, למשל cmp dword [count], 9. מעבר לזה החוקים זהים לאלה של sub.

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

הכלל: CF אחרי חיסור והשוואה

התחילו מהחיסור הבעייתי, 6 פחות 10 ב-AL, כש-AL=0x06 ומבצעים sub al, 0x0A:

Text
  1 00000110   6 + 256 borrowed = 262
-   00001010   10
  ----------
    11111100   252 = 0xFC  -> AL = 0xFC, CF = 1 (6 < 10)

כמו בחיסור בטור בבית הספר, כשאין מספיק בעמודה לוקחים הלוואה מהעמודה שמשמאל. כאן אין עמודה כזו בתוך AL, ולכן המעבד מוסיף לעצמו 256 (2 בחזקת n באופן כללי) מבחוץ, מחסר, ומסמן ב-CF=1 שההלוואה נלקחה, ומכאן גם הגלגול לאחור, כמו 0 פחות 1 שנותן 0xFF.

מתי נדרשת הלוואה כזו? רק כשהמספר שמורידים גדול מזה שממנו מורידים. לכן הכלל ל-sub a, b ול-cmp a, b הוא: CF=1 אם a < b בקריאה לא מסומנת ובגודל הפעולה, ו-CF=0 אם a >= b, ושוויון נופל בצד של CF=0.

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

חיסורים ב-8 ביט

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

  • AL=0x0A ו-sub al, 0x06: התוצאה 4 (00000100), אין לווה, CF=0.
  • AL=0x00 ו-sub al, 2: התוצאה 0xFE, ו-CF=1 כי 0 < 2.
  • AL=0x09 ו-sub al, 0x09: התוצאה 0, אין לווה ולכן CF=0, ו-ZF=1.
חזרה לתוכן העניינים

השוואות ב-32 וב-8 ביט

פקודהערכיםמה נבדקCFZF
cmp ecx, edxECX=4, EDX=94 < 9, יש לווה10
cmp ecx, edxECX=900, EDX=40900 > 4000
cmp ecx, edxECX=12, EDX=12ערכים שווים01
cmp cl, dlCL=1, DL=81 < 8, יש לווה10
sub edx, 9EDX=88 < 9, ו-EDX הופך ל-0xFFFFFFFF10
חזרה לתוכן העניינים

השוואה של תת-אוגר רואה רק אותו

ECX יכול להיות ענק ו-CL שלו אפס, כמו בקוד הבא. cmp cl, dl רואה רק את 8 הביטים התחתונים של כל צד, ולכן התשובה שלה עלולה להיות הפוכה מזו של cmp ecx, edx על אותם אוגרים, ו-CF נקבע לפי מי מהן רצה אחרונה.

Assembly
mov ecx, 0x00000200     ; ECX = 512, but CL = 0x00
mov edx, 3
cmp ecx, edx            ; 512 vs 3: no borrow, CF = 0
cmp cl, dl              ; 0x00 vs 0x03: 0 < 3, CF = 1

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

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

cmp ואחריה jc: האם הראשון קטן מהשני

הזוג cmp a, b ואחריו jc label הוא הדרך לכתוב באסמבלי תנאי של a < b: הקפיצה מתבצעת רק אם הראשון קטן. עם jnc label במקום, הקפיצה מתבצעת כש-a >= b. את הקפיצות עצמן נפרט בהמשך.

טעויות נפוצות
  • ה-cmp הראשונה בקוד קובעת את CF עד הקפיצה. כל add, sub, cmp או bt שבאה אחריה כותבת את CF מחדש. רק האחרונה שבוצעה לפני הקפיצה קובעת.
  • cmp ecx, edx משאירה את ההפרש ב-ECX. cmp לא כותבת לאף אוגר. היא משנה רק את הדגלים.
  • CF=1 כשהאופרנד הראשון גדול מהשני. זה הפוך: CF=1 כשהראשון קטן מהשני, כי רק אז יש לווה.
  • cmp cl, dl מתחשבת בכל ECX ו-EDX. היא משווה רק 8 ביטים. מה שמעל CL ו-DL לא משפיע עליה.
  • כששני הערכים שווים, או כשהחיסור נותן 0, CF=1. בשוויון אין לווה: CF=0 ו-ZF=1.
בדקו את עצמכם
ECX=25. מה CF ומה ZF אחרי cmp ecx, 25?

CF=0, כי 25 אינו קטן מ-25. ZF=1, כי הערכים שווים.

BL=0x20. מה BL ומה CF אחרי sub bl, 0x21?

32 פחות 33: יש לווה. BL=0xFF ו-CF=1.

ECX=0x300 ו-EDX=2. מה CF אחרי cmp ecx, edx, ומה אחרי cmp cl, dl שבאה מיד אחריה?

בראשונה 768 מול 2, CF=0. בשנייה CL=0x00 מול DL=0x02, ולכן CF=1.

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

הפקודות inc ו-dec: גולשות, ובכל זאת משאירות את CF

איך הן כתובות ומה הן מחשבות

Assembly
inc dest           ; dest = dest + 1
dec dest           ; dest = dest - 1

אלה צעד קדימה וצעד אחורה, ולכן אין להן מקור: הן מקבלות רק את מה שמשנים, אוגר או מקום בזיכרון שהגודל שלו כתוב, כמו inc dword [hits]. גם הן מסתובבות במעגל של 2 בחזקת n:

Assembly
mov bl, 0xFF
inc bl             ; BL = 0x00: wraps past the top
mov ecx, 0
dec ecx            ; ECX = 0xFFFFFFFF: wraps below zero
חזרה לתוכן העניינים

ההבדל שהמבחן מחפש: CF לא זז

בשתי הגלישות שלמעלה CF לא השתנה, וזה הכלל כולו: inc ו-dec אינן כותבות ל-CF, ומה שהיה בו לפניהן נמצא בו גם אחריהן. הטבלה שבהמשך מוכיחה את זה מול add ו-sub.

את ZF, לעומת זאת, הן כן מעדכנות, והוא נדלק כשהתוצאה 0. לולאה שסופרת לאחור נשענת בדיוק על זה:

Assembly
mov ecx, 3         ; loop counter
mov eax, 0
AGAIN:
add eax, 10
dec ecx            ; ZF = 1 only when ECX reaches 0, CF is left alone
jne AGAIN          ; jumps while ZF = 0
                   ; after three rounds: EAX = 30, ECX = 0

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

מצב התחלתיפקודהאחריCF אחרי
BL=0xFF, CF=0add bl, 1BL=0x001 (add קבעה)
BL=0xFF, CF=0inc blBL=0x000 (לא השתנה)
BL=0x10, CF=1add bl, 1BL=0x110 (add קבעה)
BL=0x10, CF=1inc blBL=0x111 (לא השתנה)
ECX=0, CF=0dec ecxECX=0xFFFFFFFF0 (לא השתנה)
ECX=0, CF=0sub ecx, 1ECX=0xFFFFFFFF1 (sub קבעה)

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

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

דוגמה: CF מחזיק מעמד מול inc ו-dec

Assembly
mov dl, 0x05
sub dl, 6          ; 5 < 6: DL = 0xFF, CF = 1
inc dl             ; DL = 0x00, CF still 1
dec dl             ; DL = 0xFF, CF still 1

inc dl הביאה את DL ל-0, ו-dec dl החזירה אותו ל-0xFF, ואף אחת מהן לא שינתה את CF. הוא עדיין 1, כמו שה-sub השאירה אותו.

טעויות נפוצות
  • גלישה של inc מ-0xFF או של dec מ-0 מרימה את CF, בדיוק כמו בחיבור ובחיסור. האוגר אמנם גולש, אבל inc ו-dec לא כותבות ל-CF בכלל.
  • אחרי inc או dec הדגל CF מתנקה. אם CF היה 1 לפניהן, הוא נשאר 1 אחריהן.
  • inc ו-dec לא משנות אף דגל. הן כן מעדכנות דגלים אחרים, ובהם ZF. היחיד שהן משאירות בצד הוא CF.
  • אם הערך באוגר השתנה, גם הדגל השתנה. אלה שני דברים נפרדים: ב-inc ו-dec האוגר משתנה, ו-CF נשאר.
בדקו את עצמכם
clc, אחר כך mov bl, 0xFF, אחר כך inc bl. מה BL ומה CF?

BL=0x00 ו-CF=0. ה-inc לא נגעה ב-CF, ולכן נשאר הערך שה-clc הציבה.

stc, mov ecx, 0, dec ecx, ואז jc YES. האם יש קפיצה?

כן. ECX הופך ל-0xFFFFFFFF, אבל מה שחשוב הוא ש-CF עדיין 1 מה-stc, כי לא mov ולא dec כתבו אליו.

mov dl, 0xFF, add dl, 1, inc dl. מה CF בסוף?

CF=1. ה-add הדליקה אותו, וה-inc לא שינתה אותו (DL=0x01 בסוף).

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

הפקודות stc ו-clc: הדלקה וכיבוי ישירים של CF

stc: להרים את הדגל

Assembly
stc                ; CF = 1    (SeT Carry)

אין לה מה לקבל, ולכן היא נכתבת לבד בשורה. התוצאה תמיד CF=1, בין שהדגל היה דלוק ובין שלא, ושום אוגר או דגל אחר לא מושפע.

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

clc: להוריד את הדגל

Assembly
clc                ; CF = 0    (CLear Carry)

תמונת הראי של stc: גם היא עומדת לבד, והתוצאה שלה תמיד CF=0, יהיה הערך הקודם אשר יהיה.

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

כשהן פוגשות את שאר הפקודות

לא כדאי לחשוב על stc ו-clc כעל פקודות מיוחדות. הן עוד שתי כותבות של CF, בדיוק כמו add או bt, ולכן כשהן מופיעות בקוד שאלה אחת מכריעה: מי כתב אחרון.

רצףCF בסוףהסיבה
stc / mov ecx, 9 / cmp ecx, 309 אינו קטן מ-3, וה-cmp כתבה 0 אחרי ה-stc
mov bl, 0xFF / add bl, 1 / clc0החיבור גלש והדליק, וה-clc שאחריו הורידה
clc / mov ecx, 0xFFFFFFFF / inc ecx0ECX גולש ל-0, אבל inc לא כותבת, ונשאר ה-0 של clc
stc / mov edx, 4 / dec edx1dec לא כותבת, ונשאר ה-1 של stc
clc / mov edx, 2 / bt edx, 11ביט 1 של 2 (10) דלוק, וה-bt כתבה אחרי ה-clc
clc / stc1stc אחרונה
stc / clc0clc אחרונה
טעויות נפוצות
  • אחרי stc, CF נעול על 1. כל פקודה כותבת שבאה אחריה, add, sub, cmp או bt, מחליפה אותו.
  • clc לא תשפיע אם לפניה הייתה cmp שהדליקה את CF. clc מציבה 0 בכל מצב, והיא מאוחרת יותר, ולכן היא קובעת.
  • stc מכבה ו-clc מדליקה. זה הפוך. S היא Set, הדלקה, ו-CL היא Clear, ניקוי.
בדקו את עצמכם
stc, mov ecx, 8, sub ecx, 8, ואחר כך jc L. האם קופצים?

לא. ה-sub כתבה CF: 8 פחות 8 בלי לווה, CF=0. מה שה-stc הציבה כבר נמחק.

clc ואחריה cmp ecx, edx, כש-ECX=2 ו-EDX=6. מה CF?

CF=1. ה-cmp היא האחרונה, ו-2 < 6, כלומר יש לווה.

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

הפקודות jc ו-jnc: קפיצה לפי CF

מה הן בודקות ולאן הן הולכות

Assembly
jc  label          ; Jump if Carry:     goes to label when CF = 1
jnc label          ; Jump if Not Carry: goes to label when CF = 0

שתיהן מסתכלות על CF, ולפיו מחליטות לאן הביצוע ממשיך:

פקודהכש-CF=1כש-CF=0
jc labelקופצת ל-labelממשיכה לשורה הבאה
jnc labelממשיכה לשורה הבאהקופצת ל-label

מאחורי המילה "קופצת" עומד אוגר אחד, EIP, שמחזיק את הכתובת של ההוראה הבאה. קפיצה שמתבצעת מציבה בו את הכתובת של היעד, ולכן כל מה שכתוב בין שורת הקפיצה לבין היעד מדולג; קפיצה שלא מתבצעת משאירה את EIP להתקדם כרגיל לשורה שמתחת.

הקפיצות האלה הן צרכניות של CF ולא יצרניות: הן בודקות אותו ומשאירות אותו כמו שמצאו. אותו דבר נכון ל-jmp, ל-jne ול-loop, שאף אחת מהן לא כותבת ל-CF.

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

label: שם שניתן לכתובת

בתבנית שבחלק הבא תראו שורות כמו ON: ו-DONE:. אלה תוויות (labels): שם ונקודתיים, שהאסמבלר הופך לכתובת של השורה שאחריהן, כדי שקפיצה תוכל להפנות אליה.

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

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

התבנית של if/else לפי CF

Assembly
        bt   edx, 6      ; any instruction that writes CF (cmp, add, bt ...)
        jc   ON          ; CF = 1: go to ON
        mov  ecx, 10     ; reached only when CF = 0
        jmp  DONE        ; jump over the CF = 1 branch
ON:
        mov  ecx, 20     ; reached only when CF = 1
DONE:
  1. פקודה כלשהי כותבת ל-CF (כאן bt).
  2. jc ON בודקת את CF.
  3. אם CF=1, הביצוע עובר ל-ON ומבצע את הענף של 1.
  4. אם CF=0, הביצוע ממשיך מתחת ל-jc, מבצע את הענף של 0, ואז jmp DONE מדלגת מעל הענף של 1.

ה-mov שבכל ענף לא משנה את CF, אבל זה גם לא חשוב: ההחלטה כבר נפלה ברגע ה-jc.

בלי jmp DONE, אחרי הענף של 0 הביצוע ממשיך ישר אל ON, ושני הענפים מתבצעים זה אחרי זה. כש-EDX=0x01, ביט 6 כבוי, ולכן ECX מקבל קודם 10 ואחר כך 20, ונשאר עם 20.

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

jc ו-jnc: אותה שאלה, תשובה הפוכה

אם מחליפים בתבנית את jc ON ב-jnc ON, הענפים מחליפים תפקידים: עכשיו CF=0 שולח אל ON. כדי לא להתבלבל ביניהן, הפרידו בין שתי שאלות: מה הערך של CF ברגע הקפיצה, ורק אחרי שעניתם, האם זה הערך שהקפיצה הזו מחכה לו.

CF ברגע הקפיצהjcjnc
1קופצתלא קופצת
0לא קופצתקופצת
טעויות נפוצות
  • jc קופצת כש-CF=0, ו-jnc כש-CF=1. הפוך: jc קופצת כשהדגל דלוק, ו-jnc (Not Carry) כשהוא כבוי.
  • הקפיצה מחליטה לפי הפקודה הראשונה שכתבה ל-CF. היא מחליטה לפי הערך הנוכחי, כלומר לפי הפקודה האחרונה שכתבה ל-CF לפניה.
  • גם בלי jmp DONE יתבצע רק אחד הענפים. label לא עוצר את הביצוע. כשהענף של 0 נגמר, הביצוע נכנס לענף של 1 ומבצע גם אותו.
  • jc או jnc משנות את CF או ערך של אוגר. הן רק בוחרות לאן הביצוע ממשיך. CF והאוגרים יוצאים מהן בדיוק כפי שנכנסו.
בדקו את עצמכם
ECX=9 ו-EDX=9, ומבצעים cmp ecx, edx. האם jc קופצת? ומה עם jnc?

CF=0, כי 9 אינו קטן מ-9. jc לא קופצת, ו-jnc כן.

בתבנית if/else מוחקים את jmp DONE, ו-CF היה 0. מה יקרה?

הענף של 0 יתבצע, ומיד אחריו הביצוע ימשיך אל ON ויבצע גם את הענף של 1. בסוף יישאר הערך שהענף של 1 הציב.

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

הפקודה bt: העתקת ביט אל CF

מה bt עושה

Assembly
bt operand, n      ; Bit Test: CF = bit n of operand
                   ; the operand is only read, never changed

נניח שאתם רוצים לדעת אם ביט 6 של EDX דלוק, וללכת לענף אחר לפי התשובה. bt edx, 6 ואחריה jc עושות בדיוק את זה: ה-bt מצלמת את הביט אל CF, 1 אם הוא דלוק ו-0 אם הוא כבוי, וה-jc מחליטה לפי הצילום.

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

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

איך סופרים ביטים

מספר הביט הוא בעצם החזקה של 2 שהוא מייצג: ביט n שווה 2 בחזקת n. לכן הביט הימני, ששווה 1, הוא ביט 0, שנקרא LSB (Least Significant Bit), וכל צעד שמאלה מכפיל את המשקל.

ביט76543210
משקל1286432168421
0x24 = 0010010000100100

ב-EAX=0x24, כלומר 36 שהם 32 ועוד 4, דלוקים רק ביט 5 וביט 2. כל הביטים מ-8 ומעלה כבויים, כי המספר קטן, ולכן גם bt eax, 9 נותנת CF=0.

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

מספר עשרוני מפרקים לסכום של משקלים מהטבלה. 18 הם 16 ועוד 2, ולכן דלוקים ביטים 4 ו-1 (10010). באותו אופן 6 = 4 + 2 (110), 9 = 8 + 1 (1001), ו-16 הוא משקל בודד (10000).

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

מעשרוני לבינארי בשיטת המשקל הגדול

כשהשאלה כותבת mov eax, 37, צריך לפרק את 37 למשקלים. חשבו על קופה עם שטרות של 1, 2, 4, 8, 16, 32 ו-64, שטר אחד מכל סוג: משלמים קודם בשטר הגדול ביותר שלא עובר את הסכום, ממשיכים עם היתרה, וכל שטר שהשתמשתם בו הוא ביט דלוק.

עשרוניסכום משקליםבינארי (8 ביט)
2200000010
32 + 100000011
54 + 100000101
98 + 100001001
128 + 400001100
158 + 4 + 2 + 100001111
2016 + 400010100
3632 + 400100100
4432 + 8 + 400101100

דוגמה ראשונה: 11. המשקל הגדול שנכנס הוא 8, ונשארים 3. ב-3 נכנס 2, ונשאר 1, שהוא בעצמו משקל.

Text
11 = 8 + 2 + 1   ->  bits 3, 1, 0 are on   ->  00001011
bt eax, 2  ->  CF = 0
bt eax, 1  ->  CF = 1

דוגמה שנייה: 37. נכנס 32, ונשארים 5. ב-5 נכנס 4, ונשאר 1.

Text
37 = 32 + 4 + 1  ->  bits 5, 2, 0 are on   ->  00100101
bt eax, 3  ->  CF = 0
bt eax, 5  ->  CF = 1

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

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

מספר ביט גדול מהאוגר: חשבון מודולו

ל-EDX יש ביטים 0 עד 31 בלבד, ובכל זאת bt edx, 70 היא פקודה תקינה. כשהאופרנד הוא אוגר, המעבד מסתכל רק על השארית של n בחלוקה לגודל האוגר, n mod 32 באוגר של 32 ביט, כאילו הביטים מסודרים על שעון עם 32 שנתות, וביט 32 נופל שוב על השנתה של ביט 0.

פקודהn mod 32הביט שנבדק בפועל
bt edx, 3131ביט 31, העליון
bt edx, 320ביט 0
bt edx, 331ביט 1
bt edx, 364ביט 4
bt edx, 6331ביט 31
bt edx, 640ביט 0
bt edx, 706ביט 6

השורה של 32 היא המלכודת הנפוצה: מי שחושב שאין ביט כזה ולכן CF=0 טועה, כי בפועל נבדק ביט 0. את השארית מוצאים בלי חילוק: מחסירים מ-n את הכפולה הגדולה של 32 שלא עוברת אותו (32, 64, 96...), ומה שנשאר הוא מספר הביט.

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

דוגמה מלאה: כמה bt על אותו אוגר

Assembly
mov edx, 0x48        ; 0100 1000 = 64 + 8: bits 6 and 3 are on
bt  edx, 3           ; CF = 1
bt  edx, 4           ; CF = 0   (replaces the previous CF)
bt  edx, 6           ; CF = 1
bt  edx, 70          ; 70 mod 32 = 6 -> CF = 1
                     ; EDX stays 0x48 through all of it
פקודההביט שנבדקערך הביטCFEDX
mov edx, 0x48--לא השתנה0x48
bt edx, 3ביט 3110x48
bt edx, 4ביט 4000x48
bt edx, 6ביט 6110x48
bt edx, 7070 mod 32 = 6110x48
טעויות נפוצות
  • סופרים ביטים משמאל, או מתחילים מ-1. הביט הימני הוא ביט 0, והספירה מתקדמת שמאלה.
  • bt מדליקה, מכבה או הופכת את הביט שהיא בודקת. היא רק קוראת. האוגר יוצא ממנה בדיוק כמו שנכנס.
  • bt edx, 70 בודקת "ביט 70", שאין כזה באוגר, ולכן CF=0. 70 mod 32 הוא 6, והפקודה בודקת את ביט 6. באותו אופן bt edx, 32 בודקת את ביט 0.
  • CF שנקבע לפני ה-bt, למשל מ-add או מ-cmp, נשמר אחריה. bt כותבת ל-CF תמיד. אחרי כמה bt ברצף, רק האחרונה קובעת.
  • התשובה לשאלה היא מספר הביט, או הערך שיש באוגר שנבדק. השאלה מבקשת את הערך שהקוד מציב בסוף, אחרי שהקפיצה בחרה ענף.
  • CF=1 אחרי bt אומר שהביט כבוי. CF הוא עותק של הביט: 1 פירושו שהביט דלוק.
בדקו את עצמכם
ECX=0x0C (1100 בבינארי). מה CF אחרי bt ecx, 2, ומה אחרי bt ecx, 1?

ביט 2 דלוק, ולכן CF=1. ביט 1 כבוי, ולכן CF=0.

EDX=0x40. מה CF אחרי bt edx, 102?

102 פחות 96 הם 6, כלומר הביט שנבדק הוא ביט 6. ב-0x40 (1000000) ביט 6 דלוק, ולכן CF=1.

EDX=0x48. מה EDX אחרי bt edx, 3?

עדיין 0x48. bt רק מעתיקה את הביט ל-CF.

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

הכלל המרכזי: הפקודה האחרונה שכותבת CF קובעת

מי כותב ל-CF ומי לא

פקודהכותבת ל-CF?הערך שנקבע
add a, bכן1 אם הסכום האמיתי עולה על הערך העליון של גודל הפעולה, אחרת 0
sub a, bכן1 אם a < b (לא מסומן), אחרת 0
cmp a, bכןכמו sub, אבל התוצאה לא נשמרת
bt op, nכןהביט n של האופרנד, אחרי n mod גודל האוגר
stcכן1
clcכן0
movלאCF לא משתנה
inc, decלאCF לא משתנה (ZF כן מתעדכן)
jmp, jc, jnc, jne, loopלאCF לא משתנה (jc ו-jnc קוראות אותו, jne קוראת את ZF)
חזרה לתוכן העניינים

שיטה לפתרון שאלת מעקב

כדאי לחשוב על זה כמו על חקירה שמתחילה מהסוף. הנקודה שבה צריך את CF היא ה-jc או ה-jnc, ולכן ממנה יוצאים לדרך, ולא מהשורה הראשונה של הקוד.

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

את החשוד הזה מחשבים, ורק אותו: בגודל שמופיע בפקודה, DL, DX או EDX, ועם מה שהיה באוגרים ברגע שהוא רץ. מהתוצאה יודעים לאן הקפיצה הלכה, ורק משם ממשיכים קדימה אל האוגר שהשאלה שואלת עליו.

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

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

סדר הביצוע, לא סדר השורות בדף

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

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

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

מה מוחק מה

קודםאחר כךמי קובע את CF בסוף
sub עם לווה (CF=1)cmp בין ערכים שוויםה-cmp (CF=0)
stccmp שבה הראשון גדולה-cmp (CF=0)
clcbt על ביט דלוקה-bt (CF=1)
add שגלשה (CF=1)bt על ביט כבויה-bt (CF=0)
add שגלשה (CF=1)clcה-clc (CF=0)
stcכל רצף של mov, inc ו-decה-stc (CF=1)
cmp שהדליקה CFmov שדורסת את שני האוגריםה-cmp (CF=1)
bt על ביט דלוקbt נוספת על ביט כבויה-bt השנייה (CF=0)
טעויות נפוצות
  • הפקודה הראשונה שהציבה ערך ב-CF היא זו שקובעת. זו הטעות הנפוצה ביותר בשאלות על דגלים. קובעת הכותבת האחרונה שבוצעה לפני הקפיצה.
  • mov, inc, dec או קפיצה משנות את CF. אף אחת מהן לא כותבת ל-CF. מדלגים עליהן כשמחפשים את הכותבת האחרונה.
  • cmp מתחילת הקוד עדיין קובעת, גם אחרי ש-add או bt בוצעו אחריה. כל אחת מהן כתבה ל-CF מחדש, וה-cmp כבר לא משנה דבר.
בדקו את עצמכם
mov ecx, 3, cmp ecx, 8, bt ecx, 1, clc, dec ecx, ואז jc L. האם קופצים?

לא. הכותבת האחרונה היא clc, שהציבה CF=0, ו-dec שאחריה לא נוגעת ב-CF.

stc, mov dl, 0xF0, add dl, 0, ואז jc L. האם קופצים?

לא. add dl, 0 משאירה 0xF0 בלי גלישה, וכותבת CF=0, ובכך מוחקת את מה שה-stc הציבה.

mov cl, 0xF0, add cl, 0x10, ואחר כך mov edx, 0x80 ו-bt edx, 7. מה CF ברגע הקפיצה שאחריהן?

CF=1, אבל לא בזכות החיבור: ה-bt היא הכותבת האחרונה, וביט 7 של 0x80 (10000000) דלוק.

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

דוגמאות מעקב מלאות

איך לקרוא את הדוגמאות

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

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

  • השוואה שמדליקה את הדגל וחיבור שמכבה אותו, לפני jc.
  • הוספה של 1 לאותו אוגר, פעם דרך DL, פעם דרך DX ופעם דרך EDX.
  • הלוואה בחיסור, העתקה שלא מפריעה, וחיבור שנעצר על 255 ואז עובר אותו.
  • אוגר שגולש ארבע פעמים בזמן ש-CF משתנה רק מ-stc ומ-clc.
  • בדיקת ביט במספר שעובר את 31, וענף שנבחר לפיה.
  • נשיאה מחיבור שנמחקת על ידי בדיקת ביט.
  • מציאת המקסימום משני ערכים בעזרת jnc.
  • אותה השוואה ב-8 ביט וב-32 ביט, אחרי כתיבה לחלק התחתון.
  • ארבע כותבות ברצף, ורק האחרונה נחשבת.
חזרה לתוכן העניינים

מעקב 1: הכותבת האחרונה מנצחת (cmp, add, inc)

תרחיש 1: cmp שמדליקה, add שמכבה, inc שלא נוגעת
Assembly
mov ecx, 6
mov edx, 11
cmp ecx, edx
mov ecx, 0x7FFFFFF0
add ecx, 0x0F
inc ecx
jc HIGH
mov ebx, 3
jmp DONE
HIGH:
mov ebx, 4
DONE:
פקודהערכים אחרי הפקודהCFמה קרה ולמה
mov ecx, 6ECX=6?עוד לא נכתב אף דגל
mov edx, 11EDX=11?mov לא כותבת דגלים
cmp ecx, edxללא שינוי16 < 11, יש לווה
mov ecx, 0x7FFFFFF0ECX=0x7FFFFFF01ECX הוחלף, CF נשאר
add ecx, 0x0FECX=0x7FFFFFFF0הסכום 2,147,483,647 נכנס ב-32 ביט, ו-add כתבה 0
inc ecxECX=0x800000000inc לא כותבת ל-CF
jc HIGH-0CF=0, אין קפיצה
mov ebx, 3EBX=30הענף של CF=0
jmp DONE-0דילוג מעל HIGH

בסוף EBX=3. ה-cmp אמנם הדליקה את CF, אבל ה-add שאחריה כתבה עליו 0, וה-inc לא שינתה את זה.

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

מעקב 2: חיבור של 1 בשלושה גדלים (DL, DX, EDX)

תרחיש 2: החצי העליון של EDX לא זז
Assembly
mov edx, 0x7C55B0FF
add dl, 1
add dx, 1
mov dx, 0xFFFF
add dx, 1
add edx, 1
פקודהערכים אחרי הפקודהCFמה קרה ולמה
mov edx, 0x7C55B0FFEDX=0x7C55B0FF?DH=0xB0, DL=0xFF
add dl, 1EDX=0x7C55B0001ב-DL, 0xFF ועוד 1 עובר את 255, ו-DL=0x00. DH והחצי העליון לא השתנו
add dx, 1EDX=0x7C55B0010DX=0xB000 ועוד 1 נכנס ב-16 ביט, ו-CF נכתב מחדש ל-0
mov dx, 0xFFFFEDX=0x7C55FFFF0ההצבה ל-DX מחליפה רק את 16 הביטים התחתונים
add dx, 1EDX=0x7C5500001ב-DX, 0xFFFF ועוד 1 עובר את 65,535, ו-DX=0x0000. 0x7C55 נשאר
add edx, 1EDX=0x7C5500010ב-32 ביט אין חריגה

לאורך כל הקטע החצי העליון, 0x7C55, נשאר במקומו. CF נקבע רק לפי הגודל של כל פקודה.

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

מעקב 3: לווה, mov באמצע, ושני חיבורים עד הגבול ומעבר לו

תרחיש 3: CF מתחלף עם כל פקודת חשבון
Assembly
mov bl, 0x02
sub bl, 0x09
mov cl, 0x44
add bl, 0x06
add bl, 1
פקודהערכים אחרי הפקודהCFמה קרה ולמה
mov bl, 0x02BL=0x02?ערך התחלתי, עוד אין דגל
sub bl, 0x09BL=0xF912 < 9, יש לווה: 2 + 256 - 9 = 249 = 0xF9
mov cl, 0x44CL=0x441mov לא נוגעת ב-CF
add bl, 0x06BL=0xFF00xF9 ועוד 6 הם 255, לא מעבר לגבול, ו-add כתבה 0
add bl, 1BL=0x001255 ועוד 1 הם 256, חריגה

בסוף BL=0x00 ו-CF=1. CF עבר את הערכים 1, 1, 0, 1: כל sub ו-add כתבה עליו מחדש, וה-mov עברה לידו בלי לגעת.

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

מעקב 4: גלישות בלי השפעה, ושתי פקודות שכן קובעות

תרחיש 4: ארבע גלישות, ו-CF משתנה רק פעמיים
Assembly
stc
mov edx, 0
dec edx
inc edx
clc
dec edx
inc edx
inc edx
פקודהערכים אחרי הפקודהCFמה קרה ולמה
stc-1CF=1
mov edx, 0EDX=01mov לא כותבת ל-CF
dec edxEDX=0xFFFFFFFF1גלישה מ-0 למטה, ו-dec לא נוגעת ב-CF
inc edxEDX=0x000000001גלישה חזרה ל-0, CF לא זז
clc-0CF=0
dec edxEDX=0xFFFFFFFF0שוב גלישה, CF נשאר 0
inc edxEDX=0x000000000גלישה חזרה ל-0, ו-CF עדיין 0
inc edxEDX=0x000000010גם כאן inc לא נוגעת ב-CF

מתוך שמונה הפקודות, רק stc ו-clc שינו את CF. ה-mov וחמש פקודות ה-inc וה-dec לא נגעו בו, למרות שהאוגר גלש ארבע פעמים.

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

מעקב 5: בדיקת ביט מעבר ל-31 קובעת לאן ממשיכים

תרחיש 5: מודולו 32 ובחירת ענף
Assembly
mov edx, 0x3A
bt edx, 37
jc BIG
add edx, 50
jmp FIN
BIG:
add edx, 150
FIN:
mov ecx, edx
פקודהערכים אחרי הפקודהCFמה קרה ולמה
mov edx, 0x3AEDX=0x3A?0x3A = 0011 1010 = 58
bt edx, 37EDX=0x3A137 mod 32 = 5, וביט 5 של 00111010 דלוק. EDX לא השתנה
jc BIG-1CF=1, קפיצה אל BIG
add edx, 150EDX=0xD0058 ועוד 150 הם 208 = 0xD0, בלי חריגה ב-32 ביט, ו-add כתבה 0
mov ecx, edxECX=0xD00ECX מקבל 208

בסוף ECX=208 (0xD0). השורות add edx, 50 ו-jmp FIN לא בוצעו כלל, כי הקפיצה דילגה עליהן.

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

מעקב 6: add מדליקה, bt מוחקת

תרחיש 6: הנשיאה מהחיבור לא שורדת
Assembly
mov ecx, 0xFFFFFFFE
add ecx, 2
mov edx, 12
bt edx, 0
jc ON
mov ebx, 7
jmp DONE
ON:
mov ebx, 8
DONE:
פקודהערכים אחרי הפקודהCFמה קרה ולמה
mov ecx, 0xFFFFFFFEECX=0xFFFFFFFE?שני צעדים לפני הקצה של 32 ביט
add ecx, 2ECX=0x000000001חריגה מ-32 ביט
mov edx, 12EDX=12 (1100)1mov לא נוגעת ב-CF
bt edx, 0EDX=120ביט 0 של 1100 כבוי, וה-bt מוחקת את ה-1 שהיה
jc ON-0CF=0, אין קפיצה
mov ebx, 7EBX=70הענף של 0
jmp DONE-0דילוג מעל ON

בסוף EBX=7. מי שעצר אחרי החיבור וקבע CF=1 החמיץ את ה-bt שבאה אחריו.

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

מעקב 7: cmp ו-jnc בוחרות את הגדול משניים

תרחיש 7: להשאיר את ECX רק אם הוא לא קטן
Assembly
mov ecx, 15
mov edx, 40
cmp ecx, edx
jnc STAY
mov ecx, edx
STAY:
פקודהערכים אחרי הפקודהCFמה קרה ולמה
mov ecx, 15ECX=15?המועמד הראשון
mov edx, 40EDX=40?המועמד השני
cmp ecx, edxללא שינוי115 < 40, יש לווה
jnc STAY-1jnc קופצת רק כש-CF=0, ולכן אין קפיצה
mov ecx, edxECX=401הגדול מבין השניים הועתק ל-ECX, ו-CF לא השתנה

בסוף ECX=40, הגדול מבין 15 ו-40. הפכו את הנתונים, ECX=60 ו-EDX=40, ותקבלו את הכיוון האחר: 60 לא קטן מ-40, אין לווה, jnc מדלגת ישר אל STAY, ו-ECX שומר על 60 בלי שההעתקה תרוץ.

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

מעקב 8: cmp בשני גדלים, ו-mov לתת-אוגר באמצע

תרחיש 8: אותם אוגרים, שתי תשובות
Assembly
mov ecx, 700
mov edx, 300
cmp ecx, edx
mov cl, 1
mov dl, 9
cmp cl, dl
cmp ecx, edx
פקודהערכים אחרי הפקודהCFמה קרה ולמה
mov ecx, 700ECX=0x2BC?700 = 0x2BC
mov edx, 300EDX=0x12C?300 = 0x12C
cmp ecx, edxללא שינוי0700 >= 300, אין לווה
mov cl, 1ECX=0x2010CL הוחלף מ-0xBC ל-0x01, ו-CH=0x02 נשאר: ECX=513
mov dl, 9EDX=0x1090DL הוחלף מ-0x2C ל-0x09, ו-DH=0x01 נשאר: EDX=265
cmp cl, dlללא שינוי1השוואה של 8 ביט בלבד: 1 < 9, יש לווה
cmp ecx, edxללא שינוי0השוואה של 32 ביט: 513 >= 265, אין לווה

שתי ההשוואות האחרונות פועלות על אותם אוגרים ונותנות CF הפוך, רק בגלל הגודל. jc שהייתה באה מיד אחרי cmp cl, dl הייתה קופצת, ו-jc אחרי cmp ecx, edx לא.

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

מעקב 9: stc, add, clc, sub

תרחיש 9: מי באמת קבע את CF בסוף
Assembly
stc
mov ecx, 3
add ecx, 4
clc
sub ecx, 9
פקודהערכים אחרי הפקודהCFמה קרה ולמה
stc-1CF=1
mov ecx, 3ECX=31mov לא נוגעת ב-CF
add ecx, 4ECX=70אין חריגה: add כתבה 0 ומחקה את ה-stc
clc-0CF=0. הוא כבר היה 0, אבל clc כותבת בכל מקרה
sub ecx, 9ECX=0xFFFFFFFE17 < 9, יש לווה: 7 + 2^32 - 9 = 0xFFFFFFFE

בסוף CF=1, ומי שקבע אותו הוא ה-sub, לא ה-stc שבשורה הראשונה.

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

סיכום

נושאהכלל
addCF=1 כשהסכום האמיתי עובר את הערך העליון של גודל הפעולה (255 ב-8 ביט, 65,535 ב-16, 4,294,967,295 ב-32). אחרת CF=0.
sub, cmpCF=1 כש-a < b בערכים לא מסומנים. בשוויון CF=0 ו-ZF=1. cmp לא שומרת את התוצאה.
inc, decלא משנות את CF, גם כשהאוגר גולש. את ZF הן כן מעדכנות.
movלא משנה שום דגל, ומחליפה רק את החלק של האוגר שנכתב (DL, DX או EDX).
stc, clcstc מציבה CF=1, ו-clc מציבה CF=0.
jc, jncjc קופצת כש-CF=1, ו-jnc כש-CF=0. אף אחת מהן לא משנה את CF.
btCF מקבל את ביט n של האופרנד (סופרים מ-0 מימין, ובאוגר של 32 ביט n mod 32). האופרנד לא משתנה, ו-CF הקודם נמחק.
גודלCF תלוי בגודל הפעולה: add dl לעומת add dx לעומת add edx.
הכותבת האחרונהרק הפקודה האחרונה שכתבה ל-CF (add, sub, cmp, bt, stc, clc) קובעת את ערכו.

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

  • יודעים בדיוק איזו קפיצה מחליטה, ומה היא דורשת: jc צריכה 1, jnc צריכה 0.
  • מצאתם את הכותבת של CF שרצה אחרונה לפניה, בלי לעצור על mov, inc, dec או קפיצות, ובלי לספור שורות שדולגו.
  • חישבתם אותה בגודל הנכון: בחיבור, מעבר לתקרה; בחיסור ובהשוואה, הלוואה; ב-bt, הביט אחרי השארית מ-32.
  • סימנתם את הענף שרץ, והגעתם עד השורה האחרונה שלו.
  • התשובה היא מה שנשאר באוגר שבשאלה בסוף, ולא ערך שעבר בו בדרך.
בדקו את עצמכם
DL=0xFF ו-CF=0. במה שונה CF אחרי add dl, 1 מ-CF אחרי inc dl?

אחרי add dl, 1 CF=1. אחרי inc dl CF נשאר 0, כי inc לא כותבת אליו.

mov ecx, 5, mov edx, 20, cmp ecx, edx, ואחר כך mov ecx, 0x80000000 ו-add ecx, 0x7FFFFFFF. מה CF בסוף?

CF=0. הסכום הוא 0xFFFFFFFF, שנכנס ב-32 ביט, וה-add היא הכותבת האחרונה.

EAX=0x40. האם bt eax, 6 ואחריה jc קופצות?

כן. ביט 6 (משקל 64) דלוק, ולכן CF=1 ו-jc קופצת.

mov cx, 0x000C, mov dx, 0x0004, cmp cx, dx, ואז jnc L. האם קופצים?

כן. 12 אינו קטן מ-4, ולכן CF=0, ו-jnc קופצת בדיוק כש-CF=0.

EDX=0x48. מה ערכו אחרי bt edx, 6?

עדיין 0x48. bt רק קוראת את הביט ומעתיקה אותו ל-CF.