מחשבון קרב - אסמבלי
דגלים (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 לפני הקפיצה, לפי הסדר שבו הקוד רץ באמת.
- תרגול: תשעה מעקבים פתורים ורשימת בדיקה לסיום.
מהו דגל, ומהו 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, clc | stc תמיד מציבה 1, ו-clc תמיד מציבה 0 |
שני מקרים ב-DL, שמחזיק 0 עד 255, מראים שחיבור וחיסור נשלטים כאן באותו עיקרון. 250 ועוד 9 צריכים לתת 259, ו-3 פחות 4 צריכים לתת מינוס 1: בשניהם התשובה המתמטית לא קיימת על הסרגל של 0 עד 255, ולכן CF=1.
לעומת זאת 250 ועוד 5 נותנים 255, ו-4 פחות 3 נותנים 1, ושתי התוצאות נוחתות על הסרגל, ולכן CF=0. השאלה היא תמיד אחת: האם התוצאה האמיתית נשארה בתחום של האוגר?
שלושה עקרונות שילוו אתכם לאורך כל הפרק
- לא כל פקודה כותבת ל-CF. מבין הפקודות שבפרק, אלה שכותבות הן
add,sub,cmp,bt,stcו-clc, וזו כל הרשימה. - ערך הדגל נשמר עד שמישהו כותב עליו.
mov,inc,decוכל הקפיצות עוברות לידו ולא משנות אותו. - גודל הפעולה משנה את התשובה. אותו חיבור בדיוק יכול לתת CF=1 על DL (8 ביט) ו-CF=0 על DX (16 ביט) או על EDX (32 ביט).
ZF, דגל האפס, ומה מבדיל אותו מ-CF
קל לבלבל בין CF לבין שכן שלו ב-EFLAGS, ZF (דגל האפס). ZF עונה על השאלה "האם יצא 0": הוא נדלק כשהתוצאה האחרונה היא אפס, ובהשוואה של שני ערכים שווים, ו-jne קופצת כשהוא כבוי. CF עונה על שאלה אחרת, "האם יצאנו מהתחום", ושתי השאלות לא תלויות זו בזו:
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, DH | 0 עד 255 | 0xFF |
| 16 ביט | AX, BX, CX, DX | 0 עד 65,535 | 0xFFFF |
| 32 ביט | EAX, EBX, ECX, EDX | 0 עד 4,294,967,295 | 0xFFFFFFFF |
מאיפה באים המספרים האלה? כל ביט נוסף מכפיל את מספר הצירופים, כך ש-8 ביטים נותנים 2 בחזקת 8, כלומר 256 צירופים, ו-32 ביטים נותנים יותר מארבעה מיליארד. מכיוון שהספירה מתחילה ב-0, הערך הגבוה ביותר קטן ב-1 ממספר הצירופים: 255, 65,535 ו-4,294,967,295.
חזרה לתוכן הענייניםגלישה: מה קורה לתוצאה שלא נכנסת
נתחיל מחיבור אחד ב-AL, ונראה מה נשאר ממנו:
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:
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.
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.
| hex | bin | hex | bin | hex | bin | hex | bin |
|---|---|---|---|---|---|---|---|
| 0 | 0000 | 4 | 0100 | 8 | 1000 | C | 1100 |
| 1 | 0001 | 5 | 0101 | 9 | 1001 | D | 1101 |
| 2 | 0010 | 6 | 0110 | A | 1010 | E | 1110 |
| 3 | 0011 | 7 | 0111 | B | 1011 | F | 1111 |
טעויות נפוצות
- כש-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: העתקה שלא נוגעת בדגלים
איך קוראים את הפקודה
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):
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 pointerbad.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=9 | mov ecx, 0x1F | ECX=0x1F |
| ECX=0x1F, EDX=4 | mov edx, ecx | EDX=0x1F, ECX=0x1F (המקור לא השתנה) |
| EBX=0xCAFE1234 | mov bl, 0x00 | EBX=0xCAFE1200 |
| EBX=0xCAFE1234 | mov bx, 0x0042 | EBX=0xCAFE0042 |
mov ו-CF: הדגל נשאר במקומו
כאן מסתתר מלכוד שחוזר בשאלות: החיבור הדליק את CF, ואז האוגר של החיבור עצמו נדרס לגמרי. האם הדגל נעלם יחד איתו?
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 כתובה ומה מותר בה
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.
11111110 254
+ 00000011 3
----------
1 00000001 257 > 255 -> CF = 1, AL = 0x01מקרה שני: AL=0xC0 ומבצעים add al, 0x40.
11000000 192
+ 01000000 64
----------
1 00000000 256 > 255 -> CF = 1, AL = 0x00מקרה שלישי: AL=0x3F ומבצעים add al, 0x41. כאן הביט העליון של התוצאה נדלק, אבל שום ביט לא יוצא החוצה.
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, 1 | BL=0xFF | BL=0x00 | 1 |
add bx, 1 | BX=0x00FF | BX=0x0100 | 0 |
add bx, 1 | BX=0xFFFF | BX=0x0000 | 1 |
add ebx, 1 | EBX=0x000000FF | EBX=0x00000100 | 0 |
add ebx, 1 | EBX=0xFFFFFFFF | EBX=0x00000000 | 1 |
add ebx, 0x7FFFFFFF | EBX=0x7FFFFFFF | EBX=0xFFFFFFFE | 0 |
add ebx, 0x10 | EBX=0xFFFFFFF8 | EBX=0x00000008 | 1 |
בשורה האחרונה הסכום האמיתי הוא 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: חיסור ששומר את התוצאה
sub dest, src ; dest = dest - srcהנה ניסוי קטן שמבהיר את ההבדל: ECX=10, ופעם אחת מריצים sub ecx, 4 ופעם אחרת cmp ecx, 4. אחרי sub ב-ECX יש 6, וגם ZF ו-CF עודכנו לפי החיסור. חוקי האופרנדים הם של add: גדלים תואמים, ולכל היותר אופרנד אחד בזיכרון.
cmp: חיסור שנזרק
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:
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 ביט
| פקודה | ערכים | מה נבדק | CF | ZF |
|---|---|---|---|---|
cmp ecx, edx | ECX=4, EDX=9 | 4 < 9, יש לווה | 1 | 0 |
cmp ecx, edx | ECX=900, EDX=40 | 900 > 40 | 0 | 0 |
cmp ecx, edx | ECX=12, EDX=12 | ערכים שווים | 0 | 1 |
cmp cl, dl | CL=1, DL=8 | 1 < 8, יש לווה | 1 | 0 |
sub edx, 9 | EDX=8 | 8 < 9, ו-EDX הופך ל-0xFFFFFFFF | 1 | 0 |
השוואה של תת-אוגר רואה רק אותו
ECX יכול להיות ענק ו-CL שלו אפס, כמו בקוד הבא. cmp cl, dl רואה רק את 8 הביטים התחתונים של כל צד, ולכן התשובה שלה עלולה להיות הפוכה מזו של cmp ecx, edx על אותם אוגרים, ו-CF נקבע לפי מי מהן רצה אחרונה.
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
איך הן כתובות ומה הן מחשבות
inc dest ; dest = dest + 1
dec dest ; dest = dest - 1אלה צעד קדימה וצעד אחורה, ולכן אין להן מקור: הן מקבלות רק את מה שמשנים, אוגר או מקום בזיכרון שהגודל שלו כתוב, כמו inc dword [hits]. גם הן מסתובבות במעגל של 2 בחזקת n:
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. לולאה שסופרת לאחור נשענת בדיוק על זה:
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=0 | add bl, 1 | BL=0x00 | 1 (add קבעה) |
| BL=0xFF, CF=0 | inc bl | BL=0x00 | 0 (לא השתנה) |
| BL=0x10, CF=1 | add bl, 1 | BL=0x11 | 0 (add קבעה) |
| BL=0x10, CF=1 | inc bl | BL=0x11 | 1 (לא השתנה) |
| ECX=0, CF=0 | dec ecx | ECX=0xFFFFFFFF | 0 (לא השתנה) |
| ECX=0, CF=0 | sub ecx, 1 | ECX=0xFFFFFFFF | 1 (sub קבעה) |
זו בדיוק נקודת המבחן: איזו פקודה שגולשת מעדכנת את CF, ואיזו גולשת ומשאירה אותו כמו שהיה.
חזרה לתוכן הענייניםדוגמה: CF מחזיק מעמד מול inc ו-dec
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 1inc 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: להרים את הדגל
stc ; CF = 1 (SeT Carry)אין לה מה לקבל, ולכן היא נכתבת לבד בשורה. התוצאה תמיד CF=1, בין שהדגל היה דלוק ובין שלא, ושום אוגר או דגל אחר לא מושפע.
חזרה לתוכן הענייניםclc: להוריד את הדגל
clc ; CF = 0 (CLear Carry)תמונת הראי של stc: גם היא עומדת לבד, והתוצאה שלה תמיד CF=0, יהיה הערך הקודם אשר יהיה.
כשהן פוגשות את שאר הפקודות
לא כדאי לחשוב על stc ו-clc כעל פקודות מיוחדות. הן עוד שתי כותבות של CF, בדיוק כמו add או bt, ולכן כשהן מופיעות בקוד שאלה אחת מכריעה: מי כתב אחרון.
| רצף | CF בסוף | הסיבה |
|---|---|---|
stc / mov ecx, 9 / cmp ecx, 3 | 0 | 9 אינו קטן מ-3, וה-cmp כתבה 0 אחרי ה-stc |
mov bl, 0xFF / add bl, 1 / clc | 0 | החיבור גלש והדליק, וה-clc שאחריו הורידה |
clc / mov ecx, 0xFFFFFFFF / inc ecx | 0 | ECX גולש ל-0, אבל inc לא כותבת, ונשאר ה-0 של clc |
stc / mov edx, 4 / dec edx | 1 | dec לא כותבת, ונשאר ה-1 של stc |
clc / mov edx, 2 / bt edx, 1 | 1 | ביט 1 של 2 (10) דלוק, וה-bt כתבה אחרי ה-clc |
clc / stc | 1 | stc אחרונה |
stc / clc | 0 | clc אחרונה |
טעויות נפוצות
- אחרי
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
מה הן בודקות ולאן הן הולכות
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
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:- פקודה כלשהי כותבת ל-CF (כאן
bt). jc ONבודקת את CF.- אם CF=1, הביצוע עובר ל-ON ומבצע את הענף של 1.
- אם 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 ברגע הקפיצה | jc | jnc |
|---|---|---|
| 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 עושה
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), וכל צעד שמאלה מכפיל את המשקל.
| ביט | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
|---|---|---|---|---|---|---|---|---|
| משקל | 128 | 64 | 32 | 16 | 8 | 4 | 2 | 1 |
| 0x24 = 00100100 | 0 | 0 | 1 | 0 | 0 | 1 | 0 | 0 |
ב-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 ביט) |
|---|---|---|
| 2 | 2 | 00000010 |
| 3 | 2 + 1 | 00000011 |
| 5 | 4 + 1 | 00000101 |
| 9 | 8 + 1 | 00001001 |
| 12 | 8 + 4 | 00001100 |
| 15 | 8 + 4 + 2 + 1 | 00001111 |
| 20 | 16 + 4 | 00010100 |
| 36 | 32 + 4 | 00100100 |
| 44 | 32 + 8 + 4 | 00101100 |
דוגמה ראשונה: 11. המשקל הגדול שנכנס הוא 8, ונשארים 3. ב-3 נכנס 2, ונשאר 1, שהוא בעצמו משקל.
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.
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, 31 | 31 | ביט 31, העליון |
bt edx, 32 | 0 | ביט 0 |
bt edx, 33 | 1 | ביט 1 |
bt edx, 36 | 4 | ביט 4 |
bt edx, 63 | 31 | ביט 31 |
bt edx, 64 | 0 | ביט 0 |
bt edx, 70 | 6 | ביט 6 |
השורה של 32 היא המלכודת הנפוצה: מי שחושב שאין ביט כזה ולכן CF=0 טועה, כי בפועל נבדק ביט 0. את השארית מוצאים בלי חילוק: מחסירים מ-n את הכפולה הגדולה של 32 שלא עוברת אותו (32, 64, 96...), ומה שנשאר הוא מספר הביט.
חזרה לתוכן הענייניםדוגמה מלאה: כמה bt על אותו אוגר
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| פקודה | הביט שנבדק | ערך הביט | CF | EDX |
|---|---|---|---|---|
mov edx, 0x48 | - | - | לא השתנה | 0x48 |
bt edx, 3 | ביט 3 | 1 | 1 | 0x48 |
bt edx, 4 | ביט 4 | 0 | 0 | 0x48 |
bt edx, 6 | ביט 6 | 1 | 1 | 0x48 |
bt edx, 70 | 70 mod 32 = 6 | 1 | 1 | 0x48 |
טעויות נפוצות
- סופרים ביטים משמאל, או מתחילים מ-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) |
stc | cmp שבה הראשון גדול | ה-cmp (CF=0) |
clc | bt על ביט דלוק | ה-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 שהדליקה CF | mov שדורסת את שני האוגרים | ה-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 שלא נוגעת
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, 6 | ECX=6 | ? | עוד לא נכתב אף דגל |
mov edx, 11 | EDX=11 | ? | mov לא כותבת דגלים |
cmp ecx, edx | ללא שינוי | 1 | 6 < 11, יש לווה |
mov ecx, 0x7FFFFFF0 | ECX=0x7FFFFFF0 | 1 | ECX הוחלף, CF נשאר |
add ecx, 0x0F | ECX=0x7FFFFFFF | 0 | הסכום 2,147,483,647 נכנס ב-32 ביט, ו-add כתבה 0 |
inc ecx | ECX=0x80000000 | 0 | inc לא כותבת ל-CF |
jc HIGH | - | 0 | CF=0, אין קפיצה |
mov ebx, 3 | EBX=3 | 0 | הענף של CF=0 |
jmp DONE | - | 0 | דילוג מעל HIGH |
בסוף EBX=3. ה-cmp אמנם הדליקה את CF, אבל ה-add שאחריה כתבה עליו 0, וה-inc לא שינתה את זה.
מעקב 2: חיבור של 1 בשלושה גדלים (DL, DX, EDX)
תרחיש 2: החצי העליון של EDX לא זז
mov edx, 0x7C55B0FF
add dl, 1
add dx, 1
mov dx, 0xFFFF
add dx, 1
add edx, 1| פקודה | ערכים אחרי הפקודה | CF | מה קרה ולמה |
|---|---|---|---|
mov edx, 0x7C55B0FF | EDX=0x7C55B0FF | ? | DH=0xB0, DL=0xFF |
add dl, 1 | EDX=0x7C55B000 | 1 | ב-DL, 0xFF ועוד 1 עובר את 255, ו-DL=0x00. DH והחצי העליון לא השתנו |
add dx, 1 | EDX=0x7C55B001 | 0 | DX=0xB000 ועוד 1 נכנס ב-16 ביט, ו-CF נכתב מחדש ל-0 |
mov dx, 0xFFFF | EDX=0x7C55FFFF | 0 | ההצבה ל-DX מחליפה רק את 16 הביטים התחתונים |
add dx, 1 | EDX=0x7C550000 | 1 | ב-DX, 0xFFFF ועוד 1 עובר את 65,535, ו-DX=0x0000. 0x7C55 נשאר |
add edx, 1 | EDX=0x7C550001 | 0 | ב-32 ביט אין חריגה |
לאורך כל הקטע החצי העליון, 0x7C55, נשאר במקומו. CF נקבע רק לפי הגודל של כל פקודה.
מעקב 3: לווה, mov באמצע, ושני חיבורים עד הגבול ומעבר לו
תרחיש 3: CF מתחלף עם כל פקודת חשבון
mov bl, 0x02
sub bl, 0x09
mov cl, 0x44
add bl, 0x06
add bl, 1| פקודה | ערכים אחרי הפקודה | CF | מה קרה ולמה |
|---|---|---|---|
mov bl, 0x02 | BL=0x02 | ? | ערך התחלתי, עוד אין דגל |
sub bl, 0x09 | BL=0xF9 | 1 | 2 < 9, יש לווה: 2 + 256 - 9 = 249 = 0xF9 |
mov cl, 0x44 | CL=0x44 | 1 | mov לא נוגעת ב-CF |
add bl, 0x06 | BL=0xFF | 0 | 0xF9 ועוד 6 הם 255, לא מעבר לגבול, ו-add כתבה 0 |
add bl, 1 | BL=0x00 | 1 | 255 ועוד 1 הם 256, חריגה |
בסוף BL=0x00 ו-CF=1. CF עבר את הערכים 1, 1, 0, 1: כל sub ו-add כתבה עליו מחדש, וה-mov עברה לידו בלי לגעת.
מעקב 4: גלישות בלי השפעה, ושתי פקודות שכן קובעות
תרחיש 4: ארבע גלישות, ו-CF משתנה רק פעמיים
stc
mov edx, 0
dec edx
inc edx
clc
dec edx
inc edx
inc edx| פקודה | ערכים אחרי הפקודה | CF | מה קרה ולמה |
|---|---|---|---|
stc | - | 1 | CF=1 |
mov edx, 0 | EDX=0 | 1 | mov לא כותבת ל-CF |
dec edx | EDX=0xFFFFFFFF | 1 | גלישה מ-0 למטה, ו-dec לא נוגעת ב-CF |
inc edx | EDX=0x00000000 | 1 | גלישה חזרה ל-0, CF לא זז |
clc | - | 0 | CF=0 |
dec edx | EDX=0xFFFFFFFF | 0 | שוב גלישה, CF נשאר 0 |
inc edx | EDX=0x00000000 | 0 | גלישה חזרה ל-0, ו-CF עדיין 0 |
inc edx | EDX=0x00000001 | 0 | גם כאן inc לא נוגעת ב-CF |
מתוך שמונה הפקודות, רק stc ו-clc שינו את CF. ה-mov וחמש פקודות ה-inc וה-dec לא נגעו בו, למרות שהאוגר גלש ארבע פעמים.
מעקב 5: בדיקת ביט מעבר ל-31 קובעת לאן ממשיכים
תרחיש 5: מודולו 32 ובחירת ענף
mov edx, 0x3A
bt edx, 37
jc BIG
add edx, 50
jmp FIN
BIG:
add edx, 150
FIN:
mov ecx, edx| פקודה | ערכים אחרי הפקודה | CF | מה קרה ולמה |
|---|---|---|---|
mov edx, 0x3A | EDX=0x3A | ? | 0x3A = 0011 1010 = 58 |
bt edx, 37 | EDX=0x3A | 1 | 37 mod 32 = 5, וביט 5 של 00111010 דלוק. EDX לא השתנה |
jc BIG | - | 1 | CF=1, קפיצה אל BIG |
add edx, 150 | EDX=0xD0 | 0 | 58 ועוד 150 הם 208 = 0xD0, בלי חריגה ב-32 ביט, ו-add כתבה 0 |
mov ecx, edx | ECX=0xD0 | 0 | ECX מקבל 208 |
בסוף ECX=208 (0xD0). השורות add edx, 50 ו-jmp FIN לא בוצעו כלל, כי הקפיצה דילגה עליהן.
מעקב 6: add מדליקה, bt מוחקת
תרחיש 6: הנשיאה מהחיבור לא שורדת
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, 0xFFFFFFFE | ECX=0xFFFFFFFE | ? | שני צעדים לפני הקצה של 32 ביט |
add ecx, 2 | ECX=0x00000000 | 1 | חריגה מ-32 ביט |
mov edx, 12 | EDX=12 (1100) | 1 | mov לא נוגעת ב-CF |
bt edx, 0 | EDX=12 | 0 | ביט 0 של 1100 כבוי, וה-bt מוחקת את ה-1 שהיה |
jc ON | - | 0 | CF=0, אין קפיצה |
mov ebx, 7 | EBX=7 | 0 | הענף של 0 |
jmp DONE | - | 0 | דילוג מעל ON |
בסוף EBX=7. מי שעצר אחרי החיבור וקבע CF=1 החמיץ את ה-bt שבאה אחריו.
מעקב 7: cmp ו-jnc בוחרות את הגדול משניים
תרחיש 7: להשאיר את ECX רק אם הוא לא קטן
mov ecx, 15
mov edx, 40
cmp ecx, edx
jnc STAY
mov ecx, edx
STAY:| פקודה | ערכים אחרי הפקודה | CF | מה קרה ולמה |
|---|---|---|---|
mov ecx, 15 | ECX=15 | ? | המועמד הראשון |
mov edx, 40 | EDX=40 | ? | המועמד השני |
cmp ecx, edx | ללא שינוי | 1 | 15 < 40, יש לווה |
jnc STAY | - | 1 | jnc קופצת רק כש-CF=0, ולכן אין קפיצה |
mov ecx, edx | ECX=40 | 1 | הגדול מבין השניים הועתק ל-ECX, ו-CF לא השתנה |
בסוף ECX=40, הגדול מבין 15 ו-40. הפכו את הנתונים, ECX=60 ו-EDX=40, ותקבלו את הכיוון האחר: 60 לא קטן מ-40, אין לווה, jnc מדלגת ישר אל STAY, ו-ECX שומר על 60 בלי שההעתקה תרוץ.
מעקב 8: cmp בשני גדלים, ו-mov לתת-אוגר באמצע
תרחיש 8: אותם אוגרים, שתי תשובות
mov ecx, 700
mov edx, 300
cmp ecx, edx
mov cl, 1
mov dl, 9
cmp cl, dl
cmp ecx, edx| פקודה | ערכים אחרי הפקודה | CF | מה קרה ולמה |
|---|---|---|---|
mov ecx, 700 | ECX=0x2BC | ? | 700 = 0x2BC |
mov edx, 300 | EDX=0x12C | ? | 300 = 0x12C |
cmp ecx, edx | ללא שינוי | 0 | 700 >= 300, אין לווה |
mov cl, 1 | ECX=0x201 | 0 | CL הוחלף מ-0xBC ל-0x01, ו-CH=0x02 נשאר: ECX=513 |
mov dl, 9 | EDX=0x109 | 0 | DL הוחלף מ-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 בסוף
stc
mov ecx, 3
add ecx, 4
clc
sub ecx, 9| פקודה | ערכים אחרי הפקודה | CF | מה קרה ולמה |
|---|---|---|---|
stc | - | 1 | CF=1 |
mov ecx, 3 | ECX=3 | 1 | mov לא נוגעת ב-CF |
add ecx, 4 | ECX=7 | 0 | אין חריגה: add כתבה 0 ומחקה את ה-stc |
clc | - | 0 | CF=0. הוא כבר היה 0, אבל clc כותבת בכל מקרה |
sub ecx, 9 | ECX=0xFFFFFFFE | 1 | 7 < 9, יש לווה: 7 + 2^32 - 9 = 0xFFFFFFFE |
בסוף CF=1, ומי שקבע אותו הוא ה-sub, לא ה-stc שבשורה הראשונה.
טעויות נפוצות
- מספיק למצוא את הפקודה הראשונה שכתבה ל-CF. תמיד בדקו מה בוצע אחריה. כל כותבת נוספת עד הקפיצה מחליפה את הערך.
- ערך שאוגר החזיק באמצע הריצה הוא התשובה. עונים במה שנמצא באוגר שבשאלה ברגע שהריצה נגמרה, כלומר אחרי שהענף שנבחר רץ עד סופו.
- כל השורות שכתובות בקוד בוצעו. קפיצה שהתבצעה מדלגת על שורות, ומה שבשורות האלה לא השפיע על שום דבר.
סיכום
| נושא | הכלל |
|---|---|
add | CF=1 כשהסכום האמיתי עובר את הערך העליון של גודל הפעולה (255 ב-8 ביט, 65,535 ב-16, 4,294,967,295 ב-32). אחרת CF=0. |
sub, cmp | CF=1 כש-a < b בערכים לא מסומנים. בשוויון CF=0 ו-ZF=1. cmp לא שומרת את התוצאה. |
inc, dec | לא משנות את CF, גם כשהאוגר גולש. את ZF הן כן מעדכנות. |
mov | לא משנה שום דגל, ומחליפה רק את החלק של האוגר שנכתב (DL, DX או EDX). |
stc, clc | stc מציבה CF=1, ו-clc מציבה CF=0. |
jc, jnc | jc קופצת כש-CF=1, ו-jnc כש-CF=0. אף אחת מהן לא משנה את CF. |
bt | CF מקבל את ביט 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.