מחשבון קרב - אסמבלי
תנאים ו-labels
שימוש ב-cmp וקפיצות מותנות כמו jne יחד עם labels, ומעקב אחרי הערך הסופי באוגר.
בחרו את הרמה שמתאימה לכם ואת הסט שתרצו לתרגל
חומר לימוד
תנאים ו-labels: השוואה, דגל האפס וקפיצות באסמבלי x86
הפרק עוסק ברגע שבו תוכנית באסמבלי בוחרת בין שתי דרכים: להריץ קטע קוד או לעקוף אותו, לפי תוצאה של בדיקה.
- cmp: הפקודה שמעמידה שני ערכים זה מול זה ומשאירה את התשובה בדגל.
- ZF, דגל האפס: הביט שמעביר את תשובת ההשוואה אל פקודת הקפיצה.
- jne ו-jmp: קפיצה שתלויה בדגל, וקפיצה שמתבצעת תמיד.
- labels (תוויות): השמות שמסמנים לאן קופצים.
- הכלים שבלעדיהם אי אפשר לעקוב אחרי הקוד: אוגרים ותתי אוגרים, והפקודות
mov,add,sub,incו-dec.
בכל פקודה נעצור על ארבע שאלות: מה התחביר שלה, מה מותר לשים בה, מה היא משאירה אחריה באוגרים ובדגל, ואיך דוגמה קצרה עוברת דרכה שורה אחר שורה. אין צורך בידע מוקדם באסמבלי.
למה זה חשוב גם מעבר לשאלות האלה? בשלב הסדנא המעשית, במבחן מחשבון הקרב, תכתבו קוד למעבד אחר בשפה שהומצאה לצורך המבחן. מה שעובר משם לכאן הוא המיומנות עצמה: לקרוא קוד לאט, פקודה אחרי פקודה, ולדעת בכל רגע מה יש בכל אוגר.
איך המעבד מתקדם בקוד. בתוך המעבד יש אוגר אחד שתפקידו לסמן 'איפה אנחנו': EIP (Instruction Pointer, מצביע ההוראה). הוא מצביע תמיד על הפקודה הבאה בתור, ובכל פעם שפקודה מסתיימת הוא זז מעצמו לזו שכתובה מתחתיה, כך שהביצוע עובר פקודה אחת בכל פעם, לפי סדר הכתיבה.
תוכנית בלי קפיצות דומה למסילת רכבת בלי פיצולים: היא עוברת תמיד באותן תחנות, ולכן מגיעה תמיד לאותה תוצאה. כדי להגיב לנתונים, למשל לפעול בדרך אחת כשמונה הגיע ל-10 ובדרך אחרת כשלא, צריך אמצעי לשנות את הסדר.
מה שמשנה את הסדר הוא פקודה שכותבת בעצמה ערך חדש ל-EIP, וזו בדיוק ההגדרה של קפיצה. בפרק הזה תפגשו שתיים: jne, שכותבת ל-EIP רק כשמתקיים תנאי, ו-jmp, שעושה זאת בלי לשאול שום דבר.
מי שמחפש ב-x86 פקודת if לא ימצא אותה. במקומה עובד צמד: קודם cmp בודקת ומשאירה סימן בדגל, ומיד אחריה jne מעיינת בסימן ובוחרת לאן להמשיך.
cmp ecx, 12 ; stage 1: compare and leave the answer in ZF
jne OTHER ; stage 2: look at ZF, then either jump to OTHER or fall throughמה בודקות השאלות. השאלה עצמה כמעט לא משתנה: מה יהיה ערכו של אוגר מסוים כשקטע קוד קצר יסיים לרוץ.
גם אבני הבניין של הקטע חוזרות. השוואה פותחת, קפיצה מותנית מכוונת אל תווית, ושורה או שתיים שגורלן תלוי בקפיצה יושבות ביניהן; מתחת לתווית מחכה עוד פקודה שסוגרת את הקוד. מה שמפריד בין שאלה קלה לקשה הוא מה שממלא את השורות האלה:
| דרגה | מה תראו בקוד | מה נדרש מכם |
|---|---|---|
| קלה | אוגרים שלמים של 32 ביט (eax, ebx, edx) ומספרים קטנים, עשרוניים או הקסדצימליים | לקבוע אם jne קופצת, ולחבר ולחסר נכון |
| בינונית | השוואות ופעולות על תתי אוגרים (al, ah, bl, dx ודומיהם), בהקסדצימלי | לזהות באיזה חלק של האוגר נוגעת כל פקודה, ולטפל בגלישה בתוך החלק |
| קשה | גם העתקה בין שני חצאי אוגר (כמו mov ah, al), ולפעמים add או sub שמופיעה בין cmp ל-jne | לעקוב שורה אחר שורה ולזהות איזו פקודה קבעה את הדגל ברגע הקפיצה |
כל שורה בקטע כזה מעוררת אחת מחמש שאלות, וכל אחת מהן מקבלת בהמשך פרק משלה:
- לאיזה חלק של האוגר נכתב הערך? (אוגרים ותתי אוגרים)
- מה הפקודה עושה לערך? (
mov,add,sub,inc,dec) - האם ההשוואה מצאה שוויון, ומה נרשם בדגל? (
cmpו-ZF) - האם קופצים? (
jne) - לאן קופצים, ומה רץ בכל מקרה? (תוויות,
jmp, if ו-else)
מספרים בהקסדצימלי. כשמספר פותח ב-0x, הוא כתוב בבסיס 16, ולכן ספרה אחת יכולה לייצג ערכים עד 15. כדי שיהיו מספיק סימנים, אחרי 9 ממשיכים באותיות: A=10, B=11, C=12, D=13, E=14, F=15.
כל מקום של ספרה שווה פי 16 מהמקום שמימינו. לכן ב-0x4C ה-4 שוקלת ארבע פעמים 16, ה-C מוסיפה 12, ויחד מתקבל 76. אפסים שנוספים משמאל, כמו ב-0x004C או ב-0x0000004C, משאירים את המספר 76; האורך רק רומז לאוגר שבו הוא יושב.
| כתיב הקסדצימלי | חישוב | ערך עשרוני |
|---|---|---|
| 0x0C | 12 | 12 |
| 0x11 | 1×16 + 1 | 17 |
| 0x19 | 1×16 + 9 | 25 |
| 0x28 | 2×16 + 8 | 40 |
| 0x3E | 3×16 + 14 | 62 |
| 0x40 | 4×16 + 0 | 64 |
| 0x64 | 6×16 + 4 | 100 |
| 0x80 | 8×16 + 0 | 128 |
| 0xC8 | 12×16 + 8 | 200 |
| 0xFF | 15×16 + 15 | 255 |
גם החשבון לא דורש כלים חדשים. מחברים ומחסרים בעמודות כמו בבית הספר, וההבדל היחיד הוא שעמודה 'מתמלאת' ב-16 במקום ב-10, ושם נוצרת נשיאה או נדרשת הלוואה:
- 0x40 + 0x07 = 0x47: הספרה הימנית עולה מ-0 ל-7, ואין נשיאה.
- 0x1F + 0x01 = 0x20: F ועוד 1 הם 16, כלומר 0 בעמודה ונשיאה של 1 שמעלה את ה-1 השמאלי ל-2.
- 0x90 - 0x30 = 0x60: 9 פחות 3 בעמודה השמאלית.
- 0xE0 - 0x40 = 0xA0: 14 פחות 4 הם 10, שנכתב A.
- 0x50 - 0x03 = 0x4D: כאן צריך הלוואה. בעשרוני זה 80 פחות 3, כלומר 77, ו-77 הוא 4×16 + 13, כלומר 0x4D.
אין חובה לחשב ישירות בבסיס 16. מי שבטוח יותר בעשרוני יכול לתרגם את שני המספרים, לבצע את הפעולה ולתרגם את התוצאה בחזרה. ההרגל הזה משתלם גם משום שלא פעם המספרים בקוד הקסדצימליים והתשובות עשרוניות, או ההפך.
טעויות נפוצות
- 0x3C הוא פשוט הספרה 3 ולצדה האות C. זה מספר אחד בבסיס 16: 3×16 + 12, כלומר 60.
- המעבד רשאי לבצע את השורות בסדר שנוח לו. בלי קפיצה הביצוע עובר שורה אחרי שורה מלמעלה למטה. רק קפיצה מזיזה את EIP למקום אחר.
cmpלבדה כבר מדלגת על קוד כשהערכים שונים.cmpרק רושמת תוצאה בדגל. את סדר הביצוע משנה רק פקודת קפיצה, כמוjne, שבאה אחריה.
בדקו את עצמכם
כמה הוא 0x2E בעשרוני?
2×16 + 14 = 46.
כמה הוא 0x3D + 0x05?
0x42. בעמודה הימנית D (13) ועוד 5 הם 18, כלומר 2 ונשיאה של 1, וה-3 עולה ל-4.
אוגרים ותתי אוגרים
אוגר: תא האחסון של המעבד
לפני השוואות וקפיצות צריך כלי עבודה אחד מדויק: לדעת לאן בדיוק נכנס כל ערך. בשאלות של הנושא הערכים יושבים באוגרים, ולעתים קרובות רק בחלק של אוגר.
איפה נשמרים מספרים בזמן החישוב? הזיכרון הראשי גדול אבל רחוק מהמעבד, ולכן יש למעבד גם כמה תאים קטנים משלו, בתוכו ממש, שהגישה אליהם כמעט מיידית. אלה האוגרים (registers): כל אחד מחזיק מספר אחד, והפקודות קוראות אותו וכותבות לו ישירות.
במצב 32 ביט עומדים לרשותכם שמונה אוגרים לשימוש כללי. בשאלות של הנושא מופיעים רק ארבעה מהם, eax, ebx, ecx ו-edx; ארבעת האחרים הם esi, edi, ebp ו-esp.
כשתראו ערך כמו 0x0BADF00D, ספרו את הספרות: יש שמונה, כי כל ספרה הקסדצימלית מכסה 4 ביטים, ואוגר כמו eax רוחבו 32 ביט.
חזרה לתוכן הענייניםחלקי האוגר: AX, AH ו-AL
אוגר של 32 ביט אינו יחידה אחת סגורה: לחלקים שלו יש שמות משלהם, והם נקראים תתי אוגרים. ב-eax, ax הוא החצי התחתון (ביטים 0 עד 15), ובתוכו ah הוא הבית העליון (ביטים 8 עד 15) ו-al הבית התחתון (ביטים 0 עד 7). בעמוד הזה נקרא להם גם 'חלקים של אוגר'.
אותה חלוקה קיימת גם בשלושת האחרים: ebx מתחלק ל-bx, bh ו-bl, ecx ל-cx, ch ו-cl, ו-edx ל-dx, dh ו-dl.
| ביטים 31 עד 16 | ביטים 15 עד 8 | ביטים 7 עד 0 |
|---|---|---|
| לחצי הזה אין שם נפרד | AH | AL |
אפשר לחשוב על זה כעל בובות מטריושקה: ah ו-al יושבים בתוך ax, ו-ax יושב בתוך eax. לכן שינוי ב-al משנה גם את מה שתקראו מ-ax ומ-eax.
הדרך המהירה לפרק ערך הקסדצימלי: ספרו זוגות של ספרות מימין לשמאל, כי כל זוג הוא בית (byte). הזוג הראשון מימין שייך ל-al, הזוג השני ל-ah, ושני הזוגות יחד נותנים את ax.
| ערך האוגר eax | ax | ah | al |
|---|---|---|---|
| 0xCAFEBABE | 0xBABE | 0xBA | 0xBE |
| 0x00004500 | 0x4500 | 0x45 | 0x00 |
| 0x00009ABC | 0x9ABC | 0x9A | 0xBC |
| 0x00000041 | 0x0041 | 0x00 | 0x41 |
ומה עם ארבעת האוגרים האחרים? esi, edi, ebp ו-esp מציעים רק חצי של 16 ביט (si, di, bp, sp), בלי שמות לבתים בודדים, ובשאלות של הנושא הם לא מופיעים.
חזרה לתוכן הענייניםכתיבה לחלק של אוגר
בכל שורה שאלו את עצמכם: אילו ביטים מכסה השם שכתוב בפקודה? רק הם יכולים להשתנות, וכל השאר נשמר כפי שהיה. על הכלל הזה נשענות רוב השאלות בנושא.
בכל שורה בטבלה, ebx מתחיל מאותו ערך, 0xA1B2C3D4:
| פקודה | מה נכתב | ebx אחרי הפקודה |
|---|---|---|
mov bl, 0x07 | רק הבית bl | 0xA1B2C307 |
mov bh, 0x07 | רק הבית bh | 0xA1B207D4 |
mov bx, 0x0707 | 16 הביטים הנמוכים; החצי העליון 0xA1B2 לא זז | 0xA1B20707 |
mov ebx, 0x07 | האוגר כולו, ולכן גם החצי העליון מתאפס | 0x00000007 |
העיקרון לא מוגבל להעתקה; הוא חל על כל פקודה שכותבת לאוגר. הטבלה בחלק הבא מראה אותו בפעולה עם add ועם sub.
גלישה שנשארת בתוך החלק
תת אוגר של 8 ביט מכיל מספרים מ-0x00 עד 0xFF בלבד. חשבון שחורג מהגבולות האלה מתנהג כמו מד מרחק ישן ברכב, שאחרי 999999 מציג שוב 000000; במונחים מתמטיים, התוצאה נלקחת מודולו 256.
החשוב מכול: מה שנשפך מעבר לקצה פשוט נעלם. הוא לא מטפטף אל תת האוגר הסמוך, ולכן גלישה של dl לא מזיזה את dh אפילו בביט אחד.
| רוחב | הערך הגבוה ביותר | הגבוה ביותר ועוד 1 | 0 פחות 1 |
|---|---|---|---|
| 8 ביט | 0xFF | 0x00 | 0xFF |
| 16 ביט | 0xFFFF | 0x0000 | 0xFFFF |
| 32 ביט | 0xFFFFFFFF | 0x00000000 | 0xFFFFFFFF |
בחיסור מתחת לאפס עוזר לדמיין ספרה נוספת משמאל, שממנה לווים. ב-8 ביט, 0x00 פחות 1 מחושב כמו 0x100 פחות 1.
מכאן שאי אפשר לחשב בלי להסתכל על שם האוגר בפקודה: הגודל שלו, שבעמוד הזה נקרא גם הרוחב שלו, קובע איפה נמצא הקצה. הנה אותו ערך התחלתי תחת חמש פקודות:
| ערך התחלתי | פקודה | ערך סופי | מה קרה |
|---|---|---|---|
| edx = 0x000001FF | add dl, 1 | edx = 0x00000100 | dl גלש ל-0x00, ו-dh נשאר 0x01 |
| edx = 0x000001FF | add dx, 1 | edx = 0x00000200 | ב-16 ביט יש מקום לנשיאה, והיא מעלה את dh ל-0x02 |
| edx = 0x000001FF | add edx, 1 | edx = 0x00000200 | האוגר השלם, אותה תוצאה |
| edx = 0x00000100 | sub dl, 1 | edx = 0x000001FF | dl גלש למטה ל-0xFF, ו-dh לא נתן הלוואה |
| edx = 0x00000100 | sub dx, 1 | edx = 0x000000FF | ב-16 ביט ההלוואה נלקחת מ-dh, שיורד ל-0x00 |
שני אופרנדים, רוחב אחד
כשפקודה מקבלת שני אופרנדים, האסמבלר דורש ששניהם יהיו באותו גודל. הוא לא מרחיב בית לשני בתים ולא מקצץ, אלא פשוט מסרב לתרגם את השורה.
| פקודה | מתקבלת? | הסיבה |
|---|---|---|
mov cl, dl | כן | 8 ביט ו-8 ביט |
mov cl, dh | כן | 8 מול 8; מותר לערבב משפחות שונות ולקחת גם מהבית העליון |
mov ch, cl | כן | 8 מול 8: העתקה מ-cl אל ch |
mov cx, dx | כן | 16 מול 16 |
mov cx, dl | לא | 16 ביט מול 8 ביט |
mov ecx, dx | לא | 32 ביט מול 16 ביט |
את ההודעה האמיתית ש-NASM נותן על שורה כזאת, ועל עוד כמה צורות אסורות, תראו בפרק הבא.
טעויות נפוצות
sub dl, 0x20מקטינה את edx כולו ב-0x20. הפקודה עובדת רק על dl. הבית dh והחצי העליון של edx לא משתתפים בה בכלל.- בכתיבה ל-bx או ל-bl, שאר ebx מתאפס. רק כתיבה לאוגר השלם, ebx, נוגעת בכל 32 הביטים. כתיבה לחלק משאירה את השאר בדיוק כפי שהיה.
- השם ah מתאר את שתי הספרות השמאליות של eax. ah הוא הבית השני מימין. ב-0x00004500 הוא 0x45, ולא 0x00.
- גלישה של dl מוסיפה 1 ל-dh, כמו נשיאה בחיבור רגיל. גלישה נשארת בתוך החלק שכתוב בפקודה. אם bl=0xFF ומבצעים
add bl, 1, מתקבל bl=0x00 ו-bh נשאר כמו שהיה.
בדקו את עצמכם
ecx = 0x89ABCDEF. מה ערכם של cx, ch ו-cl?
cx=0xCDEF, ch=0xCD, cl=0xEF.
edx = 0x1234FFFF, ומבצעים add dx, 1. מה ערך edx?
0x12340000. dx גולש מ-0xFFFF ל-0x0000, ו-0x1234 שבחצי העליון נשאר במקומו.
האם האסמבלר יקבל mov bx, al? ואם לא, איך מתקנים?
לא, כי bx ברוחב 16 ביט ו-al ברוחב 8 ביט. אם המטרה היא להעתיק בית אחד, כותבים mov bl, al, ששני צדדיה ברוחב 8 ביט.
הפקודות mov, add, sub, inc, dec
mov: העתקת ערך
שלוש פקודות עושות כמעט את כל העבודה בשאלות: mov, add ו-sub. הן אלה שמשנות ערכים, והקפיצות רק מחליטות אילו מהן ירוצו, ולכן כדאי להכיר אותן היטב לפני שממשיכים.
בשלושתן, וגם בשאר הפקודות בפרק, היעד בא לפני המקור. mov dest, src מקבילה להשמה dest = src בשפה עילית.
מה בדיוק קורה ב-mov? עותק של המקור נכנס ליעד ודורס את מה שהיה שם, והמקור עצמו נשאר שלם. אף דגל לא זז, ולכן mov לעולם לא תשפיע על החלטה של קפיצה.
| צורת האופרנדים | מותרת? | דוגמה |
|---|---|---|
| אוגר, אוגר (אותו רוחב) | כן | mov edx, ecx |
| אוגר, מספר קבוע | כן | mov ebx, 0x40 |
| אוגר, תא זיכרון | כן | mov ecx, [count] |
| תא זיכרון, אוגר | כן | mov [count], ecx |
| תא זיכרון, מספר קבוע (חובה לציין רוחב) | כן | mov dword [count], 9 |
| תא זיכרון, תא זיכרון | לא | mov [first], [second] |
| מספר קבוע בתור יעד | לא | mov 7, ebx |
| רוחב שונה בשני הצדדים | לא | mov bx, cl |
כך מגיב NASM לשלוש הצורות האסורות של mov, ולשתי צורות אסורות של cmp שנפגוש בהמשך הפרק:
section .data
first: dd 4
second: dd 9
section .text
mov [first], [second] ; memory to memory
mov 7, ebx ; a number as the destination
mov bx, cl ; 16 bits against 8 bits
cmp 3, ecx ; a number as the first operand of cmp
cmp bl, cx ; 8 bits against 16 bitsbad.asm:5: error: invalid combination of opcode and operands
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: invalid combination of opcode and operandsכל אחת מחמש השורות נדחית באותה הודעה: למעבד אין פקודה שמקבלת את צירוף האופרנדים הזה. המספרים 5 עד 9 הם מספרי השורות בקובץ.
דוגמאות לפני ואחרי:
| לפני | פקודה | אחרי | הסבר |
|---|---|---|---|
| ecx = ערך כלשהו | mov ecx, 0x41 | ecx = 0x00000041 | האוגר כולו מקבל את המספר |
| ebx = 0x0000004C | mov bh, bl | ebx = 0x00004C4C | bl מועתק אל bh, ו-bl עצמו לא זז |
| ebx = 0x0000ABCD | mov bl, bh | ebx = 0x0000ABAB | bh מועתק אל bl, וה-0xCD שהיה ב-bl אבד |
| eax = 3, edx = 8 | mov eax, edx | eax = 8, edx = 8 | העתקה ולא החלפה: גם edx נשאר 8 |
מלכודת שחוזרת בשאלות הקשות: שתי העתקות בין חצאים של אותו אוגר, עם שינוי ביניהן. התשובה הנכונה מתקבלת רק אם בכל שורה לוקחים את מה שיש במקור באותו רגע, ולא את מה שהיה בו בתחילת הקוד.
חזרה לתוכן הענייניםadd: חיבור
add dest, src מניחה ביעד את סכום שני האופרנדים, והמקור נשאר כפי שהיה. בדרך היא גם קובעת את ZF לפי הסכום, נושא שנחזור אליו בפרק על דגל האפס.
אין צורך ללמוד רשימה חדשה של צורות: מה שמותר ב-mov מותר גם כאן, כולל זיכרון עם מספר כשמצהירים על הגודל. גם האיסורים עוברים כמו שהם, כלומר שני תאי זיכרון או אופרנדים בגדלים שונים.
הגודל של היעד הוא גם הגודל של החשבון. חיבור ל-dl נעשה ב-8 ביט, וכל נשיאה שיוצאת ממנו אובדת לפני שהיא מגיעה ל-dh:
| לפני | פקודה | אחרי | הסבר |
|---|---|---|---|
| ecx = 31 | add ecx, 6 | ecx = 37 | 31 ועוד 6 |
| edx = 0x00000040 | add dl, 0x09 | edx = 0x00000049 | רק dl משתנה |
| ebx = 0x000000E8 | add bl, 0x30 | ebx = 0x00000018 | 0xE8 + 0x30 = 0x118; ב-bl נשאר 0x18, והנשיאה לא מגיעה ל-bh |
| ebx = 0x000000E8 | add ebx, 0x30 | ebx = 0x00000118 | באוגר השלם יש מקום, והנשיאה נשמרת |
sub: חיסור
sub dest, src מורידה את המקור מהיעד, וההפרש נשאר ביעד.
כאן הסדר מכריע: sub ebx, 4 פירושה ebx פחות 4, ומי שהופך את הכיוון מקבל מספר אחר לגמרי. בכל השאר sub מתנהגת כמו add, עם אותן צורות אופרנדים ואותה השפעה על ZF.
ומה קורה כשמחסרים יותר ממה שיש? המעבד לא כותב סימן מינוס, אלא ממשיך לספור אחורה מסוף הטווח. בחישוב ידני מוסיפים ליעד 1 מעל הספרה העליונה ורק אז מחסרים: ב-8 ביט, 0x00 פחות 0x30 הופך ל-0x100 פחות 0x30, כלומר 0xD0.
| לפני | פקודה | אחרי | הסבר |
|---|---|---|---|
| ebx = 25 | sub ebx, 4 | ebx = 21 | 25 פחות 4, ולא 4 פחות 25 |
| ecx = 0x00004000 | sub cl, 0x20 | ecx = 0x000040E0 | cl גלש למטה, ו-ch נשאר 0x40 |
| ecx = 0x00004000 | sub ecx, 0x20 | ecx = 0x00003FE0 | באוגר השלם ההלוואה ממשיכה ומורידה גם את ch |
| eax = 0x00000000 | sub ax, 0x0003 | eax = 0x0000FFFD | 16 ביט: 0x10000 פחות 3 |
| edx = 0x00000000 | sub edx, 2 | edx = 0xFFFFFFFE | 32 ביט |
inc ו-dec: צעד אחד למעלה או למטה
inc dest מגדילה את היעד ב-1, ו-dec dest מקטינה אותו ב-1.
גודל הצעד קבוע מראש, ולכן אין להן מה לקבל מלבד המקום שבו משנים: אוגר, או תא זיכרון עם גודל מוצהר. מספר קבוע לא יכול להיות המקום הזה. בטבלה רואים שגם הן מדליקות ומכבות את ZF:
| לפני | פקודה | אחרי |
|---|---|---|
| ebx = 12 | inc ebx | ebx = 13, ZF = 0 |
| edx = 1 | dec edx | edx = 0, ZF = 1 |
| ecx = 0x000000FF | inc cl | ecx = 0x00000000, ZF = 1 |
| eax = 0 | dec eax | eax = 0xFFFFFFFF, ZF = 0 |
בשילוב עם קפיצה הן יוצרות לולאה: מונה שיורד ב-dec בכל סיבוב, ו-jne שמחזירה למעלה עד שהמונה מגיע לאפס. תרחיש שלם כזה מחכה בסוף פרק המעקב.
טעויות נפוצות
mov bh, blמחליפה בין שני הבתים. היא מעתיקה בכיוון אחד בלבד, מ-bl אל bh. הערך הקודם של bh נמחק ולא עובר לשום מקום.mov cl, chלוקחת את הערך ש-ch קיבל בשורה הראשונה של הקוד. היא מעתיקה את מה שיש ב-ch ברגע הביצוע. אם פקודה קודמת כבר שינתה את ch, הערך החדש הוא שעובר.add dl, 0x20מוסיפה גם ל-dh. רק dl משתנה. חיבור שנכתב על חלק אחד לא מתפשט אל החלק השני.- ב-
sub ebx, 4מחסרים את 4 מהמספר שהופיע בשורת ה-cmp. מחסרים תמיד מהערך שנמצא כרגע ביעד, ebx. מי שמחסר מהמספר שהושווה, למשל 30 בשורהcmp ebx, 30, מגיע לתשובה שגויה. - בלבול בין
addל-subהוא טעות קטנה שלא משנה הרבה. ההחלפה הופכת את כיוון השינוי, ומובילה בדיוק לאחד המסיחים שמחכים בשאלה. - הפקודה שאחרי התווית רצה רק כשהקפיצה התבצעה. היא רצה בשני המקרים. מי ששוכח אותה עוצר את המעקב שורה אחת מוקדם מדי.
בדקו את עצמכם
ebx = 0x00000020. מבצעים mov bh, 3 ואחריה add bl, bh. מה ערך ebx?
אחרי mov bh, 3 הערך הוא 0x00000320. אחר כך bl=0x20 ועוד bh=0x03 נותנים bl=0x23, ולכן ebx = 0x00000323.
edx = 0x00000020. מה יהיה edx אחרי sub dl, 0x25, ומה אחרי sub edx, 0x25? כל אחת מהפקודות מתחילה מאותו ערך.
אחרי sub dl, 0x25: 0x000000FB, כי ב-8 ביט 0x20 פחות 0x25 גולש ל-0xFB. אחרי sub edx, 0x25: 0xFFFFFFFB, כי ההלוואה עוברת לאורך כל 32 הביטים.
האם sub [p], [q] היא פקודה חוקית?
לא. פקודה אחת לא יכולה לקבל שני אופרנדים מהזיכרון. מעבירים קודם את אחד הערכים לאוגר, ורק אז מחסרים.
cmp: השוואה
מה cmp עושה, ומה לא
אפשר לחשוב על cmp a, b כעל sub a, b שמישהו ניתק ממנה את שלב הכתיבה: החיסור a פחות b מתבצע במלואו, אבל ההפרש לא נשמר באף מקום.
התוצאה היחידה שנשארת אחריה היא מצב הדגלים. a ו-b יוצאים מהשורה בדיוק כפי שנכנסו אליה, וכך גם כל אוגר אחר.
הדגל שמעניין אותנו הוא ZF (Zero Flag, דגל האפס). שני ערכים זהים נותנים הפרש אפס, ואז ZF=1; כל הפרש אחר משאיר ZF=0.
ומה עם הקפיצה? cmp לא מזיזה את הביצוע אפילו שורה אחת. היא כמו שופט שרושם את התוצאה בפרוטוקול, ומי שקורא את הפרוטוקול ופועל לפיו הוא jne.
צורות האופרנדים של cmp
| צורת האופרנדים | מותרת? | דוגמה |
|---|---|---|
| אוגר, אוגר (אותו רוחב) | כן | cmp ecx, edx |
| אוגר, מספר | כן | cmp ecx, 45 |
| תת אוגר, מספר | כן | cmp bl, 0x31 |
| אוגר, תא זיכרון | כן | cmp ecx, [limit] |
| תא זיכרון, אוגר | כן | cmp [limit], ecx |
| תא זיכרון, מספר (חובה לציין רוחב) | כן | cmp dword [limit], 3 |
| תא זיכרון, תא זיכרון | לא | cmp [first], [second] |
| מספר בתור האופרנד הראשון | לא | cmp 3, ecx |
| רוחב שונה בשני הצדדים | לא | cmp bl, cx |
שימו לב לשורה של cmp 3, ecx. האופרנד הראשון ב-cmp ממלא את התפקיד של היעד ב-sub, כלומר ממנו מחסרים, ולכן מספר קבוע לא יכול לעמוד שם. שתי השורות האסורות האחרונות בטבלה הופיעו כבר, עם השגיאה של NASM, בקובץ השגוי שבפרק הקודם.
משווים רק את החלק שכתוב בפקודה
השוואה על תת אוגר בודקת את תת האוגר הזה ותו לא. ב-cmp bl, 0x40 משתתפים 8 ביטים בלבד, ומה שיושב ב-bh או בחצי העליון של ebx לא נכנס לחשבון.
נניח ש-ebx = 0x00000240. אז bl = 0x40, bh = 0x02 ו-bx = 0x0240:
| פקודה | מה עומד מול מה | ZF |
|---|---|---|
cmp bl, 0x40 | bl (0x40) מול 0x40 | שווים, ZF = 1 |
cmp bh, 0x02 | bh (0x02) מול 0x02 | שווים, ZF = 1 |
cmp bx, 0x40 | bx (0x0240) מול 0x0040 | שונים, ZF = 0 |
cmp ebx, 0x40 | ebx (0x00000240) מול 0x40 | שונים, ZF = 0 |
בפועל, לפני שמחשבים משהו, מסמנים איזה שם כתוב משמאל לפסיק בשורת ה-cmp. ch ו-cl הם שני בתים שונים, ומי שמתבלבל ביניהם בונה את כל ההמשך על הבית הלא נכון.
למשל, כש-ecx מחזיק 0x00005000, הבית 0x50 נמצא ב-ch, ו-cl ריק. לכן cmp ch, 0x50 מדליקה את ZF, ו-cmp cl, 0x50 משאירה אותו כבוי.
דוגמאות קצרות
| לפני | פקודה | ZF אחרי | הסבר |
|---|---|---|---|
| ecx = 41 | cmp ecx, 40 | ZF = 0 | 41 פחות 40 הוא 1, לא אפס. ecx נשאר 41 |
| ecx = 41 | cmp ecx, 41 | ZF = 1 | ההפרש אפס |
| edx = 0x60 | cmp dl, 0x70 | ZF = 0 | שונים, ו-edx לא השתנה |
| eax = 0x00005678 | cmp al, 0x78 | ZF = 1 | al הוא 0x78; ah לא נבדק |
jne יש רק שתי אפשרויות: שווים, או לא שווים.טעויות נפוצות
cmp edx, ecxעלולה לתת ל-jne תשובה הפוכה מזו שלcmp ecx, edx. שוויון לא תלוי בסדר: אם ההפרש בכיוון אחד הוא אפס, גם בכיוון השני. בשבילjneשתי השורות שקולות.- אחרי
cmp, ההפרש שמור ב-a. ההפרש מחושב ונזרק. כל האוגרים נשארים כפי שהיו, ורק הדגלים מתעדכנים. - ב-0x00005000, cl הוא 0x50. 0x50 יושב ב-ch, הבית השני מימין. cl הוא שתי הספרות האחרונות, 0x00.
cmp dl, 0x20משווה את כל edx. רק dl נבדק. שאר הביטים של edx לא נכנסים להשוואה.cmpבלי שום קפיצה אחריה כבר עוקפת את השורה הבאה. בליjneאחריה שום שורה לא נעקפת, והביצוע ממשיך כרגיל.
בדקו את עצמכם
אחרי cmp ebx, 11, האם ebx מכיל ערך אחר מזה שהיה בו?
לא. רק הדגלים משתנים.
edx = 0x00000307. האם cmp dl, 0x07 מדליקה את ZF?
כן, ZF=1. dl הוא 0x07, שווה ל-0x07, וה-0x03 שב-dh לא משתתף.
רק אחת מבין cmp 9, ebx, cmp bx, cl ו-cmp ecx, edx תעבור תרגום. איזו, ומה הבעיה בשתיים האחרות?
cmp ecx, edx. הראשונה פותחת במספר קבוע, והשנייה מעמידה 16 ביט מול 8 ביט.
דגל האפס ZF: איך cmp ו-jne מדברות
דגל: ביט אחד שמספר על התוצאה
באוגר הדגלים של המעבד כל ביט הוא מעין נורת חיווי. אחרי פעולה חשבונית, חלק מהנורות נדלקות או כבות כדי לתאר את התוצאה שיצאה.
מכל הנורות האלה, בנושא הזה מסתכלים רק על אחת: ZF.
| ערך ZF | מה הוא אומר |
|---|---|
| ZF = 1 | התוצאה האחרונה יצאה אפס. אחרי cmp: שני הערכים שווים |
| ZF = 0 | התוצאה האחרונה לא יצאה אפס. אחרי cmp: הערכים שונים |
השם עוזר לזכור: Zero Flag עונה על השאלה 'האם התוצאה אפס?', ותשובה חיובית היא 1. אחרי cmp זה קורה בדיוק כשהערכים זהים, ומי שקורא את ה-1 כ'יש הבדל' הופך את כל ההחלטה.
חמש הפקודות שקובעות את ZF
אילו פקודות מדליקות או מכבות את הנורה? בנושא הזה חמש: פקודות החשבון add ו-sub, פקודות הצעד inc ו-dec, וההשוואה cmp. בכל אחת הדגל משקף את התוצאה שלה עצמה, וזה הדגל ש-jne תקרא:
| פקודה | ZF = 1 כאשר | דוגמה |
|---|---|---|
cmp a, b | a ו-b שווים | ebx=8, cmp ebx, 8 |
sub a, b | ההפרש 0 (כלומר a היה שווה ל-b) | ecx=6, sub ecx, 6 |
add a, b | הסכום 0 ברוחב האופרנד | dl=0xFF, add dl, 1 |
inc a | התוצאה 0 | bl=0xFF, inc bl |
dec a | התוצאה 0 (הערך היה 1) | edx=1, dec edx |
כל תוצאה שאינה אפס משאירה ZF=0.
ומה נחשב 'אפס'? המספר שנשאר בתת האוגר אחרי הפעולה, ולא המספר שהיה יוצא בחישוב על דף. add cl, 1 על cl=0xFF נותנת על דף 0x100, אבל בתוך 8 ביט נשאר 0x00, ולכן ZF=1.
מי לא נוגע ב-ZF
ויש פקודות שלא נוגעות בנורות בכלל. mov מעבירה ערכים בלי לחשב דבר, ו-jmp ו-jne רק משנות את EIP, ולכן ZF יוצא משלושתן כפי שנכנס. תווית אפילו לא נכנסת לחשבון, כי היא לא פקודה.
המשמעות המעשית: הדגל 'זוכר' את הפקודה האחרונה מבין החמש, וכל mov שבאה אחריה עוברת לידו בלי להשאיר סימן.
mov ecx, 12
cmp ecx, 4 ; 12 - 4 is not 0, so ZF = 0
mov ecx, 4 ; mov leaves the flags alone: ZF is still 0
jne THERE ; the flag still says different: the jump happens
mov ebx, 1 ; skipped
THERE:כשמגיעים ל-jne, ecx כבר שווה ל-4, ובכל זאת הקפיצה מתבצעת. הדגל נקבע בשורת ההשוואה, כשהערכים היו שונים, ו-jne לא בודקת את האוגר מחדש. בהרצה, ebx נשאר 0.
הפקודה האחרונה שכתבה לדגל היא שקובעת
חשבו על ZF כעל לוח מחיק. כל אחת מחמש הפקודות מוחקת את מה שכתוב עליו וכותבת משהו חדש, ו-jne קוראת את מה שכתוב ברגע שהיא מגיעה. אם sub, add, inc, dec או cmp נוספת נכנסו בין ההשוואה לקפיצה, מה שה-cmp הראשונה כתבה כבר נמחק.
בדוגמה הבאה dl מתחיל ב-0x30:
| שורה | ZF אחריה | הסבר |
|---|---|---|
cmp dl, 0x08 | ZF = 0 | dl הוא 0x30, שונה מ-0x08 |
mov ecx, 9 | ZF = 0 | mov לא נוגעת בדגל |
sub dl, 0x30 | ZF = 1 | dl יורד ל-0x00; התוצאה אפס והדגל נכתב מחדש |
jne NEXT | ZF = 1 | אין קפיצה. ההחלטה נשענת על ה-sub בלבד |
כך מוצאים בשאלה את הפקודה הקובעת: מצביעים על שורת ה-jne וסורקים כלפי מעלה. שורות mov לא מעניינות בסריקה הזאת; היא נגמרת בפקודה הראשונה מבין החמש שפוגשים, והתוצאה שלה היא מה ש-jne תראה.
טעויות נפוצות
- ZF=1 פירושו שהערכים שונים. להפך: ZF=1 אומר שהתוצאה אפס, כלומר שהערכים שווים.
jneמסתכלת על הערך הנוכחי של האוגר.jneמסתכלת רק על ZF, שמשקף את התוצאה של הפקודה האחרונה שכתבה לו, גם אם האוגר השתנה מאז.- חיבור שגלש לאפס משאיר את ZF כבוי, כי המספר האמיתי איננו אפס. ZF נקבע לפי התוצאה ברוחב האופרנד. אם הסכום ב-8 ביט הוא 0x00, ZF=1.
- ה-cmp שהופיעה ראשונה קובעת, גם אם אחריה באה
add. קובעת הפקודה האחרונה שכתבה לדגל לפני ה-jne.addאוsubבאמצע מחליפות את מה שה-cmp השאירה. movשמופיעה ביןcmpל-jneיכולה לשנות את ההחלטה.movלא כותבת לדגלים בכלל, ולכן אין לה שום השפעה על השאלה אם קופצים.
בדקו את עצמכם
dl = 0xFF. מה ZF אחרי add dl, 1?
ZF=1, כי ב-8 ביט התוצאה היא 0x00. בחיבור הזה יש גם נשיאה החוצה, אבל היא לא חלק מהנושא.
ecx מקבל 2, ואז מופעלת עליו dec ecx פעמיים. מה ZF בסוף?
ZF=1. ecx יורד ל-1 ואז ל-0, והפקודה האחרונה מסתיימת באפס.
ברצף mov ebx, 15, cmp ebx, 2, mov ebx, 2, האוגר מסיים ב-2. האם ZF דולק?
לא, ZF=0. ההשוואה הייתה בין 15 ל-2, ו-mov שאחריה לא נגעה בדגל.
jne: קפיצה אם לא שווה
איך כותבים jne ומה היא עושה
jne מקבלת דבר אחד: שם של תווית, כמו ב-jne PASS, בלי הנקודתיים שמופיעות בהגדרת התווית. השם מקצר את Jump if Not Equal, 'קפוץ אם לא שווה'.
מבחינת מצב המעבד, jne רק קוראת: היא מעיינת ב-ZF, ולפי מה שמצאה נותנת ל-EIP להתקדם כרגיל או מציבה בו כתובת אחרת. אוגרים ודגלים יוצאים ממנה בלי שינוי.
לגבי היעד יש דרישה אחת: התווית צריכה להיות מוגדרת בקוד. המיקום שלה חופשי, כך שאותה jne יכולה לשלוח קדימה, אל שורות שעוד לא רצו, או אחורה, אל שורות שכבר רצו, וכך נבנות לולאות.
מתי היא קופצת
| ZF | המשמעות אחרי cmp | מה jne עושה |
|---|---|---|
| ZF = 0 | הערכים שונים | קופצת אל התווית |
| ZF = 1 | הערכים שווים | לא קופצת; הביצוע ממשיך לשורה שמתחתיה |
כדי לא להתבלבל, קראו את השם כפשוטו: 'לא שווה? קפוץ'. אם הערכים כן שווים, לשורה הזאת אין שום השפעה, והביצוע יורד לשורה הבאה כאילו היא לא נכתבה.
ומה קורה כשהיא כן קופצת? כל השורות שבינה לבין התווית נעקפות, גם mov תמימה למראה. הביצוע ממשיך מהפקודה הראשונה שאחרי התווית, כי זו הכתובת ש-jne הציבה ב-EIP.
jnz: אותה פקודה בשם נוסף
ייתכן שתפגשו גם את jnz, Jump if Not Zero. השם מתאר את הדגל ולא את ההשוואה, אבל מדובר באותה פקודה בדיוק, עם אותו קוד מכונה ואותו תנאי: ZF=0.
בעמוד הזה, כמו בשאלות, השם שבשימוש הוא jne.
שלוש הרצות, שלושה נתיבים בקוד
הרצה א: edx נבדק מול הערך שהוא עצמו מחזיק.
mov edx, 8 ; line 1
cmp edx, 8 ; line 2 -> ZF = 1
jne PASS ; line 3 -> ZF = 1, no jump
mov ecx, 4 ; line 4
PASS: ; line 5 (label)
mov ebx, 6 ; line 6השורות שרצות, לפי הסדר: 1, 2, 3, 4, (5), 6. בסוף ecx=4 ו-ebx=6.
הרצה ב: משנים רק את שורה 1 ל-mov edx, 2. עכשיו ההשוואה משאירה ZF=0, ושורה 3 שולחת את הביצוע אל PASS.
הפעם רצות 1, 2, 3, (5), 6, ושורה 4 לא רצה. בסוף ebx=6, ו-ecx נשאר עם מה שהיה בו קודם (אם התחיל ב-0, נשאר 0).
הרצה ג: אין cmp בכלל, ואת הדגל משאירה sub.
mov ebx, 9 ; line 1
sub ebx, 9 ; line 2 -> ebx = 0, ZF = 1
jne PASS ; line 3 -> no jump
mov eax, 3 ; line 4
PASS: ; line 5ההפרש הוא 0, לכן ZF=1 ו-jne לא קופצת. רצות 1, 2, 3, 4, (5), ובסוף eax=3.
טעויות נפוצות
jnzהיא פקודה אחרת, עם תנאי משלה. זה אותו קוד מכונה בשני שמות, ושניהם קופצים כש-ZF=0.- כשהערכים זהים,
jneשולחת אל התווית. היא קופצת רק כשהם שונים, כלומר כש-ZF=0. - גם כש-
jneלא קופצת, משהו בכל זאת נעקף. כשאין קפיצה הביצוע פשוט ממשיך לשורה הבאה, ושום דבר לא נעקף. - אחרי שהקפיצה התבצעה, ממשיכים לבצע את השורות שבין jne לתווית. הן נעקפות. הביצוע ממשיך מהשורה שאחרי התווית.
- הפקודות שאחרי התווית רצות רק באחד המקרים. הן רצות גם כשקפצו וגם כשלא.
בדקו את עצמכם
אם מתארים את ההתנהגות של jne רק לפי ZF, באיזה ערך שלו היא נשארת במקום?
ZF=1, כלומר כשהתוצאה האחרונה שנכתבה לדגל הייתה אפס, או כשההשוואה מצאה שוויון.
ecx ו-edx מתחילים ב-0. הקוד: mov ecx, 4, cmp ecx, 7, jne PASS, mov edx, 1, ואז התווית PASS:. כמה edx בסוף?
0. 4 שונה מ-7, ZF=0, jne קופצת, ו-mov edx, 1 לא רצה.
בקוד mov ebx, 5, sub ebx, 5, jne PASS, mov ecx, 8, PASS:, האם mov ecx, 8 רצה?
כן. sub השאירה 0, ZF=1, ולכן jne לא קופצת.
Label: תווית
שם לנקודה בקוד
בלי שמות, הדרך היחידה לומר 'קפוץ לשם' הייתה לכתוב כתובת מספרית. תווית (label) פותרת את זה: נותנים למקום בקוד שם, למשל AFTER:, בדרך כלל בשורה נפרדת ועם נקודתיים בסופו.
כשהאסמבלר מתרגם, הוא מחשב את הכתובת של הפקודה הראשונה שמתחת לשם, ומציב אותה בכל קפיצה שמזכירה את השם.
במעבד עצמו לא נשאר מהתווית דבר מלבד הכתובת הזאת. אין בה פעולה, והיא לא נוגעת באוגרים ולא בדגלים; היא שלט שמסמן יעד.
חזרה לתוכן הענייניםכללי כתיבה
| איפה | איך כותבים | דוגמה |
|---|---|---|
| בשורת ההגדרה | השם ואחריו נקודתיים | AFTER: |
| בפקודת הקפיצה | השם בלבד, בלי נקודתיים | jne AFTER, jmp FINISH |
את השם בוחרים בחופשיות, למשל OTHER, FINISH, REPEAT או L2, ובלבד שהקפיצה משתמשת בדיוק באותו שם. תוויות רבות יכולות לחיות באותו קוד, אבל אסור להגדיר שם אחד פעמיים.
לפי הנוהג, התווית תופסת שורה משלה, והפקודה שהיא מסמנת כתובה מתחתיה.
חזרה לתוכן הענייניםמה נעקף, ומה רץ תמיד
תווית דומה לצומת שבו שני כבישים מתמזגים: מגיעים אליה מלמעלה, כשהביצוע פשוט יורד אליה, או בקפיצה מנקודה אחרת. מרגע שעברו אותה כולם נוסעים באותו כביש, ולכן הפקודות שמתחתיה רצות בשני המקרים.
cmp ecx, 8
jne AFTER
add ecx, 20 ; runs only when jne did not jump
AFTER:
sub ecx, 1 ; runs on both paths| מצב | מה jne עושה | add ecx, 20 | sub ecx, 1 |
|---|---|---|---|
| ecx שונה מ-8 | קופצת אל AFTER | לא רצה | רצה |
| ecx שווה ל-8 | לא קופצת | רצה | רצה (המעבר דרך התווית רגיל) |
בהרצה עם ecx=3 מתקבל 2, ועם ecx=8 מתקבל 27 (8 ועוד 20, פחות 1).
בשאלות, הרבה תשובות שגויות נולדות פשוט משכחה של הפקודה האחרונה הזאת, שמחכה מתחת לתווית.
חזרה לתוכן העניינים_start ומבנה של קובץ שלם
תוכנית שלמה ב-NASM צריכה לומר למערכת מאיפה להתחיל. את זה עושה התווית _start:, שנחשפת החוצה בעזרת global _start, ואת הפקודות עצמן שמים תחת section .text.
section .text
global _start
_start:
mov ebx, 9
cmp ebx, 9
jne AFTER
add ebx, 4
AFTER:
sub ebx, 1 ; ebx = 12
mov eax, 1 ; Linux system call 1 (exit), the exit status is taken from ebx
int 0x80שתי השורות האחרונות רק מאפשרות לראות את התוצאה: קריאת המערכת exit מסיימת את התוכנית, ו-ebx הופך לקוד היציאה שלה. אחרי תרגום, קישור והרצה בלינוקס, echo $? מדפיסה את קוד היציאה:
nasm -f elf32 prog.asm -o prog.o
ld -m elf_i386 prog.o -o prog
./prog
echo $?129 שווה ל-9, לכן jne לא קופצת: 9 ועוד 4 הם 13, ואחרי התווית יורדים ל-12. בשאלות המבחן המסגרת הזאת לא מופיעה, אלא רק שורות הקוד עצמן.
טעויות נפוצות
movשנמצאת ביןjneלתווית רצה גם כשהקפיצה התבצעה. כל השורות שביןjneשקפצה לבין התווית נעקפות, וה-mov ביניהן.- כשהמעבד מגיע לתווית הוא מבצע בה משהו, למשל אוסף את התוצאות. תווית היא רק שם לכתובת. אין בה שום פעולה.
- בקפיצה כותבים
jne AFTER:, ובהגדרה מספיקAFTER. ההפך: נקודתיים באות רק בהגדרה, ובקפיצה כותבים את השם לבדו. - הקוד שמתחת לתווית רץ רק כשהגיעו אליה בקפיצה. הוא רץ גם כשמגיעים אליו בהמשך רגיל מהשורה שמעליו.
בדקו את עצמכם
רוצים לסמן מקום בשם FINISH ולקפוץ אליו. מה כותבים בכל אחד משני המקומות?
בהגדרה FINISH:, ובקפיצה jmp FINISH (או jne FINISH).
edx = 7. אילו שורות מתבצעות בקוד cmp edx, edx, jne B, mov ecx, 3, B:, mov ebx, 4?
כולן. השוואה של אוגר לעצמו תמיד מוצאת שוויון, jne לא קופצת, mov ecx, 3 רצה, הביצוע עובר דרך B:, ו-mov ebx, 4 רצה.
האם המעבר דרך שורת התווית B: משנה ערך של אוגר כלשהו?
לא. תווית אינה פקודה.
jmp: קפיצה בלתי מותנית
קופצת תמיד
jmp label היא הקפיצה הפשוטה ביותר: אין לה תנאי, והיא לא מעיפה מבט באף דגל.
מה שהיא עושה זהה לרגע הקפיצה של jne: כתובת התווית נכנסת ל-EIP, הביצוע ממשיך משם, ושום אוגר או דגל לא משתנה. ההבדל היחיד הוא שאצל jne הרגע הזה מגיע רק כש-ZF=0, כפי שמסכמת הטבלה:
| פקודה | מתי קופצת | קוראת דגל? |
|---|---|---|
jmp label | בכל מקרה | לא |
jne label | רק כש-ZF = 0 | כן, את ZF |
דוגמה: עקיפה של שורה
mov ecx, 4 ; line 1
jmp OVER ; line 2 always jumps
mov ecx, 50 ; line 3 never runs
OVER: ; line 4
add ecx, 3 ; line 5רצות השורות 1, 2, (4), 5. שורה 3 לא תרוץ לעולם, ובסוף ecx=7.
חזרה לתוכן הענייניםבשביל מה צריך אותה
למה בכלל צריך קפיצה שלא שואלת שאלות? חשבו על if ו-else: כשהמעבד מסיים את ענף ה-if, הקוד של ה-else כתוב מיד מתחתיו, ואם לא נעשה כלום הוא ירוץ גם הוא. jmp היא הגשר שמעביר את הביצוע מעליו.
יש לה גם צד מסוכן. jmp אל תווית שנמצאת מעליה מחזירה את הביצוע אחורה שוב ושוב, ומאחר שאין בה תנאי, שום דבר לא יעצור את הלולאה.
טעויות נפוצות
- השורות שבין
jmpלתווית רצות לפני הקפיצה. הקפיצה קורית מיד בשורת ה-jmp, והשורות שאחריה עד התווית נעקפות. jmpקופצת רק אם ההשוואה האחרונה מצאה שוויון.jmpלא בודקת שום תנאי ולא קוראת שום דגל. היא קופצת תמיד.- אפשר לוותר על
jmpבסוף גוף ה-if. בלי הקפיצה הזאת הביצוע ממשיך לגוף ה-else, וכך שני הגופים רצים.
בדקו את עצמכם
בקוד mov ebx, 2, jmp OVER, add ebx, 40, OVER:, add ebx, 5, כמה ebx בסוף, ואיזו שורה לא רצה?
7. add ebx, 40 נעקפת, ולכן 2 ועוד 5.
באיזה מצב jmp L ו-jne L מתנהגות אותו דבר, ובאיזה לא?
כש-ZF=0 שתיהן קופצות. כש-ZF=1 רק jmp קופצת, כי היא לא מתחשבת בדגל.
תבניות if/else ודילוג
תבנית הדילוג: if בלי else
כמעט כל שאלה בנושא היא וריאציה על השלד הבא:
cmp x, y
jne PAST
; the body: executed only when x == y
PAST:
; the continuation: executed in every caseכדי להבין את השלד, נסחו אותו במילים: הגוף הוא קטע שעוקפים 'אם לא שווה'. מכאן שהוא רץ רק במקרה ההפוך, כש-x ו-y זהים, וזה בדיוק if (x == y) בלי else.
חזרה לתוכן הענייניםהתבנית המלאה של if ו-else
cmp x, y
jne OTHER
; the if part: x == y
jmp FINISH
OTHER:
; the else part: x != y
FINISH:
; the continuation| מצב | מה קורה | מה מתבצע |
|---|---|---|
| x שווה ל-y | jne לא קופצת, חלק ה-if רץ, ו-jmp FINISH עוקפת את חלק ה-else | חלק ה-if, ואחריו FINISH |
| x שונה מ-y | jne קופצת אל OTHER | חלק ה-else, ואחריו FINISH |
מה קורה כשה-jmp חסר
מה יקרה אם נשמיט את jmp FINISH? כשהערכים שונים, שום דבר לא משתנה, כי jne ממילא קופצת ישר ל-else. אבל כשהם שווים, המעבד מסיים את חלק ה-if וגולש הלאה לתוך חלק ה-else.
mov ecx, 3
cmp ecx, 3
jne OTHER
mov edx, 40 ; runs
OTHER:
mov edx, 70 ; runs as well, since nothing jumps over itedx מסיים ב-70: הערך 40 נכתב ונדרס מיד, כי אין דבר שמונע מהשורה הבאה לרוץ.
טעויות נפוצות
- הקוד שאחרי FINISH רץ רק באחד המקרים. גם חלק ה-if וגם חלק ה-else מגיעים אליו בסופם, ולכן הוא רץ תמיד.
- אפשר לכתוב if/else בלי
jmpלפני תווית ה-else. בלי ה-jmp, במקרה של שוויון רצים גם חלק ה-if וגם חלק ה-else. - חלק ה-if רץ כשהערכים שונים. הוא רץ כשהם שווים, כי אז
jneלא קופצת.
בדקו את עצמכם
בתבנית המלאה cmp ecx, 6, jne OTHER, mov edx, 40, jmp FINISH, OTHER:, mov edx, 70, FINISH:, עבור איזה ערך של ecx יסתיים הקוד עם edx=40, ומה יתקבל עבור ecx=5?
רק עבור ecx=6, כשההשוואה מוצאת שוויון ו-jne לא קופצת. עבור 5 הקפיצה מתבצעת אל OTHER, ו-edx=70.
מוחקים מאותו קוד את jmp FINISH. האם יש עכשיו ערך של ecx שנותן edx=40 בסוף?
לא. כש-ecx=6 נכתב 40 ומיד נדרס ב-70, וכשהוא שונה מ-6 הקפיצה הולכת ישר ל-70.
דוגמאות מעקב מלאות
איך קוראים את טבלאות המעקב
בכל תרחיש הקוד מופיע פעם אחת, ואחריו טבלה עם שורה לכל פקודה: מה נשאר באוגרים וב-ZF אחריה, ומה בעצם קרה. כשבשורה מופיע רק ערך של אוגר בלי ZF, הדגל לא זז בה, כפי שקורה ב-mov, בקפיצות ובתוויות.
פקודה שהקפיצה עקפה מקבלת בטבלה 'לא רצה', והערכים לצדה מועתקים מהשורה הקודמת, כי שום דבר לא השתנה.
הסדר עולה בקושי: שני תרחישים עשרוניים, אחריהם השוואות על בתים, גלישות, דגל שנכתב מחדש, if/else ולולאה. כל ערך סופי נבדק בהרצה על x86.
חזרה לתוכן הענייניםעשרוני: כשאין קפיצה וכשיש
תרחיש 1: ערכים שווים, ולכן שתי הפעולות רצות
ההשוואה מוצאת שוויון; עקבו אחרי ecx דרך שתי הפעולות.
mov ecx, 45
cmp ecx, 45
jne NEXT
add ecx, 8
NEXT:
sub ecx, 3| פקודה | מצב אחרי הביצוע | הסבר |
|---|---|---|
mov ecx, 45 | ecx = 45 | העתקה |
cmp ecx, 45 | ecx = 45, ZF = 1 | 45 פחות 45 הוא 0: שווים |
jne NEXT | ecx = 45, ZF = 1 | ZF=1, אין קפיצה, ממשיכים למטה |
add ecx, 8 | ecx = 53, ZF = 0 | רצה. גם היא כותבת ל-ZF, אבל אחריה אין עוד קפיצה |
NEXT: | ecx = 53 | תווית: עוברים דרכה |
sub ecx, 3 | ecx = 50, ZF = 0 | רצה בכל מקרה |
התוצאה: ecx=50, וכל השורות רצו.
תרחיש 2: ערכים שונים, ולכן החיסור נעקף
הפעם 23 מול 17. מה קורה לחיסור שבאמצע?
mov edx, 23
cmp edx, 17
jne SKIP
sub edx, 5
SKIP:
add edx, 9| פקודה | מצב אחרי הביצוע | הסבר |
|---|---|---|
mov edx, 23 | edx = 23 | ערך התחלתי |
cmp edx, 17 | edx = 23, ZF = 0 | 23 פחות 17 הוא 6: שונים |
jne SKIP | edx = 23, ZF = 0 | ZF=0, קופצת אל SKIP |
sub edx, 5 | edx = 23 | לא רצה |
SKIP: | edx = 23 | מכאן ממשיכים |
add edx, 9 | edx = 32, ZF = 0 | רצה |
התוצאה: edx=32. רצו השורות 1, 2, 3, (5), 6.
הקסדצימלי: השוואה על בית אחד
תרחיש 3: השוואה על al, וחיבור לאוגר השלם
המלכודת: ההשוואה על בית אחד, החיבור על 32 ביט, והחיסור בסוף שוב על בית.
mov eax, 0x00C4
cmp al, 0xC4
jne MERGE
add eax, 0x0020
MERGE:
sub al, 0x09| פקודה | מצב אחרי הביצוע | הסבר |
|---|---|---|
mov eax, 0x00C4 | eax = 0x000000C4 | ah = 0x00, al = 0xC4 |
cmp al, 0xC4 | ZF = 1 | al שווה ל-0xC4 |
jne MERGE | ZF = 1 | אין קפיצה |
add eax, 0x0020 | eax = 0x000000E4, ZF = 0 | 0xC4 + 0x20 = 0xE4 |
MERGE: | eax = 0x000000E4 | תווית |
sub al, 0x09 | eax = 0x000000DB, ZF = 0 | 0xE4 פחות 9: 228 פחות 9 הם 219, כלומר 0xDB |
התוצאה: eax=0x000000DB, שהם 219 בעשרוני.
תרחיש 4: השוואה על ah, והעתקה בין החצאים
שאלה ראשונה: איזה בית בודקת cmp ah, 0x27? רק אחרי שעונים עליה אפשר להמשיך.
mov eax, 0x2758
cmp ah, 0x27
jne SKIP
sub eax, 0x0058
mov al, ah
SKIP:
add ah, 0x02| פקודה | מצב אחרי הביצוע | הסבר |
|---|---|---|
mov eax, 0x2758 | eax = 0x00002758 | ah = 0x27, al = 0x58 |
cmp ah, 0x27 | ZF = 1 | ah שווה ל-0x27; al לא משתתף |
jne SKIP | ZF = 1 | אין קפיצה |
sub eax, 0x0058 | eax = 0x00002700, ZF = 0 | 0x2758 פחות 0x58 = 0x2700, ו-al מתאפס |
mov al, ah | eax = 0x00002727 | al מקבל את ערכו של ah, 0x27 |
SKIP: | eax = 0x00002727 | תווית |
add ah, 0x02 | eax = 0x00002927, ZF = 0 | רק ah עולה, מ-0x27 ל-0x29 |
התוצאה: eax=0x00002927.
גלישה בתוך חלק של אוגר
תרחיש 5: חיסור שגולש ב-cl, ואחריו העתקה
שלוש מלכודות ברצף: גלישה למטה ב-cl, העתקה של הערך הגלוש אל ch, וגלישה למעלה בסוף.
mov ecx, 0x4500
cmp ch, 0x45
jne JOIN
sub cl, 0x03
mov ch, cl
JOIN:
add cl, 0x05| פקודה | מצב אחרי הביצוע | הסבר |
|---|---|---|
mov ecx, 0x4500 | ecx = 0x00004500 | ch = 0x45, cl = 0x00 |
cmp ch, 0x45 | ZF = 1 | ch שווה ל-0x45 |
jne JOIN | ZF = 1 | אין קפיצה |
sub cl, 0x03 | ecx = 0x000045FD, ZF = 0 | cl: 0x00 פחות 3 גולש ל-0xFD; ch לא זז |
mov ch, cl | ecx = 0x0000FDFD | ch מקבל 0xFD |
JOIN: | ecx = 0x0000FDFD | תווית |
add cl, 0x05 | ecx = 0x0000FD02, ZF = 0 | cl: 0xFD + 5 = 0x102, ונשאר 0x02. הנשיאה נעלמת ו-ch לא משתנה |
התוצאה: ecx=0x0000FD02.
תרחיש 6: חיבור שגולש ב-bl
כאן הגלישה היא בחיבור, ו-mov bh, bl מקבלת את מה שנשאר ב-bl אחריה.
mov ebx, 0x00E0
cmp bl, 0xE0
jne TAIL
add bl, 0x45
mov bh, bl
TAIL:
add bx, 0x0003| פקודה | מצב אחרי הביצוע | הסבר |
|---|---|---|
mov ebx, 0x00E0 | ebx = 0x000000E0 | bh = 0x00, bl = 0xE0 |
cmp bl, 0xE0 | ZF = 1 | שווים |
jne TAIL | ZF = 1 | אין קפיצה |
add bl, 0x45 | ebx = 0x00000025, ZF = 0 | 0xE0 + 0x45 = 0x125; ב-8 ביט נשאר 0x25, ו-bh לא מושפע |
mov bh, bl | ebx = 0x00002525 | bh מקבל 0x25 |
TAIL: | ebx = 0x00002525 | תווית |
add bx, 0x0003 | ebx = 0x00002528, ZF = 0 | 16 ביט: 0x2525 ועוד 3 |
התוצאה: ebx=0x00002528.
תרחיש 7: השוואה על dx ופעולות של 16 ביט
ההשוואה ברוחב 16 ביט, ושתי העתקות בין dl ל-dh מחייבות לדעת מה יש בכל בית בדיוק ברגע שלהן.
mov edx, 0x0050
cmp dx, 0x0050
jne NEXT
add edx, 0x0004
mov dl, dh
NEXT:
sub dx, 0x0006
mov dh, dl| פקודה | מצב אחרי הביצוע | הסבר |
|---|---|---|
mov edx, 0x0050 | edx = 0x00000050 | dh = 0x00, dl = 0x50 |
cmp dx, 0x0050 | ZF = 1 | dx שווה ל-0x0050 |
jne NEXT | ZF = 1 | אין קפיצה |
add edx, 0x0004 | edx = 0x00000054, ZF = 0 | חיבור לאוגר השלם |
mov dl, dh | edx = 0x00000000 | dh הוא 0x00, ולכן dl מתאפס |
NEXT: | edx = 0x00000000 | תווית |
sub dx, 0x0006 | edx = 0x0000FFFA, ZF = 0 | 16 ביט: 0x0000 פחות 6 גולש ל-0xFFFA |
mov dh, dl | edx = 0x0000FAFA | dl (0xFA) מועתק אל dh |
התוצאה: edx=0x0000FAFA.
פקודה שכותבת על הדגל לפני jne
תרחיש 8: ה-sub קובעת, לא ה-cmp
שימו לב לשורה הרביעית: sub כותבת לדגל אחרי ה-cmp, וה-mov שביניהן לא משנה בו דבר.
mov eax, 0x70
cmp al, 0x25
mov ecx, 8
sub al, 0x70
jne SKIP
add eax, 0x200
SKIP:
add al, 0x04| פקודה | מצב אחרי הביצוע | הסבר |
|---|---|---|
mov eax, 0x70 | eax = 0x00000070 | al = 0x70 |
cmp al, 0x25 | ZF = 0 | 0x70 שונה מ-0x25 |
mov ecx, 8 | ecx = 8, ZF = 0 | mov לא נוגעת בדגלים |
sub al, 0x70 | eax = 0x00000000, ZF = 1 | al: 0x70 פחות 0x70 = 0; הדגל נכתב מחדש |
jne SKIP | ZF = 1 | אין קפיצה; ההחלטה באה מה-sub |
add eax, 0x200 | eax = 0x00000200, ZF = 0 | רצה |
SKIP: | eax = 0x00000200 | תווית |
add al, 0x04 | eax = 0x00000204, ZF = 0 | al = 0x04 |
התוצאה: eax=0x00000204. מי שהחליט לפי ה-cmp היה קופץ, עוקף את החיבור של 0x200, ועונה בטעות 0x00000004.
if/else מלא
תרחיש 9: אותו קוד, שתי הרצות
שתי הרצות של אותו קוד, עם ecx=12 ועם ecx=13; edx מתחיל ב-0.
mov ecx, 12 ; second run: mov ecx, 13
cmp ecx, 12
jne OTHER
mov edx, 300
jmp FINISH
OTHER:
mov edx, 500
FINISH:
add edx, 2הרצה ראשונה, ecx=12:
| פקודה | מצב אחרי הביצוע | הסבר |
|---|---|---|
mov ecx, 12 | ecx = 12 | ערך התחלתי |
cmp ecx, 12 | ZF = 1 | שווים |
jne OTHER | ZF = 1 | אין קפיצה |
mov edx, 300 | edx = 300 | חלק ה-if |
jmp FINISH | edx = 300 | קופצת מעל חלק ה-else |
OTHER: ו-mov edx, 500 | edx = 300 | לא רצות |
FINISH: | edx = 300 | תווית |
add edx, 2 | edx = 302, ZF = 0 | רצה |
תוצאה: edx=302.
הרצה שנייה, ecx=13:
| פקודה | מצב אחרי הביצוע | הסבר |
|---|---|---|
mov ecx, 13 | ecx = 13 | ערך התחלתי |
cmp ecx, 12 | ZF = 0 | שונים |
jne OTHER | ZF = 0 | קופצת אל OTHER |
mov edx, 300 | edx = 0 | לא רצה |
jmp FINISH | edx = 0 | לא רצה |
OTHER: | edx = 0 | מכאן ממשיכים |
mov edx, 500 | edx = 500 | חלק ה-else |
FINISH: | edx = 500 | תווית |
add edx, 2 | edx = 502, ZF = 0 | רצה |
תוצאה: edx=502, בהנחה ש-edx התחיל ב-0.
תרחיש 10: if/else עם חלקי אוגר
הפעם jne שולחת אל חלק ה-else, ושם מחכה העתקה בין החצאים של ebx.
mov ebx, 0x00005C00
cmp bh, 0x30
jne OTHER
mov bl, 0x22
jmp FINISH
OTHER:
sub bh, 0x20
mov bl, bh
FINISH:
add bl, 0x03| פקודה | מצב אחרי הביצוע | הסבר |
|---|---|---|
mov ebx, 0x00005C00 | ebx = 0x00005C00 | bh = 0x5C, bl = 0x00 |
cmp bh, 0x30 | ZF = 0 | 0x5C שונה מ-0x30 |
jne OTHER | ZF = 0 | קופצת אל OTHER |
mov bl, 0x22 | ebx = 0x00005C00 | לא רצה |
jmp FINISH | ebx = 0x00005C00 | לא רצה |
OTHER: | ebx = 0x00005C00 | מכאן ממשיכים |
sub bh, 0x20 | ebx = 0x00003C00, ZF = 0 | 0x5C פחות 0x20 = 0x3C |
mov bl, bh | ebx = 0x00003C3C | bl מקבל 0x3C |
FINISH: | ebx = 0x00003C3C | תווית |
add bl, 0x03 | ebx = 0x00003C3F, ZF = 0 | bl: 0x3C + 3 = 0x3F |
תוצאה: ebx=0x00003C3F.
קפיצה אחורה: לולאה עם מונה
תרחיש 11: jne שחוזרת למעלה
התווית REPEAT יושבת מעל הקפיצה, ולכן jne כאן מחזירה אחורה, ו-dec ecx כותבת לדגל בכל סיבוב. הלולאה נגמרת כשהמונה מגיע ל-0.
mov edx, 0
mov ecx, 4
REPEAT:
add edx, 5
dec ecx
jne REPEAT| פקודה | מצב אחרי הביצוע | הסבר |
|---|---|---|
mov edx, 0 | edx = 0 | ערך התחלתי |
mov ecx, 4 | ecx = 4 | המונה |
add edx, 5 | edx = 5 | סיבוב 1 (מתחת לתווית REPEAT) |
dec ecx | ecx = 3, ZF = 0 | 3 אינו אפס |
jne REPEAT | ZF = 0 | חוזרת אל REPEAT |
add edx, 5 | edx = 10 | סיבוב 2 |
dec ecx | ecx = 2, ZF = 0 | עדיין לא אפס |
jne REPEAT | ZF = 0 | חוזרת |
add edx, 5 | edx = 15 | סיבוב 3 |
dec ecx | ecx = 1, ZF = 0 | עדיין לא אפס |
jne REPEAT | ZF = 0 | חוזרת |
add edx, 5 | edx = 20 | סיבוב 4 |
dec ecx | ecx = 0, ZF = 1 | התוצאה אפס |
jne REPEAT | ZF = 1 | אין קפיצה; יוצאים מהלולאה |
תוצאה: edx=20, ecx=0. גוף הלולאה רץ ארבע פעמים, כמו הערך ההתחלתי של המונה.
מלכודות ותרגול
טעויות נפוצות
- המעקב נגמר כשמגיעים לתווית. השורות שאחרי התווית רצות בין שקפצו ובין שלא, ובלעדיהן התשובה חסרה.
movמעתיקה את הערך שהיה במקור בתחילת הקוד. היא מעתיקה את הערך שיש במקור ברגע הביצוע, אחרי כל השינויים שקדמו לה.- אפשר להריץ את כל השורות ורק בסוף לבדוק אם הייתה קפיצה. קודם קובעים את ZF ומחליטים אם
jneקופצת. רק אז יודעים אילו שורות בכלל רצות. - פקודה על תת אוגר מעדכנת את האוגר השלם. היא משנה רק את החלק שכתוב בה, וגלישה נשארת בתוכו.
בדקו את עצמכם
הקוד: mov ecx, 0x0300, cmp ch, 0x04, jne L1, mov cl, 0x66, L1:, mov ch, cl. מה ecx מחזיק בסוף?
ch=0x03 שונה מ-0x04, ולכן jne קופצת ו-mov cl, 0x66 נעקפת. mov ch, cl מעתיקה את cl=0x00 אל ch, וכך ecx=0x00000000.
הקוד: mov ebx, 0x0009, cmp bl, 0x09, jne L1, add bl, 0xFE, L1:, add bl, 0x02. מה ebx מחזיק בסוף?
שווים, ולכן jne לא קופצת. add bl, 0xFE: 0x09 + 0xFE = 0x107, וב-8 ביט נשאר 0x07. אחר כך add bl, 0x02 מביאה ל-0x09, כלומר ebx=0x00000009.
שיטת פתרון לשאלת מעקב
שבעה צעדים
- פירוק. לכל אוגר בקוד, רשמו את ערכו ההתחלתי ולצדו את תתי האוגרים שהקוד נוגע בהם, למשל 0x00002758 = ah 0x27, al 0x58.
- ההשוואה. מה עומד מול מה? שם תת האוגר בשורת ה-cmp קובע אילו ספרות נבדקות, ובסוף הצעד רושמים 'שווים' או 'שונים'.
- מי דיבר אחרון. בין ה-cmp ל-jne יכולה להסתתר
add,sub,inc,decאוcmpנוספת. אם יש כזאת, היא ולא ההשוואה קובעת את ZF;movלא נחשבת. - ההחלטה. ZF=0 פירושו קפיצה, ואז מוחקים בדמיון את השורות שבין
jneלתווית. - החישוב. מריצים רק את מה ששרד, וכל פקודה בגודל של האופרנד שלה, כך שגלישה ב-al לא נוגעת ב-ah.
- הזנב. ממשיכים אחרי התווית עד השורה האחרונה, תמיד.
- הבדיקה. ממירים לבסיס של התשובות אם צריך, ומשווים את מה שיצא לטבלת הטעויות שלהלן.
איך נראות התשובות השגויות
מי שחיבר את השאלה בנה את התשובות השגויות מטעויות אמיתיות של נבחנים. לכן תשובה שנראית כמו אחת מהן היא אות אזהרה: אתרו את השורה המתאימה בטבלה, ובדקו שוב את הצעד שהיא מצביעה עליו.
| הטעות | מה קרה בה |
|---|---|
| השמטת הזנב | הפקודה שאחרי התווית לא בוצעה |
| כיוון הקפיצה הפוך | jne טופלה כאילו היא קופצת בשוויון, ולכן נעקף קוד שהיה צריך לרוץ, או להפך |
| ההשוואה הראשונה במקום האחרונה | ZF נלקח מה-cmp, אף ש-add או sub אחריה כתבו לו מחדש |
| האוגר הלא נכון | החישוב נעשה על eax כשבפקודה כתוב al, או התחיל מהמספר שהושווה במקום מתוכן האוגר |
| נשיאה שזלגה | גלישה של al שינתה גם את ah, או להפך |
| שני חצאים לסכום אחד | ah ו-al חוברו זה לזה, במקום שרק החלק שבפקודה ישתנה |
| mov שנקראה הפוך | mov ah, al נקראה כהעתקה מ-ah; בפועל al הוא המקור ו-ah היעד |
טעויות נפוצות
- רוחב הפקודה לא חשוב כשמחשבים גלישה. אותו חיבור גולש ב-al ולא גולש ב-eax. הגודל שכתוב בפקודה קובע את התוצאה.
- את הקפיצה מחליטים לפי הערך שהיה באוגר בתחילת הקוד. מחליטים לפי ZF, כפי שקבעה אותו הפקודה האחרונה שכתבה לו.
- שאלה קצרה אפשר לפתור בראש, בלי לרשום ערכי ביניים. בלי לרשום את ערכו של כל חצי אחרי כל שורה, קל לאבד עדכון אחד, במיוחד בהעתקות בין חצאים.
בדקו את עצמכם
הריצו את שבעת הצעדים על mov ebx, 0x0700, cmp bl, 0x07, jne SKIP, add ebx, 1, SKIP:, mov bl, bh. מה ebx בסוף?
פירוק: bh=0x07 ו-bl=0x00. cmp bl, 0x07 מעמידה 0x00 מול 0x07: שונים, ZF=0, ו-jne קופצת מעל add ebx, 1. אחרי התווית mov bl, bh מעתיקה 0x07 אל bl, ולכן ebx=0x00000707.
ועכשיו mov edx, 0x0060, cmp dl, 0x60, jne SKIP, sub dl, 0x75, SKIP:, add dl, 0x02. מה edx בסוף?
dl=0x60 שווה ל-0x60, ZF=1, ו-jne לא קופצת. sub dl, 0x75 נותנת הפרש שלילי, ולכן גולשת ל-0x160 פחות 0x75, כלומר 0xEB, ו-dh נשאר 0x00. אחרי התווית add dl, 0x02 מביאה ל-0xED, ולכן edx=0x000000ED.
סיכום
מה משתנה בכל שורה.
- פקודה על תת אוגר (al, ah, ax) משנה רק אותו, וגלישה מסתובבת בתוך הגודל שלו בלי לגעת בשכן.
movמעתיקה, לא מחליפה, ולוקחת את מה שיש במקור באותו רגע.addו-subמחשבות בגודל של היעד, ו-subמחסרת את המקור מהיעד.- בכל פקודה עם שני אופרנדים הגדלים חייבים להתאים, ושני תאי זיכרון באותה פקודה אסורים.
איך נקבעת ההחלטה.
cmp a, bמחסרת וזורקת את ההפרש: האופרנדים לא משתנים, רק הדגלים. היא משווה רק את החלק שכתוב בה.- ZF=1 פירושו 'התוצאה האחרונה הייתה אפס', ואחרי cmp: 'שווים'. ZF=0 הוא כל השאר.
- חמש פקודות כותבות ל-ZF:
cmp,add,sub,inc,dec.mov,jmpו-jneלא נוגעות בו, ולכן קובעת הכותבת האחרונה לפני ה-jne.
לאן הביצוע הולך.
jne label, שנקראת גםjnz, קופצת כש-ZF=0, כלומר כשהערכים שונים; כש-ZF=1 ממשיכים לשורה הבאה.jmp labelקופצת בכל מצב.- השורות שבין jne שקפצה לבין התווית לא רצות. תווית, שנכתבת
NAME:, אינה פקודה, ומה שמתחתיה רץ בכל דרך שבה מגיעים אליה. - ב-if/else,
jmpאל הסוף מיד אחרי חלק ה-if מונעת מחלק ה-else לרוץ גם הוא.
| פקודה | כותבת ל-ZF? | מה היא עושה |
|---|---|---|
cmp a, b | כן | מחשבת a פחות b בלי לשמור |
add d, s | כן | d מקבל d + s, בגודל של d |
sub d, s | כן | d מקבל d פחות s, בגודל של d |
inc d / dec d | כן | מוסיפה 1 או מורידה 1 |
mov d, s | לא | מעתיקה את s אל d |
jne L | לא | קופצת אל L כש-ZF = 0 |
jmp L | לא | קופצת אל L תמיד |
L: | לא | תווית, לא פקודה |