מחשבון קרב - אסמבלי
לולאות
לולאות באסמבלי עם 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.
מהי לולאה ומאילו חלקים היא בנויה
למה כותבים לולאה
נניח שצריך להוסיף 25 לאוגר ארבע פעמים. אפשר לכתוב ארבע שורות זהות, אבל אם המספר היה 400 הקוד היה מתנפח בלי סיבה. לולאה פותרת את זה: כותבים את הפקודות פעם אחת, והמעבד חוזר אליהן שוב ושוב.
כל מעבר אחד על הפקודות האלה נקרא חזרה, ובאנגלית איטרציה. כדי שהחזרות ייפסקו מתישהו, משהו חייב להשתנות בכל מעבר ולבסוף לגרום לבדיקה להחליט שלא חוזרים, וזה תנאי היציאה.
ב-x86 יש שתי דרכים לבנות לולאה. הראשונה מפקודות רגילות: קפיצה אחורה אל תווית, שמתבצעת רק כל עוד תנאי מסוים מתקיים. השנייה היא פקודה שנועדה בדיוק לזה, loop, ונגיע אליה אחרי שנכיר את הפקודות הבסיסיות.
ארבעה רכיבים שחוזרים בכל לולאה
| רכיב | תפקידו | דוגמה |
|---|---|---|
| אתחול | נותן ערכים התחלתיים לפני שהלולאה מתחילה, כולל ערך המונה | mov ecx, 4 |
| תווית פתיחה | מסמנת את המקום בקוד שאליו חוזרים | TICK: |
| גוף | הפקודות שמתבצעות בכל חזרה | add edx, 25 |
| קפיצה מותנית אחורה | בתחתית הגוף: מחזירה לתווית כל עוד התנאי מתקיים, ואחרת נותנת לביצוע לגלוש לשורה הבאה, וזו היציאה | jne TICK |
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:
| כתיב הקסדצימלי | ערך עשרוני |
|---|---|
0x20 | 32 |
0x64 | 100 |
0xA0 | 160 |
0xFF | 255 |
0x180 | 384 |
0xFFFFFFFF | 4,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, 64 | EDX=3 | EDX=64 |
mov ebx, eax | EAX=12, EBX=0 | EAX=12, EBX=12 |
mov ecx, 0x20 | ECX=9 | ECX=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, 6 | EDX=9 | EDX=15 |
add eax, ecx | EAX=20, ECX=5 | EAX=25, ECX=5 |
add ebx, ebx | EBX=40 | EBX=80 |
add ecx, 1 | ECX=0xFFFFFFFF | ECX=0, גלישה |
השורה האחרונה בטבלה מראה שתי תכונות בבת אחת. התוצאה נחתכת לרוחב האוגר, ולכן 0xFFFFFFFF ועוד 1 נותן 0 ולא מספר של 33 ביט. ומכיוון שיצא 0, ZF נדלק: add מדליקה את דגל האפס על תוצאה 0, ומכבה אותו על כל תוצאה אחרת.
sub: חיסור מהיעד
sub היא תמונת המראה של add: dest = dest - src, וההפרש נכתב ליעד. בכיוון טועים הכי הרבה, אז שננו אותו: מהאופרנד שכתוב ראשון לוקחים, את האופרנד שכתוב שני מורידים, ואף פעם לא להפך.
| פקודה | לפני | אחרי |
|---|---|---|
sub edx, 1 | EDX=8 | EDX=7 |
sub ebx, ecx | EBX=30, ECX=6 | EBX=24, ECX=6 |
sub eax, 9 | EAX=100 | EAX=91 |
sub ecx, 1 | ECX=0 | ECX=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 edx | EDX=6 | EDX=7 | כמו add edx, 1 |
dec edx | EDX=6 | EDX=5 | כמו sub edx, 1 |
dec edx | EDX=1 | EDX=0, ZF=1 | תוצאה אפס מדליקה את ZF |
dec edx | EDX=0 | EDX=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, 0 | EDX=0 | ZF=1, ו-EDX עדיין 0 |
cmp edx, 0 | EDX=3 | ZF=0, ו-EDX עדיין 3 |
cmp ebx, ecx | EBX=5, ECX=5 | ZF=1 |
cmp eax, 12 | EAX=18 | ZF=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 או בשום דגל אחר. השורות שבינה לבין התווית פשוט נעקפות, אלא אם קפיצה אחרת מובילה אליהן.
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 שעומדות בדרך לא נחשבות, כי הן לא כותבות על הפתק.
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 לא עושה בדרך: היא לא משנה אף דגל.
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, והביצוע ממשיך לשורה שמתחת.
- הורדה: ECX = ECX - 1.
- החלטה לפי הערך החדש, זה שאחרי ההורדה: שונה מ-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 ביציאה |
|---|---|---|
| 1 | 1 | 0 |
| 3 | 3 | 0 |
| 4 | 4 | 0 |
| 10 | 10 | 0 |
| 0 | 2 בחזקת 32, ראו בפרק על ECX=0 | 0 |
בלולאת loop שהגוף שלה לא נוגע ב-ECX, מספר החזרות שווה תמיד לערך ש-ECX קיבל לפני הלולאה.
אפשר לחשוב על ECX כעל ערימת אסימונים: כל ביצוע של loop לוקח ממנה אסימון אחד, והחזרה האחרונה היא זו שלוקחת את האסימון האחרון ומשאירה ערימה ריקה.
loop לעומת dec ו-jne
אפשר לפרק את loop ROUND לשתי פקודות שכבר מוכרות לכם, dec ecx ואחריה jne ROUND, ו-ECX יתנהג בדיוק אותו דבר. הפירוק לא מושלם רק בנקודה אחת, הדגלים, כפי שמראה הטבלה:
| נקודת השוואה | loop ROUND | dec 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
mov ecx, 4
mov ebx, 0
ROUND:
add ebx, 1
loop ROUND
mov edx, ebx| חזרה | EBX אחרי add | ECX אחרי loop | האם קופצים |
|---|---|---|---|
| לפני הלולאה | 0 | 4 | - |
| 1 | 1 | 3 | כן, 3 אינו 0 |
| 2 | 2 | 2 | כן |
| 3 | 3 | 1 | כן |
| 4 | 4 | 0 | לא, יוצאים |
ארבע חזרות, בדיוק כמו הערך ההתחלתי של ECX. השורה mov edx, ebx רצה פעם אחת אחרי היציאה, ולכן EDX=4.
תרחיש 2: הכפלה בכל חזרה, ECX=5
mov ecx, 5
mov eax, 5
DOUBLE:
add eax, eax ; eax = eax * 2
loop DOUBLEadd eax, eax מכפילה את EAX. ECX רק סופר את הסיבובים ולא משתתף בחישוב.
| חזרה | EAX אחרי add, עשרוני | EAX, הקסדצימלי | ECX אחרי loop |
|---|---|---|---|
| לפני | 5 | 0x5 | 5 |
| 1 | 10 | 0xA | 4 |
| 2 | 20 | 0x14 | 3 |
| 3 | 40 | 0x28 | 2 |
| 4 | 80 | 0x50 | 1 |
| 5 | 160 | 0xA0 | 0, יוצאים |
התוצאה היא EAX=160, כלומר 5 כפול 2 בחזקת 5. מי שסופר ארבע הכפלות יגיע ל-80, ומי שסופר שש יגיע ל-320.
תרחיש 3: חיסור קבוע, ECX=6
mov ecx, 6
mov edx, 100
SPEND:
sub edx, 9
loop SPEND| חזרה | EDX אחרי sub | ECX אחרי loop | האם קופצים |
|---|---|---|---|
| לפני | 100 | 6 | - |
| 1 | 91 | 5 | כן |
| 2 | 82 | 4 | כן |
| 3 | 73 | 3 | כן |
| 4 | 64 | 2 | כן |
| 5 | 55 | 1 | כן |
| 6 | 46 | 0 | לא, יוצאים |
EDX=46: שש הורדות של 9 מ-100, כלומר 100 פחות 54. ספירה של חמש חזרות הייתה נותנת 55, וחיבור במקום חיסור היה נותן 154.
תרחיש 4: הגוף משתמש בערך של ECX, ECX=5
mov ecx, 5
mov ebx, 0
SUM:
add ebx, ecx ; adds the current counter value
loop SUM| חזרה | ECX בזמן הגוף | EBX אחרי add | ECX אחרי loop |
|---|---|---|---|
| 1 | 5 | 5 | 4 |
| 2 | 4 | 9 | 3 |
| 3 | 3 | 12 | 2 |
| 4 | 2 | 14 | 1 |
| 5 | 1 | 15 | 0 |
EBX=15. מי שהניח ש-ECX קבוע לאורך כל החזרות היה מחשב 5 כפול 5, כלומר 25.
תרחיש 5: dec נוסף בגוף, ECX=8
mov ecx, 8
mov eax, 0
HALF:
add eax, 1
dec ecx ; a second decrement in every round
loop HALF| חזרה | EAX | ECX אחרי dec | ECX אחרי loop |
|---|---|---|---|
| 1 | 1 | 7 | 6 |
| 2 | 2 | 5 | 4 |
| 3 | 3 | 3 | 2 |
| 4 | 4 | 1 | 0, יוצאים |
ארבע חזרות במקום שמונה, כי כל חזרה מורידה את 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 ביט | 0xFF | 0xFF + 1 = 0x00 |
| 32 ביט | 0xFFFFFFFF | 0xFFFFFFFF + 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: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
mov ecx, 0 ; the counter starts at zero
mov ebx, 0
SPIN:
add ebx, 1
loop SPIN| חזרה | EBX אחרי add | ECX אחרי loop | האם קופצים |
|---|---|---|---|
| לפני | 0 | 0 | - |
| 1 | 1 | 0xFFFFFFFF | כן, שונה מ-0 |
| 2 | 2 | 0xFFFFFFFE | כן |
| 3 | 3 | 0xFFFFFFFD | כן |
| ... | ... | ... | ... |
| 4,294,967,296 | 0, גם 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 או כל גודל אחר), ובאיזה ערך עוצרים. הקפיצה חוזרת כל עוד המונה שונה מהערך הזה.
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 STEP | dec 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, 1 | sub ebx, 1, ואז add edx, ebx |
| מה מתווסף ל-EDX כש-EBX מתחיל ב-4 | 4, 3, 2, 1 | 3, 2, 1, 0 |
ההפרש בין שתי הגרסאות הוא 4 שלם, מספיק כדי ליפול על תשובה שגויה. לכן בטבלת המעקב כותבים ערך אחרי כל שורה בגוף, ולא רק בסוף כל חזרה.
חזרה לתוכן הענייניםמעקבים עם מונה ידני
תרחיש 7: dec ו-jne בלבד, EDX=5
mov edx, 5
mov eax, 0
NEXT:
add eax, 3
dec edx ; dec sets ZF by itself
jne NEXT| חזרה | EAX | EDX אחרי dec | ZF | jne |
|---|---|---|---|---|
| 1 | 3 | 4 | 0 | קופצת |
| 2 | 6 | 3 | 0 | קופצת |
| 3 | 9 | 2 | 0 | קופצת |
| 4 | 12 | 1 | 0 | קופצת |
| 5 | 15 | 0 | 1 | לא קופצת, יוצאים |
חמש חזרות, ו-EAX=15. המונה כאן הוא EDX, ו-ECX לא משתתף בכלל.
תרחיש 8: שני אוגרים זזים, EDX=20 ו-EBX=4
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 אחרי add | EBX אחרי sub | ZF אחרי cmp | jne |
|---|---|---|---|---|
| לפני | 20 | 4 | - | - |
| 1 | 24 (20+4) | 3 | 0 | קופצת |
| 2 | 27 (24+3) | 2 | 0 | קופצת |
| 3 | 29 (27+2) | 1 | 0 | קופצת |
| 4 | 30 (29+1) | 0 | 1 | לא קופצת |
mov eax, edx רק מעתיקה, ולכן EDX=30 וגם EAX=30. מי שהשאיר את EBX על 4 בכל החזרות חישב 20 ועוד 16, כלומר 36. מי שהחליף את סדר השורות בגוף, כמו בגרסה ב, חישב 20+3+2+1+0=26.
תרחיש 9: יעד שאינו 0, והשאלה על אוגר אחר
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 אחרי sub | cmp eax, 12 | jne |
|---|---|---|---|
| לפני | 30 | - | - |
| 1 | 24 | ZF=0 | קופצת |
| 2 | 18 | ZF=0 | קופצת |
| 3 | 12 | ZF=1 | לא קופצת, יוצאים |
אחרי הלולאה, add ecx, eax נותנת ECX = 6 + 12 = 18. שימו לב על מה נשאלתם: בתוך הלולאה ECX לא זז, ורק השורה שמתחת לה שינתה אותו. ולהפך, אילו נשאלתם על EAX התשובה הייתה 12, כי add ecx, eax כותבת רק ל-ECX.
תרחיש 10: צעד שגדל, EAX=21 ו-EBX=1
mov eax, 21
mov ebx, 1
STAIR:
sub eax, ebx
add ebx, 1 ; the step grows each round
cmp eax, 0
jne STAIR| חזרה | EAX אחרי sub | EBX אחרי add | cmp eax, 0 |
|---|---|---|---|
| לפני | 21 | 1 | - |
| 1 | 20 (21-1) | 2 | ZF=0, קופצת |
| 2 | 18 (20-2) | 3 | ZF=0, קופצת |
| 3 | 15 (18-3) | 4 | ZF=0, קופצת |
| 4 | 11 (15-4) | 5 | ZF=0, קופצת |
| 5 | 6 (11-5) | 6 | ZF=0, קופצת |
| 6 | 0 (6-6) | 7 | ZF=1, יוצאים |
שש חזרות, ובסוף EAX=0 ו-EBX=7. המספר 21 הוא רק נקודת ההתחלה של EAX, לא מספר החזרות.
תרחיש 11: בדיקה אחרי כל צעד, ושורה מתחת ללולאה
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 אחרי add | EDX אחרי add | cmp ecx, 8 |
|---|---|---|---|
| לפני | 0 | 4 | - |
| 1 | 2 | 6 | ZF=0, קופצת |
| 2 | 4 | 10 | ZF=0, קופצת |
| 3 | 6 | 16 | ZF=0, קופצת |
| 4 | 8 | 24 | ZF=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 | -1 | 0 | (8-0)/1 | 8 |
ebx=12 | -3 | 0 | (12-0)/3 | 4 |
edx=16 | -4 | 4 | (16-4)/4 | 3 |
eax=35 | -5 | 10 | (35-10)/5 | 5 |
ecx=11 | -2 | 3 | (11-3)/2 | 4 |
edx=18 | -9 | 0 | (18-0)/9 | 2 |
eax=2 | +1 | 9 | (9-2)/1 | 7 |
eax=1 | +2 | 11 | (11-1)/2 | 5 |
בשאלה אמיתית השתמשו בחישוב הזה כדי לוודא את התשובה, לא כדי להחליף את המעקב: טבלה עם שורה לכל חזרה היא עדיין הדרך שבה הכי קשה לטעות.
חזרה לתוכן הענייניםאיך מגיעים לערך הסופי של אוגר
ערך סופי נשען על שלוש תשובות: כמה חזרות היו, מה כל חזרה עושה לאוגר, ומה עושות לו השורות שמתחת ללולאה. כשהשינוי בכל חזרה קבוע, מכפילים אותו במספר החזרות ומוותרים על הטבלה. ואוגר שאף פקודה לא כותבת אליו פשוט שומר על הערך שלו מההתחלה ועד הסוף.
כשהתוספת משתנה מחזרה לחזרה, אין קיצור: רושמים את כל הערכים. כך למשל כאן, שבו EBX גדל אחרי כל חיסור:
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.
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.
ועוד דוגמה שבה התוספת גדלה, הפעם בלולאה ידנית:
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 RISEEAX מקבל בזה אחר זה 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: שתי לולאות ברצף
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| שלב | EBX | ECX | הערה |
|---|---|---|---|
| אחרי שתי ה-mov הראשונות | 2 | 4 | נקודת ההתחלה |
| FIRST, חזרה 1 | 5 | 3 | קופצת |
| FIRST, חזרה 2 | 8 | 2 | קופצת |
| FIRST, חזרה 3 | 11 | 1 | קופצת |
| FIRST, חזרה 4 | 14 | 0 | יוצאים |
mov ecx, 3 | 14 | 3 | EBX לא התאפס |
| SECOND, חזרה 1 | 18 | 2 | קופצת |
| SECOND, חזרה 2 | 22 | 1 | קופצת |
| SECOND, חזרה 3 | 26 | 0 | יוצאים |
התוצאה: EBX=26. מי שאיפס את EBX לפני הלולאה השנייה קיבל 12, ומי שהריץ את השנייה ארבע פעמים, כמו הראשונה, קיבל 30. מי ששכח שיש לולאה שנייה עצר על 14.
תרחיש 13: שני dec בכל חזרה, EDX=10
mov edx, 10
PAIR:
dec edx
dec edx ; two steps down per round
cmp edx, 0
jne PAIR| חזרה | EDX אחרי ה-dec הראשון | EDX אחרי ה-dec השני | jne |
|---|---|---|---|
| 1 | 9 | 8 | קופצת |
| 2 | 7 | 6 | קופצת |
| 3 | 5 | 4 | קופצת |
| 4 | 3 | 2 | קופצת |
| 5 | 1 | 0 | יוצאים |
חמש חזרות, חצי מהערך ההתחלתי, כי כל חזרה מורידה 2. מי שספר רק dec אחת ענה 10, ומי שחשב שה-dec השנייה מכפילה את מספר החזרות ענה 20. עם ערך התחלתי אי-זוגי, כמו 9, הלולאה הזו לא הייתה נגמרת.
תרחיש 14: inc ושני dec, ECX=4
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.
| חזרה | EBX | ECX אחרי inc | אחרי ה-dec הראשון | אחרי ה-dec השני | jne |
|---|---|---|---|---|---|
| 1 | 7 | 5 | 4 | 3 | קופצת |
| 2 | 14 | 4 | 3 | 2 | קופצת |
| 3 | 21 | 3 | 2 | 1 | קופצת |
| 4 | 28 | 2 | 1 | 0 | יוצאים |
ארבע חזרות ו-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 בתחתית הגוף, שחוזרת לתווית בלי לבדוק דבר, ולכן אין רגע שבו מוחלט לצאת. אחר כך נעבור למקרים שבהם תנאי קיים ובכל זאת לא מתקיים, לפעמים בלי שמרגישים.
mov edx, 0
FOREVER:
add edx, 2
jmp FOREVER ; no condition, so no way out
mov eax, 1 ; never reachedהשורה שמתחת ל-jmp לא תתבצע לעולם.
תנאי שאף פעם לא מתקיים
לולאה עם jne נראית בטוחה, כי יש לה תנאי. אבל תנאי עוזר רק אם מה שהוא בודק באמת משתנה:
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, וכך הוא עלול לעבור מעל היעד בלי לדרוך עליו.
mov ecx, 11
HOP:
sub ecx, 2
cmp ecx, 0
jne HOP| חזרה | ECX אחרי sub | jne |
|---|---|---|
| 1 | 9 | קופצת |
| 2 | 7 | קופצת |
| 3 | 5 | קופצת |
| 4 | 3 | קופצת |
| 5 | 1 | קופצת |
| 6 | 0xFFFFFFFF | קופצת: 1 פחות 2 גולש |
| 7 | 0xFFFFFFFD | קופצת |
| ... | ... | ... |
למה 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
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, 5 | EBX=12, EDX=5 | - |
cmp ebx, edx | 12 - 5 = 7, ההפרש לא נשמר | 0 |
mov ecx, 3 | ECX=3 | 0, mov לא כותבת לדגלים |
mov eax, 0 | EAX=0 | 0 |
חזרה 1: mov eax, ebx ו-loop | EAX=12, ECX=2 | 0, loop לא כותבת לדגלים |
| חזרה 2 | ECX=1 | 0 |
| חזרה 3 | ECX=0, יוצאים | 0 |
jne DIFFERENT | ZF=0, ולכן קופצים | 0 |
mov eax, 2 | EAX=2 | 0 |
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, b | d = d + s, d = d - s, או צעד של 1 למעלה או למטה; cmp מחשבת a - b בלי לשמור, ושוויון נותן ZF=1 |
| לא נוגעות בדגלים | mov d, s, loop L | mov שמה ב-d עותק של s; loop מורידה 1 מ-ECX וקופצת אם הוא עדיין לא 0 |
| קפיצות | jmp L, jne L | jmp קופצת תמיד ולא מסתכלת על 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.
ושיטת העבודה לכל שאלה על לולאה, בשלושה שלבים:
- לפני הלולאה: כתבו מה יש בכל אוגר, וקבעו מי המונה ומה עוצר אותו. אם זו
loop, המונה הוא ECX: ודאו שאינו 0 ובדקו אם הגוף כותב אליו. אם זו לולאה ידנית, המונה הוא האוגר שב-cmpאו זה שזז לפניjne: ודאו שהוא בכלל יכול לנחות על היעד, למשל לפי זוגיות בצעד של 2, ואם לא, הלולאה אינסופית. - בתוך הלולאה: חזרה אחר חזרה, בצעו את השורות בדיוק בסדר הכתוב ורשמו כל ערך שמשתנה, עד שהקפיצה מפסיקה: ZF=1 לפני
jne, או ECX שהגיע ל-0 ב-loop. - אחרי הלולאה: המשיכו בשורות שמתחתיה, ורק אז ענו לפי מה שנשאלתם, מספר החזרות שספרתם או הערך של האוגר המבוקש.