פרק 9 יצירת קוד

1תורת הקומפילציהאיתן אביאור


ניתוח(analysis)

חיבור(synthesis)

syntax analyserמנתח תחביר

semantic analyserמנתח משמעות

מייצר קוד ביניים intermediate code generator

code optimizerמייעל קוד

code generatorמייצר קוד

lexical analyserמנתח לקסיקאלי

יצירת קוד

code generatorמייצר קוד


מיקום מייצר הקודבצינור המהדר

תוכניתהמקור

הצדהקדמי

קודביניים

מייעלהקוד

קודביניים

מייצרהקוד

תוכניתהמטרה

טבלתהסמלים


מייצר הקוד לייצר קוד אופטימלי בשפת המכונההמטרה:דרישות:

הקוד חייב להיות נכון1.

הקוד חייב לנצל ביעילות את משאבי החומרה2.

מייצר הקוד צריך להיות יעיל בעצמו3.דילמה:

מה זה קוד אופטימלי ?זמן ריצה–דרישות זיכרון–משאבי חומרה ותוכנה–

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

הפתרון: שימוש ביוריסטיקות לייצור הקוד


נקודות בתכנות מייצר קוד

הקלט למייצר הקוד1.

תוכנית המטרה2.

ניהול הזיכרון3.

בחירת ההוראות4.

הקצאת אוגרים5.

סדר החישוב6.


הקלט למייצר הקודהקלט למייצר הקוד הינו קוד הביניים שנוצר ע"י החלק הקדמי,

שייתכן ועבר שינויים ע"י המייעל.

אפשרות:ייצוג לינארי )למשל בשיטת הסופיות(•הוראת שלוש כתובות )למשל ע"י רביעיות(•ייצוג ע"י קוד של מכונה וירטואלית )למשל מכונת מחסנית(•(DAGייצוג גרפי )למשל עצי תחביר או •

הנחות:הקוד עבר את כל בדיקות התחביר והמשמעות והוא נכון•הוכנסו בתוכנית כל השינויים הנדרשים ע"י שינויי טיפוסים •

וכדומה


אפשרויות שונותלתוכנית המטרה

תוכנית אבסולוטית בזיכרון1.שימושי למהדרי סטודנטים •

WATFIV, PL/C, COMPAS-PASCALכגון:

שימושי במערכות משובצות מחשב•

( בזיכרוןrelocatableתוכנית הניתנת למיקום מחדש )2.שימושי כאשר מהדרים בחלקים ו/או משתמשים •

בפונקציות ספריה.

תוכנית בשפת סף3.מפשט את תהליך ייצור הקוד•מצריך מעבר נוסף )או שנים( של המאסף•


ניהול הזיכרון

היכן למקם את המשתנים השונים•

כיצד לפנות אליהם•

באיזה שיטות מיעון להשתמש•

כיצד לתרגם את יעדי ההסתעפות•

אחורה–

קדימה–

תרגום לשפת סף מפשט חלק ניכר מהבעיות•


בחירת ההוראותהצעה פשוטה

כל פסוק מהסוגx := y + z

יתורגם להוראות הבאות:mov y, r0add z, r0mov r0, x

בעיההפסוק המקורי

d = b + c + e; הפך לצמד ההוראות:

a := b + cd := a + e

ויתורגם ל:mov b, r0add c, r0mov r0, amov a, r0add e, r0mov r0, d

;a=a+1או ;a += 1או ++; a המקורי:הפסוק

a := a + 1הפכו כולם ל:

inc aבמקום ל: mov a, r0ויתורגמו ל:

add #1, r0

mov r0, a שתי הוראות מיותרות


הקצאת אוגרים בחירת קבוצת המשתנים (register allocationהקצאת אוגרים )1.

שימומשו בתוך אוגרים בכל שלב בתוכנית בחירת האוגר המסוים (register assignmentהשמת אוגרים )2.

שבו נמצא משתנה ברגע נתון

המשמשים (register-pairsצמדי אוגרים )סיבוך נוסף נובע בגלל (:IBM-360לדוגמה ) בד"כ בהוראות כפל וחילוק

,NP-complete מציאת ההשמה האופטימלית לאוגרים היא בעית בעיה:גם כאשר מדובר באוגרים בודדים.

t := a + bt := t ct := t / d

t := a + bt := t + ct := t / d

L R1, aA R1, bM R0, cD R0, dST R1, t

L R0, aA R0, bA R0, c

D R0, dST R1, t

SRDA R0, 32


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

A[x+y] = (B[z+y]+C[t+r]) (D[ws]–E[u/v]);מה כדאי לחשב קודם ?–

אילו פעולות צורכות יותר משאבים )למשל אוגרים( ?–

האם החומרה מבצעת פעולות במקביל או בצינור ?–

גם כאשר לכאורה ברור מה סדר החישוב ה"נכון" ניתן לשנות •אותו ללא שינוי התוצאה

סדר החישוב ישפיע על איכות הקוד וזמן הביצוע•


מכונת המטרהנגדיר מכונת מטרה לצורך ייצור הקוד:

הזיכרון מורכב מבתים, שלכל אחד מהם יש כתובת1.

בתים4מלה הינה בת 2.

.3n :אוגרים כללים r0, r1, . . . rn-1

op src, dest הוראות שתי כתובות:4..1mov, add, sub 'וכו

שיטות5.המיעון:

תוספת עלות

שיטהצורהכתובת

1MMמוחלט0RRאוגר0contents)R(Rאוגר עקיף1c + contents)R(c(R)אינדקס1contents)c+contents)R((c(R)אינדקס עקיףמיידיc#cהקבוע 1


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

וכן את הזמן הנחוץ ע"מ להביא אותה מהזיכרון למעבדבד"כ זמן זה ארוך יותר מזמן הביצוע עצמו

העלות איננה משקפת את הזמן הנוסף הנגרם בשל שיטות •עקיפות

לא הבאנו בחשבון את הזמן הנחוץ להעברת הנתונים עצמם •בין הזיכרון והמעבד

דוגמאות:

הוראהעלות

1 mov r0, r1

2 mov r5, M

2 add #1, r3

3 sub 4(r0), 12(r1)


דוגמה ניתנת לתרגום בדרכים הבאות: a := b + cההוראה

תרגוםעלותהנחות

6 פנויr0אוגר mov b, r0 add c, r0 mov r0, a

---6 mov b, a add c, a

r0 מכיל את כתובתו של ar1 מכיל את כתובתו של br2 מכיל את כתובתו של c

2 mov r1, r0 add r2, r0

r1 מכיל את ערכו של br2 מכיל את ערכו של c

איננו נחוץ r2 ב-bערך יותר

3 add r2, r1 mov r1, a


ניהול הזיכרון בזמן ריצה מסגרות מחסנית

פרוטוקול כניסה ויציאה משגרהproc: mov bp, 2(sp)

…mov ri, di(sp)…mov sp, bpadd #2, bpadd #R+L, sp…; body of

proc…sub #R+L, sp…mov di(sp), ri

…mov 2(sp), bpret

פרוטוקול קריאה לשגרהmov an-1, 2(sp)mov an-2, 4(sp)…mov an-i, 2i(sp) …mov a0, 2n(sp) …add #2n, spcall procsub #2n, sp…mov 2i(sp), ai

…

an-1

an-2

...

a0

return address

saved bpsaved

registerslocalsand

temporaries

המסגרת במחסנית


ניהול הזיכרון בזמן ריצה משתנים סטטיים

משתנה סטטי מוקצה באזור המשתנים הסטטים במרחק מסוים מתחילתוstatic התחלת הרשומה הסטטיתידועה בזמן יצירת הקוד

dispi מרחק המשתנהi מתחילת הרשומה )נמצא בטבלת הסמלים(

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

;x = 0 למשל הפסוק המקורי:

static[dispx] := 0יהפוך ל: mov #0, 112ויתורגם ל:

100 מתחיל ב-staticכאשר

12 הוא dispxו-


ניהול הזיכרון בזמן ריצה משתנים אוטומטים

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

המצביע אליה

bp אוגר העוגן

dispi מרחק המשתנהi)מהעוגן )נמצא בטבלת הסמלים

;x = 0 הפסוק המקורי

t1 := dispx + bp יהפוך ל:

t1 := 0

mov #0, 12(bp)אבל צריך להיות מתורגם ל:

טיפול דומה ניתן למשתנים בשטחי עבודה המוקצים בצורה דינמית12 הוא dispxכאשר


(Basic Blockגוש בסיסי )סדרת הוראות של קוד הביניים (Basic Blockגוש בסיסי )

שהבקרה נכנסת אליה בתחילתה, ועוזבת אותה בסופה בלי לעצור ובלי להסתעף

דוגמה לגושהוראות עצירה והסתעפות:

halt

goto D

if cond goto D

call proc

return

t1 := a at2 := a bt3 := 2 t2

t4 := t1 + t3

t5 := b bt6 := t4 + t5


הגדרה ושימוש, משתנה חי

x := y + zההוראה

x את (definesמגדירה )

z וב-y ב-(usedמשתמשת )

בנקודה מסויימת בגוש בסיסי (liveחי )שם )של משתנה( הינו אם נעשה בו שימוש לאחר אותה נקודה בתוכנית )אולי בגוש

אחר(


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

שיטה: של ההוראות הראשונות של (leadersמובילים )נגדיר קבוצת 1.

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

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

)תלויה או בלתי-תלויה( הינה מוביל הגוש הינו כל ההוראות העוקבות עד למוביל הבא לכל מוביל 2.

או עד סוף התוכנית


דוגמההתוכנית המקורית

beginprod := 0;i := 1;do begin prod := prod +

a[i] b[i]; i := i + 1endwhile i <= 20

end

קוד הביניים1) prod := 02) i := 1

3) t1 := 4 i4) t2 := a [t1] ; compute a[i]

5) t3 := 4 i6) t4 := b [t3] ; compute b[i]

7) t5 := t2 t4

8) t6 := prod + t5

9) prod := t6

10)t7 := i + 1

11)i := t7

12)if i <= 20 goto (3)

הגושים

1 ─ 2

3 ─ 12

13 ─ . . .


טרנספורמציות של גוש בסיסי

גוש בסיסי מחשב ביטויים שונים ושומר את ערכם במקומות •

מסוימים

אם הם מחשבים את (equivalentשקולים )שני גושים ייחשבו •

אותם ביטויים ושומרים אותם באותם מקומות

הסיבות לעריכת שינויים בגוש:•

אילוצי המימוש )חומרה, אוגרים וכו'(–

ייעול הקוד–


טרנספורמציותסוגי ה

טרנספורמציות שומרות מבנה •(structure preserving transformations)

ביטול תת-ביטויים משותפים–ביטול קוד מת–שינוי שמות משתנים זמניים–החלפת סדר הוראות סמוכות–

(algebraic transformationsטרנספורמציות אלגבריות )•


ביטול תת-ביטויים משותפים

)הערכים b+c-d מחשבות את אותו ביטוי: 4 ו-2שורות •המקוריים(

נראות אותו דבר אבל לא מחשבות את אותו ביטוי 3 ו-1שורות •2 משתנה בשורה bמפני ש-

a := b + c

b := a – d

c := b + c

d := b

a := b + c

b := a – d

c := b + c

d := a - d


ביטול קוד מת

כל הוראה המגדירה שם שאיננו חי – ניתן לבטלה

x := y + zלדוגמה

לאחר xכאשר לא נעשה שימוש ב-מכן


שינוי שמות משתנים זמניים

הינו משתנה זמניtבהנחה ש-

t := b + cההוראה

u := b + cניתנת להחלפה בהוראה

. במקומוu נרשום tאם בכל מקום שמשתמשים להלן בערך

תמיד ניתן להחליף כל גוש בגוש בסיסי שקול שבו כל הוראה • מגדירה משתנה זמני חדשהמגדירה משתנה זמני

(normal-formצורה נורמלית )מ גוש מהצורה זו נקרא גוש•


החלפת סדר הוראות סמוכות

שתי ההוראות הסמוכות:

t1 := b + c

t2 := x + y

ניתנות להחלפה ביניהן בלי להשפיע על התוצאה אם ורק אם:–t1 איננו לא x ולא y

–t2 איננו לא b ולא c

בגוש מצורה נורמלית ניתן לבצע את כל ההחלפות האפשריות


טרנספורמציות אלגבריות

x := x + 0ניתן לבטל הוראות כגון:

x := x 1

x := y 2ניתן להחליף הוראה כגון: x := y y בהוראה:

מפני שפעולת חזקה דורשת בד"כ קריאה לשגרה

יותר על הנושא בפרק האופטימיזציה


(Flow Graphגרף זרימה )גושים בסיסיםצמתים:•מעברים בין גושים בסיסיםקשתות:•:B2 יכול להתבצע מעבר לגוש B1 אם בסוף גוש B2 וגוש B1קיימת קשת בין גוש •

B2 ל-B1קיימת הסתעפות )תלויה או בלתי-תלויה( בסוף –

–B2 מופיע בקוד מיד לאחר B1-ו ,B1איננו מסתיים בהסתעפות בלתי תלויה •B1 הינו ( קודםpredecessor)-ל B2

•B2 הינו ( עוקבsuccessor)-ל B1

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

–jmp (r1) או ret


דוגמה לגרף הזרימה

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

prod := 0i := 1

t1 := 4 it2 := a [ t1 ]t3 := 4 it4 := b [ t3 ]t5 := t2 t4

t6 := prod + t5

prod := t6

t7 := i + 1i := t7

if i <= 20 goto B2

B1

B2


(Loopsלולאות ) תת-קבוצה של צמתים בגרף הזרימה העומד (loopלולאה )

בתנאים הבאים:

כלומר (strongly connectedקשורים היטב ) כל הצמתים1.

קיים מסלול באורך כלשהו מכל צומת לכל צומת בתת-קבוצה

כלומר רק לצומת יחידה (entryכניסה ) יש לתת-הקבוצה2.

אחד בתת-קבוצה יש קשת הנכנסת אליו מצומת שאיננו שייך

לתת-קבוצה )או אפילו מספר קשתות כאלה(


(Next Useהשימוש הבא )x מציבה ערך למשתנה kהוראה אם:

x משתמשת ב-jהוראה

x שאיננו מציב ערך חדש ל-j להוראה kיש מעבר בין הוראה

k שחשבה הוראה xבערך ( uses משתמשת )jהוראה אזי:

בעזרת אנליזה גלובלית )בפרק הבא( ניתן לוודא אילו משתנים •

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

אם לא בוצעה אנליזה גלובלית יש להניח הנחות מחמירות •

לבי השימוש האפשרי במשתנים )נראה להלן(


השימוש הבאחישוב

בתוך הבלוק ניתן ללכת מסופו לתחילתו ולסמן את השימוש של •

כל משתנה בטבלת הסמלים נבצע x:= y op z שהיא:i כאשר אנו מגיעים להוראה•

כדלקמן:

את המידע הקיים בטבלת הסמלים בנוגע iצרף להוראה 1.z ו-x, yלשימוש הבא ולחיּות של

כ "לא חי" ו-"חסר שימוש הבא"xסמן בטבלה את 2.

כ "חי" וה-"שימוש הבא" שלהם הינו z ו-yסמן בטבלה את 3.z או y עצמו עשוי להיות xמאחר ו-הערה: iהוראה

3 ו-2אסור להחליף את סדר הפעולות


השימוש הבאאיתחול

נתחיל את האלגוריתם )כשאנו עומדים בסוף הגוש( כדלקמן:

אם יש אנליזה גלובלית, היא קובעת איזה משתנים חיים ואיזה •

לא

אם אין אנליזה גלובלית נניח כי בסוף הגוש כל המשתנים •

הקבועים חיים

אם מותרת העברת ערכים מגוש לגוש במשתנים זמניים נסמן •

משתנים אלה בשמות מיוחדים ונניח כי הם חיים בסוף הגוש

כל שאר המשתנים הזמניים מתים בסוף הגוש•


שימוש זמני באוגריםכדאי להשאיר ערכים מחושבים בתוך אוגרים ע"מ שניתן יהיה •

להשתמש בהם שוב, ורק בסוף הגוש לשמור את כל הערכים במקומם הסופי

ניתן לתרגם במספר אופנים:a := b + cאת ההוראה •

תרגוםעלותהנחות

rj מכיל את cri מכיל את bbאיננו חי לאחר הוראה זו

המחושב )הנמצא כעת aנעשה שימוש בערך (riב-

1add rj, ri

rj איננו מכיל את cוהשאר כנ"ל

2add c, ri

rj איננו מכיל את ccנעשה שימוש נוסף בערכו של

והשאר כנ"ל3

mov c, rj

add rj, ri


(Descriptorsמתארים ) שומר מעקב על ערכו הנוכחי של אוגר מתאר אוגר•

מתייעצים בו כשמחפשים אוגר פנוי–מאותחל ל-"ריק"–

שומר מעקב אחר המקום )או המקומות( מתאר כתובת•שבהם נמצא ערך של שם מסוים, כגון:

אוגר–מקום במחסנית–כתובת בזיכרון–

ערך יכול להימצא במספר מקומות בגין העתקה


אלגוריתם ליצירת קוד תתורגם ע"י:x := y op zההוראה

שבו תישמר תוצאת L ע"מ לקבל מקום getregקרא לשגרה 1.y op zהחישוב:

L יהיה מקום במחסנית דוחקיהיה בד"כ אוגר אבל במקרה של או בזיכרון

שהינו המקום ’y ומצא את yהיוועץ במתאר הכתובת של 2.yהעדיף למשיכת ערכו של

העדף אוגר ע"פ מקום בזיכרון mov ייצר את ההוראה: L אינו נמצא כבר ב-yאם ערכו של

y’,L


2אלגוריתם ליצירת קוד כנ"ל’z ומצא את zהיוועץ במתאר הכתובת של 3.

op z’, Lייצר את ההוראה: L נמצא ב-x לציין ש-xעדכן את מתאר הכתובת של

לציין שהוא מכיל L הינו אוגר עדכן את מתאר האוגר של Lאם xאת

מכל שאר מתארי האוגריםxמחק את

אין שימוש נוסף, אינם חיים z ו/או yאם לערכים הנוכחים 4.ביציאה מהגוש, והם בתוך אוגרים –

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

מקבלת טיפול דומה x := op yהוראה של פעולה אונרית 5.(z)למעט הנגיעה ב-


תרגום הוראות השמה מקבלת טיפול מיוחד:x := yהוראת השמה

x הינו אוגר, נשנה את מתאר האוגר לציין שהוא מכיל גם את yכאשר • לציין שערכו באוגר הזהxואת מתאר הכתובת של

אין שימוש נוסף ואיננו חי ביציאה מהגוש, סמן כי האוגר איננו yאם ל-yמחזיק יותר את

, x הינו מקום בזיכרון ניתן היה לסמן שהמקום מחזיק גם את yכאשר • אח"כ.yאבל זה יסבך את האלגוריתם במקרה ונרצה לשנות את

mov y’,L לקבל אוגר ונייצר את ההוראה: getregלכן, נפעיל את ( x אינו מוצא מקום )או מלכתחילה אם אין שימוש נוסף ב-getregאם

mov y’,xנייצר במקום זאת את ההוראה:


סיום הגושבסוף הגוש יש לייצר הוראות ע"מ לשמור את כל הערכים

המוחזקים רק באוגרים חזרה למקומם בזיכרון

:rkלכל אוגר •

היוועץ במתאר האוגר

המוחזק באוגרvj לכל שם

בזיכרון vj אם הערך איננו נמצא גם במקום של

mov rk, vjייצר את ההוראה:


getregהשגרה נשתמש בסכימה פשוטה וקלה למימוש המטרה:

x := y op z לחישוב ההוראה Lמציאת מקום

נמצא באוגר שאיננו מכיל שמות נוספים )ע"פ המתאר y אם:1. איננו חי,y שלו(,

לאחר ההוראה הזאתy אין שימוש נוסף ב-לציין שהוא איננו יותר באוגר הזה y עדכן את מתאר הכתובת של

L החזר את האוגר הזה בתור

L נכשל, מצא אוגר פנוי והחזר אותו בתור 1כאשר 2.


getreg 2השגרה נכשל,2כאשר 3.

הינה הוראת op יש שימוש נוסף בגוש או לחילופין xאם ל-אינדקס הדורשת אוגר

Rאתר אוגר תפוס –אין אסטרטגיה מנצחת באיזה אוגר לבחור•ניתן להעדיף אוגר שהערכים השמורים בו נמצאים גם •

במקומם בזיכרון ואין צורך "לנקות" אותוניתן להעדיף אוגר שהשימוש בערך שלו נמצא הכי רחוק •

קדימהשיקולים דומים לשיקולי ניהול זכרון מטמון וזיכרון מדומה•


getreg 3השגרה Rרוקן את האוגר –

ע"פ מתאר האוגר ומתארי הכתובות ייצר הוראת• mov R, vj

השמור באוגר ואיננו שמור במקומו בזיכרוןvjלכל שם

vjעדכן את מתאר הכתובת •

Rרוקן את מתאר האוגר •

בגוש או שאיננו יכול לשכון באוגר,xאם אין שימוש ב-•L והחזר אותו בתור xבחר מקום בזיכרון עבור


דוגמה;d = (a-b) + (a-c) + (a-c) הפסוק:

t := a – b יתורגם להוראות שלוש כתובות:u := a – cv := t + ud := v + u

האלג' שלנויפעל כדלקמן:

3הוראות כתובות

הקודהנוצר

מתאריאוגרים

מתארי כתובות

registers empty

t := a – bmov a, R0sub b, R0

R0 contains tt in R0

u := a – cmov a, R1sub c, R1

R0 contains tR1 contains u

t in R0u in R1

v := t + uadd R1, R0R0 contains vR1 contains u

u in R1v in R0

d := v + uadd R1, R0mov R0, d

R0 contains dd in R0d in R0and memory

חי בסוף הקטע.dכאשר רק


המשךדוגמה הערות:

הינם בזיכרון a ,b ,cלא ציינו את מתארי הכתובות המראים כי •

כל הזמן

בהיותם זמניים אינם בזיכרון אלא אם שמרנו t ,v ,uהנחנו כי •

movאותם במפורש ע"י הוראה

mov r0,r1אלגוריתם מתוחכם יותר היה מייצר הוראת •

aבמקום השני במקום ההוראה השלישית המעתיקה שוב את

מהזיכרון


תרגום הוראות אינדקס ומצביעים

Statementi in Register Rii in Memory Mii in Stack

CodeCostCodeCostCodeCost

a := b[i]mov b(Ri),R2mov Mi,Rmov b(R),R

4mov Si(A),Rmov b(R),R

4

a[i] := bmov b,a(Ri)3mov Mi,Rmov b,a(R)

5mov Si(A),Rmov b,a(R)

5

Statementp in Register Rpp in Memory Mpp in Stack

CodeCostCodeCostCodeCost

a := pmov Rp,a2mov Mp,Rmov R,R

3mov Sp(A),Rmov R,R

3

p := amov a,Rp2mov Mp,Rmov a,R

4mov a,Rmov R,Sp(A)

4


תרגום הוראותהסתעפות מותנית

if x < y goto zלתרגם את ההוראה המטרה:bcond R,D ( שבהן יש הוראות MIPSישנן מכונות )כגון •

כאשר–cond :הינו אחד מאלה gt,ge,ne,eq,le,lt–Rהינו אוגר שאת תוכנו משווים לאפס –Dיעד הקפיצה

נתרגם את הוראת הקפיצה ע"י:

mov x, ri

sub y, ri

blt ri, z


2תרגום הוראות הסתעפות Condition Codesישנן מכונות בהם יש סיביות מיוחדות – •

( שבהם נשמרים מאפייני התוצאות של הוראות שונות, PDP-11)כגון cmp A,Bובהן הוראות:

bcond D קיימות גם הוראות:

cmp x,y נתרגם ע"י:blt D

ולשמור את הערך האחרון שהשפיע עליהם.CCכדאי לבנות מתארי – }. . . {if ( y+z < 0 )אזי הפסוק המקורי:

t := y + z שהפך ל:if t < 0 goto D

mov y, riיתורגם ל:

add z, ri

blt D


9תום פרק

פרק 9 יצירת קוד

Documents