פרק 4: מדריך שפת ה-6502 Microprocessor Assembly

פרק 4: מדריך שפת ה-6502 Microprocessor Assembly

4.1 מבוא

המיקרו-מעבד 6502 שוחרר בשנת 1975. הוא שימש כמיקרו-מעבד עבור כמה מחשבים אישיים אז כמו Apple II, Commodore 64 ו-BBC Micro.

המיקרו-מעבד 6502 עדיין מיוצר בכמות גדולה כיום. היא כבר לא יחידת עיבוד מרכזית שמשמשת היום במחשבים אישיים (לפטופים), אבל היא עדיין מיוצרת בכמויות גדולות ומשמשת כיום במכשירים אלקטרוניים וחשמליים. על מנת להבין את ארכיטקטורות המחשב המודרניות יותר, כדאי מאוד לבחון מיקרו-מעבד ישן יותר אך מוצלח למדי כמו ה-6502.

מכיוון שהוא פשוט להבנה ולתכנות, זהו אחד המיקרו-מעבדים הטובים ביותר (אם לא הטובים ביותר) לשימוש להוראת שפת assembly. שפת הרכבה היא שפה ברמה נמוכה שניתן להשתמש בה כדי לתכנת מחשב. שימו לב ששפת ההרכבה של מיקרו-מעבד אחד שונה משפת ה-assembly של מיקרו-מעבד אחר. שפת ההרכבה של המיקרו-מעבד 6502 נלמדת בפרק זה. ליתר דיוק, זה ה-65C02 שנלמד, אבל הוא מכונה בפשטות, כ-6502.

מחשב מפורסם בעבר נקרא commodore_64. ה-6502 הוא מעבד מיקרו ממשפחת ה-6500. מחשב commodore_64 משתמש במיקרו-מעבד 6510. המיקרו-מעבד 6510 הוא של 6500 µP. ערכת ההוראות של ה-6502 µP היא כמעט כל ההוראות של ה-6510 µP. הידע של פרק זה ושל הפרק הבא מבוסס על מחשב commodore_64. ידע זה משמש כבסיס להסבר על ארכיטקטורות המחשב המודרניות ומערכות ההפעלה המודרניות בחלק זה של קורס הקריירה המקוון.

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

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

תרשים בלוקים של לוח האם Commodore 64
דיאגרמת הבלוק של לוח האם של קומודור 64 היא:

איור 4.1 תרשים בלוקים של יחידת המערכת Commodore_64

דמיינו את המיקרו-מעבד 6510 כמיקרו-מעבד 6502. הזיכרון הכולל הוא סדרה של בתים (8-ביטים לבייט). ישנו זיכרון בגישה אקראית (קריאה/כתיבה) שאליו ניתן לכתוב או למחוק את הבתים. כאשר המחשב כבוי, כל המידע בזיכרון הגישה אקראית (RAM) נמחק. יש גם את הזיכרון לקריאה בלבד (ROM). כאשר מתח המחשב כבוי, המידע ב-ROM נשאר (לא נמחק).

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

יש שלושה אפיקים (קבוצות של מוליכים חשמליים קטנים מאוד) בתרשים. כל חוט יכול להעביר סיביות 1 או סיביות 0. אפיק הנתונים, להעברת בתים של שמונה סיביות בכל פעם (פולס שעון אחד) ל-RAM וליציאת קלט/פלט (התקני קלט/פלט) הוא דו-כיווני. רוחב אפיק הנתונים הוא שמונה ביטים.

כל הרכיבים מחוברים לאפיק הכתובות. אפיק הכתובות הוא חד-כיווני מהמיקרו-מעבד. ישנם שישה עשר מוליכים לאפיק הכתובת, וכל אחד נושא ביט אחד (1 או 0). 16 ביטים נשלחים בפולס שעון אחד.

יש את אוטובוס הבקרה. חלק מהמוליכים של אפיק הבקרה יעבירו ביט אחד כל אחד מהמיקרו-מעבד לרכיבים האחרים. כמה קווי בקרה נושאים את הביטים מיציאת הקלט/פלט (IO) אל המיקרו-מעבד.

זיכרון מחשב
ה-RAM וה-ROM נחשבים כמכלול זיכרון אחד. מכלול זה מיוצג באופן דיאגרמטי באופן הבא כאשר למספרים הקסדצימליים יש את הקידומת '$':

איור 4.11 פריסת זיכרון עבור מחשב קומודור 64

זיכרון ה-RAM הוא מ-0000 ₁₆ ל-DFFF ₁₆ שנכתב מ-$0000 ל-$DFFF. בשפת ההרכבה של 6502 µP, מספר הקסדצימלי יתחיל ב-'$' ולא יתחיל (תחתי) עם 16 או H או hex. כל מידע ב-RAM נכבה כאשר המחשב כבוי. ה-ROM מתחיל מ-$E000 ל-$FFFF. יש לו תתי שגרות שלא נכבות כשהמחשב כבוי. תתי שגרות אלו הן השגרות הנפוצות המסייעות בתכנות. תוכנית המשתמש קוראת להם (עיין בפרק הבא).

הרווח (בתים) מ-$0200 ל-$D000 מיועד לתוכניות המשתמש. החלל מ-$D000 ל-$DFFF מיועד למידע שקשור ישירות לציוד ההיקפי (התקני קלט/פלט). זה חלק ממערכת ההפעלה. אז, מערכת ההפעלה של מחשב הקומודור-64 מחולקת לשני חלקים עיקריים: החלק ב-ROM שלעולם לא נכבה והחלק מ-$D000 ל-$DFFF שנכבה עם כיבוי החשמל. יש לטעון את נתוני ה-IO (קלט/פלט) מדיסק בכל פעם שהמחשב מופעל. כיום, נתונים כאלה נקראים דרייברים היקפיים. הציוד ההיקפי מתחיל מיציאת התקן קלט/פלט דרך החיבורים בלוח האם ועד ליציאות הניתנות לזיהוי על המשטחים האנכיים של המחשב שאליהם מחוברים הצג, המקלדת וכו' ואל הציוד ההיקפי עצמו (צג, מקלדת וכו' .).

הזיכרון מורכב מ-2 ¹⁶ = 65,536 מיקומי בתים. בצורה הקסדצימלית, אלה הם 10000 ₁₆ = 10000 _ח = 10000 _hex = $10,000 מיקומים. במחשוב, ספירה בבסיס שני, בסיס עשר, בסיס שש עשרה וכו' מתחילה מ-0 ולא מ-1. לכן, המיקום הראשון הוא למעשה מספר המיקום של 0000000000000000 ₂ = 0 ₁₀ = 0000 ₁₆ = $0000. בשפת ההרכבה 6502 µP, הזיהוי של מיקום הכתובת הוא קידומת $ ואין סיומת או מנוי. המיקום האחרון הוא מספר המיקום של 1111111111111111 ₂ = 65,535 ₁₀ = FFFF ₁₆ = $FFFF ולא 10000000000000000 ₂ , או 65,536 ₁₀ , או 10000 ₁₆ , או $10,000. ה-1000000000000000 ₂ , 65,536 ₁₀ , 10000 ₁₆ , או $10000 נותן את המספר הכולל של מיקומי בתים.

הנה, 2 ¹⁶ = 65,536 = 64 x 1024 = 64 x 2 ¹⁰ = 64 קילובייטים (Kilobytes). הסיומת 64 בשם Commodore-64 פירושה 64KB של זיכרון כולל (RAM ו-ROM). בית הוא 8 סיביות, ו-8 הסיביות ייכנסו למיקום בתים אחד בזיכרון.

64 קילובייט של זיכרון מחולקים לדפים. בכל עמוד יש 0100 ₁₆ = 256 ₁₀ מיקומי בתים. ה-256 הראשונים ₁₀ = 0100 הראשון ₁₆ מיקומים הוא עמוד 0. השני הוא עמוד 1, השלישי הוא עמוד 2, וכן הלאה.

על מנת לתת מענה ל-65,536 המיקומים, יש צורך ב-16 סיביות לכל מיקום (כתובת). אז, אוטובוס הכתובות מהמיקרו-מעבד לזיכרון מורכב מ-16 קווים; שורה אחת לביט אחד. ביט הוא 1 או 0.

אוגרי ה-6502 µP
אוגר הוא כמו תאי בתים עבור מיקום זיכרון בתים. ל-6502 µP יש שישה אוגרים: חמישה אוגרים של 8 סיביות ואוגר אחד של 16 סיביות. האוגר של 16 סיביות נקרא Program Counter אשר מכונה בקיצור PC. הוא מכיל את כתובת הזיכרון להוראה הבאה. תוכנית שפת assembly מורכבת מהוראות המוצבות בזיכרון. יש צורך בשש עשר (16) ביטים שונים כדי לטפל במיקום בייט מסוים בזיכרון. בדופק שעון מסוים, סיביות אלו נשלחות לקווי הכתובת של 16 סיביות של אפיק הכתובות לקריאת הוראה. כל האוגרים עבור 6502 µP מתוארים כדלקמן:

איור 4.12 6502 µP רישום

ניתן לראות את מונה התוכניות או המחשב כאוגר של 16 סיביות בתרשים. שמונה הסיביות המשמעותיות הנמוכות יותר מסומנות כ-PCL עבור Program Counter Low. שמונה ביטים המשמעותיים הגבוהים יותר מסומנים כ-PCH עבור Program Counter High. הוראה בזיכרון עבור Commodore-64 יכולה להיות מורכבת מאחד, שניים או שלושה בתים. 16 הסיביות במחשב מצביעות על ההוראה הבאה שתתבצע, בזיכרון. בין המעגלים במיקרו-מעבד, שניים מהם נקראים Arithmetic Logic Unit and Instruction Decoder. אם ההוראה הנוכחית שמעובדת ב-µP (מיקרו-מעבד) היא באורך בת אחד, שני המעגלים הללו מגדילים את המחשב האישי להוראה הבאה ביחידה אחת. אם ההוראה הנוכחית שמעובדת ב-µP היא באורך של שני בתים, כלומר היא תופסת שני בתים עוקבים בזיכרון, שני המעגלים הללו מגדילים את המחשב האישי להוראה הבאה ב-2 יחידות. אם ההוראה הנוכחית שמעובדת ב-µP היא באורך שלושה בתים, כלומר היא תופסת שלושה בתים עוקבים בזיכרון, שני המעגלים הללו מגדילים את המחשב האישי להוראה הבאה ב-3 יחידות.

המצבר 'A' הוא אוגר למטרות כלליות של שמונה סיביות המאחסן את התוצאה של רוב הפעולות האריתמטיות והלוגיות.

האוגרים 'X' ו-'Y' משמשים כל אחד לספירת שלבי התוכנית. הספירה בתכנות מתחילה מ-0. אז הם נקראים כאוגרי אינדקס. יש להם עוד כמה מטרות.

למרות ש-Stack Pointer אוגר, ל-'S' יש 9 סיביות הנחשבות כאוגר שמונה סיביות. התוכן שלו מצביע על מיקום בתים בעמוד 1 של זיכרון גישה אקראית (RAM). עמוד 1 מתחיל מבית $0100 (256 ₁₀ ) ל-$01FF (511 ₁₀ ). כאשר תוכנית פועלת, היא עוברת מהוראה אחת להוראה ברציפות הבאה בזיכרון. עם זאת, זה לא תמיד המצב. יש מקרים שבהם הוא קופץ מאזור זיכרון אחד לאזור זיכרון אחר כדי להמשיך להפעיל את ההוראות שם, ברציפות. עמוד 1 ב-RAM משמש כמחסנית. המחסנית היא אזור זיכרון RAM גדול שיש לו את הכתובות הבאות להמשך הקוד מהמקום בו יש קפיצה. הקודים עם הוראות קפיצה אינם בערימה; הם נמצאים במקום אחר בזיכרון. עם זאת, לאחר ביצוע הוראות הקפיצה אל, כתובות ההמשך (לא מקטעי קוד) נמצאות בערימה. הם נדחקו לשם כתוצאה מהוראות הקפיצה או הסניף.

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

אינדקס הסיביות הראשון והאחרון עבור כל אוגר מסומנים מעל כל אוגר בתרשים הקודם. ספירת מדד הסיביות (המיקום) באוגר מתחילה מ-0 מימין.

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

בכל עמוד יש 1,0000,0000 ₂ מספר בתים זהה ל-100 _ח מספר בתים זהה ל-256 ₁₀ מספר בתים. בתרשים הזיכרון הקודם, העמודים מצוינים עולים מעמוד 0 ולא יורדים כפי שמצוין בטבלה.

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

שאר פרק זה מסביר את שפת ההרכבה של 6502 µP תוך שימוש בכל המידע הקודם. על מנת להבין במהירות את השפה, על הקורא להוסיף ולחסור בבסיס שש עשרה במקום בבסיס עשר. זה בעצם אמור להיות בסיס שני, אבל חישוב בבסיס שני הוא מסורבל. זכור שכאשר מוסיפים שני מספרים בבסיס שני, נשיאה היא עדיין 1 כמו בבסיס עשר. אבל כשמורידים שני מספרים בבסיס שני, שאילה היא שתיים ולא עשר כמו בבסיס עשר. כשמוסיפים שני מספרים בבסיס שש עשרה, נשיאה היא עדיין 1 כמו בבסיס עשר. אבל כשמורידים שני מספרים בבסיס שש עשרה, הלוואה היא שש עשרה ולא עשר כמו בבסיס עשר.

4.2 הוראות להעברת נתונים

שקול את הטבלה הבאה של הוראות העברת הנתונים בשפת ההרכבה עבור ה-6502 µP:

כאשר בית (8 סיביות) מועתק ממיקום בתים בזיכרון ל-Accumulator Register, X Register או Y Register, זה נטען. כאשר בתים מועתקים מכל אחד מהאוגרים הללו למיקום בתים בזיכרון, כלומר העברה. כאשר בייט מועתק מאוגר אחד למשנהו, זה עדיין מועבר. בעמודה השנייה של הטבלה, החץ מציג את כיוון ההעתקה עבור בייט. שאר ארבע העמודות מציגות מצבי כתובת שונים.

ערך בעמודת מצב הכתובת הוא קוד הבתים בפועל עבור החלק המנמוני המקביל של ההוראה בהקסדצימלי. AE, למשל, הוא קוד הבתים בפועל עבור LDX שמטרתו לטעון בית מהזיכרון ל-X אוגר במצב כתובת מוחלטת כמו AE ₁₆ = 10101110 ₂ . אז, הביטים עבור LDX במיקום בתים של זיכרון הם 10101110.

שימו לב שעבור החלק ה-LDX מנמונית של ההוראה, ישנם שלושה בתים אפשריים שהם A2, AE ו-A6, וכל אחד מהם מיועד למצב כתובת מסוים. כאשר אין להעתיק את ה-byte שנטען ל-X register ממיקום בת-זיכרון, יש להקליד את הערך עם (ממש אחרי) ה-LDX Mnemonic בהוראה בהקסדצימלי או עשרוני. בפרק זה, ערכים כאלה מוקלדים בהקסדצימליים. זוהי פנייה מיידית, כך שהבייט בפועל בזיכרון לייצוג LDX הוא A2 ₁₆ = 10100010 ₂ ולא AE ₁₆ שהוא שווה ל-10101110 ₂ .

בטבלה, כל הבתים תחת כותרות מצב הכתובת נקראים Operation Codes אשר מקוצרים כ-opcodes. יכול להיות יותר מקוד אחד עבור מנמוניק אחד, בהתאם למצב הכתובת.

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

ישנם יותר מצבי כתובת מאשר ארבעת הטבלה עבור 6502 µP.

אלא אם צוין אחרת, כל קוד תכנות המשתמש בפרק זה מתחיל מכתובת 0200 ₁₆ שהיא תחילתו של אזור המשתמש בזיכרון.

זיכרון M ומצבר A

זיכרון לצובר

פנייה מיידית
ההוראה הבאה מאחסנת את המספר FF ₁₆ = 255 ₁₀ לתוך המצבר:

LDA #$FF

ה-'$' אינו משמש רק לזיהוי כתובת זיכרון. באופן כללי, הוא משמש כדי לציין שהמספר הבא שאחריו הוא הקסדצימלי. במקרה זה, $FF אינו הכתובת של מיקום בייט זיכרון כלשהו. זה המספר 255 ₁₀ בהקסדצימלי. אסור לכתוב את הבסיס 16 או כל אחד מהמנויים המקבילים האחרים שלו בהוראות שפת ה-assembly. ה-'#' מציין שכל מה שאחריו הוא הערך שיש להכניס למאגר המצבר. אפשר לכתוב את הערך גם בבסיס עשר, אבל זה לא נעשה בפרק זה. ה-'#' פירושו פנייה מיידית.

לזכרון יש דמיון מסוים לביטוי המקביל באנגלית. 'LDA #$FF' פירושו לטעון את המספר 255 ₁₀ לתוך המצבר A. מכיוון שמדובר בכתובת מיידית מהטבלה הקודמת, LDA הוא A9 ולא AD או A5. A9 בבינארי הוא 101010001. לכן, אם A9 עבור LDA נמצא בכתובת של $0200 בזיכרון, $FF הוא ב-$0301 = 0300 + כתובת אחת. ה-#$FF הוא בדיוק האופרנד לזיכרון ה-LDA.

פנייה מוחלטת
אם הערך של $FF נמצא במיקום $0333 בזיכרון, ההוראה הקודמת היא:

LDA $0333

שימו לב להיעדר #. במקרה זה, היעדר # פירושו שמה שאחריו הוא כתובת זיכרון ולא ערך הריבית (לא הערך שיש להכניס למצבר). אז, ה-opcode עבור LDA, הפעם, הוא AD ולא A9 או A5. האופרנד עבור LDA כאן הוא הכתובת $0333 ולא הערך $FF. $FF נמצא במיקום של $0333 שהוא די רחוק. ההוראה 'LDA $0333' תופסת שלושה מיקומים רצופים בזיכרון, ולא שניים, כפי שעשה האיור הקודם. 'AD' עבור LDA נמצא במיקום $0200. הבית התחתון של 0333 שהוא 33 נמצא במיקום $0301. הבית הגבוה יותר של $0333 שהוא 03 נמצא במיקום $0302. זהו מעט קצה המשמש את שפת ההרכבה 6502. שפות ההרכבה של מיקרו-מעבדים שונים שונות.

זו דוגמה להתייחסות מוחלטת. ה-$0333 הוא הכתובת של המיקום שיש בו $FF. ההוראה מורכבת משלושה בתים עוקבים ואינה כוללת את ה-$FF או את מיקום הבתים בפועל שלו.

כתובת אפס עמודים

נניח שהערך $FF נמצא במיקום הזיכרון $0050 בעמוד אפס. מיקומי הבייטים עבור עמוד האפס מתחילים מ-$0000 ומסתיימים ב-$00FF. אלה 256 ₁₀ מיקומים בסך הכל. כל עמוד בזיכרון Commodore-64 הוא 256 ₁₀ ארוך. שימו לב שהבייט הגבוה יותר הוא אפס עבור כל המיקומים האפשריים במרחב האפס עמודים בזיכרון. מצב הפנייה של אפס עמודים זהה למצב הכתובת המוחלטת, אך הבת הגבוהה יותר של 00 לא מוקלדת בהוראה. לכן, כדי לטעון את ה-$FF ממיקום $0050 לתוך המצבר, ההוראה של מצב כתובת אפס עמודים היא:

LDA $50

כאשר LDA הוא A5 ולא A9 או AD, A5 ₁₆ = 10100101 ₂ . זכור שכל בייט בזיכרון הוא של 8 תאים, וכל תא מכיל מעט. ההוראה כאן מורכבת משני בתים עוקבים. A5 עבור LDA נמצא במיקום הזיכרון של $0200 והכתובת של $50, ללא הבית הגבוה יותר של 00, נמצאת במיקום $0301. היעדר 00, שהיה צורך בייט בזיכרון הכולל של 64K, חוסך את שטח הזיכרון.

מצבר לזיכרון

פנייה מוחלטת
ההוראה הבאה מעתיקה ערך בתים, מה שזה לא יהיה, מהמצבר למיקום הזיכרון של $1444:

הם 1444 דולר

אומרים שזה עובר מהמצבר לזיכרון. זה לא נטען. הטעינה היא הפוכה. byte opcode עבור STA הוא 8D ₁₆ = 10001101 ₂ . הוראה זו מורכבת משלושה בתים עוקבים בזיכרון. ה-8D ₁₆ נמצא במיקום $0200. ה-44 ₁₆ מהכתובת של $1444 נמצאת במיקום $0201. וגם 14 ₁₆ נמצא במיקום 0202$ - מעט קצה. ה-byte בפועל המועתק אינו חלק מההוראה. 8D ולא 85 עבור כתובת אפס עמודים (בטבלה) משמשים כאן עבור STA.

אפס כתובת עמוד
ההוראה הבאה מעתיקה ערך בתים, מה שהוא, מהמצבר למיקום הזיכרון של $0050 בעמוד אפס:

STA $0050

byte opcode עבור STA כאן הוא 85 ₁₆ = 10000101 ₂ . הוראה זו מורכבת משני בתים עוקבים בזיכרון. ה-85 ₁₆ נמצא במיקום $0200. ה-50 ₁₆ של הכתובת $0050 נמצאת במיקום $0201. סוגיית הקצה אינה עולה כאן כי לכתובת יש רק בייט אחד שהוא הבית התחתון. ה-byte בפועל המועתק אינו חלק מההוראה. 85 ולא 8D עבור כתובת אפס עמודים משמשים כאן עבור STA.

לא הגיוני להשתמש בכתובת המיידית כדי להעביר בייט מהמצבר למיקום בזיכרון. הסיבה לכך היא שהערך האמיתי כמו $FF צריך להיות מצוטט בהוראה בטיפול מיידי. לכן, כתובת מיידית אינה אפשרית עבור העברה של ערך בתים מאוגר ב-µP לכל מיקום זיכרון.

LDX, STX, LDY ו-STY Mnemonics
LDX ו-STX דומים ל-LDA ו-STA, בהתאמה. אבל כאן, נעשה שימוש באוגר X ולא ברישום A (צבר). LDY ו-STY דומים ל-LDA ו-STA, בהתאמה. אבל כאן, נעשה שימוש ברישום Y ולא ברישום A. עיין בטבלה 4.21 עבור כל opcode בהקסדצימלי התואם למצב זיכרון מסוים ולמצב כתובת מסוים.

העברות הרשמה לרישום
שתי קבוצות ההוראות הקודמות בטבלה 4.21 עוסקות בהעתקת זיכרון/מיקרו-מעבד-אוגר (העברה) והעתקת רישום/רשום (העברה). ההוראות TAX, TXA, TAY, TYA, TSX ו-TXS מבצעות את ההעתקה (העברה) מהאוגר במיקרו-מעבד לאוגר אחר של אותו מיקרו-מעבד.

כדי להעתיק את הביט מ-A ל-X, ההוראה היא:

מַס

כדי להעתיק את הביט מ-X ל-A, ההוראה היא:

TX

כדי להעתיק את הביט מ-A ל-Y, ההוראה היא:

יד

כדי להעתיק את הביט מ-Y ל-A, ההוראה היא:

TYA

עבור מחשב קומודור 64, הערימה היא עמוד 1 מיד אחרי עמוד 0 בזיכרון. כמו כל עמוד אחר, הוא מורכב מ-25610 ₁₀ מיקומי בתים, מ-$0100 ל-$01FF. בדרך כלל, תוכנית מבצעת מהוראה אחת להוראה ברציפות הבאה בזיכרון. מעת לעת, יש קפיצה לקטע קוד זיכרון אחר (מערכת הוראות). לאזור המחסנית שבזיכרון (RAM) יש את כתובות ההוראות הבאות מהמקום שבו הקפיצות (או ההסתעפויות) הפסיקו להמשך התוכנית.

מצביע המחסנית 'S' הוא אוגר של 9 סיביות ב-6502 µP. הסיביות הראשונה (הכי שמאלנית) היא תמיד 1. כל כתובות מיקום הבתים בעמוד הראשון מתחילות ב-1 ואחריו 8 ביטים שונים עבור ה-256 ₁₀ מיקומים. למצביע המחסנית יש את הכתובת של המיקום בעמוד 1 שיש לו את הכתובת של ההוראה הבאה שהתוכנית צריכה לחזור ולהמשיך איתה לאחר ביצוע קטע הקוד הנוכחי (שקפץ אליו). מכיוון שהסיבית הראשונה של כל הכתובות של המחסנית (עמוד ראשון) מתחילה ב-1, אוגר מצביע המחסנית צריך להכיל רק את שמונת הביטים הנותרים. אחרי הכל, הסיביות הראשונה שלו, שהיא הסיביות השמאלית ביותר (הסיביות התשיעית סופרת מימין שלה), היא תמיד 1.

כדי להעתיק את הביט מ-S ל-X, ההוראה היא:

TSX

כדי להעתיק את הביט מ-X ל-S, ההוראה היא:

טקסט

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

הערה: אין העברה של X ל-Y או Y ל-X (העתקה).

4.3 פעולות אריתמטיות

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

הערה: כל האמנויות עבור פעולות אריתמטיות וסוגים אחרים של פעולות (כלומר, כל 6502 המנמוניות) לוקחות בייט אחד של קוד פעולה (op). אם יש יותר ממצב פנייה אחד עבור המנמונית, יהיו קודים שונים עבור אותו מנמוניק: אחד לכל מצב פנייה. ה-C, D ו-V בטבלה הם הדגלים של מאגר המצבים. משמעויותיהם יינתנו בהמשך ככל שיתעורר הצורך.

הוספת מספרים לא חתומים
עם 6502 µP, המספרים החתומים הם המספרים המשלימים של שניים. המספרים ללא סימן הם מספרים חיוביים רגילים שמתחילים מאפס. אז, עבור בייט של שמונה סיביות, המספר הקטן ביותר ללא סימן הוא 00000000 ₂ = 0 ₁₀ = 00 ₁₆ והמספר הגדול ביותר ללא חתימה הוא 11111111 ₂ = 255 ₁₀ = FF ₁₆ . עבור שני מספרים ללא סימנים, התוספת היא:

A+M+C→A

כלומר, התוכן של 8 סיביות של המצבר מתווסף על ידי היחידה הלוגית האריתמטית לבייט (8 סיביות) מהזיכרון. לאחר הוספה של A ו-M, ה-carry לסיבית התשיעית עוברת לתא דגל ה-carrier במאגר המצב. כל סיביות העברה קודמת מתוספת קודמת שעדיין נמצאת בתא דגל ה-carrier בפנקס הסטטוסים מתווספת גם היא לסכום של A ו-M, מה שהופך את A+M+C→A. התוצאה מוחזרת לתוך המצבר.

אם תוספת הריבית היא:

A + M

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

A+M+0→A זהה ל-A+M→A

הערה: אם M מתווסף ל-A, ומתרחשת נשיאה של 1 כי התוצאה גדולה מ-255 ₁₀ = 11111111 ₂ = FF ₁₆ , זהו נשיאה חדשה. העברה החדשה הזו של 1 נשלחת אוטומטית לתא הדגל של הנשיאה למקרה שהזוג הבא של שמונה סיביות יסוכם (עוד A + M).

קוד להוספת שני שמונה ביטים לא חתומים
00111111 ₂ +00010101 ₂ זהה ל-3F ₁₆ + 15 ₁₆ שזה זהה ל-63 ₁₀ +21 ₁₀ . התוצאה היא 010101002 ₂ שזה זהה ל-54 ₁₆ ו-84 ₁₀ . התוצאה אינה מעבר למספר המרבי עבור שמונה סיביות שהוא 255 ₁₀ = 11111111 ₂ = FF ₁₆ . אז, אין נשיאה מתקבלת של 1. במילים אחרות, הסחיבה המתקבלת היא 0. לפני ההוספה, אין נשיאה קודמת של 1. במילים אחרות, העברה הקודמת היא 0. הקוד לבצע את ההוספה הזו. יכול להיות:

CLC
LDA#$3F
ADC #15$

הערה: בזמן הקלדת שפת ההרכבה, מקש 'Enter' של המקלדת נלחץ בסוף כל הוראה. יש שלוש הוראות בקוד זה. ההוראה הראשונה (CLC) מנקה את דגל ה-carrier במקרה שלתוספת קודמת יש 1. CLC יכול להיעשות רק במצב כתובת מרומז. הזיכרון עבור מצב פנייה מרומז אינו לוקח אופרנד. זה מנקה את תא ה-carrier של אוגר המצב של P. ניקוי פירושו מתן ה-bit של 0 לתא דגל ה-carrier. שתי ההוראות הבאות בקוד משתמשות במצב הפנייה המיידי. עם הפנייה מיידית, יש רק אופרנד אחד למנמוניק שהוא מספר (ולא כתובת זיכרון או רישום). ולכן, יש להקדים את המספר ב-'#'. ה-'$' אומר שהמספר שאחריו הוא הקסדצימלי.

ההוראה השנייה טוענת את המספר 3F ₁₆ לתוך המצבר. עבור ההוראה השלישית, מעגל היחידה הלוגית האריתמטית של µP לוקח את השיא הקודמת (המנוקה) של 0 (מאולץ ל-0) של תא דגל הנשיאה, של אוגר המצב ומוסיף אותו ל-15 ₁₆ כמו גם לערך שכבר נמצא ב-3F ₁₆ מצבר ומחזיר את התוצאה השלמה לתוך המצבר. במקרה זה, נוצרת נשיאה של 0. ה-ALU (יחידת לוגיקה אריתמטית) שולחת (מכניסה) 0 לתא דגל ה-carrier של אוגר המצב. מרשם סטטוס המעבד ומרשם המצב אומרים אותו דבר. אם התקבלה נשיאה של 1, ה-ALU שולח 1 לדגל הנשיאה של פנקס המצב.

שלוש השורות של הקוד הקודם צריכות להיות בזיכרון לפני שהן מבוצעות. ה-opcode 1816 עבור CLC (כתובת מרומזת) נמצא במיקום בתים של $0200. ה-opcode A9 ₁₆ עבור LDA (כתובת מיידית) נמצא במיקום בתים של $0201. המספר 3F ₁₀ נמצא במיקום של $0202 בייט. האופקוד 69 ₁₆ עבור LDA (כתובת מיידית) נמצא במיקום בתים של $0203. המספר 15 ₁₀ נמצא במיקום של $0204 בתים.

הערה: LDA היא הוראת העברה (עומס) ולא הוראת חשבון (מנמונית).

קוד להוספת שני 16-ביטים לא חתומים
כל הרגיסטרים ב-6502 µP הם בעצם רגיסטרים של שמונה סיביות, מלבד ה-PC (Program Counter) שהוא 16 סיביות. אפילו מאגר המצבים הוא ברוחב של 8 סיביות, אם כי שמונה הסיביות שלו לא פועלות יחד. בסעיף זה, הוספה של שני 16 ביטים ללא סימנים, עם העברה מהזוג הראשון של שמונה ביטים לזוג השני של שמונה ביטים, נחשבת. ה-carry of interest כאן הוא ה-carry ממיקום הביט השמיני למיקום הביט התשיעי.

תן למספרים להיות 0010101010111111 ₂ = 2ABF16 ₁₆ = 10,943 ₁₀ ו-0010101010010101 ₂ = 2A95 ₁₆ = 10,901 ₁₀ . הסכום הוא 0101010101010100 ₂ = 5554 ₁₆ = 21,844 ₁₀ .

הוספת שני המספרים הלא-סימנים האלה בבסיס שני היא כדלקמן:

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

בקידוד זה, שני הבייטים התחתונים מתווספים תחילה. לאחר מכן, ה-ALU (יחידת לוגיקה אריתמטית) שולחת את ה-carry של 1 ממיקום הביט השמיני למיקום הסיביות התשיעית, אל תא דגל ה-carrier במאגר המצב. התוצאה של 0 1 0 1 0 1 0 0 ללא ההובלה עוברת למצבר. לאחר מכן, זוג הבתים השני מתווסף עם ה-carry. הזיכרון של ADC פירושו הוספה עם ה-carry הקודם באופן אוטומטי. במקרה זה, אין לשנות את ההובלה הקודמת, שהיא 1, לפני התוספת השנייה. עבור התוספת הראשונה, מכיוון שכל נשיאה קודמת אינה חלק מהתוספת השלמה הזו, יש לנקות אותה (לעשות 0).

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

A + M + 0 -> A

התוספת השנייה היא:

A + M + 1 -> A

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

CLC
LDA $0213
ADC $0215
; אין סליקה כי יש צורך בערך דגל הנשיאה
STA $0217
LDA $0214
ADC $0216
STA $0218

שים לב שעם שפת ההרכבה 6502, נקודה-פסיק מתחיל בהערה. המשמעות היא שבביצוע התוכנית מתעלמים מהנקודה-פסיק וכל מה שמימין לה. התוכנית שנכתבה בעבר נמצאת בקובץ טקסט שנשמר עם השם של בחירת המתכנת ועם הסיומת '.asm'. התוכנית הקודמת היא לא התוכנית המדויקת שעוברת לזיכרון לביצוע. התוכנית המתאימה בזיכרון נקראת התוכנית המתורגמת שבה מחליפים את הזיכרון בקודים (בתים). כל הערה נשארת בקובץ הטקסט של שפת ה-Assembly, והיא נמחקת לפני שהתוכנה המתורגמת מגיעה לזיכרון. למעשה, ישנם שני קבצים שנשמרים היום בדיסק: קובץ '.asm' וקובץ '.exe'. הקובץ '.asm' הוא הקובץ באיור הקודם. קובץ '.exe' הוא קובץ '.asm' כאשר כל ההערות מנותקות, וכל ה-Mnemonics מוחלפים בקודים שלהם. כאשר פותחים אותו בעורך טקסט, לא ניתן לזהות את קובץ '.exe'. אלא אם צוין אחרת, לצורך פרק זה, קובץ '.exe' מועתק לזיכרון החל ממיקום $0200. זו המשמעות האחרת של טעינה.

שני המספרים של 16 סיביות שיש להוסיף תופסים ארבעה בתים בזיכרון עבור כתובת מוחלטת: שני בתים למספר (זיכרון הוא רצף של בתים). עם כתובת מוחלטת, האופרנד ל-opcode נמצא בזיכרון. תוצאת הסיכום היא ברוחב של שני בתים ויש למקם אותה גם בזיכרון. זה נותן סך של 6 ₁₀ = 6 ₁₆ בתים עבור קלט ופלט. הכניסות אינן מהמקלדת והפלט אינו מהצג או המדפסת. הכניסות נמצאות בזיכרון (RAM) והפלט (תוצאת סיכום) חוזרת לזיכרון (RAM) במצב זה.

לפני הפעלת תוכנית, הגרסה המתורגמת צריכה להיות בזיכרון תחילה. בהסתכלות על קוד התוכנית הקודם, ניתן לראות שההוראות ללא ההערה מהוות 19 ₁₀ = 13 ₁₆ בתים. אז, התוכנית לוקחת ממיקום בתים של $0200 בזיכרון ל-$0200 + $13 - $1 = $0212 מיקומי בתים (החל מ-$0200 ולא $0201 מה שמרמז על - $1). הוספת 6 הבתים עבור מספרי הקלט והפלט גורמת לכל התוכנית להסתיים ב-$0212 + $6 = $0218. אורכה הכולל של התוכנית הוא 19 ₁₆ = 25 ₁₀ .

הבית התחתון של האוגנד צריך להיות בכתובת $0213, והבית הגבוה יותר של אותו אוגד צריך להיות בכתובת $0214 - little endianness. באופן דומה, הבית התחתון של התוספת צריך להיות בכתובת $0215, והבית הגבוה יותר של אותו תוספת צריך להיות בכתובת $0216 - little endianness. הבית התחתון של התוצאה (סכום) צריך להיות בכתובת $0217, והבית הגבוה יותר של אותה תוצאה צריך להיות בכתובת $0218 - little endianness.

האופקוד 18 ₁₆ עבור CLC (כתובת מרומזת) נמצא במיקום בתים של $0200. ה-opcode עבור 'LDA $0213', כלומר AD ₁₆ עבור LDA (כתובת אבסולוטית), נמצא במיקום בתים של $0201. הבית התחתון של ה-augend שהוא 10111111 נמצא במיקום בייט הזיכרון של $0213. זכור שכל opcode תופס בית אחד. הכתובת '$0213' של 'LDA $0213' נמצאת במיקומי בתים של $0202 ו-$0203. ההוראה 'LDA $0213' טוענת את הביט התחתון של ה-augend אל המצבר.

ה-opcode עבור 'ADC $0215', כלומר 6D ₁₆ עבור ADC (כתובת אבסולוטית), נמצא במיקום בתים של $0204. הבית התחתון של התוספת שהוא 10010101 נמצא במיקום הבתים של $0215. הכתובת '$0215' של 'ADC $0215' נמצאת במיקומי בתים של $0205 ו-$0206. ההוראה 'ADC $0215' מוסיפה את הביט התחתון של התוספת לבייט התחתון של ה-augend שכבר נמצא במצבר. התוצאה מונחת בחזרה במצבר. כל העברה אחרי הביט השמיני נשלחת לדגל העברה של אוגר המצב. אין לנקות את תא דגל ה-carrier לפני התוספת השנייה של הבתים הגבוהים יותר. נשיאה זו מתווספת לסכום הבתים הגבוהים יותר באופן אוטומטי. למעשה, העברה של 0 מתווספת לסכום הבתים הנמוכים באופן אוטומטי בהתחלה (שווה ערך לכך שלא התווסף נשיאה) בגלל CLC.

ההערה לוקחת את ה-48 הבאים ₁₀ = 30 ₁₆ בתים. עם זאת, זה נשאר רק בקובץ הטקסט '.asm'. זה לא מגיע לזיכרון. הוא מוסר על ידי התרגום שנעשה על ידי האסמבלר (תוכנית).

להוראה הבאה שהיא 'STA $0217', ה-opcode של STA שהוא 8D ₁₆ (כתובת מוחלטת) נמצא במיקום בייט של $0207. הכתובת '$0217' של 'STA $0217' נמצאת במיקומי הזיכרון של $0208 ו-$0209. ההוראה 'STA $0217' מעתיקה את תוכן שמונה הסיביות של המצבר למיקום הזיכרון של $0217.

הבית הגבוה של ה-augend שהוא 00101010 נמצא במיקום הזיכרון של $0214, והבית הגבוה יותר של התוספת שהוא 00101010 נמצא במיקום בתים של $02 ₁₆ . ה-opcode של 'LDA $0214' שהוא AD16 עבור LDA (כתובת אבסולוטית) נמצא במיקום בתים של $020A. הכתובת '$0214' של 'LDA $0214' נמצאת במיקומים של $020B ו-$020C. ההוראה 'LDA $0214' טוענת את הבתים הגבוהים יותר של ה-Augend אל המצבר, ומוחקת את כל מה שנמצא במצבר.

ה-opcode עבור 'ADC $0216' שהוא 6D ₁₆ עבור ADC (כתובת אבסולוטית) נמצא במיקום בתים של $020D. הכתובת '$0216' של 'ADC 0216' נמצאת במיקומי בתים של $020E ו-$020F. ההוראה 'ADC $0216' מוסיפה את הביט הגבוה יותר של ההוספה לבייט הגבוה יותר של האוגנד שכבר נמצא בצובר. התוצאה מוחזרת לתוך המצבר. אם יש נשיאה של 1, עבור התוספת השנייה הזו, היא ממוקמת אוטומטית בתא הנשיאה של אוגר המצב. למרות שה-carry מעבר לסיביות השישה-עשר (משמאל) אינו נדרש לבעיה זו, נחמד לבדוק אם נשיאה של 1 אכן התרחשה על ידי בדיקה אם דגל הנשיאה הפך ל-1.

עבור ההוראה הבאה והאחרונה שהיא 'STA $0218', ה-opcode של STA שהוא 8D16 (כתובת מוחלטת) נמצא במיקום בתים של $0210. הכתובת '$0218' של 'STA $0218' נמצאת במיקומי הזיכרון של $0211 ו-$0212. ההוראה 'STA $0218' מעתיקה את תוכן שמונה הסיביות של המצבר למיקום הזיכרון של $0218. התוצאה של התוספת של שני המספרים של שש עשרה סיביות היא 0101010101010100, כשהבייט התחתון של 01010100 במיקום הזיכרון הוא $0217 והבייט הגבוה יותר של 01010101 במיקום הזיכרון של $0218 - מעט אנדיאניות.

חִסוּר
עם 6502 µP, המספרים החתומים הם המספרים המשלימים של שניים. מספר המשלים של שתיים יכול להיות שמונה סיביות, שש עשרה סיביות או כל כפולה של שמונה סיביות. עם השלמה של שתיים, הסיביות הראשונה משמאל היא סיביות הסימן. עבור מספר חיובי, הסיביות הראשונה הזו היא 0 כדי לציין את הסימן. שאר הביטים יוצרים את המספר בדרך הרגילה. כדי לקבל את ההשלמה של השניים למספר שלילי, הפוך את כל הביטים עבור המספר החיובי המתאים, ולאחר מכן הוסף 1 לתוצאה מהקצה הימני.

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

כאשר השאיבה מונחת כ-1. התוצאה בצובר היא ההפרש בהשלמה של שניים. לכן, כדי להחסיר שני מספרים, יש להגדיר את דגל הנשיאה (להפוך ל-1).

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

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

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

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

תוצאת ההשלמה של השניים זהה לתוצאה המתקבלת מהחיסור הרגיל. עם זאת, שימו לב שמתעלמים מה-1 שעובר לעמדת הביט השבע-עשרה מימין. המינואנד והמשנה מחולקים לשני שמונה ביטים כל אחד. ההשלמה של השניים של 10010110 של ה-subtrahend התחתון של ה-subtrahend נקבעת ללא תלות ב-byte הגבוה יותר שלו ובכל העברת נתונים. ההשלמה של השניים של 11101011 של ה-subtrahend הגבוה יותר של ה-subtrahend נקבעת ללא תלות ב-byte התחתון שלו ובכל העברת נתונים.

16 הסיביות של המינואנד כבר נמצאים בהשלמה של שניים, מתחילים ב-0 משמאל. אז, זה לא צריך שום התאמה בסיביות. עם ה-6502 µP, הבת התחתון של ה-minuend ללא כל שינוי נוסף לבייט התחתון של המשלים של השניים של subtrahend. הביט התחתון של המינואנד אינו מומר בהשלמה של שתיים מכיוון ששש עשר הסיביות של כל המינואנד צריכות להיות כבר בהשלמה של שניים (עם 0 בתור הביט הראשון משמאל). בתוספת הראשונה הזו, מתווספת נשיאה חובה של 1 עקב הוראת 1=0 SEC.

בחיסור האפקטיבי הנוכחי, יש העברה של 1 (של חיבור) מהסיבית השמינית לסיבית התשיעית (מימין). מכיוון שלמעשה מדובר בחיסור, כל ביט שאמור להיות בדגל ה-carrier בפנקס הסטטוסים משלים (הפוך). אז, הנשיאה של 1 הופכת ל-0 בדגל C. בפעולה השנייה, הבת הגבוה יותר של ה-minuend מתווסף לבייט המשלים של השניים הגבוהים יותר של subtrahend. סיבית הדגל המשלימה אוטומטית של אוגר המצב (במקרה זה הוא 0) מתווספת גם היא (לבייטים הגבוהים יותר). מתעלמים מכל 1 שחורג מהסיביות השש עשרה מימין.

הדבר הבא הוא רק לקודד את כל הסכימה כדלקמן:

SEC
LDA $0213
SBC $0215
; אין סליקה כי יש צורך בערך הדגל ההפוך
STA $0217
LDA $0214
SBC $0216
STA $0218

זכור שעם שפת ה-assembly 6502, נקודה-פסיק מתחילה הערה שאינה כלולה בגרסת התוכנית המתורגמת בזיכרון. שני המספרים של 16 סיביות לחיסור תופסים ארבעה בתים של זיכרון עם כתובת מוחלטת; שניים למספר (זיכרון הוא סדרה של בתים). כניסות אלו אינן מהמקלדת. תוצאת הסיכום היא שני בתים וגם יש למקם בזיכרון במקום אחר. פלט זה אינו עובר לצג או למדפסת; זה עובר לזיכרון. זה נותן סך של 6 ₁₀ = 6 ₁₆ בתים עבור כניסות ופלט שיוצבו בזיכרון (RAM).

לפני שתוכנית מבוצעת, היא צריכה להיות בזיכרון תחילה. בהסתכלות על קוד התוכנית, ניתן לראות שההוראות ללא ההערה מהוות 19 ₁₀ = 13 ₁₆ בתים. מכיוון שכל התוכניות בפרק זה מתחילות ממיקום הזיכרון של $0200, התוכנית לוקחת ממיקום הבתים של $0200 בזיכרון למיקום $0200 + $13 – $1 = $0212 בתים (החל מ-$0200 ולא $0201). טווח זה אינו כולל את האזור עבור בתי הקלט והפלט. שני מספרי הקלט לוקחים 4 בתים ומספר הפלט האחד לוקח 2 בתים. הוספת 6 הבתים עבור מספרי הקלט והפלט הופכת את הטווח עבור התוכנית שמסתיים ב-$0212 + $6 = 0218$. אורכה הכולל של התוכנית הוא 19 ₁₆ = 25 ₁₀ .

הבית התחתון של ה-minuend צריך להיות בכתובת $0213, וה-byte הגבוה יותר של אותו minuend צריך להיות בכתובת $0214 - little endianness. באופן דומה, הבית התחתון של ה-subtrahend צריך להיות בכתובת $0215, וה-byte הגבוה יותר של אותו subtrahend צריך להיות בכתובת $0216 - little endianness. הבית התחתון של התוצאה (ההבדל) צריך להיות בכתובת $0217, והבית הגבוה יותר של אותה תוצאה צריך להיות בכתובת $0218 - little endianness.

האופקוד של 38 ₁₆ עבור SEC (כתובת מרומזת) נמצא בכתובת $0200. ההנחה היא שכל התוכניות בפרק זה יתחילו במיקום הזיכרון של 0200$, תוך ביטול כל תוכנית שהיתה שם; אלא שצוין אחרת. ה-opcode עבור 'LDA $0213', כלומר AD ₁₆ , עבור LDA (כתובת אבסולוטית) נמצא במיקום $0201 בייט. הבית התחתון של ה-minuend שהוא 10111111 נמצא במיקום בייט הזיכרון של $0213. זכור שכל opcode תופס בית אחד. הכתובת '$0213' של 'LDA $0213' נמצאת במיקומי בתים של $0202 ו-$0203. ההוראה 'LDA $0213' טוענת את ה-byte התחתון של ה-minuend אל המצבר.

ה-opcode עבור 'SBC $0215', כלומר ED ₁₆ , עבור SBC (כתובת אבסולוטית) נמצא במיקום $0204 בתים. הבית התחתון של ה-subtrahend שהוא 01101010 נמצא במיקום בתים של $0215. הכתובת '$0215' של 'ADC $0215' נמצאת במיקומי בתים של $0205 ו-$0206. ההוראה 'SBC $0215' מפחיתה את הביט התחתון של ה-subtrahend מהבייט התחתון של ה-minuend שכבר נמצא במצבר. זהו חיסור משלים של שניים. התוצאה מונחת בחזרה במצבר. ההשלמה (היפוך) של כל carry לאחר הביט השמיני נשלח לדגל ה-carrier של אוגר המצב. אסור לנקות את דגל השיא הזה לפני החיסור השני עם הבתים הגבוהים יותר. נשיאה זו מתווספת לחיסור הבתים הגבוהים באופן אוטומטי.

ההערה לוקחת את 57 הבאים ₁₀ = 3916 ₁₆ בתים. עם זאת, זה נשאר רק בקובץ הטקסט '.asm'. זה לא מגיע לזיכרון. הוא מוסר על ידי התרגום שנעשה על ידי האסמבלר (תוכנית).

להוראה הבאה שהיא 'STA $0217', ה-opcode של STA, כלומר 8D ₁₆ (כתובת מוחלטת), נמצא במיקום של $0207 בתים. הכתובת '$0217' של 'STA $0217' נמצאת במיקומי הזיכרון של $0208 ו-$0209. ההוראה 'STA $0217' מעתיקה את תוכן שמונה הסיביות של המצבר למיקום הזיכרון של $0217.

הבית הגבוה יותר של ה-minuend שהוא 00101010 נמצא במיקום הזיכרון של $0214, והבית הגבוה יותר של ה-subtrahend שהוא 00010101 נמצא במיקום בייט של $0216. ה-opcode עבור 'LDA $0214', כלומר AD ₁₆ עבור LDA (כתובת אבסולוטית), נמצא במיקום בתים של $020A. הכתובת '$0214' של 'LDA $0214' נמצאת במיקומים של $020B ו-$020C. ההוראה 'LDA $0214' טוענת את ה-byte הגבוה יותר של ה-minuend אל המצבר, ומוחקת את כל מה שנמצא במצבר.

ה-opcode עבור 'SBC $0216', כלומר ED ₁₆ עבור SBC (כתובת אבסולוטית), נמצא במיקום בתים של $020D. הכתובת '$0216' של 'SBC $0216' נמצאת במיקומי בתים של $020E ו-$020F. ההוראה 'SBC $0216' מפחיתה את הבת הגבוהה יותר של ה-subtrahend מהבייט הגבוה יותר של ה-minuend (השלמה של שניים) שכבר נמצא במצבר. התוצאה מוחזרת לתוך המצבר. אם ישנה נשיאה של 1 עבור חיסור שני זה, ההשלמה שלו ימוקם בתא הנשיאה של אוגר המצב באופן אוטומטי. למרות שהסחיבה מעבר לסיבית השישה עשרה (משמאל) אינה נדרשת לבעיה זו, נחמד לבדוק אם השאיבה המשלימה מתרחשת על ידי בדיקת דגל הנשיאה.

עבור ההוראה הבאה והאחרונה שהיא 'STA $0218', ה-opcode של STA, כלומר 8D ₁₆ (כתובת מוחלטת), נמצא במיקום $0210 בתים. הכתובת '$0218' של 'STA $0218' נמצאת במיקומי הזיכרון של $0211 ו-$0212. ההוראה 'STA $0218' מעתיקה את תוכן שמונה הסיביות של המצבר למיקום הזיכרון של $0218. התוצאה של החיסור עם שני המספרים של שש עשרה סיביות היא 0001010101010101 עם הבת התחתון של 01010101 במיקום הזיכרון של $0217 והבייט הגבוה יותר של 00010101 במיקום הזיכרון של $0218 - מעט אנדיאניות.

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

4.4 פעולות לוגיות

ב-6502 µP, ה-Mnemonic עבור OR הוא ORA וה-Mnemonic עבור OR בלעדי הוא EOR. שימו לב שלפעולות הלוגיות אין את הכתובת המשתמעת. הפנייה המשתמעת אינה דורשת אופרנד. כל אחד מהאופרטורים הלוגיים חייב לקחת שני אופרנדים. הראשון נמצא בצובר, והשני נמצא בזיכרון או בהוראה. התוצאה (8 סיביות) חזרה אל המצבר. הראשון בצובר מוכנס לשם בהוראה מיידית או מועתק מהזיכרון עם כתובת מוחלטת. בחלק זה, רק כתובת אפס עמודים משמשת להמחשה. האופרטורים הלוגיים הללו הם כולם אופרטורים של Bitwise.

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

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

LDA #$9A ; לא מהזיכרון - התייחסות מיידית
AND #$CD ; לא מהזיכרון - התייחסות מיידית
STA $30; מאחסנת 88 $ ב-0030 $ מבוסס אפס

אוֹ
הטבלה הבאה ממחישה את OR Bitwise בבינארי, הקסדצימלי ועשרוני:

LDA #$9A ; לא מהזיכרון - התייחסות מיידית
ORA #$CD ; לא מהזיכרון - התייחסות מיידית
STA $30; מאחסנת CF$ ב-0030$ מבוסס אפס

חינם
הטבלה הבאה ממחישה את ה-Bitwise XOR בבינארי, הקסדצימלי ועשרוני:

LDA #$9A ; לא מהזיכרון - התייחסות מיידית
EOR #$CD ; לא מהזיכרון - התייחסות מיידית
STA $30; מאחסנת 57 $ ב-0030 $ מבוסס אפס

4.5 פעולות העברה וסיבוב

המנמוניות והאופקודים עבור אופרטורי ההילוך והסיבוב הם:

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

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

כדי לבצע תזוזה או סיבוב עם המצבר, ההוראה היא בערך כך:

LSR א

זה משתמש במצב פנייה אחר הנקרא מצב כתובת מצבר.

כדי לבצע תזוזה או סיבוב עם מיקום זיכרון בתים, ההוראה היא בערך כך:

ROR $2BCD

כאשר 2BCD הוא מיקום הזיכרון.

שים לב שאין מצב פנייה מיידי או מרומז להסטה או סיבוב. אין מצב פנייה מיידי כי אין טעם להזיז או לסובב מספר שנשאר רק בהוראה. אין מצב פנייה מרומז מכיוון שהמתכננים של ה-6502 µP רוצים שרק התוכן של המצבר (A register) או מיקום בתים של זיכרון יוזז או יסובב.

4.6 מצב פנייה יחסית

המיקרו-מעבד תמיד מגדיל (ב-1, 2 או 3 יחידות) את מונה התוכניות (PC) כדי להצביע על ההוראה הבאה שאמורה להתבצע. ל-6502 µP יש הוראה שהזיכרון שלה הוא BVS שפירושו Branch on Overflow Set. המחשב האישי מורכב משני בתים. הוראה זו גורמת למחשב האישי לכתובת זיכרון שונה עבור ההוראה הבאה שתתבצע שאינה נובעת מהגדלה רגילה. הוא עושה זאת על ידי הוספה או חיסור של ערך, הנקרא היסט, לתוכן המחשב האישי. וכך, המחשב מצביע על מיקום זיכרון אחר (מסועף) עבור המחשב להמשיך בביצוע משם. ההיסט הוא מספר שלם מ-128 ₁₀ ל-+127 ₁₀ (השלמה של שניים). אז, ההיסט יכול לגרום לקפיצה להתקדם בזיכרון. אם הוא חיובי או מאחור בזיכרון, או אם הוא שלילי.

הוראת BVS לוקחת רק אופרנד אחד שהוא ההיסט. BVS משתמש בכתובת היחסית. שקול את ההוראה הבאה:

BVS $7F

בבסיס שני, 7F _ח הוא 01111111 ₂ = 127 ₁₀ . נניח שהתוכן במחשב האישי להוראה הבאה הוא $0300. הוראת BVS גורמת להוספת $7F (מספר חיובי כבר בהשלמה של שניים) ל-$0300 כדי לתת $037F. אז, במקום ההוראה הבאה שתתבצע במיקום הזיכרון של $0300, היא נמצאת במיקום הזיכרון של $037F (בערך חצי עמוד הבדל).

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

4.7 כתובת באינדקס ופנייה עקיפה בנפרד

מצבי הפנייה הללו מאפשרים ל-6502 µP לטפל בכמויות האדירות של נתונים בפרקי זמן קצרים עם מספר מופחת של הוראות. ישנם מיקומים של 64KB עבור כל זיכרון Comodore-64. לכן, כדי לגשת לכל מיקום בתים, של 16 ביטים, יש צורך ביצירת שני בתים. החריג היחיד לצורך של שני בתים הוא עבור עמוד אפס שבו הבית הגבוה יותר של $00 מושמט כדי לחסוך את המקום שתופסת ההוראה בזיכרון. במצב מענה שאינו עמוד אפס, גם הבייטים הגבוהים והנמוכים יותר של כתובת הזיכרון של 16 סיביות מסומנים בדרך כלל איכשהו.

כתובת אינדקס בסיסית

כתובת אינדקס מוחלטת
זכור שהאוגר X או Y נקרא אוגר האינדקס. שקול את ההוראה הבאה:

LDA $C453,X

נניח שהערך של 6 _ח נמצא ברישום X. שימו לב ש-6 אינו מוקלד בשום מקום בהוראה. הוראה זו מוסיפה את הערך של 6H ל-C453 _ח שהיא חלק מההוראה המוקלדת בקובץ הטקסט שעדיין יש להרכיב – C453 _ח + 6 _ח = C459 _ח . LDA פירושו טעינת בתים למצבר. הבת שייטען לתוך המצבר מגיע מהכתובת $C459. $C459 שהוא הסכום של $C453 שמוקלד עם ההוראה ו-6 _ח שנמצא במאגר X הופך לכתובת האפקטיבית שממנה מגיע ה-byte שייטען לתוך המצבר. אם 6 _ח היה ברישום Y, Y מוקלד במקום X בהוראה.

בהצהרת ההוראה המוקלדת, $C453 ידוע ככתובת הבסיס וה-6 _ח במאגר X או Y ידוע כחלק הספירה או האינדקס עבור הכתובת האפקטיבית. כתובת הבסיס יכולה להתייחס לכל כתובת בתים בזיכרון, ול-256 הבאות ₁₀ ניתן לגשת לכתובות, בהנחה שהאינדקס (או הספירה) שהתחיל באוגר X או Y הוא 0. זכור שבית אחד יכול לתת טווח רציף של עד 256 ₁₀ מספרים (כלומר 00000000 ₂ למספר 11111111 ₂ ).

אז, הכתובת המוחלטת מוסיפה את כל מה שכבר הוכנס (הוכנס על ידי הוראה אחרת) ב-X או Y אוגר ל-16 הכתובות המוקלדות עם ההוראה לקבל את הכתובת האפקטיבית. בהוראה המוקלדת, שני אוגרי האינדקס מובחנים על ידי X או Y המוקלדים לאחר פסיק. או X או Y מוקלדים; לא שניהם.

אחרי הכל התוכנה מוקלדת בעורך טקסט ונשמרת עם סיומת הקובץ '.asm', האסמבלר, שהיא תוכנה אחרת, צריך לתרגם את התוכנית שהוקלדה למה שנמצא (טעון) בזיכרון. ההוראה הקודמת, שהיא 'LDA $C453,X', תופסת שלושה מיקומי בתים בזיכרון, ולא חמישה.

זכור שמנמונית כגון LDA יכולה לכלול יותר מקוד אחד (בתים שונים). ה-opcode להוראה המשתמשת ב-X שונה מה-opcode שמשתמש ב-Y register. האסמבלר יודע באיזה opcode להשתמש בהתבסס על ההוראה המוקלדת. קוד האופציה של בית אחד עבור 'LDA $C453,X' שונה מקוד האופציה של בית אחד עבור 'LDA $C453,Y'. למעשה, ה-opcode עבור LDA ב-'LDA $C453,X' הוא BD, וה-opcode עבור LDA ב-'LDA $C453,9' הוא BD.

אם ה-opcode עבור LDA נמצא במיקום $0200 בתים. לאחר מכן, כתובת 16 הסיביות של $C453 לוקחת את מיקומי הבייטים הבאים בזיכרון שהם $0201 ו-$0202. בית ה-opcode המסוים מציין אם מדובר באוגר X או ב-Y אוגר. וכך, הוראת השפה המורכבת שהיא 'LDA $C453,X' או 'LDA $C453,Y' תופסת שלושה בתים עוקבים בזיכרון, ולא ארבעה או חמישה.

כתובת אפס-עמוד באינדקס
כתובת האינדקס של אפס עמודים היא כמו כתובת האינדקס המוחלטת שתוארה קודם לכן, אבל בייט היעד חייב להיות רק בעמוד אפס (מ-$0000 עד $00FF). כעת, כאשר עוסקים בעמוד האפס, הבת הגבוהה יותר שהוא תמיד 00 _ח עבור מיקומי הזיכרון נמנעים בדרך כלל. אז, בדרך כלל מוזכר שעמוד אפס מתחיל מ-$00 ל-FF. וכך, ההוראה הקודמת של 'LDA $C453,X' היא:

LDA $53.X

לא ניתן להשתמש ב-$C4, בית גבוה יותר המתייחס לעמוד שמעל לדף אפס, לא ניתן להשתמש בהוראה זו מכיוון שהוא מציב את בייט היעד הצפוי להיטען לתוך הבית המצטבר מחוץ לדף אפס ומעליו.

כאשר הערך המוקלד בהוראה מתווסף לערך בפנקס האינדקס, הסכום לא אמור לתת תוצאה מעל העמוד אפס (FF _ח ). לכן, לא בא בחשבון לקבל הוראה כמו 'LDA $FF, X' וערך כמו FF _ח בפנקס האינדקס כי FF _ח + FF _ח = 200 _ח שהוא המיקום הראשון של בייט ($0200) של עמוד 2 (עמוד שלישי) בזיכרון, נמצא במרחק גדול מעמוד 0. לכן, עם כתובת אפס-עמוד באינדקס, הכתובת האפקטיבית חייבת להיות בעמוד אפס.

פנייה עקיפה

קפיצה כתובת אבסולוטית
לפני שנדון בכתובת העקיפה המוחלטת, כדאי להסתכל תחילה על הפנייה המוחלטת של JMP. נניח שהכתובת שיש לה ערך ריבית (בייט יעד) היא $8765. זהו 16-ביט המורכב משני בתים: הבית הגבוה יותר שהוא 87 _ח והבייט התחתון שהוא 65 _ח . אז, שני הבתים עבור $8765 מוכנסים למחשב (מונה תוכניות) להוראה הבאה. מה שמוקלד בתוכנית שפת ה-Assembly (קובץ) הוא:

JMP $8765

התוכנית המבצעת בזיכרון קופצת מכל כתובת שהיא ניגשה אליה ל-$8765. ל-JMP Mnemonic שלושה קודים שהם 4C, 6C ו-7C. ה-opcode עבור הכתובת המוחלטת הזו הוא 4C. ה-opcode עבור הכתובת העקיפה המוחלטת של JMP הוא 6C (עיין באיורים הבאים).

כתובת עקיפה מוחלטת
זה משמש רק עם הוראת הקפיצה (JMP). נניח שהכתובת שבה יש את בייט הריבית (בייט יעד) היא $8765. זהו 16-ביט המורכב משני בתים: הבית הגבוה יותר שהוא 87 _ח והבייט התחתון שהוא 65 _ח . עם כתובת עקיפה מוחלטת, שני בתים אלה ממוקמים למעשה בשני מיקומי בתים עוקבים במקום אחר בזיכרון.

נניח שהם ממוקמים במיקומי הזיכרון של $0210 ו-$0211. לאחר מכן, הבית התחתון של כתובת העניין שהוא 65 _ח נמצא בכתובת $0210, והבייט הגבוה יותר שהוא 87 _ח נמצא בכתובת $0211. כלומר, בית הזיכרון התחתון של עניין הולך לכתובת רציפה נמוכה יותר, ובית הזיכרון הגבוה יותר של עניין הולך לכתובת הרצויה הגבוהה יותר - מעט קצה.

כתובת 16 סיביות יכולה להתייחס לשתי כתובות רצופות בזיכרון. לאור זאת, הכתובת $0210 מתייחסת לכתובות של $0210 ו-$0211. צמד הכתובות של $0210 ו-$0211 מכיל את הכתובת האולטימטיבית (16 סיביות של שני בתים) של בייט היעד, כשהבייט התחתון הוא 65 _ח ב-$0210 והבייט הגבוה יותר של 87 _ח ב-$0211. אז, הוראת הקפיצה המוקלדת היא:

JMP ($0210)

ל-JMP Mnemonic שלושה קודים שהם 4C, 6C ו-7C. ה-opcode עבור כתובת עקיפה מוחלטת הוא 6C. מה שמוקלד בקובץ הטקסט הוא 'JMP ($0210)'. בגלל הסוגריים, האסמבלר (מתרגם) משתמש ב-opcode 6C עבור JMP, ולא 4C או 7C.

עם כתובת עקיפה מוחלטת, ישנם למעשה שלושה אזורי זיכרון. האזור הראשון עשוי להיות מורכב ממיקומי הבייטים של $0200, $0201 ו-$0202. יש לזה את שלושת הבתים להוראה 'JMP ($0210)'. האזור השני, שאינו בהכרח ליד הראשון, מורכב משני מיקומי הבתים הרצופים של $0210 ו-$0211. זהו ה-byte התחתון כאן ($0210) שמוקלד בהוראת תוכנית שפת ה-assembly. אם הכתובת לעניין היא $8765, הבת התחתון הוא 65 _ח נמצא במיקום $0210 בתים, והבייט הגבוה יותר של 87 _ח נמצא במיקום $0211 בייט. האזור השלישי מורכב ממיקום בתים אחד בלבד. זה בכתובת של $8765 עבור בייט הממוקד (בית עניין אולטימטיבי). צמד הכתובות הרצופות, $0210 ו-$0211, מכיל את המצביע של $8765 שהוא כתובת העניין. לאחר פרשנות המחשוב, 8765$ נכנסים למחשב האישי (Program Counter) כדי לגשת לבייט היעד.

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

JMP ($50)

הבית הגבוה יותר של המצביע נמצא במיקום בתים של $51. הכתובת האפקטיבית (המחודדת) לא חייבת להיות בעמוד אפס.

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

4.8 כתובת עקיפה באינדקס

כתובת עקיפה מוחלטת באינדקס
מצב פנייה זה משמש עם הוראת JMP בלבד.
עם כתובת עקיפה מוחלטת, יש את הערך המחודד (בייט) עם שתי כתובות בתים עוקבות משלו. שתי הכתובות הרצופות הללו יוצרות את המצביע להיות באזור המצביע של שני בתים עוקבים בזיכרון. הבית התחתון של אזור המצביע הוא מה שמוקלד בהוראה בסוגריים. המצביע הוא הכתובת של הערך המחודד. במצב הקודם, $8765 הוא הכתובת של הערך המחודד. ה-$0210 (אחריו $0211) היא הכתובת שהתוכן שלה הוא $8765 שהוא המצביע. במצב הפנייה העקיפה המוחלט, זה ($0210) שמוקלד בתוכנית (קובץ טקסט), כולל הסוגריים.

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

JMP ($020A,X)

כאשר לאוגר X יש ערך של 6 _ח . 020A _ח + 6 _ח = 0210 _ח . האוגר Y אינו בשימוש עם מצב פנייה זה.

אפס עמוד אינדקס כתובת עקיפה
מצב פנייה זה משתמש באוגר X ולא באוגר Y. במצב הפנייה הזה, עדיין יש את הערך המחודד והמצביע באזור מצביע הכתובת בן שני הבתים שלו. חייבים להיות שני בתים עוקבים בעמוד אפס עבור המצביע. הכתובת המוקלדת בהוראה היא כתובת בית אחד. ערך זה מתווסף לערך באוגר X וכל העברה נמחק. התוצאה מצביעה על אזור המצביע בעמוד 0. לדוגמה, אם כתובת העניין (החודדת) היא $8765 והיא נמצאת במיקומי בתים של $50 ו-$51 של עמוד 0, והערך באוגר X הוא $30, הוראה מוקלדת היא משהו כזה:

LDA ($20.X)

כי $20 + $30 = $50.

כתובת אינדקס עקיפה
מצב פנייה זה משתמש באוגר Y ולא ברישום X. במצב הפנייה הזה, עדיין יש את הערך המחודד ואת אזור המצביע, אבל התוכן של אזור המצביע פועל אחרת. חייבים להיות שני בתים עוקבים בעמוד אפס עבור אזור המצביע. הכתובת התחתונה של אזור המצביע מוקלדת בהוראה. המספר הזה (זוג בתים) הכלול באזור המצביע מתווסף לערך באוגר Y כדי לקבל את המצביע האמיתי. לדוגמה, תן לכתובת העניין (החודדת) להיות $8765, הערך של 6H יהיה בפנקס Y, והמספר (שני בתים) יהיה בכתובת 50 _ח ו-51 _ח . שני הבייטים ביחד הם $875F מאז $875F + $6 = $8765. ההוראה המוקלדת היא בערך כך:

LDA ($50),Y

4.9 הוראות הגדלה, הפחתה ובדיקות-BIT

הטבלה הבאה מציגה את הפעולות של הוראות ההגדלה וההפחתה:

ה-INA ו-DEA מגדילים ומקטינים את המצבר, בהתאמה. זה נקרא כתובת מצבר. INX, DEX, INY ו-DEY הם עבור אוגרי X ו-Y, בהתאמה. הם לא לוקחים שום אופרנד. אז, הם משתמשים במצב הכתובת המרומז. הגדלה פירושה הוספת 1 ל-register או בייט הזיכרון. ירידה פירושה הפחתה של 1 מהאוגר או בייט הזיכרון.

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

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

• N שהוא סיביות 7 והביט האחרון (משמאל) של אוגר המצב, מקבל סיביות 7 של מיקום הזיכרון לפני ה-ANDing.
• V שהוא סיביות 6 של אוגר המצב מקבל סיביות 6 של מיקום הזיכרון לפני ה-ANDing.
• דגל ה-Z של אוגר הסטטוס נקבע (נעשה 1) אם התוצאה של ה-AND היא אפס (00000000 ₂ ). אחרת, הוא נמחק (נעשה 0).

4.10 השוואה בין הוראות

זכרוני ההשוואה של הוראות ה-6502 µP הם CMP, CPX ו-CPY. לאחר כל השוואה, הדגלים N, Z ו-C של אוגר מצב המעבד 'P' מושפעים. דגל N נקבע (עושה 1) כאשר התוצאה היא מספר שלילי. דגל ה-Z מוגדר (עושה 1) כאשר התוצאה היא אפס (000000002). דגל ה-C נקבע (עושה 1) כאשר יש העברה מהביט השמונה ל-9. הטבלה הבאה נותנת המחשה מפורטת

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

4.11 הוראות קפיצה וענף

הטבלה הבאה מסכמת את הוראות הקפיצה וההסתעפות:

הוראת JMP משתמשת בכתובת המוחלטת והעקיפה. שאר ההוראות בטבלה הן הוראות סניף. הם משתמשים רק בכתובת היחסית עם ה-6502 µP. בכך, הטבלה הופכת לעצמה אם היא נקראת משמאל לימין ומלמעלה למטה.

שימו לב שניתן להחיל את הענפים רק על כתובות בטווח של -128 עד +127 בתים מהכתובת הנתונה. זו התייחסות יחסית. הן עבור הוראות ה-JMP והן עבור הסניף, מונה התוכניות (PC) מושפע ישירות. ה-6502 µP אינו מאפשר לסניפים לכתובת מוחלטת, אם כי הקפיצה יכולה לבצע את הכתובת המוחלטת. הוראת JMP אינה הוראת סניף.

הערה: כתובת יחסית משמשת רק עם הוראות סניף.

4.12 אזור המחסנית

תת-שגרה היא כמו אחת מהתוכניות הקצרות הקודמות להוסיף שני מספרים או להחסיר שני מספרים. אזור המחסנית בזיכרון מתחיל מ-$0100 עד $01FF כולל. אזור זה נקרא בפשטות המחסנית. כאשר המיקרו-מעבד מבצע קפיצה להוראת המשנה (JSR – עיין בדיון הבא), הוא צריך לדעת לאן לחזור בסיום. ה-6502 µP שומר מידע זה (כתובת החזרה) בזיכרון נמוך מ-$0100 ל-$01FF (אזור המחסנית) ומשתמש בתוכן אוגר המחסנית שהוא 'S' במיקרו-מעבד כמצביע (9 סיביות) לכתובת האחרונה שהוחזרה זה מאוחסן בעמוד 1 ($0100 עד $01FF) של הזיכרון. הערימה גדלה מ-$01FF ומאפשרת לקנן את תתי-השגרה עד לעומק של 128 רמות.

שימוש נוסף במצביע המחסנית הוא לטפל בפסיקות. ל-6502 µP יש את הפינים המסומנים כ-IRQ ו-NMI. ייתכן שכמה אותות חשמליים קטנים יופעלו על הפינים הללו ויגרמו ל-6502 µP להפסיק את הפעלת תוכנית אחת ולגרום לה להתחיל לבצע תוכנית אחרת. במקרה זה, התוכנית הראשונה מופסקת. כמו תתי שגרות, ניתן לקנן את מקטעי קוד הפסיקה. עיבוד פסיקה נדון בפרק הבא.

הערה : למצביע המחסנית יש 8 סיביות עבור כתובת הבתים הנמוכה בכתובת המיקומים מ-$0100 ל-$01FF. הבית הגבוה יותר של 00000001 ₂ מונחה.

הטבלה הבאה נותנת את ההוראות המקשרות את מצביע המחסנית 'S' עם האוגרים A, X, Y ו-P לאזור המחסנית בזיכרון:

4.13 תת שגרת שיחה והחזרה

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

JSR : קפוץ ל-SubRoutine

ההוראה לחזור מתת שגרה היא:

RTS: חזרה משגרת משנה

למיקרו-מעבד יש נטייה לבצע ברציפות את ההוראות בזיכרון, בזו אחר זו. נניח שהמיקרו-מעבד מבצע כעת קטע קוד והוא נתקל בהוראה קפיצה (JMP) ללכת ולבצע קטע קוד שמקודד מאחוריו שהוא עשוי כבר להתבצע. הוא מבצע את קטע הקוד מאחור וממשיך לבצע את כל קטעי הקוד (ההוראות) בעקבות קטע הקוד שמאחור, עד שהוא מבצע שוב את קטע הקוד הנוכחי וממשיך למטה. JMP לא דוחף את ההוראה הבאה לערימה.

שלא כמו JMP, JSR דוחף את הכתובת של ההוראה הבאה אחריה מהמחשב האישי (מונה תוכניות) אל המחסנית. מיקום הערימה של כתובת זו ממוקם במצביע המחסנית 'S'. כאשר נתקלים בהוראה RTS (מתבצעת) בתת-השגרה, הכתובת שנדחפת על הערימה מושכת את המחסנית והתוכנית מתחדשת בכתובת הנשלפת הזו שהיא כתובת ההוראה הבאה ממש לפני קריאת תת-השגרה. הכתובת האחרונה שהוסרה מהמחסנית נשלחת לדלפק התוכניות. הטבלה הבאה מציגה את הפרטים הטכניים של הוראות JSR ו-RTS:

ראה את האיור הבא לשימושים של JSR ו-RTS:

4.14 דוגמה של ספירה לאחור

תת-השגרה הבאה סופרת לאחור מ-$FF ל-$00 (סה'כ 256 ₁₀ סופר):

התחל LDX #$FF ; טען X עם $FF = 255
לולאה DEX ; X = X – 1
לולאת BNE ; אם X לא אפס אז ללכת ללולאה
RTS ; לַחֲזוֹר

לכל שורה יש הערה. הערות לעולם אינן נכנסות לזיכרון לצורך ביצוע. האסמבלר (מתרגם) שממיר תוכנית למה שהיא בזיכרון לצורך ביצוע (ריצה) תמיד מסיר את ההערות. הערה מתחילה ב-';' . ה'התחלה' וה'לולאה' בתוכנית זו נקראים תוויות. תווית מזהה (השם) עבור הכתובת של ההוראה. אם ההוראה היא הוראת בתים בודדת (פנייה מרומזת), התווית היא הכתובת של אותה הוראה. אם ההוראה היא הוראה מרובה בתים, התווית מזהה את הבית הראשון להוראה מרובה בתים. ההוראה הראשונה לתוכנית זו מורכבת משני בתים. בהנחה שהוא מתחיל בכתובת $0300, ניתן להחליף את הכתובת $0300 ב-'התחלה' למטה בתוכנית. ההוראה השנייה (DEX) היא הוראה של בתים בודדים, וצריכה להיות בכתובת $0302. זה אומר שניתן להחליף את הכתובת $0302 ב-'לולאה', למטה בתוכנית, וזה למעשה כך ב-'BNE loop'.

'לולאת BNE' פירושה הסניף לכתובת הנתונה כאשר דגל ה-Z של אוגר המצב הוא 0. כאשר הערך באוגר A או X או Y הוא 00000000 ₂ , עקב הפעולה האחרונה, דגל ה-Z הוא 1 (סט). אז בעוד שהוא 0 (לא 1), ההוראות השניות והשלישיות בתוכנית חוזרות על עצמן בסדר זה. בכל רצף חוזר, הערך (המספר השלם) באוגר X מצטמצם ב-1. DEX פירושו X = X – 1. כאשר הערך באוגר X הוא $00 = 00000000 ₂ , Z הופך ל-1. בשלב זה, אין יותר חזרה על שתי ההוראות. הוראת ה-RTS האחרונה בתוכנית, שהיא הוראת בייט בודד (פנייה מרומזת), חוזרת מתת-השגרה. ההשפעה של הוראה זו היא להפוך את כתובת מונה התוכנית במחסנית עבור הקוד שאמור להתבצע לפני קריאת המשנה ולחזור למונה התוכניות (PC). כתובת זו היא הכתובת של ההוראה שאמורה להתבצע לפני קריאת תת-השגרה.

הערה: בעת כתיבת תוכנית שפת assembly עבור 6502 µP, רק תווית חייבת להתחיל בתחילת השורה; יש להזיז כל קוד שורה אחר לפחות רווח אחד ימינה.

קריאה לשגרת משנה
בהתעלמות משטח הזיכרון שנלקח על ידי התוויות הקודמות, התוכנית לוקחת 6 בתים של מיקומים רצופים בזיכרון (RAM) מ-$0300 ל-$0305. במקרה זה, התוכנית היא:

LDX #$FF ; טען X עם $FF = 255
DEX ; X = X – 1
BNE $0302 ; אם X לא אפס אז ללכת ללולאה
RTS ; לַחֲזוֹר

החל מהכתובת של $0200 בזיכרון יכולה להיות הקריאה לשגרת המשנה. הוראת השיחה היא:

התחלה של JSR; ההתחלה היא כתובת $0300, כלומר JSR $0300

תת-השגרה והקריאה שלה שנכתבות כהלכה בקובץ עורך הטקסט היא:

הפעל את LDX #$FF; טען X עם $FF = 255
לולאה DEX ; X = X – 1

לולאת BNE ; אם X לא אפס אז ללכת ללולאה
RTS ; לַחֲזוֹר

התחלה של JSR: קפיצה לשגרה החל מ-$0300

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

4.15 תרגום תוכנית

תרגום תוכנית או הרכבה אומר אותו דבר. שקול את התוכנית הבאה:

התחל LDX #$FF : טען X עם $FF = 255
לולאה DEX : X = X – 1
לולאה BNE: אם X לא אפס אז עברו ללולאה
RTS: לחזור
התחלה של JSR: קפיצה לשגרה החל מ-$0300

זו התוכנית שנכתבה בעבר. היא מורכבת מתת-השגרה, ההתחלה והקריאה לתת-השגרה. התוכנית סופרת לאחור מ-255 ₁₀ ל-0 ₁₀ . התוכנית מתחילה בכתובת ההתחלה של המשתמש של $0200 (RAM). התוכנה מוקלדת בעורך טקסט ונשמרת בדיסק. יש לו שם כמו 'sample.asm' כאשר 'sample' הוא שם הבחירה של המתכנת אבל הסיומת '.asm' לשפת ה-Assembly חייבת להיות משויכת לשם הקובץ.

התוכנית המורכבת מופקת על ידי תוכנה אחרת הנקראת אסמבלר. ההרכב מסופק על ידי היצרן של ה-6502 µP או על ידי צד שלישי. האסמבלר משחזר את התוכנית בצורה כזו שהיא בזיכרון (RAM) בזמן שהיא מבצעת (ריצה).

נניח שהפקת JSR מתחילה בכתובת $0200 ותת-השגרה מתחילה בכתובת $0300. האסמבלר מסיר את כל ההערות והרווחים הלבנים. ההערות והרווחים הלבנים מבזבזים את הזיכרון שהוא תמיד דל. שורה ריקה אפשרית בין קטע קוד התת-שגרה הקודם לקריאת תת-השגרה היא דוגמה לרווח לבן. הקובץ המורכב עדיין שמור בדיסק, והוא נקרא משהו כמו 'sample.exe'. ה-'דוגמא' הוא שם הבחירה של המתכנת, אבל הסיומת '.exe' צריכה להיות שם כדי לציין שזהו קובץ הפעלה.

ניתן לתעד את התוכנית המורכבת באופן הבא:

אומרים שהפקת מסמך כזה היא הרכבה ידנית. שימו לב שההערות במסמך זה אינן מופיעות בזיכרון (לביצוע). עמודת הכתובות בטבלה מציינת את כתובות ההתחלה של ההוראות בזיכרון. שים לב ש-'JSR start' כלומר 'JSR $0300', שצפוי להיות מקודד כ-'20 03 00', מקודד למעשה כ-'20 00 03' כאשר כתובת בת הזיכרון התחתון לוקחת את הבית התחתון בזיכרון כתובת ביתית זיכרון גבוהה יותר שלוקחת את הבת הגבוהה יותר בזיכרון - מעט endianness. ה-opcode עבור JSR הוא 20 ₁₆ .

שימו לב שהקיזוז להוראת ענף כמו BNE הוא מספר משלים של שני בטווח של 128 ₁₀ ל-+127 ₁₀ . אז, 'לולאת BNE' פירושה 'BNE -1 ₁₀ ' שהוא למעשה 'D0 FF' בצורת הקוד של FF ₁₆ הוא -1 בהשלמה של שניים שנכתב כ= 11111111 בבסיס שני. תוכנית האסמבלר מחליפה את התוויות והשדות למספרים הקסדצימליים בפועל (מספרים הקסדצימליים הם מספרים בינאריים המקובצים בארבע סיביות). הכתובות בפועל שבהן כל הוראה מתחילה כלולות למעשה.

הערה: הוראת 'התחלת JSR' מוחלפת בהוראות קצרות יותר ששולחות את התוכן הנוכחי (גבוהים ונמוכים) של מונה התוכנית אל המחסנית עם מצביע המחסנית המופחת פעמיים (פעם אחת עבור בית גבוה ופעם עבור בתים נמוך) ו ואז טוען מחדש את המחשב עם הכתובת $0300. מצביע המחסנית מצביע כעת על $00FD, בהנחה שהוא מאותחל ל-$01FF.

כמו כן, הוראת ה-RTS מוחלפת במספר הוראות קצרות יותר אשר מגדילות את מצביע המחסנית 'S' פעמיים (פעם אחת עבור בייט נמוך ופעם עבור בייט גבוה) ומושכת את שני בתים המתאימים של כתובת ממצביע המחסנית למחשב האישי עבור ההוראה הבאה.

הערה: טקסט תווית לא צריך לכלול יותר מ-8 תווים.

'לולאת BNE' משתמשת בכתובת היחסית. זה אומר להוסיף -3 ₁₀ לתוכן דלפק התוכנית הבא של $0305. הבתים עבור 'לולאת BNE' הם 'D0 FD' כאשר FD הוא ההשלמה של השניים של -3 ₁₀ .

הערה: פרק זה אינו מציג את כל ההוראות עבור 6502 µP. את כל ההוראות ופרטיהן ניתן למצוא במסמך שכותרתו 'SY6500 8-Bit Microprocessor Family'. קיים קובץ PDF בשם '6502.pdf' עבור מסמך זה הזמין בחינם באינטרנט. ה-6502 µP המתואר במסמך זה הוא 65C02.

4.16 הפסקות

האותות של כל התקן שמחובר ליציאות החיצוניות (משטח אנכי) של ה-Commodore 64 צריכים לעבור דרך מעגלי CIA 1 או CIA 2 (ICs) לפני שהם מגיעים למיקרו-מעבד 6502. האותות מאפיק הנתונים של ה-6502 µP צריכים לעבור דרך שבב CIA 1 או CIA 2 לפני שהם מגיעים לכל מכשיר חיצוני. CIA ראשי תיבות של Complex Interface Adapter. באיור 4.1 'דיאגרמת בלוקים של לוח האם של Commodore_64', התקני הקלט/פלט הבלוק מייצגים את ה-CIA 1 וה-CIA 2. כאשר תוכנית פועלת, ניתן להפריע לה להפעיל קטע קוד אחר לפני שתמשיך. יש הפרעה בחומרה והפרעה בתוכנה. להפרעות בחומרה, ישנם שני פיני אות כניסה ל-6502 µP. שמות הפינים הללו הם IRQ ו NMI . אלה אינם קווי נתונים של µP. קווי הנתונים עבור µP הם D7, D6, D5, D4, D3, D2, D1 ו-D0; עם D0 עבור הסיביות הפחות משמעותיות ו-D7 עבור הסיביות המשמעותיות ביותר.

IRQ מייצג Interrupt ReQuest 'פעיל' נמוך. קו כניסה זה ל- µP הוא בדרך כלל גבוה, ב-5 וולט בערך. כאשר הוא יורד ל-0 וולט בערך, זוהי בקשת פסיקה שמאותתת ל- µP. ברגע שהבקשה מתקבלת, התור חוזר גבוה. מתן בקשת ההפסקה פירושה שה- µP מסתעף אל הקוד (תת-השגרה) המטפל בהפרעה.

NMI מייצג פסיקה שאינה ניתנת למסיכה 'פעילה' נמוכה. בעוד הקוד עבור IRQ מוצא להורג NMI יכול לרדת נמוך. במקרה הזה, NMI מטופל (קוד משלו מבוצע). לאחר מכן, הקוד עבור IRQ ממשיך. אחרי הקוד עבור IRQ מסתיים, קוד התוכנית הראשי ממשיך. זה, NMI קוטע את IRQ מטפל. האות עבור NMI עדיין ניתן לתת ל-µP גם כאשר ה-µP אינו פעיל ואינו מטפל בכלום או לא מריץ תוכנית ראשית.

הערה: זה בעצם המעבר מגבוה לנמוך, של NMI , זה ה NMI אות - עוד על כך בהמשך. IRQ בדרך כלל מגיע מ-CIA 1 ו NMI בדרך כלל מגיע מ-CIA 2. NMI , אשר ראשי תיבות של Non-Maskable Interrupt, יכולה להיחשב כפסיקה בלתי ניתנת לעצירה.

טיפול בהפרעות
האם הבקשה היא מ IRQ אוֹ NMI , יש להשלים את ההוראה הנוכחית. ל-6502 יש רק את אוגרי A, X ו-Y. בזמן שתת שגרה פועלת, ייתכן שהיא משתמשת בשלושת האוגרים הללו יחד. מטפל בפסיקה הוא עדיין תת-שגרה, אם כי לא נתפסת ככזו. לאחר השלמת ההוראה הנוכחית, התוכן של אוגרי A, X ו-Y עבור 65C02 µP נשמר בערימה. הכתובת של ההוראה הבאה של מונה התוכניות נשלחת גם היא למחסנית. לאחר מכן, ה- µP מסתעף אל הקוד של ההפסקה. לאחר מכן, התוכן של האוגרים A, X ו-Y משוחזר מהמחסנית בסדר הפוך שאליו הם נשלחים.

דוגמה לקידוד לפסיקה
לשם הפשטות, נניח שהשגרה עבור µP IRQ הפרעה היא רק להוסיף את המספרים $01 ו-$02 ולשמור את התוצאה של $03 בכתובת הזיכרון של $0400. הקוד הוא:

ISR PHA
PHX
PHY
;
LDA #$01
ADC #$02
הם עולים 0400$
;
PLY
PLX
PLA
RTI

ISR היא תווית ומזהה את כתובת הזיכרון שבה נמצאת הוראת ה-PHA. ISR פירושו שגרת שירות פסיקה. PHA, PHX ו-PHY שולחים את התוכן של הרגיסטרים A, X ו-Y לערימה בתקווה שהם יהיו נחוצים בכל קוד (תוכנית) שפועל ממש לפני ההפרעה. שלוש ההוראות הבאות מהוות את הליבה של המטפל בפסיקה. הוראות ה-PLY, PLX וה-PLA צריכות להיות בסדר הזה, והן מחזירות את התוכן של אוגרי Y, X ו-A. ההוראה האחרונה, שהיא RTI, (ללא אופרנד) מחזירה את המשך הביצוע לכל קוד (תוכנית) שמבצע לפני הפרעה. RTI מושך את הכתובת של ההוראה הבאה של הקוד שמבצעת מהמחסנית בחזרה למונה התוכנית. RTI פירושו ReTurn from Interrupt. בכך הסתיים הטיפול בפסיקות (תת שגרת).

הפרעה בתוכנה
הדרך העיקרית להפסקת תוכנה עבור 6502 µP היא באמצעות הוראת הכתובת המרומזת של BRK. נניח שהתוכנית הראשית פועלת והיא נתקלת בהוראה BRK. מנקודה זו, יש לשלוח את הכתובת של ההוראה הבאה במחשב האישי למחסנית עם השלמת ההוראה הנוכחית. תת שגרה לטיפול בהוראת התוכנה צריכה להיקרא 'הבא'. תת-שגרת פסיקה זו צריכה לדחוף את תוכן האוגר A, X ו-Y לערימה. לאחר ביצוע הליבה של תת-השגרה, יש למשוך את התוכן של האוגרים A, X ו-Y לאחור מהמחסנית אל האוגרים שלהם על ידי תת-השגרה המשלימה. ההצהרה האחרונה בשגרה היא RTI. גם תוכן המחשב נמשך חזרה מהמחסנית למחשב האישי באופן אוטומטי בגלל RTI.

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

4.17 סיכום של 6502 מצבי הכתובת העיקריים

כל הוראה עבור 6502 היא בת אחד, ואחריו אפס אופרנדים או יותר.

מצב פנייה מיידית
עם מצב פנייה מיידית, אחרי האופרנד, הוא הערך ולא כתובת זיכרון. יש להקדים את הערך ב-#. אם הערך הוא הקסדצימלי, ה-'#' חייב להיות אחריו '$'. הוראות הפנייה המיידיות עבור ה-65C02 הן: ADC, AND, BIT, CMP, CPX, CPY, EOR, LDA, LDX, LDY, ORA, SBC. על הקורא לעיין בתיעוד עבור 65C02 µP על מנת לדעת כיצד להשתמש בהוראות המפורטות כאן שאינן מוסברות בפרק זה. הוראה לדוגמה היא:

LDA #77 $

מצב כתובת מוחלטת
במצב כתובת מוחלטת, יש אופרנד אחד. אופרנד זה הוא הכתובת של הערך בזיכרון (בדרך כלל בהקסדצימלי או תווית). יש 64K ₁₀ = 65,536 ₁₀ כתובות זיכרון עבור 6502 µP. בדרך כלל, הערך של בית אחד נמצא באחת מהכתובות הללו. הוראות הכתובת המוחלטות עבור ה-65C02 הן: ADC, AND, ASL, BIT, CMP, CPX, CPY, DEC, EOR, INC, JMP, JSR, LDA, LDX, LDY, LSR, ORA, ROL, ROR, SBC, STA , STX, STY, STZ, TRB, TSB. על הקורא לעיין בתיעוד עבור 65C02 µP כדי לדעת כיצד להשתמש בהוראות המפורטות כאן, כמו גם עבור שאר מצבי הפנייה שאינם מוסברים בפרק זה. הוראה לדוגמה היא:

הם 1234 דולר

מצב כתובת מרומזת
במצב כתובת מרומזת, אין אופרנד. כל אוגר µP המעורב משתמע מההוראה. הוראות הפנייה המרומזות עבור ה-65C02 הן: BRK, CLC, CLD, CLI, CLV, DEX, DEY, INX, INY, NOP, PHA, PHP, PHX, PHY, PLA, PLP, PLX, PLY, RTI, RTS, SEC , SED, SEI, TAX, TAY, TSX, TXA, TXS, TYA. הוראה לדוגמה היא:

DEX : הקטנת אוגר X ביחידה אחת.

מצב כתובת יחסית
מצב פנייה יחסי עוסק רק בהוראות סניף. במצב פנייה יחסי, יש רק אופרנד אחד. זה ערך מ-128 ₁₀ ל-+127 ₁₀ . ערך זה נקרא היסט. בהתבסס על הסימן, ערך זה מתווסף או מופחת מההוראה הבאה של מונה התוכנית כדי להביא את הכתובת של ההוראה הבאה המיועדת. הוראות מצב הכתובות היחסיות הן: BCC, BCS, BEQ, BMI, BNE, BPL, BRA, BVC, BVS. דוגמאות ההוראות הן:

BNE $7F : (ענף אם Z = 0 ברישום הסטטוס, P)

מה שמוסיף 127 למונה התוכנית הנוכחית (כתובת לביצוע) ומתחיל לבצע את ההוראה בכתובת זו. באופן דומה:

BEQ $F9 : (ענף אם Z = : ברישום הסטטוס, P)

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

כתובת אינדקס מוחלטת
בכתובת אינדקס מוחלטת, התוכן של אוגר X או Y מתווסף לכתובת המוחלטת הנתונה (בכל מקום מ-$0000 ל-$FFFF, כלומר מ-0 ₁₀ למספר 65536 ₁₀ ) כדי לקבל את הכתובת האמיתית. כתובת מוחלטת זו נקראת כתובת הבסיס. אם נעשה שימוש באוגר X, הוראת ההרכבה היא בערך כך:

LDA $C453,X

אם נעשה שימוש ברישום Y, זה משהו כמו:

LDA $C453,Y

הערך של האוגר X או Y נקרא ערך הספירה או האינדקס, והוא יכול להיות בכל מקום מ-$00 (0 ₁₀ ) ל-$FF (250 ₁₀ ). זה לא נקרא קיזוז.

הוראות הפנייה לאינדקס המוחלטות הן: ADC, AND, ASL (X בלבד), BIT (עם מצבר וזיכרון, עם X בלבד), CMP, DEC (זיכרון ו-X בלבד), EOR, INC (זיכרון ו-X בלבד), LDA , LDX, LDY, LSR (X בלבד), ORA, ROL (X בלבד), ROR (X בלבד), SBC, STA, STZ (X בלבד).

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

JMP ($3456)

עם הסוגריים, ו-$13 נמצא במיקום הכתובת של $3456 ואילו $EB נמצא במיקום הכתובת של $3457 (=$3456 + 1). לאחר מכן, כתובת היעד היא $13EB ו-$13EB הוא המצביע. ה-$3456 המוחלט מופיע בסוגריים בהוראה כאשר 34 הוא הבית התחתון ו-56 הוא הבית הגבוה יותר.

4.18 יצירת מחרוזת עם שפת ה-Assembly 6502 µP

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

ישנן שתי דרכים עיקריות ליצור מחרוזת של קודי ASCII. בשתי הדרכים, כל קודי ה-ASCII (תווים) תופסים מיקומי בתים עוקבים בזיכרון. באחת הדרכים, מקדים לרצף זה של בתים בית שלם שהוא האורך (מספר התווים) ברצף (מחרוזת). בדרך אחרת, אחרי רצף התווים ממשיך (מיד אחריו) ה-Null byte שהוא 00 ₁₆ , כלומר $00. אורך המחרוזת (מספר התווים) אינו מצוין בדרך אחרת זו. התו Null אינו בשימוש בדרך הראשונה.

לדוגמה, שקול את ה'אני אוהב אותך!' מחרוזת ללא המרכאות. האורך כאן הוא 11; רווח נחשב כבייט ASCII אחד (תו). נניח שיש למקם את המחרוזת בזיכרון כאשר התו הראשון נמצא בכתובת $0300.

הטבלה הבאה מציגה את הגדרת זיכרון המחרוזת כאשר הבת הראשון הוא 11 ₁₀ = 0B ₁₆ :

הטבלה הבאה מציגה את הגדרת זיכרון המחרוזת כאשר הבית הראשון הוא 'I' והבית האחרון הוא Null ($00):

ניתן להשתמש בהוראה הבאה כדי להתחיל ביצירת המחרוזת:

הם עולים 0300 $

נניח שהבייט הראשון נמצא בצובר שאמור להישלח למיקום הכתובת של $0300. הוראה זו נכונה לשני המקרים (שני סוגי המחרוזות).

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

4.19 יצירת מערך עם שפת ה-Assembly 6502 µP

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

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

4.20 בעיות

מומלץ לקורא לפתור את כל הבעיות בפרק לפני המעבר לפרק הבא.

1. כתוב תוכנית שפת assembly שמתחילה ב-$0200 עבור ה-6502 µP ומוסיפה את המספרים הלא-חתומים של 2A94 _ח (הוסף) ל-2ABF _ח (אוגנד). תן לכניסות ולפלט להיות בזיכרון. כמו כן, הפק את מסמך התוכנית המורכב ביד.
2. כתוב תוכנית שפת assembly שמתחילה ב-$0200 עבור ה-6502 µP ומחסירת את המספרים הבלתי-חתומים של 1569 _ח (subtrahend) מ-2ABF _ח (מינוד). תן לכניסות וליציאות להיות בזיכרון. כמו כן, הפק את מסמך התוכנית המורכב ביד.
3. כתוב תוכנית שפת assembly עבור 6502 µP שסופרת מ-$00 עד $09 באמצעות לולאה. התוכנית צריכה להתחיל ב-$0200. כמו כן, הפק את מסמך התוכנית המורכב ביד.
4. כתוב תוכנית שפת assembly שמתחיל ב-$0200 עבור ה-6502 µP. לתוכנית שתי תתי שגרות. תת-השגרה הראשונה מוסיפה את המספרים הלא חתומים של 0203 _ח (augend) ו-0102H (הוספה). תת-השגרה השנייה מוסיפה את הסכום מתת-השגרה הראשונה שהיא 0305H ל-0006 _ח (אוגנד). התוצאה הסופית נשמרת בזיכרון. קרא לתת-השגרה הראשונה שהיא FSTSUB ולתת-השגרה השנייה שהיא SECSUB. תן לכניסות וליציאות להיות בזיכרון. כמו כן, הפק את מסמך התוכנית המורכב עבור כל התוכנית ביד.
5. בהתחשב בכך א IRQ המטפל מוסיף $02 ל-$01 במצטבר כטיפול הליבה תוך כדי NMI מונפקת וטיפול הליבה עבור NMI מוסיף $05 ל-$04 ב-accumulator, כתוב שפת assembly עבור שני המטפלים כולל הקריאות שלהם. הקריאה ל- IRQ המטפל צריך להיות בכתובת של $0200. ה IRQ המטפל צריך להתחיל בכתובת של $0300. ה NMI המטפל צריך להתחיל בכתובת של $0400. התוצאה של IRQ יש לשים את המטפל בכתובת של $0500, ואת התוצאה של NMI יש לשים את המטפל בכתובת של $0501.
6. הסבר בקצרה כיצד משתמשים בהוראת BRK להפקת פסיקת התוכנה במחשב 65C02.
7. צור טבלה שמשווה ומעמתת תת-שגרה רגילה לשגרת שירות פסיקה.
8. הסבר בקצרה את מצבי הפנייה העיקריים של 65C02 µP בהינתן דוגמאות של הוראות שפת ההרכבה.
9. א) כתוב תוכנית שפת מכונה 6502 כדי לשים את ה'אני אוהב אותך!' מחרוזת קודי ASCII בזיכרון, החל מכתובת $0300 עם אורך המחרוזת. התוכנית צריכה להתחיל בכתובת $0200. השג כל דמות מהמצבר אחד-אחד, בהנחה שהם נשלחים לשם, על ידי תת-שגרה כלשהי. כמו כן, הרכיבו את התוכנית ביד. (אם אתה צריך לדעת את קודי ASCII של 'אני אוהב אותך!'. הנה הם: 'אני':49 ₁₆ , מקום: 20 ₁₆ , 'l': 6C ₁₆ , 'o':6F ₁₆ , 'ב':76 ₁₆ , 'e':65, 'y':79 ₁₆ , 'ב':75 ₁₆ , ו'!':21 ₁₆ (הערה: כל קוד תופס 1 בייט).
   ב) כתוב תוכנית שפת מכונה 6502 כדי לשים את ה'אני אוהב אותך!' מחרוזת קודי ASCII בזיכרון, החל מכתובת $0300 ללא אורך המחרוזת אך מסתיימת ב-00 ₁₆ . התוכנית צריכה להתחיל בכתובת $0200. השג כל דמות מהמצבר, בהנחה שהם נשלחים לשם, אחד אחד, על ידי תת-שגרה כלשהי. כמו כן, הרכיבו את התוכנית ביד.