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

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

לולאות

לולאות באסמבלי עם cmp, jne ו-loop: כמה פעמים הלולאה תתבצע ומהו הערך הסופי.

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

חומר לימוד

לולאות: הפקודה loop, מונה ידני וספירת חזרות

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

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

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

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

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

מהי לולאה ומאילו חלקים היא בנויה

למה כותבים לולאה

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

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

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

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

ארבעה רכיבים שחוזרים בכל לולאה

רכיבתפקידודוגמה
אתחולנותן ערכים התחלתיים לפני שהלולאה מתחילה, כולל ערך המונהmov ecx, 4
תווית פתיחהמסמנת את המקום בקוד שאליו חוזריםTICK:
גוףהפקודות שמתבצעות בכל חזרהadd edx, 25
קפיצה מותנית אחורהבתחתית הגוף: מחזירה לתווית כל עוד התנאי מתקיים, ואחרת נותנת לביצוע לגלוש לשורה הבאה, וזו היציאהjne TICK
Assembly
mov ecx, 4          ; setup: four rounds
mov edx, 0
TICK:               ; label: every round starts here
  add edx, 25       ; body
  dec ecx           ; body: the counter moves
  jne TICK          ; back to TICK while ecx is not 0
mov eax, edx        ; reached once, after the last round

בקטע הזה הגוף רץ ארבע פעמים, ובסופו EDX=100. השורה mov eax, edx כתובה מתחת לקפיצה, ולכן היא מתבצעת פעם אחת בלבד, אחרי שהלולאה הסתיימה, ו-EAX מקבל 100.

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

תוויות: שם לכתובת בקוד

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

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

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

השם עצמו שרירותי: TICK, ROUND ו-FIRST עובדים באותה מידה. בתוכנית יכולות להיות תוויות רבות, בתנאי שאין שתיים עם אותו שם.

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

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

בכל הקטעים בפרק מופיעים ארבעה אוגרים: EAX, EBX, ECX ו-EDX. אלה תאי אחסון בתוך המעבד עצמו, מהירים בהרבה מהזיכרון, ובכל אחד מהם נכנסים 32 ביט.

מבחינת לולאות רק אחד מהם מיוחד: ECX, שהפקודה loop משתמשת בו כמונה בלי שתכתבו את שמו, ולכן זה התפקיד המקובל שלו. EAX, EBX ו-EDX משמשים בדרך כלל לנתונים ולחישובים.

32 ביט מספיקים לכל ערך שלם בין 0 ל-4,294,967,295. בטבלאות המעקב חלק מהערכים כתובים בבסיס 16, ואותם מזהים לפי הקידומת 0x:

כתיב הקסדצימליערך עשרוני
0x2032
0x64100
0xA0160
0xFF255
0x180384
0xFFFFFFFF4,294,967,295, הערך המקסימלי ב-32 ביט

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

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

הפקודות שבונות לולאה

סדר האופרנדים, והפקודה mov

שמונה פקודות מרכיבות כמעט כל לולאה בשאלות, ושווה להכיר אותן לפני loop. בכולן חל אותו כלל של תחביר Intel: אחרי שם הפקודה בא קודם האופרנד שמשתנה, ורק אחריו האופרנד שמספק ערך. ב-mov edx, 7, למשל, EDX הוא היעד שמקבל את התוצאה, ו-7 הוא המקור.

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

פקודהמה קורהמותר?
mov edx, 7המקור הוא קבוע, ו-EDX מקבל 7כן
mov ebx, eaxהמקור הוא אוגר: EBX מקבל עותק של EAX, ו-EAX לא משתנהכן
mov ecx, ecxאוגר מועתק לעצמו, ושום ערך לא משתנהכן, אבל בלי שום השפעה
mov 7, edxקבוע לא יכול לשמש יעדלא
mov bx, clאוגר של 16 ביט מול אוגר של 8 ביט: הגדלים לא תואמיםלא
mov [a], [b]שני האופרנדים בזיכרון, ואין העתקה ישירה מזיכרון לזיכרון בפקודה אחתלא
פקודהלפניאחרי
mov edx, 64EDX=3EDX=64
mov ebx, eaxEAX=12, EBX=0EAX=12, EBX=12
mov ecx, 0x20ECX=9ECX=32

בשתי הטבלאות אין עמודת דגלים, וזה לא מקרה: mov לא כותבת לאף דגל. התפקיד הקבוע שלה בשאלות הוא האתחול, למשל mov ecx, N שקובע מראש כמה חזרות תעשה loop. וגם כשהיא יושבת בין cmp ל-jne, הקפיצה עדיין מחליטה רק לפי ה-cmp.

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

add: חיבור אל היעד

ב-add edx, 6 הערך שהיה ב-EDX גדל ב-6, וה-6 עצמו לא נפגע: הסכום נכתב חזרה אל היעד, dest = dest + src. במקום המספר יכול לבוא גם אוגר, ואם זה אותו אוגר, כמו add ebx, ebx, התוצאה היא הכפלה שלו פי 2.

פקודהלפניאחרי
add edx, 6EDX=9EDX=15
add eax, ecxEAX=20, ECX=5EAX=25, ECX=5
add ebx, ebxEBX=40EBX=80
add ecx, 1ECX=0xFFFFFFFFECX=0, גלישה

השורה האחרונה בטבלה מראה שתי תכונות בבת אחת. התוצאה נחתכת לרוחב האוגר, ולכן 0xFFFFFFFF ועוד 1 נותן 0 ולא מספר של 33 ביט. ומכיוון שיצא 0, ZF נדלק: add מדליקה את דגל האפס על תוצאה 0, ומכבה אותו על כל תוצאה אחרת.

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

sub: חיסור מהיעד

sub היא תמונת המראה של add: dest = dest - src, וההפרש נכתב ליעד. בכיוון טועים הכי הרבה, אז שננו אותו: מהאופרנד שכתוב ראשון לוקחים, את האופרנד שכתוב שני מורידים, ואף פעם לא להפך.

פקודהלפניאחרי
sub edx, 1EDX=8EDX=7
sub ebx, ecxEBX=30, ECX=6EBX=24, ECX=6
sub eax, 9EAX=100EAX=91
sub ecx, 1ECX=0ECX=0xFFFFFFFF, גלישה

ZF מתנהג כאן כמו ב-add, ונדלק כשההפרש יוצא 0. זה מה שמאפשר לולאה שבה jne באה ישר אחרי sub בלי cmp בתווך, כפי שתראו בפרק על המונה הידני.

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

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

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

מבחינת התוצאה ומבחינת ZF הן מתנהגות בדיוק כמו add dest, 1 ו-sub dest, 1. ההבדל היחיד, שלא נוגע לשאלות על לולאות, הוא שהן לא משנות את דגל הנשא CF, בניגוד ל-add ול-sub.

פקודהלפניאחרימה לשים לב
inc edxEDX=6EDX=7כמו add edx, 1
dec edxEDX=6EDX=5כמו sub edx, 1
dec edxEDX=1EDX=0, ZF=1תוצאה אפס מדליקה את ZF
dec edxEDX=0EDX=0xFFFFFFFF, ZF=0ההקטנה לא נעצרת ב-0 אלא גולשת

השורה השלישית בטבלה היא בדיוק מה שסיים את לולאת TICK: ה-dec הרביעית הורידה את ECX מ-1 ל-0 והדליקה את ZF, וה-jne שאחריה לא קפצה, בלי שום cmp. השורה הרביעית מראה מה היה קורה אילו ECX היה מתחיל ב-0: גלישה, ZF=0, וקפיצה.

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

cmp: השוואה שלא נוגעת באוגרים

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

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

פקודהמצב האוגריםתוצאה
cmp edx, 0EDX=0ZF=1, ו-EDX עדיין 0
cmp edx, 0EDX=3ZF=0, ו-EDX עדיין 3
cmp ebx, ecxEBX=5, ECX=5ZF=1
cmp eax, 12EAX=18ZF=0

האופרנד השני יכול להיות קבוע או אוגר, כמו בשורה השלישית בטבלה. ואם תתבלבלו בין cmp ל-sub, שאלו דבר אחד: האם ההפרש נשמר ביעד? ב-sub כן, ב-cmp לא.

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

דגל האפס ZF

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

הקריאה שלו פשוטה: 1 אומר שהתוצאה האחרונה הייתה 0, או ש-cmp מצאה שוויון, ו-0 אומר שהיא לא הייתה 0.

פקודההאם היא כותבת ל-ZF?
add, sub, inc, dec, cmpכן, לפי התוצאה
movלא
loopלא
jmpלא, וגם לא קוראת אותו
jneלא, היא רק קוראת אותו

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

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

jmp: קפיצה בלי תנאי

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

Assembly
  mov ebx, 3
  jmp READY
  mov ebx, 40     ; never runs
READY:
  add ebx, 4      ; ebx = 7

ה-mov ebx, 40 לא מתבצעת לעולם, ולכן בסוף EBX=7, כלומר 3 ועוד 4.

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

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

jne: קפיצה כשהערכים שונים

השם jne בא מ-Jump if Not Equal. היא קופצת לתווית כש-ZF=0, כלומר כשההשוואה האחרונה מצאה ערכים שונים או כשהחישוב האחרון לא יצא 0. כש-ZF=1 אין קפיצה, והביצוע ממשיך לשורה שמתחת.

jne עצמה לא מחשבת כלום, היא רק מציצה בפתק של ZF. מה שהיא רואה שם הוא מה שכתבה הפקודה המעדכנת האחרונה, cmp, sub, add, inc או dec, ואילו mov או loop שעומדות בדרך לא נחשבות, כי הן לא כותבות על הפתק.

Assembly
mov edx, 9
cmp edx, 9          ; equal values, so ZF=1
jne ELSEWHERE       ; ZF=1: no jump
mov eax, 2          ; this line runs
ELSEWHERE:

כאן EAX=2, כי הקפיצה לא התבצעה. אילו ההשוואה הייתה cmp edx, 4, היה מתקבל ZF=0, ה-jne הייתה מדלגת אל ELSEWHERE, ו-EAX היה נשאר עם הערך שהיה בו קודם.

ברוב הלולאות הידניות jne היא השורה האחרונה בגוף: היא מחזירה את הביצוע לתווית כל עוד המונה עוד לא הגיע ליעד.

טעויות נפוצות
  • cmp ebx, 4 משנה את EBX. cmp רק מחשבת הפרש בשביל הדגלים וזורקת אותו. EBX נשאר בדיוק כמו שהיה.
  • sub ecx, edx מחשבת EDX פחות ECX. הכיוון תמיד יעד פחות מקור: ECX פחות EDX, והתוצאה נכתבת ל-ECX.
  • jne קופצת כשהשניים שווים. ההפך: היא קופצת כש-ZF=0, כלומר כשהם שונים. בשוויון היא נותנת לביצוע להמשיך למטה.
  • mov שנמצאת בין cmp לבין jne משנה את תוצאת הקפיצה. mov לא כותבת לדגלים, ולכן jne עדיין רואה את מה שה-cmp קבעה.
  • רק cmp יכולה להכין את ZF בשביל jne. גם inc, dec, add ו-sub כותבות ל-ZF לפי התוצאה שלהן.
  • הערך שאוגר קיבל אחרי החזרה הראשונה הוא מספר החזרות. ערך ביניים של אוגר ומספר הפעמים שהגוף רץ הם שני דברים שונים. כדי לדעת כמה חזרות היו, סופרים שורות בטבלת המעקב.
בדקו את עצמכם
EBX=9 ו-ECX=5. מתבצעות sub ebx, ecx ואחריה cmp ebx, 4. מה יש ב-EBX, ומה ערכו של ZF?

sub משאירה ב-EBX את 4. ה-cmp משווה 4 ל-4 ולא כותבת לאוגר, ולכן EBX=4 ו-ZF=1.

ECX=0xFFFFFFFF ומתבצעת inc ecx. מה התוצאה, ומה ZF?

ECX=0, כי ב-32 ביט הערך המקסימלי ועוד 1 גולש ל-0. התוצאה אפס, ולכן ZF=1.

אחרי mov eax, edx, מה השתנה ב-EDX?

שום דבר. EDX הוא המקור, והוא רק נקרא: EAX מקבל עותק של הערך שלו.

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

הפקודה loop

התחביר ומה הפקודה עושה

בפקודה loop כתובה רק תווית, אבל היא עובדת עם שני דברים: התווית, ו-ECX, שלא מופיע בשורה ובכל זאת משתתף תמיד. בכל ביצוע היא לוקחת 1 מ-ECX; אם נשאר בו ערך שאינו 0 היא חוזרת לתווית, ואם נשאר 0 הביצוע ממשיך למטה.

בגלל התפקיד הקבוע הזה ECX נקרא המונה של הלולאה. ודבר אחד loop לא עושה בדרך: היא לא משנה אף דגל.

Assembly
mov ecx, 2
mov edx, 10
BEAT:
  add edx, 5
  loop BEAT         ; ecx = ecx - 1, back to BEAT while ecx != 0

כאן הגוף רץ פעמיים, ולכן EDX עולה מ-10 ל-20.

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

מה קורה ברגע שהמעבד מגיע ל-loop

עקבו אחרי הקטע BEAT ברגע שהמעבד מגיע ל-loop בפעם הראשונה. ECX היה 2, והפקודה קודם מורידה אותו ל-1 ורק אז מסתכלת עליו: 1 אינו 0, ולכן הביצוע חוזר ל-BEAT. בפעם השנייה ECX יורד ל-0, והביצוע ממשיך לשורה שמתחת.

  1. הורדה: ECX = ECX - 1.
  2. החלטה לפי הערך החדש, זה שאחרי ההורדה: שונה מ-0, קפיצה לתווית; שווה ל-0, המשך לפקודה שמתחת ל-loop.

מכאן שאין רגע שבו loop בוחנת את ECX לפני ההורדה, ושעד הבדיקה הראשונה הגוף כבר רץ פעם אחת. ובכל התהליך היא לא כותבת לשום אוגר אחר: מה שקורה ל-EAX, ל-EBX ול-EDX תלוי רק בגוף.

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

ECX=N נותן בדיוק N חזרות

ספרו הורדות: כל חזרה מסתיימת ב-loop אחת, וכל loop לוקחת 1 מ-ECX. אם התחלתם עם ערך N שגדול מ-0, ה-loop היחידה שמשאירה 0 היא ה-N-ית, ולכן הגוף רץ N פעמים בדיוק ו-ECX יוצא מהלולאה כשהוא 0.

ECX לפני הלולאהכמה פעמים הגוף רץECX ביציאה
110
330
440
10100
02 בחזקת 32, ראו בפרק על ECX=00

בלולאת loop שהגוף שלה לא נוגע ב-ECX, מספר החזרות שווה תמיד לערך ש-ECX קיבל לפני הלולאה.

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

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

loop לעומת dec ו-jne

אפשר לפרק את loop ROUND לשתי פקודות שכבר מוכרות לכם, dec ecx ואחריה jne ROUND, ו-ECX יתנהג בדיוק אותו דבר. הפירוק לא מושלם רק בנקודה אחת, הדגלים, כפי שמראה הטבלה:

נקודת השוואהloop ROUNDdec ecx ואחריה jne ROUND
מה קורה ל-ECXיורד ב-1יורד ב-1
מתי קופציםכש-ECX החדש שונה מ-0כש-ZF=0, כלומר כש-ECX החדש שונה מ-0
מה קורה ל-ZFלא משתנהמתעדכן לפי הערך החדש של ECX
חזרה לתוכן העניינים

loop לא נוגעת בדגלים

נניח ש-cmp התבצעה לפני הלולאה, ושורת jne מחכה מתחתיה. אם בגוף יש רק פקודות שלא כותבות לדגלים, כמו mov, ה-jne תחליט לפי אותה cmp, כי loop לא דרסה את ZF בדרך. מעקב מלא של מקרה כזה מופיע בפרק דגלים לפני הלולאה, בתוכה ואחריה.

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

ECX בתוך הגוף: לקרוא אותו ולשנות אותו

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

קריאה: הגוף רץ לפני ה-loop של אותה חזרה, ולכן הוא רואה את ECX עוד לפני ההורדה. בחזרה הראשונה זה N, בשנייה N - 1, ובאופן כללי בחזרה ה-k (כשסופרים מ-1) זה N - k + 1, וזה מה שהופך את add ebx, ecx עם ECX=5 לסכום 5+4+3+2+1=15.

כתיבה: כל שינוי של ECX בגוף מצטרף להורדה של loop, ואז מספר החזרות כבר לא שווה לערך ההתחלתי. dec ecx אחת בגוף, למשל, הופכת כל חזרה להורדה של 2, ולכן ECX=8 נגמר אחרי 4 חזרות ולא אחרי 8.

עם ערך התחלתי אי-זוגי זה כבר מסוכן. ב-ECX=7 ה-loop רואה 5, 3 ו-1, ואז ה-dec שבגוף מורידה את ה-1 ל-0, וה-loop מורידה את ה-0 ל-0xFFFFFFFF. מכאן ה-loop בודקת תמיד ערך אי-זוגי, לא תראה 0 לעולם, והלולאה לא נגמרת.

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

מעקבים עם loop

תרחיש 1: לולאה בסיסית עם ECX=4
Assembly
mov ecx, 4
mov ebx, 0
ROUND:
  add ebx, 1
  loop ROUND
mov edx, ebx
חזרהEBX אחרי addECX אחרי loopהאם קופצים
לפני הלולאה04-
113כן, 3 אינו 0
222כן
331כן
440לא, יוצאים

ארבע חזרות, בדיוק כמו הערך ההתחלתי של ECX. השורה mov edx, ebx רצה פעם אחת אחרי היציאה, ולכן EDX=4.

תרחיש 2: הכפלה בכל חזרה, ECX=5
Assembly
mov ecx, 5
mov eax, 5
DOUBLE:
  add eax, eax      ; eax = eax * 2
  loop DOUBLE

add eax, eax מכפילה את EAX. ECX רק סופר את הסיבובים ולא משתתף בחישוב.

חזרהEAX אחרי add, עשרוניEAX, הקסדצימליECX אחרי loop
לפני50x55
1100xA4
2200x143
3400x282
4800x501
51600xA00, יוצאים

התוצאה היא EAX=160, כלומר 5 כפול 2 בחזקת 5. מי שסופר ארבע הכפלות יגיע ל-80, ומי שסופר שש יגיע ל-320.

תרחיש 3: חיסור קבוע, ECX=6
Assembly
mov ecx, 6
mov edx, 100
SPEND:
  sub edx, 9
  loop SPEND
חזרהEDX אחרי subECX אחרי loopהאם קופצים
לפני1006-
1915כן
2824כן
3733כן
4642כן
5551כן
6460לא, יוצאים

EDX=46: שש הורדות של 9 מ-100, כלומר 100 פחות 54. ספירה של חמש חזרות הייתה נותנת 55, וחיבור במקום חיסור היה נותן 154.

תרחיש 4: הגוף משתמש בערך של ECX, ECX=5
Assembly
mov ecx, 5
mov ebx, 0
SUM:
  add ebx, ecx      ; adds the current counter value
  loop SUM
חזרהECX בזמן הגוףEBX אחרי addECX אחרי loop
1554
2493
33122
42141
51150

EBX=15. מי שהניח ש-ECX קבוע לאורך כל החזרות היה מחשב 5 כפול 5, כלומר 25.

תרחיש 5: dec נוסף בגוף, ECX=8
Assembly
mov ecx, 8
mov eax, 0
HALF:
  add eax, 1
  dec ecx           ; a second decrement in every round
  loop HALF
חזרהEAXECX אחרי decECX אחרי loop
1176
2254
3332
4410, יוצאים

ארבע חזרות במקום שמונה, כי כל חזרה מורידה את ECX ב-2. בסוף EAX=4.

טעויות נפוצות
  • ECX=6 לפני loop נותן חמש חזרות, או שבע. ECX=N נותן בדיוק N חזרות. שגיאה של אחת לכאן או לכאן היא הטעות הנפוצה ביותר בשאלות האלה.
  • loop משנה גם את EAX. היא כותבת רק ל-ECX. כל שינוי באוגר אחר מגיע מפקודות הגוף.
  • בתוך הגוף ECX שומר על הערך ההתחלתי. הוא יורד ב-1 בסוף כל חזרה, ולכן add ebx, ecx מוסיפה ערך אחר בכל סיבוב.
  • add eax, eax מוסיפה ל-EAX את המונה. שני האופרנדים הם EAX, ולכן זו הכפלה של EAX. ECX לא מופיע בפקודה בכלל.
  • הערך שיש באוגר ברגע היציאה מהלולאה הוא התשובה. פקודות שכתובות מתחת ללולאה, כמו add eax, 5 או sub eax, ecx, ממשיכות לשנות את האוגר. התשובה היא הערך אחרי כולן.
  • dec ecx בתוך גוף של loop לא משנה את מספר החזרות. היא מצטרפת להורדה של loop, ו-ECX יורד ב-2 בכל חזרה: פחות חזרות, ועם ערך התחלתי אי-זוגי לולאה שלא נגמרת.
  • loop מדליקה את ZF כש-ECX מגיע ל-0. loop לא כותבת לדגלים בכלל, גם לא ברגע היציאה.
בדקו את עצמכם
ECX=4 ו-EDX=30, והגוף הוא sub edx, 6 ואחריו loop. מה יש ב-EDX בסוף?

ארבע חזרות שכל אחת מורידה 6, כלומר 24 בסך הכול. EDX = 30 - 24 = 6.

אם ECX=1 לפני הלולאה, כמה פעמים רץ הגוף?

פעם אחת. loop מורידה את ECX ל-0, ולכן לא קופצת חזרה.

מה נשאר ב-ECX אחרי שלולאת loop מסתיימת, כשהגוף לא נוגע בו?

0. זה בדיוק המצב שגרם ל-loop להפסיק לקפוץ.

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

המלכודת של ECX=0

מה יוצא מ-0 פחות 1

מה קורה לאוגר של 32 ביט שמכיל 0 כשמורידים ממנו 1? מינוס 1 לא בא בחשבון: בשאלות האלה ערכי האוגר נקראים בלי סימן, מ-0 ועד 0xFFFFFFFF. במקום זה האוגר מסתובב אל הקצה השני של הטווח.

חשבו על שעון דיגיטלי שמראה 00:00: דקה אחת אחורה, והוא מראה 23:59 ולא מינוס דקה. באוגר זה אותו דבר עם מעגל ארוך הרבה יותר: כל החישובים נעשים מודולו 2 בחזקת 32.

רוחב האוגר0 פחות 1המקסימום ועוד 1
8 ביט0xFF0xFF + 1 = 0x00
32 ביט0xFFFFFFFF0xFFFFFFFF + 1 = 0x00000000

בשביל לולאה זה אומר דבר אחד: dec ecx על ECX=0 לא מגיעה לא ל-0 ולא למספר שלילי, אלא ל-0xFFFFFFFF, ערך שאינו 0.

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

loop שמתחילה כש-ECX=0

דמיינו שהמעבד מגיע לקטע SPIN שבהמשך כש-ECX=0. הוא לא עוצר לשאול על ECX: הגוף מתבצע, EBX עולה ל-1, ורק אז loop עושה את מה שהיא עושה תמיד, מורידה 1 ובודקת.

ההורדה מ-0 נותנת 0xFFFFFFFF, ערך רחוק מאוד מ-0, ולכן הקפיצה מתבצעת. מכאן ECX צריך לרדת לאורך כל הטווח עד שיחזור ל-0, וזה קורה רק אחרי 4,294,967,296 חזרות בסך הכול, כלומר 2 בחזקת 32, קצת יותר מ-4 מיליארד.

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

לולאה ידנית לא מצילה מזה. dec ecx על 0 נותנת אותו 0xFFFFFFFF, ZF נשאר 0, ו-jne קופצת בדיוק כמו loop:
Assembly
mov ecx, 0
DRAIN:
  dec ecx           ; 0 - 1 gives 0xFFFFFFFF, ZF=0
  jne DRAIN

גם כאן הגוף רץ 2 בחזקת 32 פעמים. בהרצה אמיתית ECX חזר ל-0, ו-ZF נדלק, רק אחרי 4,294,967,296 הורדות.

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

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

תרחיש 6: ECX=0 לפני loop
Assembly
mov ecx, 0          ; the counter starts at zero
mov ebx, 0
SPIN:
  add ebx, 1
  loop SPIN
חזרהEBX אחרי addECX אחרי loopהאם קופצים
לפני00-
110xFFFFFFFFכן, שונה מ-0
220xFFFFFFFEכן
330xFFFFFFFDכן
............
4,294,967,2960, גם EBX גלש0לא, יוצאים

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

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

טעויות נפוצות
  • ECX=0 פירושו שהגוף לא רץ אף פעם. loop נמצאת בתחתית הגוף, ומורידה לפני שהיא בודקת. הגוף רץ, ואז ECX גולש.
  • הגוף רץ פעם אחת ואז הלולאה עוצרת. אחרי הריצה הראשונה ECX כבר 0xFFFFFFFF, שונה מ-0, ו-loop קופצת שוב ושוב.
  • המעבד ייעצר עם שגיאה, כי ECX=0 אינו ערך חוקי ל-loop. אין שום בדיקה כזו. ההורדה וההשוואה ל-0 מתבצעות כרגיל.
  • 0 פחות 1 הוא מינוס 1, וזה עוצר את הלולאה. באוגר של 32 ביט התוצאה היא 0xFFFFFFFF, ערך גדול מאוד ששונה מ-0.
  • רק loop רגישה ל-ECX=0. dec ecx ואחריה jne נופלות לאותו בור: 0xFFFFFFFF נותן ZF=0, והקפיצה מתבצעת.
בדקו את עצמכם
ECX=0 כשהביצוע מגיע ל-loop בפעם הראשונה. מה יש ב-ECX מיד אחריה, והאם היא קופצת?

0xFFFFFFFF, ולכן היא קופצת חזרה לתווית.

mov ecx, 1 ואחריה לולאת loop. כמה חזרות?

אחת. זה המקרה הרגיל N=1, לא המלכודת: loop מורידה ל-0 ויוצאת.

אוגר של 8 ביט מכיל 0, ומורידים ממנו 1. מה מתקבל?

0xFF, כלומר 255. זה אותו עיקרון כמו 0xFFFFFFFF ב-32 ביט, רק במעגל קצר יותר.

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

לולאה עם מונה ידני

המבנה

loop מחביאה בתוכה שלוש פעולות: הזזת מונה, בדיקה וקפיצה. בלולאה ידנית כותבים את שלושתן במפורש בתחתית הגוף, עם dec, inc, sub או add להזזה, cmp לבדיקה ו-jne לקפיצה, וזה נותן חופש שאין ל-loop.

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

Assembly
mov ebx, 6          ; the counter starts at 6
STEP:
  ...               ; body
  sub ebx, 1        ; move the counter
  cmp ebx, 0        ; compare it with the target
  jne STEP          ; different: one more round
                    ; equal: fall through to the next line

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

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

כשהיעד הוא 0, ה-cmp מיותרת

בקטע של STEP, ה-sub ebx, 1 כבר כתבה ל-ZF את התשובה לשאלה אם EBX הגיע ל-0, עוד לפני ה-cmp. ה-cmp ebx, 0 רק כותבת שוב את אותה תשובה, ולכן כשהיעד הוא 0 אפשר לוותר עליה, וזה נכון לכל אחת מ-dec, sub, add ו-inc:

עם cmpבלי cmp
sub ebx, 1, אחריה cmp ebx, 0, אחריה jne STEPdec ebx, אחריה jne STEP

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

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

יעד כלשהו, בכל כיוון

בקטע של STEP היעד היה 0, אבל cmp מקבלת כל ערך: קבוע, כמו cmp eax, 12, או אוגר אחר, כמו cmp eax, ebx. גם הכיוון חופשי, ומונה יכול לטפס, למשל ב-add eax, 2 עד שהוא משתווה ל-EBX=11.

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

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

הסדר בתוך הגוף משנה את התשובה

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

מה משוויםגרסה א: חיבור ואז הורדהגרסה ב: הורדה ואז חיבור
הגוףadd edx, ebx, ואז sub ebx, 1sub ebx, 1, ואז add edx, ebx
מה מתווסף ל-EDX כש-EBX מתחיל ב-44, 3, 2, 13, 2, 1, 0

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

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

מעקבים עם מונה ידני

תרחיש 7: dec ו-jne בלבד, EDX=5
Assembly
mov edx, 5
mov eax, 0
NEXT:
  add eax, 3
  dec edx           ; dec sets ZF by itself
  jne NEXT
חזרהEAXEDX אחרי decZFjne
1340קופצת
2630קופצת
3920קופצת
41210קופצת
51501לא קופצת, יוצאים

חמש חזרות, ו-EAX=15. המונה כאן הוא EDX, ו-ECX לא משתתף בכלל.

תרחיש 8: שני אוגרים זזים, EDX=20 ו-EBX=4
Assembly
mov edx, 20
mov ebx, 4          ; this time the counter is ebx
GROW:
  add edx, ebx
  sub ebx, 1
  cmp ebx, 0
  jne GROW
mov eax, edx
חזרהEDX אחרי addEBX אחרי subZF אחרי cmpjne
לפני204--
124 (20+4)30קופצת
227 (24+3)20קופצת
329 (27+2)10קופצת
430 (29+1)01לא קופצת

mov eax, edx רק מעתיקה, ולכן EDX=30 וגם EAX=30. מי שהשאיר את EBX על 4 בכל החזרות חישב 20 ועוד 16, כלומר 36. מי שהחליף את סדר השורות בגוף, כמו בגרסה ב, חישב 20+3+2+1+0=26.

תרחיש 9: יעד שאינו 0, והשאלה על אוגר אחר
Assembly
mov eax, 30
mov ecx, 6
CUT:
  sub eax, ecx
  cmp eax, 12       ; the target is 12, not 0
  jne CUT
add ecx, eax
חזרהEAX אחרי subcmp eax, 12jne
לפני30--
124ZF=0קופצת
218ZF=0קופצת
312ZF=1לא קופצת, יוצאים

אחרי הלולאה, add ecx, eax נותנת ECX = 6 + 12 = 18. שימו לב על מה נשאלתם: בתוך הלולאה ECX לא זז, ורק השורה שמתחת לה שינתה אותו. ולהפך, אילו נשאלתם על EAX התשובה הייתה 12, כי add ecx, eax כותבת רק ל-ECX.

תרחיש 10: צעד שגדל, EAX=21 ו-EBX=1
Assembly
mov eax, 21
mov ebx, 1
STAIR:
  sub eax, ebx
  add ebx, 1        ; the step grows each round
  cmp eax, 0
  jne STAIR
חזרהEAX אחרי subEBX אחרי addcmp eax, 0
לפני211-
120 (21-1)2ZF=0, קופצת
218 (20-2)3ZF=0, קופצת
315 (18-3)4ZF=0, קופצת
411 (15-4)5ZF=0, קופצת
56 (11-5)6ZF=0, קופצת
60 (6-6)7ZF=1, יוצאים

שש חזרות, ובסוף EAX=0 ו-EBX=7. המספר 21 הוא רק נקודת ההתחלה של EAX, לא מספר החזרות.

תרחיש 11: בדיקה אחרי כל צעד, ושורה מתחת ללולאה
Assembly
mov edx, 4
mov ecx, 0
PACE:
  add ecx, 2
  add edx, ecx
  cmp ecx, 8
  jne PACE
sub edx, ecx        ; runs once, after the loop
חזרהECX אחרי addEDX אחרי addcmp ecx, 8
לפני04-
126ZF=0, קופצת
2410ZF=0, קופצת
3616ZF=0, קופצת
4824ZF=1, יוצאים

אחרי היציאה, sub edx, ecx נותנת EDX = 24 - 8 = 16. מי שעצר על הערך שביציאה מהלולאה ענה 24. מי שקרא את jne כאילו היא קופצת בשוויון יצא כבר אחרי החזרה הראשונה, עם ECX=2 ו-EDX=6, וקיבל 4.

טעויות נפוצות
  • jne קופצת בשוויון, ולכן הלולאה נגמרת אחרי חזרה אחת. הקפיצה מתבצעת דווקא כשהערכים שונים. היציאה קורית רק כשה-cmp מוצאת שוויון.
  • ברגע שהלולאה נגמרת, אפשר לענות. השורות שמתחת ללולאה רצות גם הן, ולפעמים הן משנות בדיוק את האוגר שנשאלתם עליו.
  • לא משנה אם החיבור בא לפני הזזת המונה או אחריה. הסדר קובע איזה ערך של המונה נכנס לחישוב, ולכן הוא קובע את התשובה.
  • מונה שמשתתף בחישוב שומר על הערך ההתחלתי שלו. הוא זז בכל חזרה, וכל חזרה משתמשת בערך העדכני שלו.
  • אפשר להעיף מבט בשורות ה-mov ולהתחיל לעקוב. טעות של 1 בערך התחלתי, למשל להתחיל מ-2 כשה-mov נתנה 1, משנה כל שורה בטבלה ואת התשובה. קראו את שורות האתחול בעיון לפני שמתחילים.
  • הערך ההתחלתי של המונה הוא מספר החזרות. זה נכון רק כשהמונה יורד ב-1 בכל חזרה עד 0. בכל מקרה אחר צריך לחשב או לעקוב.
  • אחרי dec חייבים cmp מול 0 לפני jne. dec כבר מעדכנת את ZF, ולכן dec ואחריה jne מספיקות כשהיעד הוא 0.
בדקו את עצמכם
EDX=7 ו-EAX=0. הגוף: add eax, 5, dec edx, jne. מה ערכו של EAX בסוף?

שבע חזרות, כל אחת מוסיפה 5, ולכן EAX=35.

EBX=24, והגוף: sub ebx, 8, cmp ebx, 0, jne. כמה חזרות?

EBX עובר ל-16, ל-8 ול-0, ולכן שלוש חזרות.

האם cmp edx, 0 משנה את EDX?

לא. היא כותבת רק לדגלים.

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

ספירת חזרות וחישוב ערכים סופיים

מה נחשב חזרה

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

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

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

נוסחה מהירה למספר החזרות

כשהצעד קבוע אפשר לחסוך את הטבלה: מונה שמתחיל ב-A, זז ב-S בכל חזרה ועוצר ב-T, רץ (המרחק בין A ל-T) חלקי S פעמים. התנאי היחיד הוא שהחלוקה תצא שלמה. אחרת המונה עוקף את היעד, ובצעד של 2 זו לולאה שלא נגמרת, כפי שמוסבר בפרק הבא.

התחלהצעדיעדחישובחזרות
ecx=8-10(8-0)/18
ebx=12-30(12-0)/34
edx=16-44(16-4)/43
eax=35-510(35-10)/55
ecx=11-23(11-3)/24
edx=18-90(18-0)/92
eax=2+19(9-2)/17
eax=1+211(11-1)/25

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

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

איך מגיעים לערך הסופי של אוגר

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

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

Assembly
mov ecx, 5
mov eax, 60
mov ebx, 2
TAKE:
  sub eax, ebx
  add ebx, 2        ; the amount taken grows
  loop TAKE

מ-EAX יורדים 2, 4, 6, 8 ו-10, בסך הכול 30, ולכן EAX=30 ו-EBX=12. מי שהוריד 2 בכל אחת מחמש החזרות קיבל 50, ומי שספר ארבע חזרות קיבל 40.

בקטע הבא כל חזרה עושה שני דברים בסדר קבוע: add eax, eax מכפילה את EAX פי 2, ורק אחריה add eax, 1 מוסיפה 1.

Assembly
mov eax, 2
mov ecx, 4
TWICE:
  add eax, eax      ; double first
  add eax, 1        ; then add one
  dec ecx
  jne TWICE

ערך התחלתי 2 הופך ל-5, ל-11, ל-23 ול-47. אילו הסדר היה הפוך, כלומר הוספה לפני ההכפלה, אותן ארבע חזרות היו נותנות 62, ובלי ה-add eax, 1 בכלל התוצאה הייתה 32.

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

Assembly
mov eax, 10
mov ebx, 2
mov ecx, 4
RISE:
  add eax, ebx      ; add the current ebx
  add ebx, 1        ; only then raise it
  dec ecx
  jne RISE

EAX מקבל בזה אחר זה 2, 3, 4 ו-5, ולכן EAX = 10 + 14 = 24, ו-EBX מסיים ב-6. מי שהתחיל את EBX מ-3 קיבל 28, ומי שספר שלוש חזרות קיבל 19. מי שהתעלם מ-add ebx, 1 הוסיף 2 ארבע פעמים וקיבל 18.

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

שתי לולאות זו אחרי זו

כשלולאה אחת באה אחרי אחרת, חשבו על השנייה כהמשך של הסיפור, לא כהתחלה חדשה. ב-EBX נשאר מה שהראשונה השאירה, ורק mov שכותבת אליו יכולה לשנות את זה.

עם המונה המצב הפוך: הראשונה הסתיימה כי ECX הגיע ל-0, ולכן השנייה צריכה mov ecx, N משלה כדי שיהיה לה מה לספור. וכדי שהקפיצות לא יתערבבו, לכל לולאה תווית בשם אחר, כמו FIRST ו-SECOND במעקב הבא.

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

מעקבים

תרחיש 12: שתי לולאות ברצף
Assembly
mov ecx, 4
mov ebx, 2
FIRST:
  add ebx, 3
  dec ecx
  cmp ecx, 0
  jne FIRST
mov ecx, 3          ; a new count for the second loop
SECOND:
  add ebx, 4
  dec ecx
  cmp ecx, 0
  jne SECOND
שלבEBXECXהערה
אחרי שתי ה-mov הראשונות24נקודת ההתחלה
FIRST, חזרה 153קופצת
FIRST, חזרה 282קופצת
FIRST, חזרה 3111קופצת
FIRST, חזרה 4140יוצאים
mov ecx, 3143EBX לא התאפס
SECOND, חזרה 1182קופצת
SECOND, חזרה 2221קופצת
SECOND, חזרה 3260יוצאים

התוצאה: EBX=26. מי שאיפס את EBX לפני הלולאה השנייה קיבל 12, ומי שהריץ את השנייה ארבע פעמים, כמו הראשונה, קיבל 30. מי ששכח שיש לולאה שנייה עצר על 14.

תרחיש 13: שני dec בכל חזרה, EDX=10
Assembly
mov edx, 10
PAIR:
  dec edx
  dec edx           ; two steps down per round
  cmp edx, 0
  jne PAIR
חזרהEDX אחרי ה-dec הראשוןEDX אחרי ה-dec השניjne
198קופצת
276קופצת
354קופצת
432קופצת
510יוצאים

חמש חזרות, חצי מהערך ההתחלתי, כי כל חזרה מורידה 2. מי שספר רק dec אחת ענה 10, ומי שחשב שה-dec השנייה מכפילה את מספר החזרות ענה 20. עם ערך התחלתי אי-זוגי, כמו 9, הלולאה הזו לא הייתה נגמרת.

תרחיש 14: inc ושני dec, ECX=4
Assembly
mov ecx, 4
mov ebx, 0
MIX:
  add ebx, 7
  inc ecx
  dec ecx
  dec ecx           ; net change per round: -1
  cmp ecx, 0
  jne MIX

נטו, כל חזרה מעלה את ECX ב-1 ומורידה אותו ב-2, כלומר מורידה 1.

חזרהEBXECX אחרי incאחרי ה-dec הראשוןאחרי ה-dec השניjne
17543קופצת
214432קופצת
321321קופצת
428210יוצאים

ארבע חזרות ו-EBX=28, בדיוק כמו בלולאה עם dec אחת. מי שהתעלם מה-inc ספר ירידה של 2 בכל חזרה וענה שתיים, ומי שחשב שהשלוש מבטלות זו את זו הכריז על לולאה אינסופית.

טעויות נפוצות
  • חמש חזרות זה בערך כמו ארבע או שש. שגיאת off-by-one היא הטעות הקלאסית כאן: חזרה אחת יותר או פחות משנה כל תשובה שתלויה בה.
  • מספר החזרות שווה תמיד לערך ההתחלתי של המונה. רק כשהמונה יורד ב-1 בכל חזרה והיעד הוא 0. בצעד אחר או ביעד אחר מחשבים.
  • כש-EDX יורד מ-18 ל-9 בחזרה הראשונה, 9 הוא מספר החזרות. 9 הוא ערך ביניים. בצעד של 9 EDX מגיע ל-0 בחזרה השנייה, ולכן היו שתי חזרות.
  • מונה שעולה נספר אחרת ממונה שיורד. הספירה זהה: המרחק בין ההתחלה ליעד חלקי הצעד, למשל מ-1 עד 11 בצעדים של 2 הן חמש חזרות.
  • dec נוספת בגוף לא משנה את קצב הירידה. שתי הורדות בכל חזרה הן צעד של 2, ומספר החזרות יורד בחצי.
  • כשהתוספת משתנה, מכפילים את התוספת הראשונה במספר החזרות. כש-add ebx, ecx רצה ו-ECX יורד, כל חזרה מוסיפה ערך אחר, וצריך לסכם את כל הערכים.
  • בין שתי לולאות האוגרים חוזרים ל-0. שום דבר לא מאפס אותם. רק mov מפורשת משנה את נקודת ההתחלה של הלולאה השנייה.
בדקו את עצמכם
EDX=40, והגוף: sub edx, 6, cmp edx, 10, jne. כמה חזרות?

34, 28, 22, 16, 10: חמש חזרות. בדיקה בנוסחה: (40-10)/6=5.

EAX=2, והגוף: add eax, 4, cmp eax, 18, jne. כמה חזרות, ומה EAX בסוף?

6, 10, 14, 18: ארבע חזרות, ו-EAX=18.

ECX=3 ו-EDX=10, הגוף: add edx, 4 ואז loop, ומתחת ללולאה mov eax, edx. מה יש ב-EAX?

שלוש חזרות מוסיפות 12, כך ש-EDX=22, וה-mov מעתיקה: EAX=22.

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

לולאה שלא נגמרת

קפיצה אחורה בלי תנאי

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

Assembly
mov edx, 0
FOREVER:
  add edx, 2
  jmp FOREVER       ; no condition, so no way out
mov eax, 1          ; never reached

השורה שמתחת ל-jmp לא תתבצע לעולם.

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

תנאי שאף פעם לא מתקיים

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

Assembly
mov ebx, 4
mov eax, 0
WAIT:
  add eax, 1        ; only eax changes
  cmp ebx, 0        ; ebx is still 4, so ZF=0
  jne WAIT

כאן EAX גדל בכל סיבוב, אבל אף פקודה לא נוגעת ב-EBX, ולכן ה-cmp שואלת בכל פעם את אותה שאלה ומקבלת את אותה תשובה: 4 אינו 0, ZF=0. ה-jne קופצת לנצח, כי המונה לא מתקרב ליעד אפילו בצעד אחד.

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

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

מונה שעובר מעל היעד

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

Assembly
mov ecx, 11
HOP:
  sub ecx, 2
  cmp ecx, 0
  jne HOP
חזרהECX אחרי subjne
19קופצת
27קופצת
35קופצת
43קופצת
51קופצת
60xFFFFFFFFקופצת: 1 פחות 2 גולש
70xFFFFFFFDקופצת
.........

למה 0 לא מופיע? המונה התחיל ב-11, אי-זוגי, וירידה של 2 משאירה אותו תמיד בין המספרים האי-זוגיים. גם המעבר דרך 0xFFFFFFFF לא משנה את זה, כי הגלישה מוסיפה 2 בחזקת 32, מספר זוגי, ולכן אחריה המונה ממשיך באי-זוגיים ו-0 לא יגיע לעולם.

מכאן מבחן מהיר לצעד של 2, הצעד שמופיע כמעט בכל שאלת מבחן: השוו את הזוגיות של ערך ההתחלה לזוגיות של היעד. אם הן שונות, למשל 30 מול 9 או 11 מול 0, הלולאה לא תיעצר לעולם. אם הן זהות, ההפרש זוגי, ומונה שזז לכיוון היעד נוחת עליו עוד לפני כל גלישה.

בצעדים אחרים, עצירה לפני גלישה דורשת שההפרש יתחלק בצעד. אחרי גלישה מה שקובע הוא החזקה הגדולה ביותר של 2 שמחלקת את הצעד: בצעד של 4 ההפרש חייב להתחלק ב-4, ולכן מונה שיורד מ-10 אל 0 עובר ב-6 וב-2 ולא נעצר לעולם. בצעד של 6 החזקה היא רק 2, ולכן מ-10 אל 0 הוא כן נעצר, אחרי גלישה ו-1,431,655,767 חזרות בהרצה אמיתית.

צעד אי-זוגי, כמו 3, הוא המקרה הקיצוני של אותו כלל: החזקה של 2 שמחלקת אותו היא 1, ולכן המונה מגיע ליעד תמיד, אבל לפעמים רק אחרי גלישה ומיליארדי חזרות. בהרצה על מעבד אמיתי, מונה שהתחיל ב-10 וירד ב-3 נעצר על 0 אחרי 2,863,311,534 חזרות.

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

השפעה נטו של הגוף על המונה

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

הפקודות בגוףהשינוי נטו ב-ECXמה יקרה
inc ecx, dec ecx, dec ecxירידה של 1: עלייה אחת מול שתי ירידותנגמרת, כמו עם dec אחת
inc ecx, dec ecxאפס, ECX לא זזאינסופית, אם שום פקודה אחרת לא משנה אותו
dec ecx, dec ecxירידה של 2כשהיעד 0, נגמרת רק אם ECX ההתחלתי זוגי

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

טעויות נפוצות
  • אם בגוף יש גם inc וגם dec, הלולאה אינסופית. סכמו את הצעדים. inc אחת מול שתי dec היא ירידה של 1 בכל חזרה, והלולאה נגמרת.
  • אחרי שהמונה הזוגי יגלוש ויסתובב, הוא ינחת בסוף על ערך אי-זוגי. הגלישה היא ביחס ל-2 בחזקת 32, מספר זוגי, ולכן חיסור של 2 שומר על הזוגיות גם דרכה.
  • כשהיעד ב-cmp הוא 7 והמונה זוגי, הלולאה תיעצר ב-6, הערך הזוגי הקרוב, או כשהמונה יגיע ל-0. היציאה קורית רק בשוויון מדויק לערך שכתוב ב-cmp. ערך קרוב, או 0 שלא מופיע בהשוואה, לא עוצרים דבר.
  • לולאה שנעצרת בערך קרוב ליעד היא מספיק טובה. cmp ו-jne בודקות שוויון מדויק בלבד. אין עצירה בערך קרוב.
  • לולאה אינסופית נוצרת רק ממונה שמדלג מעל היעד. jmp חזרה לתווית, בלי שום בדיקה, היא לולאה אינסופית גם בלי מונה בכלל.
בדקו את עצמכם
ECX=13, והגוף: sub ecx, 2, cmp ecx, 0, jne. האם הלולאה נגמרת?

לא. 13 אי-זוגי, חיסור של 2 שומר על הזוגיות, ולכן ECX לא יגיע ל-0.

EBX=12, והגוף: sub ebx, 4, cmp ebx, 0, jne. האם היא נגמרת, ואחרי כמה חזרות?

כן, אחרי שלוש חזרות: 8, 4, 0. ההפרש 12 מתחלק ב-4.

האם SPINNING: jmp SPINNING מסתיימת?

לא. זו קפיצה בלי תנאי אל אותה תווית, ואין ממנה יציאה.

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

דגלים לפני הלולאה, בתוכה ואחריה

אילו פקודות כותבות לדגלים

תסריט שחוזר במבחנים: cmp לפני הלולאה, jne מתחתיה, ובאמצע כמה חזרות של loop. כדי לדעת אם ה-jne קופצת, עברו על הפקודות שבין השתיים ושאלו על כל אחת: האם היא כותבת ל-ZF?

mov ו-loop עונות לא, ולכן כשהגוף בנוי רק מהן, ה-ZF של ה-cmp מגיע אל ה-jne שלם. כל add, sub, inc, dec או cmp בגוף עונה כן, ואז האחרונה מהן שהתבצעה היא שקובעת.

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

מעקב: cmp לפני הלולאה, jne אחריה

תרחיש 15: ZF שעובר דרך לולאת loop
Assembly
mov ebx, 12
mov edx, 5
cmp ebx, edx        ; 12 vs 5: different, ZF=0
mov ecx, 3
mov eax, 0
IDLE:
  mov eax, ebx      ; mov leaves the flags alone
  loop IDLE         ; so does loop
jne DIFFERENT
mov eax, 1
jmp FINISH
DIFFERENT:
mov eax, 2
FINISH:
שלבערכיםZF
mov ebx, 12 ו-mov edx, 5EBX=12, EDX=5-
cmp ebx, edx12 - 5 = 7, ההפרש לא נשמר0
mov ecx, 3ECX=30, mov לא כותבת לדגלים
mov eax, 0EAX=00
חזרה 1: mov eax, ebx ו-loopEAX=12, ECX=20, loop לא כותבת לדגלים
חזרה 2ECX=10
חזרה 3ECX=0, יוצאים0
jne DIFFERENTZF=0, ולכן קופצים0
mov eax, 2EAX=20
FINISH:אין פקודות אחרי התווית, והביצוע נגמר0

בסוף EAX=2, כי ה-jne ראתה את ה-ZF=0 שה-cmp השאירה שלוש חזרות קודם. התשובה 1 שייכת למי שהאמין ש-loop מדליקה את ZF ביציאה, ו-12 הוא ערך ביניים של EAX שה-mov eax, 2 דרסה.

עכשיו שנו שורה אחת: במקום mov eax, ebx שימו בגוף dec edx. מעתה ה-jne מחליטה לפי ה-dec האחרונה, ועם EDX=5 ושלוש חזרות EDX יורד ל-2, ZF=0, והקפיצה עדיין מתבצעת.

אבל אילו EDX היה מתחיל ב-3, ה-dec השלישית הייתה מגיעה ל-0 ומדליקה את ZF. אז ה-jne לא הייתה קופצת ו-EAX היה מקבל 1, למרות שה-cmp מצאה ערכים שונים.

טעויות נפוצות
  • loop מאפסת את מה שה-cmp קבעה. loop לא כותבת לדגלים בכלל, ולכן ה-ZF של ה-cmp שורד את כל החזרות.
  • mov שבאמצע הדרך משנה את ZF. mov רק מעתיקה ערך. הדגלים נשארים כפי שהיו.
  • jne קופצת כש-ZF=1. היא קופצת כש-ZF=0. ZF=1 מסמן שוויון, ובשוויון היא לא קופצת.
  • הערך ש-EAX החזיק באמצע התוכנית הוא התשובה. התשובה היא מה שנשאר בסוף, אחרי ה-mov שבענף שנבחר.
  • גם dec בגוף לא משפיעה על ה-jne שמתחת ללולאה. add, sub, inc ו-dec כותבות ל-ZF, ולכן האחרונה מביניהן היא שקובעת.
בדקו את עצמכם
cmp edx, 9 כש-EDX=2, אחריה mov ecx, 3, לולאת loop שבגוף שלה רק mov eax, 6, ומתחת ללולאה jne SKIP. האם קופצים?

כן. ה-cmp השאירה ZF=0, ואף אחת מהפקודות שבדרך לא כתבה לדגלים.

אותו קוד, אבל בגוף יש inc edx במקום ה-mov. מה קובע עכשיו את הקפיצה?

ה-inc האחרונה. אחרי שלוש חזרות EDX=5, התוצאה אינה 0, ולכן ZF=0 והקפיצה מתבצעת.

cmp eax, eax, אחריה לולאת loop שבגוף שלה רק mov ebx, 1, ומתחת ללולאה jne. האם קופצים?

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

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

סיכום

קבוצהפקודותמה לזכור
כותבות ל-ZF לפי התוצאהadd d, s, sub d, s, inc d, dec d, cmp a, bd = d + s, d = d - s, או צעד של 1 למעלה או למטה; cmp מחשבת a - b בלי לשמור, ושוויון נותן ZF=1
לא נוגעות בדגליםmov d, s, loop Lmov שמה ב-d עותק של s; loop מורידה 1 מ-ECX וקופצת אם הוא עדיין לא 0
קפיצותjmp L, jne Ljmp קופצת תמיד ולא מסתכלת על ZF; jne רק קוראת את ZF, וקופצת כשהוא 0
  • לולאה בנויה מאתחול, תווית, גוף וקפיצה מותנית בתחתית, ולכן הגוף רץ תמיד לפחות פעם אחת.
  • loop עם ECX=N שגדול מ-0: הגוף רץ N פעמים בדיוק, ו-ECX יוצא 0.
  • ECX=0 לפני loop: ההורדה הראשונה נותנת 0xFFFFFFFF, והגוף רץ 2 בחזקת 32 פעמים. אותה מלכודת קיימת ב-dec ו-jne.
  • שינוי של ECX בגוף של loop משנה את מספר החזרות, ועם ערך אי-זוגי ו-dec נוספת הלולאה לא נגמרת.
  • לולאה ידנית: הזזת מונה, cmp ו-jne. כשהיעד 0, dec ו-jne מספיקות.
  • מספר החזרות הוא מספר ההגעות לתווית שבראש הלולאה, וכשהצעד קבוע הוא המרחק ליעד חלקי הצעד.
  • לולאה אינסופית: jmp בלי יציאה, מונה שהגוף לא מזיז, או מונה שמדלג מעל היעד, למשל צעד 2 והפרש אי-זוגי.
  • mov ו-loop שקופות לדגלים, ולכן jne שמתחת ללולאה רואה את הפקודה האחרונה שכתבה ל-ZF.

ושיטת העבודה לכל שאלה על לולאה, בשלושה שלבים:

  1. לפני הלולאה: כתבו מה יש בכל אוגר, וקבעו מי המונה ומה עוצר אותו. אם זו loop, המונה הוא ECX: ודאו שאינו 0 ובדקו אם הגוף כותב אליו. אם זו לולאה ידנית, המונה הוא האוגר שב-cmp או זה שזז לפני jne: ודאו שהוא בכלל יכול לנחות על היעד, למשל לפי זוגיות בצעד של 2, ואם לא, הלולאה אינסופית.
  2. בתוך הלולאה: חזרה אחר חזרה, בצעו את השורות בדיוק בסדר הכתוב ורשמו כל ערך שמשתנה, עד שהקפיצה מפסיקה: ZF=1 לפני jne, או ECX שהגיע ל-0 ב-loop.
  3. אחרי הלולאה: המשיכו בשורות שמתחתיה, ורק אז ענו לפי מה שנשאלתם, מספר החזרות שספרתם או הערך של האוגר המבוקש.