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

1. פרק 9 יצירת קוד תורת הקומפילציה

2. ניתוח (analysis) מנתח לקסיקאלי lexical analyser מנתח תחבירsyntax analyser מנתח משמעות semantic analyser מייצר קוד בינייםintermediate code generator מייעל קוד code optimizer חיבור (synthesis) מייצר קוד code generator יצירת קוד מייצר קוד code generator תורת הקומפילציה

3. מיקום מייצר הקודבצינור המהדר הצד הקדמי מייעל הקוד מייצר הקוד תוכנית המקור קוד ביניים קוד ביניים תוכנית המטרה טבלת הסמלים תורת הקומפילציה

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

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

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

7. אפשרויות שונותלתוכנית המטרה • תוכנית אבסולוטית בזיכרון • שימושי למהדרי סטודנטים כגון: WATFIV, PL/C, COMPAS-PASCAL • שימושי במערכות משובצות מחשב • תוכנית הניתנת למיקום מחדש (relocatable) בזיכרון • שימושי כאשר מהדרים בחלקים ו/או משתמשים בפונקציות ספריה. • תוכנית בשפת סף • מפשט את תהליך ייצור הקוד • מצריך מעבר נוסף (או שנים) של המאסף תורת הקומפילציה

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

9. בחירת ההוראות בעיה הפסוק המקורי d = b + c + e ; הפך לצמד ההוראות: a := b + c d := a + e ויתורגם ל: mov b, r0 add c, r0 mov r0, a mov a, r0 add e, r0 mov r0, d הצעה פשוטה כל פסוק מהסוג x := y + z יתורגם להוראות הבאות: mov y, r0 add z, r0 mov r0, x הפסוק המקורי:a++;אוa+=1;או a=a+1; הפכו כולם ל: a := a + 1 ויתורגמו ל: mov a, r0 במקום ל: inc a add #1, r0 mov r0, a שתי הוראות מיותרות תורת הקומפילציה

10. הקצאת אוגרים • הקצאת אוגרים (register allocation) בחירת קבוצת המשתנים שימומשו בתוך אוגרים בכל שלב בתוכנית • השמת אוגרים (register assignment) בחירת האוגר המסוים שבו נמצא משתנה ברגע נתון סיבוך נוסף נובע בגלל צמדי אוגרים (register-pairs) המשמשים בד"כ בהוראות כפל וחילוקלדוגמה (IBM-360): בעיה: מציאת ההשמה האופטימלית לאוגרים היא בעית NP-complete, גם כאשר מדובר באוגרים בודדים. t := a + b L R1, a t := a + b L R0, a t := t  c A R1, b t := t + c A R0, b t := t / d M R0, c t := t / d A R0, c D R0, d SRDA R0, 32 ST R1, t D R0, d ST R1, t תורת הקומפילציה

11. בחירת סדר החישוב • סדר החישוב אינו מוגדר תמיד על ידי השפה: A[x+y] = (B[z+y]+C[t+r])  (D[ws]–E[u/v]); • מה כדאי לחשב קודם ? • אילו פעולות צורכות יותר משאבים (למשל אוגרים) ? • האם החומרה מבצעת פעולות במקביל או בצינור ? • גם כאשר לכאורה ברור מה סדר החישוב ה"נכון" ניתן לשנות אותו ללא שינוי התוצאה • סדר החישוב ישפיע על איכות הקוד וזמן הביצוע תורת הקומפילציה

12. מכונת המטרה נגדיר מכונת מטרה לצורך ייצור הקוד: • הזיכרון מורכב מבתים, שלכל אחד מהם יש כתובת • מלה הינה בת 4 בתים • nאוגרים כללים:r0, r1, . . . rn-1 • הוראות שתי כתובות:op src, dest • mov, add, subוכו' • שיטותהמיעון: תורת הקומפילציה

13. עלות הוראה • עלות ההוראה הינה 1 + העלויות הנוספות בגין שיטות המיעון • עלות זו משקפת את כמות הזיכרון הנחוצה להוראה,וכן את הזמן הנחוץ ע"מ להביא אותה מהזיכרון למעבדבד"כ זמן זה ארוך יותר מזמן הביצוע עצמו • העלות איננה משקפת את הזמן הנוסף הנגרם בשל שיטות עקיפות • לא הבאנו בחשבון את הזמן הנחוץ להעברת הנתונים עצמם בין הזיכרון והמעבד דוגמאות: תורת הקומפילציה

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

15. ניהול הזיכרון בזמן ריצה מסגרות מחסנית פרוטוקול קריאה לשגרה mov an-1, 2(sp) mov an-2, 4(sp) … mov an-i, 2i(sp) … mov a0, 2n(sp) … add #2n, sp call proc sub #2n, sp … mov 2i(sp), ai … פרוטוקול כניסה ויציאה משגרה proc: mov bp, 2(sp) … mov ri, di(sp) … mov sp, bp add #2, bp add #R+L, sp … ; body of proc … sub #R+L, sp … mov di(sp), ri … mov 2(sp), bp ret המסגרת במחסנית an-1 an-2 ... a0 return address saved bp saved registers locals and temporaries תורת הקומפילציה

16. ניהול הזיכרון בזמן ריצה משתנים סטטיים משתנה סטטי מוקצה באזור המשתנים הסטטים במרחק מסוים מתחילתו staticהתחלת הרשומה הסטטית  ידועה בזמן יצירת הקוד dispiמרחק המשתנה i מתחילת הרשומה (נמצא בטבלת הסמלים) על מנת לשמור על פורטביליות ייתכן שהגישה תירשם כגישת אינדקס בקוד הביניים. למשל הפסוק המקורי:x = 0; יהפוך ל:static[dispx] := 0 ויתורגם ל:mov #0, 112 כאשר static מתחיל ב-100 ו-dispx הוא 12 תורת הקומפילציה

17. ניהול הזיכרון בזמן ריצה משתנים אוטומטים משתנים אוטומטים ופרמטרים המועברים במחסנית נמצאים ברשומת ההפעלה שבמחסנית, במרחק מסוים מהעוגן המצביע אליה bpאוגר העוגן dispiמרחק המשתנה i מהעוגן (נמצא בטבלת הסמלים) הפסוק המקורי x=0; יהפוך ל:t1:=dispx+bp t1:=0 אבל צריך להיות מתורגם ל:mov #0, 12(bp) כאשר dispx הוא 12 טיפול דומה ניתן למשתנים בשטחי עבודה המוקצים בצורה דינמית תורת הקומפילציה

18. גוש בסיסי (Basic Block) גוש בסיסי (Basic Block) סדרת הוראות של קוד הבינייםשהבקרה נכנסת אליה בתחילתה, ועוזבת אותה בסופה בלי לעצור ובלי להסתעף הוראות עצירה והסתעפות:דוגמה לגוש halt goto D if cond goto D call proc return t1 := a a t2 := a b t3 := 2 t2 t4 := t1+ t3 t5 := b b t6 := t4+ t5 תורת הקומפילציה

19. הגדרה ושימוש, משתנה חי ההוראה x := y + z מגדירה (defines) את x משתמשת (used) ב-y וב-z שם (של משתנה) הינו חי (live) בנקודה מסויימת בגוש בסיסי אם נעשה בו שימוש לאחר אותה נקודה בתוכנית (אולי בגוש אחר) תורת הקומפילציה

20. אלגוריתם ליצירת גושים קלט:סדרת הוראות שלוש כתובות פלט:רשימת הגושים כך שכל הוראה משתייכת לגוש אחד בדיוק שיטה: • נגדיר קבוצת מובילים (leaders) של ההוראות הראשונות של כל גוש:א. ההוראה הראשונה בסדרה הינה מובילב. כל הוראה שהינה הייעד של קפיצה או הסתעפות (תלויה או בלתי-תלויה) הינה מובילג. כל הוראה הנמצאת מיד לאחר הוראת קפיצה או הסתעפות (תלויה או בלתי-תלויה) הינה מוביל • לכל מוביל  הגוש הינו כל ההוראות העוקבות עד למוביל הבא או עד סוף התוכנית תורת הקומפילציה

21. דוגמה התוכנית המקורית begin prod := 0; i := 1; do begin prod := prod + a[i]  b[i]; i := i + 1 end while i <= 20 end קוד הביניים • prod := 0 • i := 1 • t1 := 4  i • t2 := a [t1] ;computea[i] • t3 := 4  i • t4 := b [t3]; computeb[i] • t5 := t2  t4 • t6 := prod + t5 • prod := t6 • t7 := i + 1 • i := t7 • if i <= 20 goto (3) הגושים 1 ─ 2 3 ─ 12 13 ─ . . . תורת הקומפילציה

22. טרנספורמציות של גוש בסיסי • גוש בסיסי מחשב ביטויים שונים ושומר את ערכם במקומות מסוימים • שני גושים ייחשבו שקולים (equivalent) אם הם מחשבים את אותם ביטויים ושומרים אותם באותם מקומות • הסיבות לעריכת שינויים בגוש: • אילוצי המימוש (חומרה, אוגרים וכו') • ייעול הקוד תורת הקומפילציה

23. סוגי הטרנספורמציות • טרנספורמציות שומרות מבנה (structure preserving transformations) • ביטול תת-ביטויים משותפים • ביטול קוד מת • שינוי שמות משתנים זמניים • החלפת סדר הוראות סמוכות • טרנספורמציות אלגבריות (algebraic transformations) תורת הקומפילציה

24. ביטול תת-ביטויים משותפים • שורות 2 ו-4 מחשבות את אותו ביטוי: b+c-d (הערכים המקוריים) • שורות 1 ו-3 נראות אותו דבר אבל לא מחשבות את אותו ביטוי מפני ש-b משתנה בשורה 2 a := b + c b := a – d c := b + c d := a - d a := b + c b := a – d c := b + c d := b תורת הקומפילציה

25. ביטול קוד מת כל הוראה המגדירה שם שאיננו חי – ניתן לבטלה לדוגמה x := y + z כאשר לא נעשה שימוש ב-x לאחר מכן תורת הקומפילציה

26. שינוי שמות משתנים זמניים בהנחה ש- t הינו משתנה זמני ההוראה t := b + c ניתנת להחלפה בהוראה u := b + c אם בכל מקום שמשתמשים להלן בערך t נרשום u במקומו. • תמיד ניתן להחליף כל גוש בגוש בסיסי שקול שבו כל הוראה המגדירה משתנה זמני  מגדירה משתנה זמני חדש • גוש מהצורה זו נקרא גושמצורה נורמלית (normal-form) תורת הקומפילציה

27. החלפת סדר הוראות סמוכות שתי ההוראות הסמוכות: t1 := b + c t2 := x + y ניתנות להחלפה ביניהן בלי להשפיע על התוצאה אם ורק אם: • t1 איננו לא xולא y • t2 איננו לא b ולא c בגוש מצורה נורמלית ניתן לבצע את כל ההחלפות האפשריות תורת הקומפילציה

28. טרנספורמציות אלגבריות ניתן לבטל הוראות כגון: x := x + 0 x := x  1 ניתן להחליף הוראה כגון: x := y  2 בהוראה:x := y  y מפני שפעולת חזקה דורשת בד"כ קריאה לשגרה יותר על הנושא בפרק האופטימיזציה תורת הקומפילציה

29. גרף זרימה (Flow Graph) • צמתים:גושים בסיסים • קשתות:מעברים בין גושים בסיסים • קיימת קשת בין גוש B1 וגוש B2 אם בסוף גוש B1 יכול להתבצע מעבר לגוש B2: • קיימת הסתעפות (תלויה או בלתי-תלויה) בסוף B1 ל-B2 • B2 מופיע בקוד מיד לאחר B1, ו-B1 איננו מסתיים בהסתעפות בלתי תלויה • B1 הינו קודם (predecessor) ל-B2 • B2 הינו עוקב (successor) ל-B1 • לגוש יכולים להיות הרבה קודמים • לגוש המסתיים ללא הסתעפות יש עוקב יחיד • לגוש המסתיים בהסתעפות בלתי-מותנית וישירה יש עוקב יחיד • לגוש המסתיים בהסתעפות מותנית ישירה יש שני עוקבים • לגוש המסתיים בקפיצה עקיפה יש הרבה עוקבים • jmp (r1)אוret תורת הקומפילציה

30. דוגמה לגרף הזרימה prod := 0 i := 1 B1 t1 := 4  i t2 := a [ t1 ] t3 := 4  i t4 := b [ t3 ] t5 := t2  t4 t6 := prod + t5 prod := t6 t7 := i + 1 i := t7 if i <= 20 goto B2 B2 הערה: יעדי הוראות הקפיצה הם כעת גושים במקום הוראות תורת הקומפילציה

31. לולאות (Loops) לולאה (loop) תת-קבוצה של צמתים בגרף הזרימה העומד בתנאים הבאים: • כל הצמתיםקשורים היטב (strongly connected) כלומר קיים מסלול באורך כלשהו מכל צומת לכל צומת בתת-קבוצה • יש לתת-הקבוצהכניסה (entry)יחידה  כלומר רק לצומת אחד בתת-קבוצה יש קשת הנכנסת אליו מצומת שאיננו שייך לתת-קבוצה (או אפילו מספר קשתות כאלה) תורת הקומפילציה

32. השימוש הבא (Next Use) אם: הוראה k מציבה ערך למשתנה x הוראה j משתמשת ב-x יש מעבר בין הוראה k להוראה j שאיננו מציב ערך חדש ל-x אזי: הוראה j משתמשת (uses) בערך x שחשבה הוראה k • בעזרת אנליזה גלובלית (בפרק הבא) ניתן לוודא אילו משתנים חיים בסוף הבלוק ובאילו משתנים נעשה שימוש מאוחר יותר • אם לא בוצעה אנליזה גלובלית יש להניח הנחות מחמירות לבי השימוש האפשרי במשתנים (נראה להלן) תורת הקומפילציה

33. חישוב השימוש הבא • בתוך הבלוק ניתן ללכת מסופו לתחילתו ולסמן את השימוש של כל משתנה בטבלת הסמלים • כאשר אנו מגיעים להוראהi שהיא:x:= y op z נבצע כדלקמן: • צרף להוראה i את המידע הקיים בטבלת הסמלים בנוגע לשימוש הבא ולחיוּת של x, y ו-z • סמן בטבלה את x כ "לא חי" ו-"חסר שימוש הבא" • סמן בטבלה את y ו-z כ "חי" וה-"שימוש הבא" שלהם הינו הוראה i הערה: מאחר ו-x עצמו עשוי להיות y או z אסור להחליף את סדר הפעולות 2 ו-3 תורת הקומפילציה

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

35. שימוש זמני באוגרים • כדאי להשאיר ערכים מחושבים בתוך אוגרים ע"מ שניתן יהיה להשתמש בהם שוב, ורק בסוף הגוש לשמור את כל הערכים במקומם הסופי • את ההוראה a := b + c ניתן לתרגם במספר אופנים: תורת הקומפילציה

36. מתארים (Descriptors) • מתאר אוגר שומר מעקב על ערכו הנוכחי של אוגר • מתייעצים בו כשמחפשים אוגר פנוי • מאותחל ל-"ריק" • מתאר כתובת שומר מעקב אחר המקום (או המקומות) שבהם נמצא ערך של שם מסוים, כגון: • אוגר • מקום במחסנית • כתובת בזיכרון ערך יכול להימצא במספר מקומות בגין העתקה תורת הקומפילציה

37. אלגוריתם ליצירת קוד ההוראה x := y op z תתורגם ע"י: • קרא לשגרה getreg ע"מ לקבל מקום L שבו תישמר תוצאת החישוב: y op zLיהיה בד"כ אוגר אבל במקרה של דוחק יהיה מקום במחסנית או בזיכרון • היוועץ במתאר הכתובת של y ומצא את y’ שהינו המקום העדיף למשיכת ערכו של yהעדף אוגר ע"פ מקום בזיכרון אם ערכו של y אינו נמצא כבר ב-L ייצר את ההוראה: mov y’,L תורת הקומפילציה

38. אלגוריתם ליצירת קוד  2 • היוועץ במתאר הכתובת של z ומצא את z’ כנ"לייצר את ההוראה: op z’, Lעדכן את מתאר הכתובת של x לציין ש-x נמצא ב-Lאם L הינו אוגר עדכן את מתאר האוגר של L לציין שהוא מכיל את xמחק את x מכל שאר מתארי האוגרים • אם לערכים הנוכחים y ו/או z אין שימוש נוסף, אינם חיים ביציאה מהגוש, והם בתוך אוגרים –שחרר את האוגרים הללו ע"י ריקון המתארים שלהם • הוראה של פעולה אונרית x := op y מקבלת טיפול דומה (למעט הנגיעה ב-z) תורת הקומפילציה

39. תרגום הוראות השמה הוראת השמה x := y מקבלת טיפול מיוחד: • כאשר y הינו אוגר, נשנה את מתאר האוגר לציין שהוא מכיל גם את x ואת מתאר הכתובת של x לציין שערכו באוגר הזהאם ל-y אין שימוש נוסף ואיננו חי ביציאה מהגוש, סמן כי האוגר איננו מחזיק יותר את y • כאשר y הינו מקום בזיכרון ניתן היה לסמן שהמקום מחזיק גם את x, אבל זה יסבך את האלגוריתם במקרה ונרצה לשנות את yאח"כ.לכן, נפעיל את getreg לקבל אוגר ונייצר את ההוראה: mov y’,Lאם getreg אינו מוצא מקום (או מלכתחילה אם אין שימוש נוסף ב-x) נייצר במקום זאת את ההוראה: mov y’,x תורת הקומפילציה

40. סיום הגוש בסוף הגוש יש לייצר הוראות ע"מ לשמור את כל הערכים המוחזקים רק באוגרים חזרה למקומם בזיכרון • לכל אוגר rk : היוועץ במתאר האוגר לכל שם vj המוחזק באוגר אם הערך איננו נמצא גם במקום של vj בזיכרון ייצר את ההוראה: mov rk, vj תורת הקומפילציה

41. השגרה getreg נשתמש בסכימה פשוטה וקלה למימוש המטרה:מציאת מקום L לחישוב ההוראה x := y op z • אם: y נמצא באוגר שאיננו מכיל שמות נוספים (ע"פ המתאר שלו), y איננו חי, אין שימוש נוסף ב-y לאחר ההוראה הזאתעדכן את מתאר הכתובת שלyלציין שהוא איננו יותר באוגר הזההחזר את האוגר הזה בתורL • כאשר 1 נכשל, מצא אוגר פנוי והחזר אותו בתור L תורת הקומפילציה

42. השגרה getreg 2 • כאשר 2 נכשל,אם ל-x יש שימוש נוסף בגוש או לחילופין op הינה הוראת אינדקס הדורשת אוגר • אתר אוגר תפוס R • אין אסטרטגיה מנצחת באיזה אוגר לבחור • ניתן להעדיף אוגר שהערכים השמורים בו נמצאים גם במקומם בזיכרון ואין צורך "לנקות" אותו • ניתן להעדיף אוגר שהשימוש בערך שלו נמצא הכי רחוק קדימה • שיקולים דומים לשיקולי ניהול זכרון מטמון וזיכרון מדומה תורת הקומפילציה

43. השגרה getreg 3 • רוקן את האוגר R • ע"פ מתאר האוגר ומתארי הכתובות ייצר הוראתmov R, vjלכל שם vj השמור באוגר ואיננו שמור במקומו בזיכרון • עדכן את מתאר הכתובת vj • רוקן את מתאר האוגר R • אם אין שימוש ב-x בגוש או שאיננו יכול לשכון באוגר,בחר מקום בזיכרון עבור x והחזר אותו בתור L תורת הקומפילציה

44. דוגמה הפסוק: d = (a-b) + (a-c) + (a-c); יתורגם להוראות שלוש כתובות: t := a – b u := a – c v := t + u d := v + u האלג' שלנו יפעל כדלקמן: כאשר רק d חי בסוף הקטע. תורת הקומפילציה

45. דוגמה  המשך הערות: • לא ציינו את מתארי הכתובות המראים כי a ,b ,c הינם בזיכרון כל הזמן • הנחנו כי t ,v ,u בהיותם זמניים אינם בזיכרון אלא אם שמרנו אותם במפורש ע"י הוראה mov • אלגוריתם מתוחכם יותר היה מייצר הוראת mov r0,r1 במקום השני במקום ההוראה השלישית המעתיקה שוב את a מהזיכרון תורת הקומפילציה

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

47. תרגום הוראותהסתעפות מותנית המטרה: לתרגם את ההוראה if x < y goto z • ישנן מכונות (כגון MIPS) שבהן יש הוראותbcond R,Dכאשר • condהינו אחד מאלה: gt,ge,ne,eq,le,lt • R הינו אוגר שאת תוכנו משווים לאפס • D יעד הקפיצה נתרגם את הוראת הקפיצה ע"י: mov x, ri sub y, ri blt ri, z תורת הקומפילציה

48. תרגום הוראות הסתעפות  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 תורת הקומפילציה

49. תום פרק 9 תורת הקומפילציה