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

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

תתי אוגרים

מעקב אחרי ערכים באוגרים כשכותבים לחלקים שלהם: 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.
קטעי הקוד שמוצג לצדם פלט הורכבו ב-nasm והורצו באמת, בתוך עטיפה קטנה ב-C שמדפיסה את האוגרים שמופיעים בפלט מיד אחרי השורה האחרונה של הקטע. ההרצה נעשתה על מעבד 64 ביט, ולגבי כל מה שנבדק כאן האוגרים של 32, 16 ו-8 ביט מתנהגים בו בדיוק כמו במצב 32 ביט. קטעים שמתחילים ב-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בית יחיד: 4D8 ביט
0xB2E0שני בתים: B2 ואחריו E016 ביט
0x13579BDFארבעה בתים: 13, 57, 9B, DF32 ביט
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=0x9C3E71A50x9C0x3E0x710xA5
חלק מ-EAX?כןכןכןכן
חלק מ-AX?לאלאכןכן
שם של 8 ביטאיןאיןAHAL

שני הבתים הימניים, 0x71A5, נקראים יחד AX. בתוכם, הבית השמאלי 0x71 הוא AH (ה-H של High) והימני 0xA5 הוא AL (ה-L של Low), ואילו 0x9C3E משמאל לא מקבל שם.

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

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

Assembly
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 EAX
פלט
EBX=0x000071A5 ECX=0x00000071 EDX=0x000000A5
חזרה לתוכן העניינים

ארבעה אוגרים, אותה חלוקה

EAX לא מיוחד בזה. EBX, ECX ו-EDX בנויים בדיוק כמוהו:

32 ביט16 ביטהבית העליון של ה-16הבית התחתון של ה-16
EAXAXAHAL
EBXBXBHBL
ECXCXCHCL
EDXDXDHDL

שם כזה מפענחים לפי חלקיו. ב-CH, למשל, C אומר לכם שמדובר ב-ECX ו-H אומר שזה הבית העליון של CX; ב-DX, ה-X אומר שזה כל חלק ה-16 ביט של EDX.

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

ESI, EDI, EBP ו-ESP: רק חצי של 16 ביט

מה קורה אם מנסים לתת ל-ESI את אותו טיפול? השם SI עובד, אבל ניסיון לפנות לבית שלו נכשל כבר בהרכבה:

Assembly
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 ביט
ESISIאין
EDIDIאין
EBPBPאין
ESPSPאין

החצי הזה מתנהג כמו AX. נניח ESI=0x9C3E71A5: אחרי mov si, 0x0042 נקבל ESI=0x9C3E0042, כי השתנו רק 16 הביטים התחתונים.

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

החצי העליון: ביטים בלי שם

חזרו לטבלה של EAX: בשורת השמות, מעל ביטים 16 עד 31, כתוב פעמיים אין. זה לא חסר בטבלה, פשוט אין לחצי הזה שם, לא ב-EAX ולא באף אחד משבעת האחרים, ואין אוגר כמו EAX_HIGH.

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

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

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

המפה בטבלה אחת

שםרוחבמספרי הביטיםהערך כש-EAX=0x9C3E71A5
EAX32 ביט0 עד 310x9C3E71A5
AX16 ביט0 עד 150x71A5
AH8 ביט8 עד 150x71
AL8 ביט0 עד 70xA5
החצי העליון (אין שם)16 ביט16 עד 310x9C3E
טעויות נפוצות
  • כש-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. לפני שנכיר כל אחת, נקרא שלוש שורות לדוגמה ונראה מה אפשר ללמוד מהן על צורת הכתיבה.

Assembly
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, 0xA1B2C3D4EBX=0x00000000EBX=0xA1B2C3D4כל 32 הביטים קיבלו ערך חדש.
mov bx, 0x0042EBX=0xA1B2C3D4EBX=0xA1B20042רק 16 הביטים התחתונים הוחלפו, ו-0xA1B2 נשאר.
mov bl, chEBX=0xA1B20042, ECX=0x99887766EBX=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 ביט) לפני הסוגריים.

כך האסמבלר מקבל את הצורות התקינות ועוצר בשתי האחרונות:

Assembly
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 source
פלט
forms.asm:9: error: invalid combination of opcode and operands
forms.asm:10: error: invalid combination of opcode and operands
אל תסמכו על האסמבלר שינחש את הרוחב. גרסת nasm שבה נבדקו הדוגמאות כאן קיבלה mov [dst], 7 בלי רוחב ובחרה בשקט לכתוב בית אחד, וגרסאות אחרות עוצרות עם שגיאה על רוחב חסר. בשני המקרים הפתרון זהה: כותבים byte, word או dword.
חזרה לתוכן העניינים

add ו-sub: חשבון שנכתב ליעד

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

פקודהלפניאחרימה קרה
add ebx, ecxEBX=9, ECX=5EBX=14 (0x0E)ECX נשאר 5.
add cl, 4ECX=0x00000203ECX=0x000002073 ועוד 4 הם 7, והחיבור כולו בתוך CL.
add di, 0x0010EDI=0x00030025EDI=0x00030035החיבור בתוך DI, והחצי העליון 0x0003 לא זז.
sub edi, 8EDI=20EDI=12חיסור פשוט.
sub dl, 0x20DL=0x6ADL=0x4A0x6A פחות 0x20.
sub ch, 0x09CH=0x04CH=0xFB0x04 קטן מ-0x09, ולכן ההפרש גולש מטה.

כתבו את זה כנוסחה: add cl, 4 פירושו CL = CL + 4, ו-sub dl, 0x20 פירושו DL = DL - 0x20. בחיבור הסדר לא משנה, אבל בחיסור הוא מכריע: מחסרים את הימני מהשמאלי, ואף פעם לא להפך.

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

בניגוד ל-mov, שתיהן מעדכנות דגלים. בפרק הזה מעניינים אותנו רק שניים: ZF, שנדלק כשהתוצאה אפס, ו-CF, שמסמן נשיאה (carry) בחיבור ולווה (borrow) בחיסור.

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

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

inc ו-dec: הוספה או הפחתה של 1

Assembly
inc esi          ; esi = esi + 1
dec bh           ; bh = bh - 1
פקודהלפניאחרימה קרה
inc esiESI=9ESI=10פלוס 1.
dec esiESI=3ESI=2מינוס 1.
inc clECX=0x000000FFECX=0x00000000CL עובר מ-0xFF ל-0x00, CH לא משתנה, ו-CF נשאר כפי שהיה.
dec bhEBX=0x56780202EBX=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 עם קבוע שלא נכנס? הוא לא עוצר, אלא מזהיר ושומר רק את מה שנכנס. בשאלות לא תפגשו כתיבה כזו, וגם בקוד אמיתי לא כותבים כך:

Assembly
bits 32
mov bl, 0x2A0     ; does not fit in 8 bits
פלט
fit.asm:2: warning: byte exceeds bounds [-w+number-overflow]

הפקודה שנוצרה בפועל טוענת ל-BL רק את הבית התחתון, 0xA0, והספרה 2 פשוט אבדה.

ועוד נקודה שקל לפספס: כשהיעד הוא DX והקבוע הוא 0x0033, נכתבים כל 16 הביטים של DX, ובכללם DH שמתאפס. השוו בין שני הקטעים הבאים, שמתחילים מאותו EDX:

Assembly
mov edx, 0xC0DE4477
mov dl, 0x33     ; 8-bit destination
פלט
EDX=0xC0DE4433
Assembly
mov edx, 0xC0DE4477
mov dx, 0x0033   ; 16-bit destination
פלט
EDX=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, 0x000-70x9C3E7100AH=0x71 והחצי העליון 0x9C3E
mov ah, 0x008-150x9C3E00A5AL=0xA5 והחצי העליון 0x9C3E
mov ax, 0x00000-150x9C3E0000החצי העליון 0x9C3E
mov eax, 0x000000000-310x00000000שום דבר

אוגר שיש לו רק חצי של 16 ביט מתנהג אותו דבר. אם ESI=0x9C3E71A5, אחרי mov si, 0x0042 נקבל ESI=0x9C3E0042, והחצי העליון 0x9C3E שרד.

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

בניית ערך משני בתים

מה יוצא כשכותבים לשני הבתים של CX, כל אחד בשורה משלו?

Assembly
mov cl, 0xB0     ; low byte of CX
mov ch, 0x0E     ; high byte of CX
פלט
CX=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. ההבדל היחיד ביניהם הוא רוחב היעד:

Assembly
mov cx, 0x00FF
add cx, 1        ; 16-bit add
פלט
CX=0x0100
Assembly
mov cx, 0x00FF
add cl, 1        ; 8-bit add
פלט
CX=0x0000

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

רוחבטווחהערך הגדול ביותרמודולו
8 ביט (למשל CL, DH)0x00 עד 0xFF0xFF, כלומר 255256 (0x100)
16 ביט (למשל CX)0x0000 עד 0xFFFF0xFFFF, כלומר 6553565536 (0x10000)
32 ביט (למשל ECX)0x00000000 עד 0xFFFFFFFF0xFFFFFFFF2 בחזקת 32 (0x100000000)

ב-CL, שהוא 8 ביט, 0xFF ועוד 1 כבר עובר את הגבול וחוזר לאפס. ב-CX, שהוא 16 ביט, 0x0100 עדיין רחוק מהגבול, ולכן התוצאה נשמרה במלואה.

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

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

גלישה למעלה

מצבפקודהסכום מלאמה נשאר
CL=0xFFadd cl, 10x100CL=0x00: מוחקים את ה-1 שמשמאל.
DL=0xE8add dl, 0x300x118 (232 ועוד 48 הם 280)DL=0x18: נשארות שתי הספרות הימניות.
AX=0xFFFFadd ax, 10x10000AX=0x0000: נשארות ארבע ספרות.
ESI=0xFFFFFFFFadd esi, 10x100000000ESI=0x00000000: נשארות שמונה ספרות.

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

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

גלישה למטה

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

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

מצבפקודההחישובתוצאה
BL=0x00sub bl, 10x100 - 1BL=0xFF
DL=0x02sub dl, 0x030x102 - 0x03DL=0xFF
AL=0x04sub al, 70x104 - 0x07AL=0xFD

dec מתנהג אותו דבר. ב-ECX=0, הפקודה dec ecx משאירה 0xFFFFFFFF.

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

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

בקטע עם add cl, 1 שבתחילת הנושא, ה-1 שנמחק משמאל לא הופיע ב-CH. זה המקום שבו טועים הכי הרבה, ולכן נראה את אותו עיקרון שוב, במצב שבו הבית העליון לא ריק:

Assembly
mov dx, 0x3BFF
add dl, 1        ; DL: 0xFF + 1 wraps to 0x00, DH stays 0x3B
פלט
DX=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, הנשיאה עברה לבית העליון כי הוא היה חלק מהיעד. הגבול של הגלישה הוא תמיד הגבול של היעד.

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

מה קורה לדגלים

לדגלים יש פרק משלהם, אבל ארבע הרצות קצרות מספיקות כדי לראות מה קורה להם כשתת-אוגר גולש:

Assembly
mov dl, 0xFF
add dl, 1        ; 8-bit add: the carry has nowhere to go
פלט
DL=0x00 CF=1 ZF=1
Assembly
mov dx, 0x00FF
add dx, 1        ; 16-bit add: the carry fits in DH
פלט
DX=0x0100 CF=0 ZF=0
Assembly
mov al, 0x00
sub al, 1        ; borrow below zero
פלט
AL=0xFF CF=1 ZF=0
Assembly
mov dl, 0xFF
clc              ; start with CF=0
inc dl           ; DL wraps to 0x00
פלט
DL=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 יקבל:

Assembly
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 16
פלט
sizes.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 ביט.

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

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

העתקה בין חלקים של אוגרים

Assembly
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=0x4B5A7869
פלט
ECX=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

הזיכרון: שורה ארוכה של בתים

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

הגדירו בקטע הנתונים משתנה אחד של ארבעה בתים:

Assembly
section .data
cnt dd 0x0A0B0C0D    ; cnt names the address of four bytes

dd מקצה ארבעה בתים, dw מקצה שניים ו-db מקצה אחד, ו-cnt הוא שם לכתובת שבה הם מתחילים. הזיכרון כולו הוא שורה ארוכה של בתים, ולכל בית בה יש כתובת משלו; ארבעת הבתים של cnt יושבים זה ליד זה.

בקוד מבחינים בין הכתובת לבין התוכן. cnt לבדו הוא הכתובת, [cnt] בסוגריים מרובעים הוא מה שיושב בה, ו-[cnt+1] הוא התוכן של הבית הבא.

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

little-endian: הבית הקטן בכתובת הנמוכה

אם תציצו בזיכרון אחרי ההגדרה הזו, תראו את הבתים בסדר הבא:

כתובתcntcnt+1cnt+2cnt+3
הבית שבה0x0D0x0C0x0B0x0A

קראו את השורה משמאל לימין, 0D 0C 0B 0A, והיא נראית הפוכה מהמספר שהגדרנו. זה הסדר שנקרא little-endian, ומעבדי x86 עובדים בו: הבית הפחות משמעותי, 0D, נכנס לכתובת הנמוכה, והמשמעותי ביותר, 0A, לגבוהה.

ההיפוך הזה קיים רק בזיכרון. ברגע שהערך נטען לאוגר הוא שוב יחידה אחת של 32 ביט, ו-CL הוא תמיד 8 הביטים התחתונים שלה.

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

טעינה מהזיכרון לתוך תת-אוגר

כמה בתים ייקראו בכל טעינה? את זה קובע רוחב האוגר שמקבל אותם, והקריאה מתחילה בכתובת שבסוגריים. בהרצה הבאה EBX, ECX ו-EDX מתחילים ב-0xFFFFFFFF, כך שכל בית שלא נטען נשאר F:

Assembly
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+3EAX=0x0A0B0C0D: המעבד מסדר את הבתים בחזרה.
mov dx, [cnt]2, מ-cnt ו-cnt+1DX=0x0C0D, וב-EDX החצי העליון נשאר 0xFFFF.
mov cl, [cnt]1, מ-cntCL=0x0D, הבית הנמוך.
mov ch, [cnt+1]1, מ-cnt+1CH=0x0C.
mov bl, [cnt+3]1, מ-cnt+3BL=0x0A, הבית העליון של הערך, כי הוא בכתובת הגבוהה.

בשורות של DX, CL, CH ו-BL הטעינה מתנהגת כמו כל כתיבה לתת-אוגר: היא מחליפה רק את החלק שלה, וה-F של שאר האוגר נשארים.

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

Assembly
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=0xAABBCCDD

mov [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
Assembly
mov edx, 0x99AABBCC
mov dx, 0x0071
mov dh, 0x3A
sub dl, 0x20
פלט
EDX=0x99AA3A51
שורהפקודהEDX אחריהסבר
1mov edx, 0x99AABBCC0x99AABBCCהאוגר כולו מקבל ערך.
2mov dx, 0x00710x99AA0071היעד 16 ביט: DH הופך ל-0x00 ו-DL ל-0x71, ו-0x99AA לא זז.
3mov dh, 0x3A0x99AA3A71הבית העליון של DX מתחלף; 0x71 של DL נשאר.
4sub dl, 0x200x99AA3A510x71 פחות 0x20 הם 0x51, בלי גלישה, ו-DH לא מושפע.
תרחיש 2: כתיבה ל-CX ואחריה ל-CL
Assembly
mov ecx, 0x13572468
mov cx, 0x4455
mov cl, 0x00
פלט
ECX=0x13574400
שורהפקודהECX אחריהסבר
1mov ecx, 0x135724680x13572468בנקודת ההתחלה CH=0x24 ו-CL=0x68.
2mov cx, 0x44550x13574455שני הבתים התחתונים מתחלפים, 0x1357 נשאר.
3mov cl, 0x000x13574400מתאפס הבית הימני בלבד, ו-0x44 של CH שורד.
חזרה לתוכן העניינים

מעקבים עם גלישה

תרחיש 3: גלישה למעלה ב-DL אחרי ש-DH נכתב
Assembly
mov dx, 0x00FF
mov dh, 0x2C
add dl, 0x01
פלט
DX=0x2C00 CF=1 ZF=1
שורהפקודהDX אחריהסבר
1mov dx, 0x00FF0x00FFDH=0x00 ו-DL=0xFF.
2mov dh, 0x2C0x2CFFמתחלף רק הבית השמאלי.
3add dl, 0x010x2C00הסכום המלא 0x100, וב-DL נשאר 00. ה-1 לא מגיע ל-DH אלא ל-CF, ו-ZF נדלק כי DL התאפס.
תרחיש 4: גלישה למטה ב-BL ואחריה כתיבה ל-BH
Assembly
mov bl, 0x00
sub bl, 0x01
mov bh, 0x07
פלט
BX=0x07FF
שורהפקודהBH / BLהסבר
1mov bl, 0x00BL=0x00ב-BH יש עדיין מה שהיה שם קודם, ואנחנו לא יודעים מה.
2sub bl, 0x01BL=0xFFחיסור מאפס חוזר מהקצה העליון; BH לא מושפע, ו-CF=1.
3mov bh, 0x07BH=0x07, BL=0xFFגם הבית העליון ידוע עכשיו, ולכן BX=0x07FF.

לא צריך לדעת מה היה ב-EBX בהתחלה, כי שני הבתים של BX נכתבו. בהרצה ניסינו שני ערכי התחלה שונים ל-EBX, ובשניהם BX יצא 0x07FF.

תרחיש 5: חיבור ב-AL שעובר את 0xFF
Assembly
mov eax, 0x00005600
mov al, 0xE0
add al, 0x40
פלט
EAX=0x00005620
שורהפקודהEAX אחריהסבר
1mov eax, 0x000056000x00005600AH=0x56 ו-AL=0x00.
2mov al, 0xE00x000056E0רק הבית הימני.
3add al, 0x400x000056200xE0 ועוד 0x40 נותנים 0x120; AL שומר 20, AH נשאר 0x56, ו-CF=1.
תרחיש 6: חיבור ב-BH שלא נוגע בחצי העליון
Assembly
mov ebx, 0x3000EF12
mov bl, 0x00
add bh, 0x01
פלט
EBX=0x3000F000
שורהפקודהEBX אחריהסבר
1mov ebx, 0x3000EF120x3000EF12BH=0xEF ו-BL=0x12, ומעליהם 0x3000.
2mov bl, 0x000x3000EF00מתאפס הבית הימני בלבד.
3add bh, 0x010x3000F000בתוך BH, 0xEF ועוד 1 הם 0xF0 (נשיאה בין שתי הספרות של אותו בית); BL ו-0x3000 לא זזים.
חזרה לתוכן העניינים

חצי של 16 ביט, העתקות, זיכרון וחשבון

תרחיש 7: EDI: אוגר שיש לו רק חצי של 16 ביט
Assembly
mov edi, 0x00080040
mov di, 0x0002
add di, 0x0005
פלט
EDI=0x00080007
שורהפקודהEDI אחריהסבר
1mov edi, 0x000800400x00080040DI=0x0040.
2mov di, 0x00020x00080002החצי התחתון מתחלף; 0x0008 נשאר במקומו.
3add di, 0x00050x000800072 ועוד 5 הם 7, והכול קורה בתוך DI.
תרחיש 8: העתקות בין חלקים של אוגרים שונים
Assembly
mov eax, 0x13243546
mov edx, 0x9ABCDEF0
mov dl, ah
mov dh, al
mov ax, dx
פלט
EAX=0x13244635 EDX=0x9ABC4635
שורהפקודהEAXEDXהסבר
1mov eax, 0x132435460x13243546?EDX עוד לא קיבל ערך.
2mov edx, 0x9ABCDEF00x132435460x9ABCDEF0שימו לב לבתים של EAX: AH=0x35 ו-AL=0x46.
3mov dl, ah0x132435460x9ABCDE350x35 נכנס לבית הימני של EDX.
4mov dh, al0x132435460x9ABC46350x46 נכנס לבית שמשמאלו.
5mov ax, dx0x132446350x9ABC46350x4635 עובר ל-AX, ו-0x1324 בחלק העליון של EAX לא נפגע.
תרחיש 9: קריאה מהזיכרון בסדר little-endian
Assembly
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.

שורהפקודהאחרי השורההסבר
1mov eax, 0xFFFFFFFFEAX=0xFFFFFFFFכל הביטים דולקים, כדי שנראה מה מתחלף.
2mov al, [t]EAX=0xFFFFFF6Cנקרא בית אחד, 0x6C, מהכתובת הנמוכה.
3mov ah, [t+1]EAX=0xFFFF7D6Cהבית הבא בזיכרון, 0x7D, נכנס ל-AH.
4mov edx, 0xFFFFFFFFEDX=0xFFFFFFFFשוב כל הביטים דולקים.
5mov dx, [t]EDX=0xFFFF7D6Cשני בתים בבת אחת נותנים 0x7D6C, ו-0xFFFF שמעליהם נשאר.
6mov cl, [t+3]CL=0x9Fבכתובת האחרונה יושב הבית העליון של הערך. שאר ECX לא משתנה.
תרחיש 10: חשבון על אוגרים מלאים וחיבור בתוך CL
Assembly
mov ebx, 11
mov ecx, 7
add ebx, ecx
sub ebx, 5
mov ecx, 0x200
mov cl, 6
add cl, 2
inc ecx
dec ecx
פלט
EBX=0x0000000D ECX=0x00000208
שורהפקודהEBXECXהסבר
1mov ebx, 1111?קבוע עשרוני.
2mov ecx, 7117עוד קבוע עשרוני.
3add ebx, ecx18 (0x12)7EBX מקבל את הסכום, ו-ECX רק נקרא.
4sub ebx, 513 (0x0D)718 פחות 5.
5mov ecx, 0x200130x00000200בבתים: CH=0x02 ו-CL=0x00.
6mov cl, 6130x00000206רק הבית הימני; 6 עשרוני הוא 0x06.
7add cl, 2130x00000208החיבור נשאר בתוך CL.
8inc ecx130x00000209פלוס 1 על האוגר כולו.
9dec ecx130x00000208מינוס 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.

  1. כתבו את ערך ההתחלה בשמונה ספרות ופרקו לבתים: 51, A0, FF, E3.
  2. לכל שורה קבעו את רוחב היעד ואת הביטים שלו. DH הוא 8 ביט, ביטים 8 עד 15; DL הוא 8 ביט, ביטים 0 עד 7.
  3. החליפו רק את הביטים האלה והעתיקו את השאר. אחרי השורה הראשונה: 0x51A010E3.
  4. בחשבון על תת-אוגר, חשבו סכום מלא וחתכו לרוחב. 0xE3 ועוד 0x30 הם 0x113, ולכן DL=0x13, וה-1 לא עובר ל-DH.
  5. קראו בדיוק את האוגר שנשאל, במספר הספרות של הרוחב שלו: 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.