שפות ביניים

1. שפות ביניים Aho, Sethi and Ullman – Ch. 8

2. יצירת קוד ביניים syntax analysis syntax tree semantic analysis decorated syntax tree intermediate code generator intermediate code machine independent optimizations intermediate code code generator

3. חשיבות קוד הביניים • אפשרות ליצר קוד עבור מכונות שונות באמצעות אותו front end • שימוש בשיטות אופטימיזציה שאינן תלויות במכונה הספציפית • שימוש באותו back end עבור שפות שונות

4. ייצוג ביניים – intermediate representation • ייצוגים אפשריים • syntax tree • postfix notation • three address code • נתקדם בשלבים • תרגום מונחה דקדוק ליצירת עץ הניתוח התחבירי + סימונים בצמתים • את העץ נתרגם ל- three address code • הערה – לפעמים נשתמש ב- DAG במקום בעץ

5. decorated syntax trees / DAGs • נתון: a := b * – c + b * – c • ייצוג כ- DAG • ייצוג כעץ • ייצוג ב- postfix a b c uminus * b c uminus * + assign

6. תרגום מונחה דקדוק ליצירת עץ מעוטר • פונקציות עזר • mkleaf – יצירת עלה • mkunode – יצירת צומת חדש עבור אופרטור אונרי • mknode – יצירת צומת חדש עבור אופרטור בינארי • id.place – מצביע לטבלת הסמלים • הערה – אפשר להחליף את mkleaf, mkunode, ו- mknode בפונקציות המחזירות מצביע לצמתים קיימים על מנת ליצור DAG

7. assign * * id a id id b b +   uminus uminus     id id c c   ייצוג בזיכרון של עץ מעוטר

8. אופרטור ↑ ↑ ↑ 3 הכתובות three address code • הצורה הכללית x := y op z • x, y, ו-z הם שמות, קבועים, או משתנים זמניים שנוצרו ע"י הקומפיילר • op הוא אופרטור כלשהו • אין פעולות מורכבות

9. assign assign a + a + * * * b unimus b unimus b unimus c c c t1 := – c t1 := – c t2 := b * t1 t2 := b * t1 t3 := – c t3 := t2 + t2 t4 := b * t3 a := t3 t5 := t2 +t4 a := t5 three address code

10. קוד ביניים – סוגי המשפטים relop = relational op (==, >=, etc.) n = actual number of parameters הבחירה של סט פקודות מתאים היא חשובה. סט מצומצם יקל על ייצור הקוד, אך הקוד יהיה פחות יעיל, ומעמסה גדולה יותר תיפול על ה- optimizer

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

12. יצירת קוד ביניים בעל 3 כתובות על ידי תרגום מונחה דקדוק השיטה – שימוש במשתנים זמניים • S.code – תכונה המכילה את הקוד הנוצר עבור S • E.code – הקוד הנוצר עבור E • E.place – שם של משתנה שעתיד להכיל את הערך של E • newtemp – פונקציה המחזירה שם של משתנה חדש

13. יצירת קוד ביניים בעל 3 כתובות על ידי תרגום מונחה דקדוק

14. production semantic rule S →while E do S1 S.begin := newlable ; S.after := newlabel ; S.code := gen ( S.begin ' : ' ) || E.code || gen ( ' if ' E.place ' = '' 0 '' goto ' S.after ) || S1.code || gen ( ' goto ' S.begin ) || gen (S.after ' : ' ) יצירת קוד ביניים בעל 3 כתובות על ידי תרגום מונחה דקדוק • newlabel– פונקציה היוצרת תווית חדשה • S.begin – תווית המסמנת את תחילת הקוד • S.after – תווית המסמנת את סוף הקוד • 0 – מייצג את false האם באמת קופצים לקוד שאחרי ה-while?

15. ↑ ↑ ↑ מצביעים לטבלת הסמלים op arg 1 arg 2 result (0) uminus c t1 (1) * b t1 t2 (2) uminus c t3 (3) * b t3 t4 (4) + t2 t4 t5 (5) =: t5 a מימוש של קוד בעל 3 כתובות • רביעיות op, arg1, arg2, result • חסרון – temporaries נמצאים בטבלת הסמלים

16. ↑ ↑ op arg 1 arg 2 מצביעים לטבלת הסמלים או למספר הסידורי של השורה המחשבת את הערך (0) uminus c (1) * b (0) (2) uminus c (3) * b (2) (4) + (1) (3) (5) assign a (4) op op arg 1 arg 1 arg 2 arg 2 (0) (0) [ ] = = [ ] x y i i (1) (1) assign assign x (0) (0) y x [ i ] := y x := y [ i ] מימוש של קוד בעל 3 כתובות • שלשות op, arg1, arg2 • אין צורך ב- result • פעולה טרנרית כמו x [ i ] := y דורשת שתי שורות

17. op arg 1 arg 2 statement uminus c (14) (0) (14) * b (14) (15) (1) (15) uminus c (16) (2) (16) * b (16) (17) (3) (17) + (15) (17) (18) (4) (18) assign a (18) (19) (5) (19) מימוש של קוד בעל 3 כתובות • indirect triples – השלשות מופרדות מהסדר בינהן • הערות • בייצוג כרביעיות קל להזיז קטעי קוד; בשיטת השלשות הדבר בלתי אפשרי • בייצוג כ- indirect triples אפשר להזיז קטעי קוד ולחסוך במקום אם קיימות שלשות זהות

18. הכרזות וטיפול במשתנים • הבעיה המרכזית – חישוב ה- offset

19. הכרזות וטיפול במשתנים • הבעיה המרכזית – חישוב ה- offset • הערה – אין כאן יצירה של קוד _____________