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

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

תנאים ו-labels

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

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

חומר לימוד

תנאים ו-labels: השוואה, דגל האפס וקפיצות באסמבלי x86

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

  • cmp: הפקודה שמעמידה שני ערכים זה מול זה ומשאירה את התשובה בדגל.
  • ZF, דגל האפס: הביט שמעביר את תשובת ההשוואה אל פקודת הקפיצה.
  • jne ו-jmp: קפיצה שתלויה בדגל, וקפיצה שמתבצעת תמיד.
  • labels (תוויות): השמות שמסמנים לאן קופצים.
  • הכלים שבלעדיהם אי אפשר לעקוב אחרי הקוד: אוגרים ותתי אוגרים, והפקודות mov, add, sub, inc ו-dec.

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

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

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

איך המעבד מתקדם בקוד. בתוך המעבד יש אוגר אחד שתפקידו לסמן 'איפה אנחנו': EIP (Instruction Pointer, מצביע ההוראה). הוא מצביע תמיד על הפקודה הבאה בתור, ובכל פעם שפקודה מסתיימת הוא זז מעצמו לזו שכתובה מתחתיה, כך שהביצוע עובר פקודה אחת בכל פעם, לפי סדר הכתיבה.

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

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

מי שמחפש ב-x86 פקודת if לא ימצא אותה. במקומה עובד צמד: קודם cmp בודקת ומשאירה סימן בדגל, ומיד אחריה jne מעיינת בסימן ובוחרת לאן להמשיך.

Assembly
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; האורך רק רומז לאוגר שבו הוא יושב.

כתיב הקסדצימליחישובערך עשרוני
0x0C1212
0x111×16 + 117
0x191×16 + 925
0x282×16 + 840
0x3E3×16 + 1462
0x404×16 + 064
0x646×16 + 4100
0x808×16 + 0128
0xC812×16 + 8200
0xFF15×16 + 15255

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

אפשר לחשוב על זה כעל בובות מטריושקה: ah ו-al יושבים בתוך ax, ו-ax יושב בתוך eax. לכן שינוי ב-al משנה גם את מה שתקראו מ-ax ומ-eax.

הדרך המהירה לפרק ערך הקסדצימלי: ספרו זוגות של ספרות מימין לשמאל, כי כל זוג הוא בית (byte). הזוג הראשון מימין שייך ל-al, הזוג השני ל-ah, ושני הזוגות יחד נותנים את ax.

ערך האוגר eaxaxahal
0xCAFEBABE0xBABE0xBA0xBE
0x000045000x45000x450x00
0x00009ABC0x9ABC0x9A0xBC
0x000000410x00410x000x41

ומה עם ארבעת האוגרים האחרים? esi, edi, ebp ו-esp מציעים רק חצי של 16 ביט (si, di, bp, sp), בלי שמות לבתים בודדים, ובשאלות של הנושא הם לא מופיעים.

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

כתיבה לחלק של אוגר

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

בכל שורה בטבלה, ebx מתחיל מאותו ערך, 0xA1B2C3D4:

פקודהמה נכתבebx אחרי הפקודה
mov bl, 0x07רק הבית bl0xA1B2C307
mov bh, 0x07רק הבית bh0xA1B207D4
mov bx, 0x070716 הביטים הנמוכים; החצי העליון 0xA1B2 לא זז0xA1B20707
mov ebx, 0x07האוגר כולו, ולכן גם החצי העליון מתאפס0x00000007

העיקרון לא מוגבל להעתקה; הוא חל על כל פקודה שכותבת לאוגר. הטבלה בחלק הבא מראה אותו בפעולה עם add ועם sub.

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

גלישה שנשארת בתוך החלק

תת אוגר של 8 ביט מכיל מספרים מ-0x00 עד 0xFF בלבד. חשבון שחורג מהגבולות האלה מתנהג כמו מד מרחק ישן ברכב, שאחרי 999999 מציג שוב 000000; במונחים מתמטיים, התוצאה נלקחת מודולו 256.

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

רוחבהערך הגבוה ביותרהגבוה ביותר ועוד 10 פחות 1
8 ביט0xFF0x000xFF
16 ביט0xFFFF0x00000xFFFF
32 ביט0xFFFFFFFF0x000000000xFFFFFFFF

בחיסור מתחת לאפס עוזר לדמיין ספרה נוספת משמאל, שממנה לווים. ב-8 ביט, 0x00 פחות 1 מחושב כמו 0x100 פחות 1.

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

ערך התחלתיפקודהערך סופימה קרה
edx = 0x000001FFadd dl, 1edx = 0x00000100dl גלש ל-0x00, ו-dh נשאר 0x01
edx = 0x000001FFadd dx, 1edx = 0x00000200ב-16 ביט יש מקום לנשיאה, והיא מעלה את dh ל-0x02
edx = 0x000001FFadd edx, 1edx = 0x00000200האוגר השלם, אותה תוצאה
edx = 0x00000100sub dl, 1edx = 0x000001FFdl גלש למטה ל-0xFF, ו-dh לא נתן הלוואה
edx = 0x00000100sub dx, 1edx = 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 שנפגוש בהמשך הפרק:

Assembly
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 bits
פלט
bad.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, 0x41ecx = 0x00000041האוגר כולו מקבל את המספר
ebx = 0x0000004Cmov bh, blebx = 0x00004C4Cbl מועתק אל bh, ו-bl עצמו לא זז
ebx = 0x0000ABCDmov bl, bhebx = 0x0000ABABbh מועתק אל bl, וה-0xCD שהיה ב-bl אבד
eax = 3, edx = 8mov eax, edxeax = 8, edx = 8העתקה ולא החלפה: גם edx נשאר 8

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

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

add: חיבור

add dest, src מניחה ביעד את סכום שני האופרנדים, והמקור נשאר כפי שהיה. בדרך היא גם קובעת את ZF לפי הסכום, נושא שנחזור אליו בפרק על דגל האפס.

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

הגודל של היעד הוא גם הגודל של החשבון. חיבור ל-dl נעשה ב-8 ביט, וכל נשיאה שיוצאת ממנו אובדת לפני שהיא מגיעה ל-dh:

לפניפקודהאחריהסבר
ecx = 31add ecx, 6ecx = 3731 ועוד 6
edx = 0x00000040add dl, 0x09edx = 0x00000049רק dl משתנה
ebx = 0x000000E8add bl, 0x30ebx = 0x000000180xE8 + 0x30 = 0x118; ב-bl נשאר 0x18, והנשיאה לא מגיעה ל-bh
ebx = 0x000000E8add ebx, 0x30ebx = 0x00000118באוגר השלם יש מקום, והנשיאה נשמרת
חזרה לתוכן העניינים

sub: חיסור

sub dest, src מורידה את המקור מהיעד, וההפרש נשאר ביעד.

כאן הסדר מכריע: sub ebx, 4 פירושה ebx פחות 4, ומי שהופך את הכיוון מקבל מספר אחר לגמרי. בכל השאר sub מתנהגת כמו add, עם אותן צורות אופרנדים ואותה השפעה על ZF.

ומה קורה כשמחסרים יותר ממה שיש? המעבד לא כותב סימן מינוס, אלא ממשיך לספור אחורה מסוף הטווח. בחישוב ידני מוסיפים ליעד 1 מעל הספרה העליונה ורק אז מחסרים: ב-8 ביט, 0x00 פחות 0x30 הופך ל-0x100 פחות 0x30, כלומר 0xD0.

לפניפקודהאחריהסבר
ebx = 25sub ebx, 4ebx = 2125 פחות 4, ולא 4 פחות 25
ecx = 0x00004000sub cl, 0x20ecx = 0x000040E0cl גלש למטה, ו-ch נשאר 0x40
ecx = 0x00004000sub ecx, 0x20ecx = 0x00003FE0באוגר השלם ההלוואה ממשיכה ומורידה גם את ch
eax = 0x00000000sub ax, 0x0003eax = 0x0000FFFD16 ביט: 0x10000 פחות 3
edx = 0x00000000sub edx, 2edx = 0xFFFFFFFE32 ביט
חזרה לתוכן העניינים

inc ו-dec: צעד אחד למעלה או למטה

inc dest מגדילה את היעד ב-1, ו-dec dest מקטינה אותו ב-1.

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

לפניפקודהאחרי
ebx = 12inc ebxebx = 13, ZF = 0
edx = 1dec edxedx = 0, ZF = 1
ecx = 0x000000FFinc clecx = 0x00000000, ZF = 1
eax = 0dec eaxeax = 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, 0x40bl (0x40) מול 0x40שווים, ZF = 1
cmp bh, 0x02bh (0x02) מול 0x02שווים, ZF = 1
cmp bx, 0x40bx (0x0240) מול 0x0040שונים, ZF = 0
cmp ebx, 0x40ebx (0x00000240) מול 0x40שונים, ZF = 0

בפועל, לפני שמחשבים משהו, מסמנים איזה שם כתוב משמאל לפסיק בשורת ה-cmp. ch ו-cl הם שני בתים שונים, ומי שמתבלבל ביניהם בונה את כל ההמשך על הבית הלא נכון.

למשל, כש-ecx מחזיק 0x00005000, הבית 0x50 נמצא ב-ch, ו-cl ריק. לכן cmp ch, 0x50 מדליקה את ZF, ו-cmp cl, 0x50 משאירה אותו כבוי.

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

דוגמאות קצרות

לפניפקודהZF אחריהסבר
ecx = 41cmp ecx, 40ZF = 041 פחות 40 הוא 1, לא אפס. ecx נשאר 41
ecx = 41cmp ecx, 41ZF = 1ההפרש אפס
edx = 0x60cmp dl, 0x70ZF = 0שונים, ו-edx לא השתנה
eax = 0x00005678cmp al, 0x78ZF = 1al הוא 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, ba ו-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התוצאה 0bl=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 שבאה אחריה עוברת לידו בלי להשאיר סימן.

Assembly
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, 0x08ZF = 0dl הוא 0x30, שונה מ-0x08
mov ecx, 9ZF = 0mov לא נוגעת בדגל
sub dl, 0x30ZF = 1dl יורד ל-0x00; התוצאה אפס והדגל נכתב מחדש
jne NEXTZF = 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 נבדק מול הערך שהוא עצמו מחזיק.

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

Assembly
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, ובלבד שהקפיצה משתמשת בדיוק באותו שם. תוויות רבות יכולות לחיות באותו קוד, אבל אסור להגדיר שם אחד פעמיים.

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

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

מה נעקף, ומה רץ תמיד

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

Assembly
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, 20sub ecx, 1
ecx שונה מ-8קופצת אל AFTERלא רצהרצה
ecx שווה ל-8לא קופצתרצהרצה (המעבר דרך התווית רגיל)

בהרצה עם ecx=3 מתקבל 2, ועם ecx=8 מתקבל 27 (8 ועוד 20, פחות 1).

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

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

_start ומבנה של קובץ שלם

תוכנית שלמה ב-NASM צריכה לומר למערכת מאיפה להתחיל. את זה עושה התווית _start:, שנחשפת החוצה בעזרת global _start, ואת הפקודות עצמן שמים תחת section .text.

Assembly
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 $? מדפיסה את קוד היציאה:

Bash
nasm -f elf32 prog.asm -o prog.o
ld -m elf_i386 prog.o -o prog
./prog
echo $?
פלט
12

9 שווה ל-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
חזרה לתוכן העניינים

דוגמה: עקיפה של שורה

Assembly
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

כמעט כל שאלה בנושא היא וריאציה על השלד הבא:

Assembly
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

Assembly
cmp x, y
jne OTHER
; the if part: x == y
jmp FINISH
OTHER:
; the else part: x != y
FINISH:
; the continuation
מצבמה קורהמה מתבצע
x שווה ל-yjne לא קופצת, חלק ה-if רץ, ו-jmp FINISH עוקפת את חלק ה-elseחלק ה-if, ואחריו FINISH
x שונה מ-yjne קופצת אל OTHERחלק ה-else, ואחריו FINISH
חזרה לתוכן העניינים

מה קורה כשה-jmp חסר

מה יקרה אם נשמיט את jmp FINISH? כשהערכים שונים, שום דבר לא משתנה, כי jne ממילא קופצת ישר ל-else. אבל כשהם שווים, המעבד מסיים את חלק ה-if וגולש הלאה לתוך חלק ה-else.

Assembly
mov ecx, 3
cmp ecx, 3
jne OTHER
mov edx, 40   ; runs
OTHER:
mov edx, 70   ; runs as well, since nothing jumps over it

edx מסיים ב-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 דרך שתי הפעולות.

Assembly
mov ecx, 45
cmp ecx, 45
jne NEXT
add ecx, 8
NEXT:
sub ecx, 3
פקודהמצב אחרי הביצועהסבר
mov ecx, 45ecx = 45העתקה
cmp ecx, 45ecx = 45, ZF = 145 פחות 45 הוא 0: שווים
jne NEXTecx = 45, ZF = 1ZF=1, אין קפיצה, ממשיכים למטה
add ecx, 8ecx = 53, ZF = 0רצה. גם היא כותבת ל-ZF, אבל אחריה אין עוד קפיצה
NEXT:ecx = 53תווית: עוברים דרכה
sub ecx, 3ecx = 50, ZF = 0רצה בכל מקרה

התוצאה: ecx=50, וכל השורות רצו.

תרחיש 2: ערכים שונים, ולכן החיסור נעקף

הפעם 23 מול 17. מה קורה לחיסור שבאמצע?

Assembly
mov edx, 23
cmp edx, 17
jne SKIP
sub edx, 5
SKIP:
add edx, 9
פקודהמצב אחרי הביצועהסבר
mov edx, 23edx = 23ערך התחלתי
cmp edx, 17edx = 23, ZF = 023 פחות 17 הוא 6: שונים
jne SKIPedx = 23, ZF = 0ZF=0, קופצת אל SKIP
sub edx, 5edx = 23לא רצה
SKIP:edx = 23מכאן ממשיכים
add edx, 9edx = 32, ZF = 0רצה

התוצאה: edx=32. רצו השורות 1, 2, 3, (5), 6.

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

הקסדצימלי: השוואה על בית אחד

תרחיש 3: השוואה על al, וחיבור לאוגר השלם

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

Assembly
mov eax, 0x00C4
cmp al, 0xC4
jne MERGE
add eax, 0x0020
MERGE:
sub al, 0x09
פקודהמצב אחרי הביצועהסבר
mov eax, 0x00C4eax = 0x000000C4ah = 0x00, al = 0xC4
cmp al, 0xC4ZF = 1al שווה ל-0xC4
jne MERGEZF = 1אין קפיצה
add eax, 0x0020eax = 0x000000E4, ZF = 00xC4 + 0x20 = 0xE4
MERGE:eax = 0x000000E4תווית
sub al, 0x09eax = 0x000000DB, ZF = 00xE4 פחות 9: 228 פחות 9 הם 219, כלומר 0xDB

התוצאה: eax=0x000000DB, שהם 219 בעשרוני.

תרחיש 4: השוואה על ah, והעתקה בין החצאים

שאלה ראשונה: איזה בית בודקת cmp ah, 0x27? רק אחרי שעונים עליה אפשר להמשיך.

Assembly
mov eax, 0x2758
cmp ah, 0x27
jne SKIP
sub eax, 0x0058
mov al, ah
SKIP:
add ah, 0x02
פקודהמצב אחרי הביצועהסבר
mov eax, 0x2758eax = 0x00002758ah = 0x27, al = 0x58
cmp ah, 0x27ZF = 1ah שווה ל-0x27; al לא משתתף
jne SKIPZF = 1אין קפיצה
sub eax, 0x0058eax = 0x00002700, ZF = 00x2758 פחות 0x58 = 0x2700, ו-al מתאפס
mov al, aheax = 0x00002727al מקבל את ערכו של ah, 0x27
SKIP:eax = 0x00002727תווית
add ah, 0x02eax = 0x00002927, ZF = 0רק ah עולה, מ-0x27 ל-0x29

התוצאה: eax=0x00002927.

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

גלישה בתוך חלק של אוגר

תרחיש 5: חיסור שגולש ב-cl, ואחריו העתקה

שלוש מלכודות ברצף: גלישה למטה ב-cl, העתקה של הערך הגלוש אל ch, וגלישה למעלה בסוף.

Assembly
mov ecx, 0x4500
cmp ch, 0x45
jne JOIN
sub cl, 0x03
mov ch, cl
JOIN:
add cl, 0x05
פקודהמצב אחרי הביצועהסבר
mov ecx, 0x4500ecx = 0x00004500ch = 0x45, cl = 0x00
cmp ch, 0x45ZF = 1ch שווה ל-0x45
jne JOINZF = 1אין קפיצה
sub cl, 0x03ecx = 0x000045FD, ZF = 0cl: 0x00 פחות 3 גולש ל-0xFD; ch לא זז
mov ch, clecx = 0x0000FDFDch מקבל 0xFD
JOIN:ecx = 0x0000FDFDתווית
add cl, 0x05ecx = 0x0000FD02, ZF = 0cl: 0xFD + 5 = 0x102, ונשאר 0x02. הנשיאה נעלמת ו-ch לא משתנה

התוצאה: ecx=0x0000FD02.

תרחיש 6: חיבור שגולש ב-bl

כאן הגלישה היא בחיבור, ו-mov bh, bl מקבלת את מה שנשאר ב-bl אחריה.

Assembly
mov ebx, 0x00E0
cmp bl, 0xE0
jne TAIL
add bl, 0x45
mov bh, bl
TAIL:
add bx, 0x0003
פקודהמצב אחרי הביצועהסבר
mov ebx, 0x00E0ebx = 0x000000E0bh = 0x00, bl = 0xE0
cmp bl, 0xE0ZF = 1שווים
jne TAILZF = 1אין קפיצה
add bl, 0x45ebx = 0x00000025, ZF = 00xE0 + 0x45 = 0x125; ב-8 ביט נשאר 0x25, ו-bh לא מושפע
mov bh, blebx = 0x00002525bh מקבל 0x25
TAIL:ebx = 0x00002525תווית
add bx, 0x0003ebx = 0x00002528, ZF = 016 ביט: 0x2525 ועוד 3

התוצאה: ebx=0x00002528.

תרחיש 7: השוואה על dx ופעולות של 16 ביט

ההשוואה ברוחב 16 ביט, ושתי העתקות בין dl ל-dh מחייבות לדעת מה יש בכל בית בדיוק ברגע שלהן.

Assembly
mov edx, 0x0050
cmp dx, 0x0050
jne NEXT
add edx, 0x0004
mov dl, dh
NEXT:
sub dx, 0x0006
mov dh, dl
פקודהמצב אחרי הביצועהסבר
mov edx, 0x0050edx = 0x00000050dh = 0x00, dl = 0x50
cmp dx, 0x0050ZF = 1dx שווה ל-0x0050
jne NEXTZF = 1אין קפיצה
add edx, 0x0004edx = 0x00000054, ZF = 0חיבור לאוגר השלם
mov dl, dhedx = 0x00000000dh הוא 0x00, ולכן dl מתאפס
NEXT:edx = 0x00000000תווית
sub dx, 0x0006edx = 0x0000FFFA, ZF = 016 ביט: 0x0000 פחות 6 גולש ל-0xFFFA
mov dh, dledx = 0x0000FAFAdl (0xFA) מועתק אל dh

התוצאה: edx=0x0000FAFA.

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

פקודה שכותבת על הדגל לפני jne

תרחיש 8: ה-sub קובעת, לא ה-cmp

שימו לב לשורה הרביעית: sub כותבת לדגל אחרי ה-cmp, וה-mov שביניהן לא משנה בו דבר.

Assembly
mov eax, 0x70
cmp al, 0x25
mov ecx, 8
sub al, 0x70
jne SKIP
add eax, 0x200
SKIP:
add al, 0x04
פקודהמצב אחרי הביצועהסבר
mov eax, 0x70eax = 0x00000070al = 0x70
cmp al, 0x25ZF = 00x70 שונה מ-0x25
mov ecx, 8ecx = 8, ZF = 0mov לא נוגעת בדגלים
sub al, 0x70eax = 0x00000000, ZF = 1al: 0x70 פחות 0x70 = 0; הדגל נכתב מחדש
jne SKIPZF = 1אין קפיצה; ההחלטה באה מה-sub
add eax, 0x200eax = 0x00000200, ZF = 0רצה
SKIP:eax = 0x00000200תווית
add al, 0x04eax = 0x00000204, ZF = 0al = 0x04

התוצאה: eax=0x00000204. מי שהחליט לפי ה-cmp היה קופץ, עוקף את החיבור של 0x200, ועונה בטעות 0x00000004.

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

if/else מלא

תרחיש 9: אותו קוד, שתי הרצות

שתי הרצות של אותו קוד, עם ecx=12 ועם ecx=13; edx מתחיל ב-0.

Assembly
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, 12ecx = 12ערך התחלתי
cmp ecx, 12ZF = 1שווים
jne OTHERZF = 1אין קפיצה
mov edx, 300edx = 300חלק ה-if
jmp FINISHedx = 300קופצת מעל חלק ה-else
OTHER: ו-mov edx, 500edx = 300לא רצות
FINISH:edx = 300תווית
add edx, 2edx = 302, ZF = 0רצה

תוצאה: edx=302.

הרצה שנייה, ecx=13:

פקודהמצב אחרי הביצועהסבר
mov ecx, 13ecx = 13ערך התחלתי
cmp ecx, 12ZF = 0שונים
jne OTHERZF = 0קופצת אל OTHER
mov edx, 300edx = 0לא רצה
jmp FINISHedx = 0לא רצה
OTHER:edx = 0מכאן ממשיכים
mov edx, 500edx = 500חלק ה-else
FINISH:edx = 500תווית
add edx, 2edx = 502, ZF = 0רצה

תוצאה: edx=502, בהנחה ש-edx התחיל ב-0.

תרחיש 10: if/else עם חלקי אוגר

הפעם jne שולחת אל חלק ה-else, ושם מחכה העתקה בין החצאים של ebx.

Assembly
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, 0x00005C00ebx = 0x00005C00bh = 0x5C, bl = 0x00
cmp bh, 0x30ZF = 00x5C שונה מ-0x30
jne OTHERZF = 0קופצת אל OTHER
mov bl, 0x22ebx = 0x00005C00לא רצה
jmp FINISHebx = 0x00005C00לא רצה
OTHER:ebx = 0x00005C00מכאן ממשיכים
sub bh, 0x20ebx = 0x00003C00, ZF = 00x5C פחות 0x20 = 0x3C
mov bl, bhebx = 0x00003C3Cbl מקבל 0x3C
FINISH:ebx = 0x00003C3Cתווית
add bl, 0x03ebx = 0x00003C3F, ZF = 0bl: 0x3C + 3 = 0x3F

תוצאה: ebx=0x00003C3F.

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

קפיצה אחורה: לולאה עם מונה

תרחיש 11: jne שחוזרת למעלה

התווית REPEAT יושבת מעל הקפיצה, ולכן jne כאן מחזירה אחורה, ו-dec ecx כותבת לדגל בכל סיבוב. הלולאה נגמרת כשהמונה מגיע ל-0.

Assembly
mov edx, 0
mov ecx, 4
REPEAT:
add edx, 5
dec ecx
jne REPEAT
פקודהמצב אחרי הביצועהסבר
mov edx, 0edx = 0ערך התחלתי
mov ecx, 4ecx = 4המונה
add edx, 5edx = 5סיבוב 1 (מתחת לתווית REPEAT)
dec ecxecx = 3, ZF = 03 אינו אפס
jne REPEATZF = 0חוזרת אל REPEAT
add edx, 5edx = 10סיבוב 2
dec ecxecx = 2, ZF = 0עדיין לא אפס
jne REPEATZF = 0חוזרת
add edx, 5edx = 15סיבוב 3
dec ecxecx = 1, ZF = 0עדיין לא אפס
jne REPEATZF = 0חוזרת
add edx, 5edx = 20סיבוב 4
dec ecxecx = 0, ZF = 1התוצאה אפס
jne REPEATZF = 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.

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

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

שבעה צעדים

  1. פירוק. לכל אוגר בקוד, רשמו את ערכו ההתחלתי ולצדו את תתי האוגרים שהקוד נוגע בהם, למשל 0x00002758 = ah 0x27, al 0x58.
  2. ההשוואה. מה עומד מול מה? שם תת האוגר בשורת ה-cmp קובע אילו ספרות נבדקות, ובסוף הצעד רושמים 'שווים' או 'שונים'.
  3. מי דיבר אחרון. בין ה-cmp ל-jne יכולה להסתתר add, sub, inc, dec או cmp נוספת. אם יש כזאת, היא ולא ההשוואה קובעת את ZF; mov לא נחשבת.
  4. ההחלטה. ZF=0 פירושו קפיצה, ואז מוחקים בדמיון את השורות שבין jne לתווית.
  5. החישוב. מריצים רק את מה ששרד, וכל פקודה בגודל של האופרנד שלה, כך שגלישה ב-al לא נוגעת ב-ah.
  6. הזנב. ממשיכים אחרי התווית עד השורה האחרונה, תמיד.
  7. הבדיקה. ממירים לבסיס של התשובות אם צריך, ומשווים את מה שיצא לטבלת הטעויות שלהלן.
חזרה לתוכן העניינים

איך נראות התשובות השגויות

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

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