מחשבון קרב - אסמבלי
תתי אוגרים
מעקב אחרי ערכים באוגרים כשכותבים לחלקים שלהם: al, ah, ax, dx, cl, bx ועוד.
בחרו את הרמה שמתאימה לכם ואת הסט שתרצו לתרגל
חומר לימוד
תתי אוגרים: איך EAX מתפרק ומה כל כתיבה משנה בו
אוגר של 32 ביט הוא לא יחידה אטומה: לחלקים שלו יש שמות, ואפשר לכתוב לכל אחד מהם בנפרד. בפרק נפרק את המבנה הזה מהיסוד, ונתרגל את השאלה שחוזרת בכל מבחן: אחרי רצף פקודות, מה בדיוק יש באוגר.
במבחן מחשבון הקרב הקוד כתוב בשפה מומצאת שמיועדת למעבד אחר. ובכל זאת, מי שמבין את העקרונות שכאן ימצא את דרכו שם מהר הרבה יותר.
- הפירוק של EAX ל-AX, ל-AH ול-AL, ואותו מבנה ב-EBX, ב-ECX וב-EDX.
- ESI, EDI, EBP ו-ESP: יש להם חצי של 16 ביט, אבל אין להם חלקים של 8 ביט.
- 16 הביטים העליונים של EAX, שאין להם שם בכלל.
- הכלל המרכזי: כתיבה לתת-אוגר לא נוגעת בשאר האוגר.
- גלישה בתוך תת-אוגר, שלא יוצאת ממנו החוצה.
- חמש הפקודות mov, add, sub, inc ו-dec, ומה בדיוק כל אחת עושה.
- התאמת הרוחב בין האופרנדים של פקודה אחת, וקריאה מהזיכרון בסדר little-endian.
bits 32 רק הורכבו ולא הורצו, והפלט שלהם הוא ההודעה האמיתית של nasm, שגיאה או אזהרה.אוגר, ביט והקסדצימלי: היסודות, ולמה לאוגר יש חלקים
מהו אוגר
דמיינו את הצג של מחשבון כיס: המספר שעליו הוא זה שאתם עובדים עליו ברגע זה, וכל לחיצה משנה אותו. אוגר (register) ממלא את התפקיד הזה בתוך המעבד.
המעבד יכול לחשב גם על ערכים שבזיכרון, אבל אוגר יושב בתוכו פנימה, ולכן אין מקום מהיר יותר לשמור בו מספר. לכל אוגר יש שם קבוע, ובכל רגע הוא מחזיק ערך אחד.
במעבד x86 בגרסת 32 הביט, IA-32, יש שמונה אוגרים כלליים ברוחב 32 ביט. ארבעה מהם הם EAX, EBX, ECX ו-EDX, והארבעה האחרים הם ESI, EDI, EBP ו-ESP.
השאלות בפרק בודקות מה קורה בתוך אוגר, ולא למה הוא משמש. רק לידיעה: לפי המוסכמות EAX מקבל חישובים ואת ערך ההחזרה של פונקציה, ECX סופר סיבובים של לולאה, ו-ESP מסמן את ראש המחסנית.
חזרה לתוכן הענייניםביט, בית וכתיב הקסדצימלי
נתחיל מהספרה. בבסיס 16, הקסדצימלי, יש 16 ספרות: 0 עד 9 ואחריהן A=10, B=11, C=12, D=13, E=14 ו-F=15, ובאסמבלי מסמנים מספר כזה בקידומת 0x.
ביט (bit) מחזיק 0 או 1, וארבעה ביטים יחד יכולים לייצג בדיוק 16 צירופים. לכן כל ספרה הקסדצימלית שווה בדיוק ארבעה ביטים, וזה כל הסוד של הבסיס הזה.
מכאן הכול נגזר בחשבון פשוט. שתי ספרות הן 8 ביטים, כלומר בית (byte) אחד, שערכיו 0x00 עד 0xFF, או 0 עד 255; שמונה ספרות הן 32 ביט, כלומר ארבעה בתים, וזה בדיוק רוחב של אוגר שלם.
קחו את 0x9C3E71A5. משמאל לימין הבתים שלו הם 9C, 3E, 71, A5; השמאלי, 9C, הוא הבית המשמעותי ביותר (most significant), והימני, A5, הוא הפחות משמעותי (least significant).
| ערך | פירוק לבתים, משמאל לימין | רוחב |
|---|---|---|
| 0x4D | בית יחיד: 4D | 8 ביט |
| 0xB2E0 | שני בתים: B2 ואחריו E0 | 16 ביט |
| 0x13579BDF | ארבעה בתים: 13, 57, 9B, DF | 32 ביט |
| 0x00AB0000 | ארבעה בתים: 00, AB, 00, 00. את האפסים משמאל כותבים כדי שכל 32 הביטים ייראו | 32 ביט |
ארבעה ערכים שחוזרים שוב ושוב, וכדאי לזהות אותם בלי לחשב: 0x10 הוא 16, 0xFF הוא 255, 0x100 הוא 256 ו-0xFFFF הוא 65535.
נסו להוסיף 1 ל-0x3F. הספרה הימנית, F, כבר בערך הגבוה ביותר שלה, ולכן היא חוזרת ל-0 ושולחת 1 שמאלה, והתוצאה 0x40. זו הנשיאה המוכרת מעשרוני, אלא שהיא קורית במעבר מ-15 ל-16 ולא מ-9 ל-10.
- 0x3E + 1 = 0x3F: אין נשיאה, ה-E פשוט מתקדם ל-F.
- 0x9F + 1 = 0xA0: ה-F מתאפס, וה-9 שמשמאלו עולה ל-A, כי בבסיס 16 אחרי 9 בא A ולא 10.
- בחיסור הכיוון הפוך: 0x40 - 1 = 0x3F. ה-4 נותן 16 לספרה שמימינו, ו-16 פחות 1 הם F.
למה לחלקים של האוגר יש שמות
חשבו על מדף אחד שמחולק לארבעה תאים. EAX הוא השם של המדף כולו, AX הוא השם של שני התאים הימניים, ו-AL הוא השם של התא הימני ביותר.
כשמכניסים משהו לתא דרך השם AL, מי שמסתכל על המדף כולו דרך EAX רואה את השינוי באותו תא, ורק בו. לכן AX, AH ו-AL אינם אוגרים נוספים עם אחסון משלהם: כל השמות מובילים לאותם ביטים פיזיים בתוך EAX.
השמות הקצרים הם שריד היסטורי. הדור הקודם של x86 עבד ב-16 ביט, ו-AX היה אז האוגר כולו; כשהמשפחה התרחבה ל-32 ביט נוסף ה-E בהתחלה, והשם הישן נשאר צמוד לחלק התחתון.
השמות האלה גם שימושיים. תו בודד, או כל מספר מ-0 עד 255, מסתפק בבית אחד, ואין טעם להקצות לו 32 ביט שלמים.
טעויות נפוצות
- ב-0xFF יש שני ביטים, אחד לכל ספרה. כל ספרה הקסדצימלית שקולה לארבעה ביטים, ולכן שתי ספרות הן 8 ביטים, בית שלם.
- אפשר לשים ב-AL מספר אחד וב-EAX מספר אחר, שלא קשור אליו. AL הוא שם נוסף לביטים 0 עד 7 של EAX. מה שנכתב ל-AL מופיע מיד בבית התחתון של EAX.
- 0x10 הוא עשר. הספרה 1 עומדת במקום של ה-16, ולכן 0x10 הוא 16.
בדקו את עצמכם
הערך 0x3C7 כתוב בשלוש ספרות הקסדצימליות. כמה ביטים תופסות שלוש ספרות כאלה, כמה ביטים הערך עצמו צריך לכל הפחות, והאם הוא נכנס בבית?
שלוש ספרות תופסות 12 ביטים. הערך עצמו, 967, צריך לפחות 10 ביטים, כי הוא קטן מ-1024 (2 בחזקת 10) וגדול מ-512. כך או כך הוא גדול מ-0xFF, ולכן לא נכנס בבית ודורש שני בתים.
מהו הבית הפחות משמעותי של 0x7E5D3C1B, ומהו המשמעותי ביותר?
הפחות משמעותי הוא 1B, הימני, והמשמעותי ביותר הוא 7E, השמאלי.
כתבו את 44 בהקסדצימלי.
44 הם 2 פעמים 16 ועוד 12, ולכן 0x2C.
מפת האוגרים: 32, 16 ו-8 ביט
איך EAX מתחלק
כתבו את EAX=0x9C3E71A5 כארבעה בתים, ושאלו על כל בית איזה שם מגיע אליו. התשובה בטבלה:
| ביטים 31-24 | ביטים 23-16 | ביטים 15-8 | ביטים 7-0 | |
|---|---|---|---|---|
| כש-EAX=0x9C3E71A5 | 0x9C | 0x3E | 0x71 | 0xA5 |
| חלק מ-EAX? | כן | כן | כן | כן |
| חלק מ-AX? | לא | לא | כן | כן |
| שם של 8 ביט | אין | אין | AH | AL |
שני הבתים הימניים, 0x71A5, נקראים יחד AX. בתוכם, הבית השמאלי 0x71 הוא AH (ה-H של High) והימני 0xA5 הוא AL (ה-L של Low), ואילו 0x9C3E משמאל לא מקבל שם.
מספור הביטים בכותרת מתחיל מימין: ביט 0 בקצה הימני וביט 31 בשמאלי, כמו סדר הספרות בכתיב. לכן מה שכתוב בשתי הספרות הימניות הוא תמיד AL.
אפשר לראות את הפירוק בהרצה: מעתיקים כל חלק לאוגר אחר שאופס קודם, ואז קוראים את האוגר האחר.
mov eax, 0x9C3E71A5
mov ebx, 0
mov bx, ax ; copy bits 0-15 of EAX
mov ecx, 0
mov cl, ah ; copy bits 8-15 of EAX
mov edx, 0
mov dl, al ; copy bits 0-7 of EAXEBX=0x000071A5 ECX=0x00000071 EDX=0x000000A5ארבעה אוגרים, אותה חלוקה
EAX לא מיוחד בזה. EBX, ECX ו-EDX בנויים בדיוק כמוהו:
| 32 ביט | 16 ביט | הבית העליון של ה-16 | הבית התחתון של ה-16 |
|---|---|---|---|
| EAX | AX | AH | AL |
| EBX | BX | BH | BL |
| ECX | CX | CH | CL |
| EDX | DX | DH | DL |
שם כזה מפענחים לפי חלקיו. ב-CH, למשל, C אומר לכם שמדובר ב-ECX ו-H אומר שזה הבית העליון של CX; ב-DX, ה-X אומר שזה כל חלק ה-16 ביט של EDX.
חזרה לתוכן הענייניםESI, EDI, EBP ו-ESP: רק חצי של 16 ביט
מה קורה אם מנסים לתת ל-ESI את אותו טיפול? השם SI עובד, אבל ניסיון לפנות לבית שלו נכשל כבר בהרכבה:
bits 32
mov si, 5 ; fine: SI is the low 16 bits of ESI
mov sil, 5 ; an 8-bit part of ESI?regs32.asm:3: error: invalid operands in 32-bit modeכך בנויים ארבעת האוגרים האחרונים ברשימה. לכל אחד יש שם לחצי התחתון, SI, DI, BP או SP, אבל אין שום חלוקה לבתים: במצב 32 ביט אין SIL, אין SIH, ואין מקבילות שלהם.
(במצב 64 ביט נוספו שמות כמו SIL ו-DIL, אבל השאלות כאן עוסקות במצב 32 ביט, ובו הם לא קיימים.)
| 32 ביט | 16 ביט | שמות של 8 ביט |
|---|---|---|
| ESI | SI | אין |
| EDI | DI | אין |
| EBP | BP | אין |
| ESP | SP | אין |
החצי הזה מתנהג כמו AX. נניח ESI=0x9C3E71A5: אחרי mov si, 0x0042 נקבל ESI=0x9C3E0042, כי השתנו רק 16 הביטים התחתונים.
החצי העליון: ביטים בלי שם
חזרו לטבלה של EAX: בשורת השמות, מעל ביטים 16 עד 31, כתוב פעמיים אין. זה לא חסר בטבלה, פשוט אין לחצי הזה שם, לא ב-EAX ולא באף אחד משבעת האחרים, ואין אוגר כמו EAX_HIGH.
המשמעות המעשית: כל פקודה שאמורה לשנות את הבתים האלה חייבת לקבל את EAX המלא כיעד, ושום יעד קטן יותר לא מגיע אליהם.
בשאלות על תתי אוגרים לא תצטרכו לשנות את החצי העליון. הוא מופיע בהן כמבחן לכלל ההפוך: כשאף פקודה לא כותבת ל-EAX כולו, הבתים שלו נשארים בדיוק כפי שהתחילו.
חזרה לתוכן הענייניםהמפה בטבלה אחת
| שם | רוחב | מספרי הביטים | הערך כש-EAX=0x9C3E71A5 |
|---|---|---|---|
| EAX | 32 ביט | 0 עד 31 | 0x9C3E71A5 |
| AX | 16 ביט | 0 עד 15 | 0x71A5 |
| AH | 8 ביט | 8 עד 15 | 0x71 |
| AL | 8 ביט | 0 עד 7 | 0xA5 |
| החצי העליון (אין שם) | 16 ביט | 16 עד 31 | 0x9C3E |
טעויות נפוצות
- כש-AX=0x71A5, הערך של AL הוא 0x71. קוראים מימין: שתי הספרות הימניות הן AL=0xA5, ו-0x71 הוא AH.
- ל-EDI ול-ESP יש בתים עם שמות, כמו DL ו-DH של EDX. רק לארבעת האוגרים A עד D יש שמות של 8 ביט. ל-EDI יש DI ול-ESP יש SP, וזהו.
- AL יושב בצד השמאלי של AX. AH הוא הבית השמאלי, העליון, ו-AL הוא הימני, התחתון.
- לביטים 16 עד 31 של EAX יש שם, ודרכו אפשר לכתוב אליהם לבד. אין להם שם. רק כתיבה ל-EAX כולו משנה אותם.
בדקו את עצמכם
EDX=0x0BADF00D. איזה שם מחזיק את 0xF0, איזה את 0x0D, ואיזה ערך נשאר בלי שם?
DH מחזיק את 0xF0 ו-DL את 0x0D (וביחד DX=0xF00D). 0x0BAD הוא החצי העליון, שאין לו שם.
בקוד של 32 ביט מופיעה השורה mov dil, 7. מה יקרה בהרכבה, ולמה?
nasm ידחה אותה, כי במצב 32 ביט ל-EDI אין חלק של 8 ביט; יש לו רק DI.
איזה שם מכסה את ביטים 8 עד 15 של ECX, וכמה ביטים יש בו?
CH, ובו 8 ביטים.
חמש הפקודות שמופיעות בשאלות
מבנה השורה: פקודה, יעד, מקור
כל הקוד בשאלות על תתי אוגרים בנוי מחמש פקודות בלבד: mov, add, sub, inc ו-dec. לפני שנכיר כל אחת, נקרא שלוש שורות לדוגמה ונראה מה אפשר ללמוד מהן על צורת הכתיבה.
mov ecx, 9 ; destination: ecx, source: the number 9
add dh, cl ; destination: dh, source: cl
sub ebx, ecx ; ebx becomes ebx - ecx, ecx is only readבכל שורה המילה הראשונה היא שם הפקודה, ואחריה שני ערכים מופרדים בפסיק, האופרנדים. זה התחביר של Intel, כפי ש-NASM קורא אותו.
- השמאלי מבין השניים הוא היעד (destination), והוא היחיד שמשתנה בשורה.
- הימני הוא המקור (source): הפקודה רק קוראת אותו.
- מה שבא אחרי
;הוא הערה למתכנת, והמעבד מתעלם ממנו. - אותיות גדולות או קטנות לא משנות:
ecxו-ECXמתייחסים לאותו אוגר.
בשלוש השורות מופיעים אוגרים (ecx, dh) וקבוע, מספר שכתוב בתוך הפקודה (immediate), כמו 9 או 0x2F. הסוג השלישי של אופרנד הוא תא בזיכרון, כמו [v], ונפגוש אותו בחלק על הזיכרון.
השורות רצות אחת אחרי השנייה, לפי הסדר שבו הן כתובות. זה מה שמכתיב את שיטת הפתרון: עוברים על הקוד שורה אחר שורה, ואחרי כל שורה רושמים איך נראים האוגרים.
חזרה לתוכן הענייניםmov: העתקה
שלוש פקודות mov ברצף, וכל אחת מתחילה מהמצב שהשאירה הקודמת:
| פקודה | לפני | אחרי | מה קרה |
|---|---|---|---|
mov ebx, 0xA1B2C3D4 | EBX=0x00000000 | EBX=0xA1B2C3D4 | כל 32 הביטים קיבלו ערך חדש. |
mov bx, 0x0042 | EBX=0xA1B2C3D4 | EBX=0xA1B20042 | רק 16 הביטים התחתונים הוחלפו, ו-0xA1B2 נשאר. |
mov bl, ch | EBX=0xA1B20042, ECX=0x99887766 | EBX=0xA1B20077 | בית הועתק לבית. CH=0x77 נשאר גם ב-ECX. |
מהשורה האחרונה רואים שלמרות השם, שבא מ-move, שום דבר לא זז ממקומו: CH עדיין 0x77, ו-mov הוא בעצם העתקה. מהשורה השנייה רואים שהערך הישן של היעד נמחק רק בטווח שהיעד מכסה.
ועוד תכונה שלא רואים בטבלה: mov לא משנה אף דגל.
| צורה | מותר? | דוגמה |
|---|---|---|
| אוגר, קבוע | כן, כשהקבוע נכנס ברוחב האוגר | mov ebx, 0xA1B2C3D4, mov cl, 7 |
| אוגר, אוגר | כן, רק כששניהם באותו רוחב | mov dx, cx, mov bl, ch |
| אוגר, זיכרון | כן; רוחב האוגר קובע כמה בתים נקראים | mov dl, [v] |
| זיכרון, אוגר | כן | mov [v], ebx |
| זיכרון, קבוע | כן, אבל חובה לכתוב את הרוחב | mov word [v], 7 |
| זיכרון, זיכרון | לא: אין mov שמעביר ישירות מזיכרון לזיכרון | mov [dst], [src] |
| שני אוגרים ברוחב שונה | לא | mov bx, cl (16 מול 8) |
למה הצורה של זיכרון וקבוע דורשת מילה נוספת? כשאחד האופרנדים הוא אוגר, השם שלו מגלה כמה ביטים מעבירים, אבל ל-7 ולתא זיכרון אין רוחב משלהם, ולכן כותבים byte (8 ביט), word (16 ביט) או dword (32 ביט) לפני הסוגריים.
כך האסמבלר מקבל את הצורות התקינות ועוצר בשתי האחרונות:
bits 32
section .data
src dd 7
dst dd 0
section .text
mov eax, [src] ; memory to register
mov [dst], eax ; register to memory
mov dword [dst], 7 ; immediate to memory, size stated
mov [dst], [src] ; memory to memory
mov ax, bl ; 16-bit destination, 8-bit sourceforms.asm:9: error: invalid combination of opcode and operands
forms.asm:10: error: invalid combination of opcode and operandsmov [dst], 7 בלי רוחב ובחרה בשקט לכתוב בית אחד, וגרסאות אחרות עוצרות עם שגיאה על רוחב חסר. בשני המקרים הפתרון זהה: כותבים byte, word או dword.add ו-sub: חשבון שנכתב ליעד
שתי הפקודות האלה עובדות לפי אותה תבנית: לוקחות את היעד ואת המקור, מחברות או מחסרות, ומניחות את התוצאה ביעד. התבנית נראית היטב בדוגמאות:
| פקודה | לפני | אחרי | מה קרה |
|---|---|---|---|
add ebx, ecx | EBX=9, ECX=5 | EBX=14 (0x0E) | ECX נשאר 5. |
add cl, 4 | ECX=0x00000203 | ECX=0x00000207 | 3 ועוד 4 הם 7, והחיבור כולו בתוך CL. |
add di, 0x0010 | EDI=0x00030025 | EDI=0x00030035 | החיבור בתוך DI, והחצי העליון 0x0003 לא זז. |
sub edi, 8 | EDI=20 | EDI=12 | חיסור פשוט. |
sub dl, 0x20 | DL=0x6A | DL=0x4A | 0x6A פחות 0x20. |
sub ch, 0x09 | CH=0x04 | CH=0xFB | 0x04 קטן מ-0x09, ולכן ההפרש גולש מטה. |
כתבו את זה כנוסחה: add cl, 4 פירושו CL = CL + 4, ו-sub dl, 0x20 פירושו DL = DL - 0x20. בחיבור הסדר לא משנה, אבל בחיסור הוא מכריע: מחסרים את הימני מהשמאלי, ואף פעם לא להפך.
מבחינת אופרנדים, add ו-sub מקבלות בדיוק את מה ש-mov מקבלת: אוגר עם קבוע, שני אוגרים ברוחב שווה, אוגר וזיכרון לשני הכיוונים, אבל לא שני תאי זיכרון. החשבון נעשה ברוחב היעד, ותוצאה שלא נכנסת בו נחתכת, כמו בשורה האחרונה בטבלה; נפרט את זה בחלק על הגלישה.
בניגוד ל-mov, שתיהן מעדכנות דגלים. בפרק הזה מעניינים אותנו רק שניים: ZF, שנדלק כשהתוצאה אפס, ו-CF, שמסמן נשיאה (carry) בחיבור ולווה (borrow) בחיסור.
שאר הדגלים שייכים לפרק הדגלים. מה שנוגע לתתי אוגרים יבוא בחלק על הדגלים שבסוף נושא הגלישה.
חזרה לתוכן הענייניםinc ו-dec: הוספה או הפחתה של 1
inc esi ; esi = esi + 1
dec bh ; bh = bh - 1| פקודה | לפני | אחרי | מה קרה |
|---|---|---|---|
inc esi | ESI=9 | ESI=10 | פלוס 1. |
dec esi | ESI=3 | ESI=2 | מינוס 1. |
inc cl | ECX=0x000000FF | ECX=0x00000000 | CL עובר מ-0xFF ל-0x00, CH לא משתנה, ו-CF נשאר כפי שהיה. |
dec bh | EBX=0x56780202 | EBX=0x56780102 | רק BH ירד ב-1. |
כאן אין מקור, רק יעד אחד, ובו מוסיפים 1 (inc) או מורידים 1 (dec). היעד יכול להיות אוגר מכל רוחב, או תא בזיכרון עם byte, word או dword.
נשאלת השאלה למה לא לכתוב פשוט add esi, 1. הערך ייצא אותו ערך, אבל inc ו-dec מקודדות בפחות בתים ולא נוגעות ב-CF; הן כן מעדכנות את ZF.
השורה השלישית בטבלה מראה שגם הן כפופות לרוחב היעד: CL גלש מ-0xFF לאפס ולא השפיע על שום דבר מחוצה לו.
חזרה לתוכן הענייניםמספרים שכתובים בתוך הפקודה
| כתיב | מה חשוב לדעת |
|---|---|
mov cl, 32 מול mov cl, 0x20 | אותה פקודה בדיוק. עשרוני והקסדצימלי הם רק שתי דרכים לכתוב את אותו מספר. |
mov dx, 0x0033 מול mov dx, 0x33 | גם הן זהות. האפסים משמאל לא משנים את הערך, רק מזכירים לקורא שהיעד ברוחב 16 ביט. |
mov cl, 0xFF, mov cx, 0xFFFF, mov ecx, 0xFFFFFFFF | אלה הקבועים הגדולים ביותר שנכנסים ביעד של 8, 16 ו-32 ביט. קבוע גדול יותר כבר לא נכנס. |
מה עושה NASM עם קבוע שלא נכנס? הוא לא עוצר, אלא מזהיר ושומר רק את מה שנכנס. בשאלות לא תפגשו כתיבה כזו, וגם בקוד אמיתי לא כותבים כך:
bits 32
mov bl, 0x2A0 ; does not fit in 8 bitsfit.asm:2: warning: byte exceeds bounds [-w+number-overflow]הפקודה שנוצרה בפועל טוענת ל-BL רק את הבית התחתון, 0xA0, והספרה 2 פשוט אבדה.
ועוד נקודה שקל לפספס: כשהיעד הוא DX והקבוע הוא 0x0033, נכתבים כל 16 הביטים של DX, ובכללם DH שמתאפס. השוו בין שני הקטעים הבאים, שמתחילים מאותו EDX:
mov edx, 0xC0DE4477
mov dl, 0x33 ; 8-bit destinationEDX=0xC0DE4433mov edx, 0xC0DE4477
mov dx, 0x0033 ; 16-bit destinationEDX=0xC0DE0033בשני המקרים DL מסתיים ב-0x33, אבל רק בשני גם DH נכתב, וה-0x44 שלו הפך ל-0x00.
טעויות נפוצות
- בטבלת מעקב מספיק להגיע ל-mov האחרון ולעצור. add או sub שבאים אחריו עדיין משנים את התוצאה, ודווקא אותם קל לשכוח.
mov dx, 0x0033כותבת רק ל-DL, כי הקבוע קטן. מה שקובע הוא היעד, לא גודל המספר. היעד DX, ולכן גם DH מקבל 0x00.- אחרי
mov bl, chנשאר ב-CH אפס. mov קוראת את המקור ולא נוגעת בו. CH שומר על ערכו. sub dl, 0x20מחשבת 0x20 פחות DL. בחיסור מורידים את הימני מהשמאלי: DL פחות 0x20.- אפשר לכתוב mov שמעתיקה ישר מתא זיכרון אחד לתא אחר. צורה כזו לא קיימת. מעבירים דרך אוגר: טוענים לאוגר, ומשם כותבים לזיכרון.
- בכל קטע, inc ו-dec מבטלים זה את זה, אז אפשר לדלג עליהם. רק זוג של inc ו-dec מתקזז. אם יש שני inc ו-dec אחד, נשאר שינוי של 1+.
בדקו את עצמכם
איזה ערך X צריך לטעון ב-mov ebx, X כדי שאחרי sub ebx, 6 ואחרי inc ebx יהיה EBX=10?
X=15: 15 פחות 6 הם 9, ועוד 1 הם 10.
ECX=0. איזו מהשתיים תשאיר בו 0xFFFFFFFF: inc ecx או dec ecx?
dec ecx. הפחתה מאפס ממשיכה מהקצה העליון של הטווח, כפי שיוסבר בחלק על גלישה כלפי מטה.
לכל שורה, אמרו אם היא בסדר, ואם לא, מה הבעיה: mov bl, 0x30, mov bl, 0x300, mov [x], [y].
הראשונה בסדר. בשנייה הקבוע גדול מ-255 ולא נכנס בבית (nasm היה מזהיר ושומר רק 0x00), ובשלישית אין mov בין שני תאי זיכרון.
כתיבה לתת-אוגר: מה משתנה ומה נשאר
הכלל: נכתבים רק הביטים של היעד
קחו את EAX=0x9C3E71A5 והריצו mov ah, 0x00. התוצאה היא 0x9C3E00A5: הבית 71 התחלף ב-00, ו-A5 שמימינו ו-9C3E שמשמאלו לא זזו בכלל.
זה כל הכלל, והוא נכון לכל יעד: הפקודה מחליפה את הביטים שהיעד מכסה, וכל ביט אחר של אותו אוגר בן 32 ביט נשאר כמו שהיה. כך זה נראה לכל אחד מהשמות של EAX:
- יעד AL: משתנים ביטים 0 עד 7. AH והחצי העליון של EAX לא זזים.
- יעד AH: משתנים ביטים 8 עד 15, ו-AL לא זז.
- יעד AX: משתנים ביטים 0 עד 15, כלומר גם AH וגם AL. החצי העליון לא זז.
- יעד EAX: משתנים כל 32 הביטים.
הכלל לא שייך דווקא ל-mov. add al, 1, וכל sub, inc או dec שהיעד שלהן AL, נוגעות גם הן רק ב-AL; ומי שקורא את AL מקבל את ביטים 0 עד 7 בלבד, בלי לשנות שום ביט.
אותו אוגר, ארבע כתיבות
בכל שורה בטבלה EAX מתחיל מ-0x9C3E71A5, והשורות לא נמשכות זו מזו. בכל אחת כותבים אפס ליעד אחר:
| פקודה | ביטים שנכתבים | EAX אחרי | מה לא נפגע |
|---|---|---|---|
mov al, 0x00 | 0-7 | 0x9C3E7100 | AH=0x71 והחצי העליון 0x9C3E |
mov ah, 0x00 | 8-15 | 0x9C3E00A5 | AL=0xA5 והחצי העליון 0x9C3E |
mov ax, 0x0000 | 0-15 | 0x9C3E0000 | החצי העליון 0x9C3E |
mov eax, 0x00000000 | 0-31 | 0x00000000 | שום דבר |
אוגר שיש לו רק חצי של 16 ביט מתנהג אותו דבר. אם ESI=0x9C3E71A5, אחרי mov si, 0x0042 נקבל ESI=0x9C3E0042, והחצי העליון 0x9C3E שרד.
בניית ערך משני בתים
מה יוצא כשכותבים לשני הבתים של CX, כל אחד בשורה משלו?
mov cl, 0xB0 ; low byte of CX
mov ch, 0x0E ; high byte of CXCX=0x0EB0כל שורה פוגעת בבית אחר, ולכן אף אחת לא דורסת את מה שהשנייה כתבה. וכיוון ששני הבתים נכתבו, לא משנה מה היה ב-ECX לפני הקטע: CX יוצא 0x0EB0 בכל מקרה.
אילו רק CL היה נכתב, CH היה שומר על הערך שהיה בו קודם, ואז הערך הקודם כן היה משפיע על התוצאה.
שימו לב איך מרכיבים את התשובה: CH נכתב בשורה השנייה, ובכל זאת הוא בא ראשון, משמאל. המיקום נקבע לפי השם, עליון או תחתון, ולא לפי סדר השורות, ולכן התוצאה 0x0EB0 ולא 0xB00E.
וכשהבית העליון נכתב קודם, התוצאה לא משתנה: mov bh, 0x02 ואחריה mov bl, 0x04 נותנות BX=0x0204, בדיוק כמו בסדר ההפוך.
טעויות נפוצות
- BH=0x02 ו-BL=0x04 מצטרפים ל-BX=0x0402. הבית העליון עומד משמאל, ולכן BX=0x0204.
- כש-CL מקבל ערך חדש, CH מתאפס, ואולי גם כל ECX. היעד CL מכסה רק את ביטים 0 עד 7, ושאר הביטים לא זזים.
- אחרי שכותבים ל-BH, ב-BL נשאר אפס. BH ו-BL הם שני בתים נפרדים, וכל כתיבה פוגעת רק בבית שלה.
- כתיבה ל-DX מנקה גם את החצי העליון של EDX. DX הוא ביטים 0 עד 15 בלבד. ביטים 16 עד 31 נשארים.
- DI שונה מ-DX: כתיבה אליו מוחקת את כל EDI. DI מתנהג בדיוק כמו DX, ומשנה רק את 16 הביטים התחתונים.
- כשבונים ערך משני בתים, רק השורה האחרונה קובעת. כל שורה קובעת את הבית שלה, ושתיהן נכנסות לתוצאה.
mov dx, 0x0071שבאה לפניmov dh, 0x3Aכבר קובעת את DX הסופי. הכתיבה המאוחרת ל-DH מחליפה את הבית העליון, וצריך להחיל גם אותה.
בדקו את עצמכם
EDX=0xFEEDFACE. כל אחת משלוש הפקודות הבאות רצה לבד, מהערך המקורי הזה: mov dl, 0, mov dx, 0, mov dh, 0x2B. מה ערך EDX אחרי כל אחת?
אחרי mov dl, 0: 0xFEEDFA00. אחרי mov dx, 0: 0xFEED0000. אחרי mov dh, 0x2B: 0xFEED2BCE.
רוצים לשנות ב-ECX את ביטים 8 עד 15 ואף ביט אחר. לאיזה שם כותבים?
ל-CH, למשל mov ch, 0x5E.
EBX=0xEEEE0000. אחרי mov bh, 0x5A ו-mov bl, 0x3C, אילו בתים של EBX השתנו, ומה הערך שלו?
השתנו רק שני הבתים התחתונים, ו-EBX=0xEEEE5A3C. החצי העליון 0xEEEE לא נגע.
גלישה בתוך תת-אוגר
כל רוחב סופר עד גבול, ואז מתחיל מחדש
שני הקטעים הבאים מתחילים מאותו CX=0x00FF ומוסיפים לו 1. ההבדל היחיד ביניהם הוא רוחב היעד:
mov cx, 0x00FF
add cx, 1 ; 16-bit addCX=0x0100mov cx, 0x00FF
add cl, 1 ; 8-bit addCX=0x0000ההסבר: לכל רוחב יש מספר קבוע של ערכים אפשריים, ותוצאה שעוברת את הגדול שבהם מתחילה שוב מאפס. זה כמו שעון של 24 שעות, שבו 23:00 ועוד שלוש שעות הן 02:00; במתמטיקה זה נקרא חישוב מודולו.
| רוחב | טווח | הערך הגדול ביותר | מודולו |
|---|---|---|---|
| 8 ביט (למשל CL, DH) | 0x00 עד 0xFF | 0xFF, כלומר 255 | 256 (0x100) |
| 16 ביט (למשל CX) | 0x0000 עד 0xFFFF | 0xFFFF, כלומר 65535 | 65536 (0x10000) |
| 32 ביט (למשל ECX) | 0x00000000 עד 0xFFFFFFFF | 0xFFFFFFFF | 2 בחזקת 32 (0x100000000) |
ב-CL, שהוא 8 ביט, 0xFF ועוד 1 כבר עובר את הגבול וחוזר לאפס. ב-CX, שהוא 16 ביט, 0x0100 עדיין רחוק מהגבול, ולכן התוצאה נשמרה במלואה.
בפועל לא צריך לחשוב על מודולו: מחשבים את הסכום המלא, ואז מוחקים משמאל כל ספרה שלא נכנסת. ליעד של 8 ביט משאירים שתי ספרות הקסדצימליות, וליעד של 16 ביט ארבע.
חזרה לתוכן הענייניםגלישה למעלה
| מצב | פקודה | סכום מלא | מה נשאר |
|---|---|---|---|
| CL=0xFF | add cl, 1 | 0x100 | CL=0x00: מוחקים את ה-1 שמשמאל. |
| DL=0xE8 | add dl, 0x30 | 0x118 (232 ועוד 48 הם 280) | DL=0x18: נשארות שתי הספרות הימניות. |
| AX=0xFFFF | add ax, 1 | 0x10000 | AX=0x0000: נשארות ארבע ספרות. |
| ESI=0xFFFFFFFF | add esi, 1 | 0x100000000 | ESI=0x00000000: נשארות שמונה ספרות. |
בכל השורות התהליך זהה, ורק מספר הספרות שנשארות משתנה עם הרוחב.
חזרה לתוכן הענייניםגלישה למטה
השעון עובד גם אחורה: שעה אחת לפני 00:00 היא 23:00, ולא מינוס אחת. אותו דבר קורה כשמחסרים מתת-אוגר יותר ממה שיש בו.
כדי לחשב, דמיינו שלפני החיסור הוספתם לערך את גודל הטווח, 0x100 ליעד של 8 ביט. ההפרש שיוצא הוא התשובה:
| מצב | פקודה | החישוב | תוצאה |
|---|---|---|---|
| BL=0x00 | sub bl, 1 | 0x100 - 1 | BL=0xFF |
| DL=0x02 | sub dl, 0x03 | 0x102 - 0x03 | DL=0xFF |
| AL=0x04 | sub al, 7 | 0x104 - 0x07 | AL=0xFD |
dec מתנהג אותו דבר. ב-ECX=0, הפקודה dec ecx משאירה 0xFFFFFFFF.
הגלישה נשארת בתוך התת-אוגר
בקטע עם add cl, 1 שבתחילת הנושא, ה-1 שנמחק משמאל לא הופיע ב-CH. זה המקום שבו טועים הכי הרבה, ולכן נראה את אותו עיקרון שוב, במצב שבו הבית העליון לא ריק:
mov dx, 0x3BFF
add dl, 1 ; DL: 0xFF + 1 wraps to 0x00, DH stays 0x3BDX=0x3B00ה-1 העודף לא עבר ל-DH, כי החישוב התבצע ברוחב של DL בלבד, ול-DH אין בו חלק. כך בדיוק נראה כל מקרה של גלישה בתוך תת-אוגר:
- בבית העליון: AX=0xFF2D ואחריו
add ah, 1נותנים AX=0x002D. AH גולש לאפס, ו-AL לא מקבל דבר. - בכיוון מטה: BX=0x7700 ואחריו
sub bl, 1נותנים BX=0x77FF. BL גולש ל-0xFF, ו-BH נשאר 0x77. - ברוחב 16 ביט: EBX=0x0009FFFF ואחריו
add bx, 1נותנים EBX=0x00090000. BX גולש, והחצי העליון לא משתנה.
השוו לזוג שבתחילת הנושא: שם, כשהיעד היה CX, הנשיאה עברה לבית העליון כי הוא היה חלק מהיעד. הגבול של הגלישה הוא תמיד הגבול של היעד.
חזרה לתוכן הענייניםמה קורה לדגלים
לדגלים יש פרק משלהם, אבל ארבע הרצות קצרות מספיקות כדי לראות מה קורה להם כשתת-אוגר גולש:
mov dl, 0xFF
add dl, 1 ; 8-bit add: the carry has nowhere to goDL=0x00 CF=1 ZF=1mov dx, 0x00FF
add dx, 1 ; 16-bit add: the carry fits in DHDX=0x0100 CF=0 ZF=0mov al, 0x00
sub al, 1 ; borrow below zeroAL=0xFF CF=1 ZF=0mov dl, 0xFF
clc ; start with CF=0
inc dl ; DL wraps to 0x00DL=0x00 CF=0 ZF=1מה רואים בהרצות:
- הראשונה: add שהתוצאה שלה לא נכנסת ביעד מדליקה את CF. ה-1 שנמחק משמאל לא נעלם לגמרי, הוא עבר לדגל.
- השנייה: אותה הוספה של 1 ל-0xFF, אבל ברוחב 16 ביט, לא גולשת, ולכן CF=0. הדגל תלוי ברוחב הפעולה.
- השלישית: sub שמחסרת מספר גדול ממספר קטן, בלי סימן, מדליקה גם היא CF, הפעם כלווה.
- הרביעית: DL גלש כמו בראשונה, אבל CF נשאר 0, כי inc לא נוגעת בו, ובאותו אופן dec. mov לא משנה אף דגל.
- ובכל הרצה שבה התוצאה אפס, ZF=1.
כדי לענות על שאלה שמבקשת ערך של אוגר לא צריך את הדגלים. הם רק משלימים את התמונה: הנשיאה שנזרקה מהתת-אוגר מגיעה לדגל, ולעולם לא לחלק אחר של האוגר.
טעויות נפוצות
- DL=0xE8 ועוד 0x30 משאירים ב-DL את 0x118. לבית יש שתי ספרות בלבד. מוחקים את ה-1 שמשמאל ונשאר DL=0x18.
- 0xE8 ועוד 0x30 הם 0x11B. 8 ועוד 0 הם 8, ו-E ועוד 3 הם 17, כלומר 1 במקום ו-1 בנשיאה. הסכום המלא הוא 0x118.
- כש-DL עובר את 0xFF, DH מקבל את ה-1. החישוב היה ברוחב DL. ה-1 נזרק, ובפקודת add הוא מופיע רק ב-CF.
- BL שירד מתחת לאפס לוקח 1 מ-BH. החיסור כולו בתוך BL, ו-BH לא משתנה.
- 0x00 פחות 1 נשאר 0x00, כי אין מספרים שליליים. הספירה ממשיכה אחורה מהקצה העליון, ולכן התוצאה 0xFF.
- אין הבדל בין
add cx, 1לביןadd cl, 1. כש-CL=0xFF יש: היעד CX מקבל את הנשיאה ל-CH, והיעד CL זורק אותה. - כש-BX גולש, החצי העליון של EBX עולה ב-1. ביטים 16 עד 31 אינם חלק מ-BX ולא מושפעים ממנו.
בדקו את עצמכם
BX=0x02FE. מהו הקבוע הקטן ביותר שיגרום ל-add bl, k לגלוש? ומה יהיה BX אחרי add bl, 3?
k=2, כי 0xFE ועוד 2 הם 0x100. אחרי add bl, 3 הסכום המלא 0x101, נשאר BL=0x01, ו-BX=0x0201.
DL=1 ומריצים sub dl, 4. מה יהיה DL, ומה מצב CF?
DL=0xFD, כי 0x101 פחות 4 הם 0xFD. CF=1, כי היה לווה.
ECX=0x000BFFFF. מה ההבדל בין התוצאה של add cx, 1 לבין זו של add ecx, 1?
add cx, 1 גולשת בתוך CX ונותנת ECX=0x000B0000. add ecx, 1 לא גולשת, והנשיאה עוברת הלאה: ECX=0x000C0000.
התאמת גדלים בין האופרנדים
שני האופרנדים באותו רוחב
הנה עשר שורות, וההערה בכל אחת אומרת מה רוחב שני האופרנדים שלה. נסו לנחש לפני שאתם קוראים את הפלט אילו מהן nasm יקבל:
bits 32
mov cl, dh ; 8 and 8
mov bh, al ; 8 and 8
mov dx, cx ; 16 and 16
mov edi, esi ; 32 and 32
mov bx, cl ; 16 and 8
mov ecx, dl ; 32 and 8
mov edi, di ; 32 and 16
mov dx, ah ; 16 and 8
sub cl, dx ; 8 and 16sizes.asm:6: error: invalid combination of opcode and operands
sizes.asm:7: error: invalid combination of opcode and operands
sizes.asm:8: error: invalid combination of opcode and operands
sizes.asm:9: error: invalid combination of opcode and operands
sizes.asm:10: error: invalid combination of opcode and operandsהשגיאות נופלות בדיוק על השורות שבהן הרוחבים שונים, גם כשהפקודה היא sub. מכאן הכלל: שני אוגרים באותה פקודה חייבים להיות באותו רוחב, כי המעבד לא ירחיב או יקצר ערך בשבילכם.
כדי להפעיל את הכלל צריך לזהות רוחב מהשם בלבד, והשמות מתחלקים לשלוש קבוצות:
- שם שמתחיל ב-E הוא 32 ביט: EAX, EBX, ECX ו-EDX, וגם ESI, EDI, EBP ו-ESP.
- שם של שתי אותיות שמסתיים ב-X, או SI, DI, BP ו-SP, הוא 16 ביט.
- שם שמסתיים ב-H או ב-L, כמו AL, AH, BL, BH, CL, CH, DL ו-DH, הוא 8 ביט.
גם קבוע נמדד ביחס ליעד: הוא צריך להיכנס ברוחב של היעד, כמו שראינו בחלק על מספרים בתוך הפקודה.
חזרה לתוכן הענייניםמה עובר הרכבה ומה לא
| פקודה | תקינה? | הסיבה |
|---|---|---|
mov cl, dh | כן | 8 ביט ו-8 ביט. |
mov bh, al | כן | שניהם 8 ביט. בית עליון של אוגר אחד ובית תחתון של אוגר אחר הם צירוף תקין. |
mov dx, cx | כן | 16 ו-16. |
mov edi, esi | כן | 32 ו-32. |
mov bx, cl | לא | 16 מול 8. |
mov ecx, dl | לא | 32 מול 8. |
mov edi, di | לא | 32 מול 16. |
mov dx, ah | לא | 16 מול 8. |
mov dil, 7 | לא | במצב 32 ביט אין ל-EDI חלק של 8 ביט. |
sub cl, dx | לא | 8 מול 16. הכלל חל על add ועל sub בדיוק כמו על mov. |
mov bl, 0x2A0 | לא כותבים כך | הקבוע גדול מבית. NASM מזהיר וחותך אותו, ובשאלות זה לא מופיע. |
את mov dil, 7 בדקנו בקובץ נפרד, והיא קיבלה את אותה שגיאה שראינו קודם עם SIL: invalid operands in 32-bit mode.
העתקה בין חלקים של אוגרים
mov ecx, 0x0F1E2D3C
mov edx, 0x4B5A6978
mov cl, dh ; DH=0x69 -> ECX=0x0F1E2D69
mov ch, dl ; DL=0x78 -> ECX=0x0F1E7869
mov dx, cx ; CX=0x7869 -> EDX=0x4B5A7869ECX=0x0F1E7869 EDX=0x4B5A7869שלוש ההעתקות כאן תקינות, כי בכל אחת שני הצדדים ברוחב שווה; לא משנה שהן חוצות בין ECX ל-EDX, ולא משנה שבשורה השלישית בית עליון עובר למקום של בית תחתון. בכל פעם עוברים רק 8 או 16 ביטים, וכל השאר באוגר היעד לא זז.
עקבו גם אחרי המקורות: DH ו-DL נקראו, אבל EDX נשאר 0x4B5A6978 עד השורה האחרונה, שבה הוא עצמו היה היעד. אז DX הפך ל-0x7869, ו-0x4B5A שמעליו נשאר.
טעויות נפוצות
mov cl, dhמשנה גם את DH. DH הוא המקור, ומקור רק נקרא.- אסור להעתיק מבית תחתון לבית עליון, כמו ב-
mov bh, al. הכלל בודק רוחב ולא מיקום. 8 ו-8, ולכן תקין. - ב-
mov bx, clהמעבד ישלים את הבית החסר באפסים. אין השלמה כזו. 16 מול 8 נדחה כבר בהרכבה. - אפשר לכתוב בית ל-SIL, החלק הקטן של ESI. במצב 32 ביט SIL לא קיים. ל-ESI יש רק SI.
בדקו את עצמכם
mov bx, ch ו-mov edi, di נדחות. תקנו כל אחת בהחלפה של שם אוגר אחד בלבד, כך שתעבור הרכבה.
למשל mov bl, ch (8 ו-8) ו-mov edi, esi (32 ו-32). גם mov bh, ch מתקנת את הראשונה, ו-mov di, di את השנייה (תקינה, אם כי לא עושה כלום).
EAX=0x89ABCDEF ו-EBX=0. אילו שתי פקודות של 8 ביט יכניסו ל-BX את 0xCDEF, ומה יהיה EBX אחריהן?
mov bl, al ו-mov bh, ah, בכל סדר. EBX=0x0000CDEF.
לשורה mov [w], 9 חסר רוחב. כתבו שלוש גרסאות מתוקנות, ואמרו כמה בתים כותבת כל אחת.
mov byte [w], 9 כותבת בית אחד, mov word [w], 9 שני בתים, ו-mov dword [w], 9 ארבעה בתים.
זיכרון וסדר little-endian
הזיכרון: שורה ארוכה של בתים
עד כאן הערכים הגיעו מקבועים ומאוגרים. כשהם מגיעים מהזיכרון, יש שאלה נוספת: באיזה סדר הבתים שלהם מונחים שם.
הגדירו בקטע הנתונים משתנה אחד של ארבעה בתים:
section .data
cnt dd 0x0A0B0C0D ; cnt names the address of four bytesdd מקצה ארבעה בתים, dw מקצה שניים ו-db מקצה אחד, ו-cnt הוא שם לכתובת שבה הם מתחילים. הזיכרון כולו הוא שורה ארוכה של בתים, ולכל בית בה יש כתובת משלו; ארבעת הבתים של cnt יושבים זה ליד זה.
בקוד מבחינים בין הכתובת לבין התוכן. cnt לבדו הוא הכתובת, [cnt] בסוגריים מרובעים הוא מה שיושב בה, ו-[cnt+1] הוא התוכן של הבית הבא.
little-endian: הבית הקטן בכתובת הנמוכה
אם תציצו בזיכרון אחרי ההגדרה הזו, תראו את הבתים בסדר הבא:
| כתובת | cnt | cnt+1 | cnt+2 | cnt+3 |
|---|---|---|---|---|
| הבית שבה | 0x0D | 0x0C | 0x0B | 0x0A |
קראו את השורה משמאל לימין, 0D 0C 0B 0A, והיא נראית הפוכה מהמספר שהגדרנו. זה הסדר שנקרא little-endian, ומעבדי x86 עובדים בו: הבית הפחות משמעותי, 0D, נכנס לכתובת הנמוכה, והמשמעותי ביותר, 0A, לגבוהה.
ההיפוך הזה קיים רק בזיכרון. ברגע שהערך נטען לאוגר הוא שוב יחידה אחת של 32 ביט, ו-CL הוא תמיד 8 הביטים התחתונים שלה.
חזרה לתוכן הענייניםטעינה מהזיכרון לתוך תת-אוגר
כמה בתים ייקראו בכל טעינה? את זה קובע רוחב האוגר שמקבל אותם, והקריאה מתחילה בכתובת שבסוגריים. בהרצה הבאה EBX, ECX ו-EDX מתחילים ב-0xFFFFFFFF, כך שכל בית שלא נטען נשאר F:
section .data
cnt dd 0x0A0B0C0D
section .text
mov ebx, 0xFFFFFFFF
mov ecx, 0xFFFFFFFF
mov edx, 0xFFFFFFFF
mov eax, [cnt]
mov dx, [cnt]
mov cl, [cnt]
mov ch, [cnt+1]
mov bl, [cnt+3]EAX=0x0A0B0C0D EDX=0xFFFF0C0D ECX=0xFFFF0C0D EBX=0xFFFFFF0A| טעינה | בתים שנקראו | מה התקבל |
|---|---|---|
mov eax, [cnt] | 4, מ-cnt עד cnt+3 | EAX=0x0A0B0C0D: המעבד מסדר את הבתים בחזרה. |
mov dx, [cnt] | 2, מ-cnt ו-cnt+1 | DX=0x0C0D, וב-EDX החצי העליון נשאר 0xFFFF. |
mov cl, [cnt] | 1, מ-cnt | CL=0x0D, הבית הנמוך. |
mov ch, [cnt+1] | 1, מ-cnt+1 | CH=0x0C. |
mov bl, [cnt+3] | 1, מ-cnt+3 | BL=0x0A, הבית העליון של הערך, כי הוא בכתובת הגבוהה. |
בשורות של DX, CL, CH ו-BL הטעינה מתנהגת כמו כל כתיבה לתת-אוגר: היא מחליפה רק את החלק שלה, וה-F של שאר האוגר נשארים.
כתיבה לזיכרון עובדת באותו היגיון, בכיוון ההפוך. בקטע הבא כותבים פעם את AL ופעם את EAX לאותו משתנה, ובכל פעם קוראים אותו בחזרה:
section .data
q dd 0x11111111
section .text
mov eax, 0xAABBCCDD
mov [q], al ; one byte: only address q changes
mov ebx, [q]
mov [q], eax ; four bytes
mov ecx, [q]EBX=0x111111DD ECX=0xAABBCCDDmov [q], al החליפה בית אחד, זה שבכתובת q, ולכן EBX קרא 0x111111DD. mov [q], eax החליפה את כל ארבעת הבתים, ו-ECX קרא את הערך המלא.
טעויות נפוצות
- גם EAX מחזיק את הבתים בסדר הפוך, כמו בזיכרון. באוגר הערך מסודר כרגיל, ו-AL הוא תמיד הבית התחתון. ההיפוך הוא עניין של זיכרון בלבד.
- אחרי
cnt dd 0x0A0B0C0D, בכתובת cnt יושב 0A. הכתובת הנמוכה מקבלת את הבית הפחות משמעותי, ולכן ב-cnt יושב 0D. mov [cnt], 3לא צריכה תוספת, האסמבלר ידע כמה בתים לכתוב. בכתיבה של קבוע לזיכרון כותבים byte, word או dword.mov [dst], [src]היא דרך מקוצרת להעתיק משתנה. mov לא עובדת בין שני תאי זיכרון. מעבירים דרך אוגר.
בדקו את עצמכם
מהכתובת x והלאה רואים בזיכרון FF EE 66 55. איזו הגדרת dd יצרה אותם?
x dd 0x5566EEFF: הבית הנמוך, FF, הוא האחרון בכתיב.
באותו x, ECX=0. איזו טעינה אחת תכניס ל-CH את 0x55, ומה יהיה ECX אחריה?
mov ch, [x+3], כי 0x55 יושב בכתובת הגבוהה. ECX=0x00005500.
כמה בתים קוראת כל אחת, ומה היא מכניסה: mov edx, [x], mov dx, [x], mov dl, [x]?
הראשונה ארבעה בתים, EDX=0x5566EEFF. השנייה שניים, DX=0xEEFF. השלישית אחד, DL=0xFF, ושאר EDX לא משתנה בשתי האחרונות.
מעקבים מלאים, שורה אחר שורה
איך עובדים על מעקב
כאן מתחברים כל הכללים. בכל מעקב רושמים את ערך האוגר אחרי כל שורה, ועדיף לעשות זאת לבד לפני שמציצים בטבלה.
הפלט שמתחת לכל קטע הוא הערך הסופי כפי שהתקבל בהרצה. הערכים שבטבלאות הם המעקב שורה אחר שורה, וגם הם נבדקו בהרצה, בעזרת צילום של האוגרים אחרי כל שורה.
חזרה לתוכן הענייניםמעקבים על כתיבות
תרחיש 1: כתיבה ל-DX, אחר כך ל-DH, ובסוף חיסור מ-DL
mov edx, 0x99AABBCC
mov dx, 0x0071
mov dh, 0x3A
sub dl, 0x20EDX=0x99AA3A51| שורה | פקודה | EDX אחרי | הסבר |
|---|---|---|---|
| 1 | mov edx, 0x99AABBCC | 0x99AABBCC | האוגר כולו מקבל ערך. |
| 2 | mov dx, 0x0071 | 0x99AA0071 | היעד 16 ביט: DH הופך ל-0x00 ו-DL ל-0x71, ו-0x99AA לא זז. |
| 3 | mov dh, 0x3A | 0x99AA3A71 | הבית העליון של DX מתחלף; 0x71 של DL נשאר. |
| 4 | sub dl, 0x20 | 0x99AA3A51 | 0x71 פחות 0x20 הם 0x51, בלי גלישה, ו-DH לא מושפע. |
תרחיש 2: כתיבה ל-CX ואחריה ל-CL
mov ecx, 0x13572468
mov cx, 0x4455
mov cl, 0x00ECX=0x13574400| שורה | פקודה | ECX אחרי | הסבר |
|---|---|---|---|
| 1 | mov ecx, 0x13572468 | 0x13572468 | בנקודת ההתחלה CH=0x24 ו-CL=0x68. |
| 2 | mov cx, 0x4455 | 0x13574455 | שני הבתים התחתונים מתחלפים, 0x1357 נשאר. |
| 3 | mov cl, 0x00 | 0x13574400 | מתאפס הבית הימני בלבד, ו-0x44 של CH שורד. |
מעקבים עם גלישה
תרחיש 3: גלישה למעלה ב-DL אחרי ש-DH נכתב
mov dx, 0x00FF
mov dh, 0x2C
add dl, 0x01DX=0x2C00 CF=1 ZF=1| שורה | פקודה | DX אחרי | הסבר |
|---|---|---|---|
| 1 | mov dx, 0x00FF | 0x00FF | DH=0x00 ו-DL=0xFF. |
| 2 | mov dh, 0x2C | 0x2CFF | מתחלף רק הבית השמאלי. |
| 3 | add dl, 0x01 | 0x2C00 | הסכום המלא 0x100, וב-DL נשאר 00. ה-1 לא מגיע ל-DH אלא ל-CF, ו-ZF נדלק כי DL התאפס. |
תרחיש 4: גלישה למטה ב-BL ואחריה כתיבה ל-BH
mov bl, 0x00
sub bl, 0x01
mov bh, 0x07BX=0x07FF| שורה | פקודה | BH / BL | הסבר |
|---|---|---|---|
| 1 | mov bl, 0x00 | BL=0x00 | ב-BH יש עדיין מה שהיה שם קודם, ואנחנו לא יודעים מה. |
| 2 | sub bl, 0x01 | BL=0xFF | חיסור מאפס חוזר מהקצה העליון; BH לא מושפע, ו-CF=1. |
| 3 | mov bh, 0x07 | BH=0x07, BL=0xFF | גם הבית העליון ידוע עכשיו, ולכן BX=0x07FF. |
לא צריך לדעת מה היה ב-EBX בהתחלה, כי שני הבתים של BX נכתבו. בהרצה ניסינו שני ערכי התחלה שונים ל-EBX, ובשניהם BX יצא 0x07FF.
תרחיש 5: חיבור ב-AL שעובר את 0xFF
mov eax, 0x00005600
mov al, 0xE0
add al, 0x40EAX=0x00005620| שורה | פקודה | EAX אחרי | הסבר |
|---|---|---|---|
| 1 | mov eax, 0x00005600 | 0x00005600 | AH=0x56 ו-AL=0x00. |
| 2 | mov al, 0xE0 | 0x000056E0 | רק הבית הימני. |
| 3 | add al, 0x40 | 0x00005620 | 0xE0 ועוד 0x40 נותנים 0x120; AL שומר 20, AH נשאר 0x56, ו-CF=1. |
תרחיש 6: חיבור ב-BH שלא נוגע בחצי העליון
mov ebx, 0x3000EF12
mov bl, 0x00
add bh, 0x01EBX=0x3000F000| שורה | פקודה | EBX אחרי | הסבר |
|---|---|---|---|
| 1 | mov ebx, 0x3000EF12 | 0x3000EF12 | BH=0xEF ו-BL=0x12, ומעליהם 0x3000. |
| 2 | mov bl, 0x00 | 0x3000EF00 | מתאפס הבית הימני בלבד. |
| 3 | add bh, 0x01 | 0x3000F000 | בתוך BH, 0xEF ועוד 1 הם 0xF0 (נשיאה בין שתי הספרות של אותו בית); BL ו-0x3000 לא זזים. |
חצי של 16 ביט, העתקות, זיכרון וחשבון
תרחיש 7: EDI: אוגר שיש לו רק חצי של 16 ביט
mov edi, 0x00080040
mov di, 0x0002
add di, 0x0005EDI=0x00080007| שורה | פקודה | EDI אחרי | הסבר |
|---|---|---|---|
| 1 | mov edi, 0x00080040 | 0x00080040 | DI=0x0040. |
| 2 | mov di, 0x0002 | 0x00080002 | החצי התחתון מתחלף; 0x0008 נשאר במקומו. |
| 3 | add di, 0x0005 | 0x00080007 | 2 ועוד 5 הם 7, והכול קורה בתוך DI. |
תרחיש 8: העתקות בין חלקים של אוגרים שונים
mov eax, 0x13243546
mov edx, 0x9ABCDEF0
mov dl, ah
mov dh, al
mov ax, dxEAX=0x13244635 EDX=0x9ABC4635| שורה | פקודה | EAX | EDX | הסבר |
|---|---|---|---|---|
| 1 | mov eax, 0x13243546 | 0x13243546 | ? | EDX עוד לא קיבל ערך. |
| 2 | mov edx, 0x9ABCDEF0 | 0x13243546 | 0x9ABCDEF0 | שימו לב לבתים של EAX: AH=0x35 ו-AL=0x46. |
| 3 | mov dl, ah | 0x13243546 | 0x9ABCDE35 | 0x35 נכנס לבית הימני של EDX. |
| 4 | mov dh, al | 0x13243546 | 0x9ABC4635 | 0x46 נכנס לבית שמשמאלו. |
| 5 | mov ax, dx | 0x13244635 | 0x9ABC4635 | 0x4635 עובר ל-AX, ו-0x1324 בחלק העליון של EAX לא נפגע. |
תרחיש 9: קריאה מהזיכרון בסדר little-endian
section .data
t dd 0x9F8E7D6C ; in memory: 6C 7D 8E 9F
section .text
mov eax, 0xFFFFFFFF
mov al, [t]
mov ah, [t+1]
mov edx, 0xFFFFFFFF
mov dx, [t]
mov cl, [t+3]EAX=0xFFFF7D6C EDX=0xFFFF7D6C CL=0x9Fבזיכרון יושבים הבתים 6C, 7D, 8E ו-9F, בכתובות t עד t+3.
| שורה | פקודה | אחרי השורה | הסבר |
|---|---|---|---|
| 1 | mov eax, 0xFFFFFFFF | EAX=0xFFFFFFFF | כל הביטים דולקים, כדי שנראה מה מתחלף. |
| 2 | mov al, [t] | EAX=0xFFFFFF6C | נקרא בית אחד, 0x6C, מהכתובת הנמוכה. |
| 3 | mov ah, [t+1] | EAX=0xFFFF7D6C | הבית הבא בזיכרון, 0x7D, נכנס ל-AH. |
| 4 | mov edx, 0xFFFFFFFF | EDX=0xFFFFFFFF | שוב כל הביטים דולקים. |
| 5 | mov dx, [t] | EDX=0xFFFF7D6C | שני בתים בבת אחת נותנים 0x7D6C, ו-0xFFFF שמעליהם נשאר. |
| 6 | mov cl, [t+3] | CL=0x9F | בכתובת האחרונה יושב הבית העליון של הערך. שאר ECX לא משתנה. |
תרחיש 10: חשבון על אוגרים מלאים וחיבור בתוך CL
mov ebx, 11
mov ecx, 7
add ebx, ecx
sub ebx, 5
mov ecx, 0x200
mov cl, 6
add cl, 2
inc ecx
dec ecxEBX=0x0000000D ECX=0x00000208| שורה | פקודה | EBX | ECX | הסבר |
|---|---|---|---|---|
| 1 | mov ebx, 11 | 11 | ? | קבוע עשרוני. |
| 2 | mov ecx, 7 | 11 | 7 | עוד קבוע עשרוני. |
| 3 | add ebx, ecx | 18 (0x12) | 7 | EBX מקבל את הסכום, ו-ECX רק נקרא. |
| 4 | sub ebx, 5 | 13 (0x0D) | 7 | 18 פחות 5. |
| 5 | mov ecx, 0x200 | 13 | 0x00000200 | בבתים: CH=0x02 ו-CL=0x00. |
| 6 | mov cl, 6 | 13 | 0x00000206 | רק הבית הימני; 6 עשרוני הוא 0x06. |
| 7 | add cl, 2 | 13 | 0x00000208 | החיבור נשאר בתוך CL. |
| 8 | inc ecx | 13 | 0x00000209 | פלוס 1 על האוגר כולו. |
| 9 | dec ecx | 13 | 0x00000208 | מינוס 1, ושוב הערך של שורה 7. |
טעויות ותרגול במעקבים
טעויות נפוצות
- את
add dl, 3מחשבים על הערך ש-DL קיבל בשורה הראשונה של הקטע. החישוב תמיד על הערך הנוכחי, כפי שהשאירו אותו כל השורות שלפניו. - כש-CL גולש, ה-1 עובר ל-CH. גלישה לא חוצה את גבול התת-אוגר.
- אחרי
mov dx, ...אפשר להתעלם מ-mov dh, ...שבא אחריו. השורה המאוחרת מחליפה בית אחד, ובלעדיה התשובה שגויה. - CH=0x09 ו-CL=0x01, אז CX=0x0109. CH עומד משמאל, ולכן CX=0x0901.
- שורות שנראות לא חשובות אפשר לדלג, ולרשום רק את הסוף. כל שורה יכולה לשנות בית אחר. רושמים את המצב אחרי כל אחת.
בדקו את עצמכם
mov ecx, 0x89AB5678, אחריה mov ch, cl ואחריה dec cl. מה ערך ECX?
mov ch, cl מעתיקה את 0x78, ו-ECX=0x89AB7878. dec cl מורידה את הבית הימני ל-0x77: ECX=0x89AB7877.
בקטע mov ebx, 0xFFFFFFFF, add ebx, 1, mov bx, 0xFFFF, inc bx: אחרי אילו שורות EBX שווה אפס?
אחרי השורה השנייה, שבה כל האוגר גלש לאפס, ואחרי הרביעית, שבה BX גלש מ-0xFFFF לאפס והחצי העליון כבר היה 0x0000. אחרי השלישית EBX=0x0000FFFF.
סיכום
כל הנושא מתנקז לשיטה אחת. נריץ אותה על דוגמה חדשה: EDX=0x51A0FFE3, ואחריו mov dh, 0x10 ו-add dl, 0x30, והשאלה היא מה ערך DX.
- כתבו את ערך ההתחלה בשמונה ספרות ופרקו לבתים: 51, A0, FF, E3.
- לכל שורה קבעו את רוחב היעד ואת הביטים שלו. DH הוא 8 ביט, ביטים 8 עד 15; DL הוא 8 ביט, ביטים 0 עד 7.
- החליפו רק את הביטים האלה והעתיקו את השאר. אחרי השורה הראשונה: 0x51A010E3.
- בחשבון על תת-אוגר, חשבו סכום מלא וחתכו לרוחב. 0xE3 ועוד 0x30 הם 0x113, ולכן DL=0x13, וה-1 לא עובר ל-DH.
- קראו בדיוק את האוגר שנשאל, במספר הספרות של הרוחב שלו: DX=0x1013 (ו-EDX כולו 0x51A01013).
והכללים שעליהם השיטה נשענת, לפי נושאים:
| נושא | מה לזכור |
|---|---|
| מבנה | EAX הוא חצי עליון בלי שם ועוד AX, ו-AX הוא AH משמאל ו-AL מימין. כך גם EBX, ECX ו-EDX; ל-ESI, ל-EDI, ל-EBP ול-ESP יש רק SI, DI, BP ו-SP. |
| כתיבה | כתיבה לתת-אוגר מחליפה רק אותו, בלי קשר לסדר השורות. כשקוראים AX, הסדר תמיד 0x(AH)(AL). |
| חשבון | add ו-sub שמות ביעד את היעד ועוד המקור, או את היעד פחות המקור; inc ו-dec מוסיפים או מורידים 1 ולא נוגעים ב-CF. גלישה נשארת בתוך היעד. |
| רוחב | שני אוגרים בפקודה אחת באותו רוחב: mov bh, al תקינה, mov bx, al לא. |
| mov וזיכרון | mov מעתיקה, לא משנה דגלים ולא עובדת בין שני תאי זיכרון. ב-little-endian הבית הנמוך בכתובת הנמוכה, כך ש-0x0A0B0C0D מונח בזיכרון כ-0D 0C 0B 0A. |
טעויות נפוצות
- כשהשאלה שואלת על DX, אפשר לענות עם EDX כולו, או רק עם DL. התשובה היא האוגר שנשאל, לא חלק ממנו ולא אוגר רחב יותר.
- בתשובה אפשר להשמיט אפסים ולכתוב 0x208 במקום 0x00000208. בלי מלוא הספרות קל לאבד את גבולות הבתים. 32 ביט נכתבים בשמונה ספרות, 16 בארבע, ו-8 בשתיים.
- 0xE3 ועוד 0x30 הם 0x113, וזה הערך של DL. זה רק הסכום המלא. החיתוך לרוחב הוא הצעד שהכי קל לשכוח, וב-DL נשאר 0x13.
בדקו את עצמכם
בדוגמה של השיטה, מה היה DX אילו השורה השנייה הייתה add dx, 0x30 במקום add dl, 0x30?
DX=0x1113. ברוחב 16 ביט, 0x10E3 ועוד 0x30 הם 0x1113, והנשיאה נכנסת ל-DH.
EBX=0x0000ABFF. איזו מהשתיים משנה את BH: inc bl או add bx, 1? מה EBX אחרי כל אחת, מאותה נקודת התחלה?
רק add bx, 1, שנותנת 0x0000AC00. inc bl גולשת בתוך BL ונותנת 0x0000AB00, ו-BH נשאר 0xAB.