1. ארכיטקטורת מחשבים ומעבדת תכנות מערכות טל סובול שיקלר שעת קבלה: יום א', 9-10, חדר:

2. בשיעורים שעברו

3. מה למדנו √ √ Physical Layers High-Level Languages, e.g. ML
Compiled Languages, e.g. C++
Assembly Languages Programs
Machine Code/ Architecture
Computer Organization Level
Digital Logic Level
Transistors & Layout
Materials/ Physics √ √
Physical Layers

4. מונחים ארגון המחשב שפת מכונה ארכיטקטורה
מבנה המחשב – זיכרון, מעבד, BUSes, קלט-פלט
מבנה המעבד – רגיסטרים ודגלים, יחידת ביצוע, יחידת בקרה
שפת מכונה
קוד בינארי, המייצג את פקודות שפת המכונה וניתן לביצוע על-ידה
Opcodes, operand & operation specifiers
ארכיטקטורה
סט הפקודות של המכונה: סוגי פעולות, סוגי משתנים, הגדרת המשתנים, מבנה הפקודה, משאבים

5. הארכיטקטורה – סט הפקודות של המחשב תלויה בארגון המכונה, תלויה ביצרן
סוגי המשתנים הנתמכים:
תלוי בסוגי הרגיסטרים
ב- 80x86 – סוגים, ייעודים, ואורכים שונים לרגיסטרים
סוגי ומבני הפקודות:
RISC או CISC
ב- 80x86 – אורך הפקודה 1-17 בתים
סט גדול מאוד של פקודות
מספר מגוון של מאפייני פקודה ומאפייני משתנים
בשל דרישת תאימות לאחור – מבנים שונים לאותה פקודה

6. שפת אסמבלי היא (כמעט) תרגום ישיר של שפת המכונה
מרכיבי שפת אסמבלי (בשיעור שעבר):
גרסה סמלית של פקודות שפת המכונה - mnemonics
תוויות לייצוג קבועים וכתובות בזיכרון – labels
משתנים – גלויים ועקיפים, בגדלים שונים – operands

7. שיעור 4: 1. שיטות מיעון 2. שפות עיליות, פונקציות

8. שיטות מיעון

9. Addressing modes לא כל שיטות המיעון, ולא כל שילוביהן מותרים עבור
המידע הדרוש למימוש הפקודה ולשמירת תוצריה - מוגדר בפקודה
מוגדרת אחת משיטות המיעון השונות (addressing modes)
שיטות המיעון - תלויות מכונה
שמות השיטות - תלויים ביצרן
מידע יכול להישמר ברגיסטרים או בזיכרון
ברוב פקודות ה- :80x86 לפחות אחד המשתנים חייב להיות רגיסטר או מיידי (immediate)
לא כל שיטות המיעון,
ולא כל שילוביהן
מותרים עבור
כל פקודה!

10. כל שיטת מיעון מתאימה לסוג מסוים של גישה למידע
Addressing modes
Register
Immediate
Direct (absolute)
Register indirect
Displacement (offset)
Relative
Indexed
Indirect
Auto-increment/ auto-decrement …
כל שיטת מיעון מתאימה לסוג מסוים של גישה למידע
(Common data access)

11. Register addressing שימושים: משתנים או משתני ביניים קוד מכונה: אסמבלי:
מספר ביטים בפקודה
אסמבלי:
נקיבה בשם הרגיסטר
דוגמאות:
שפת מכונה אסמבלי
inc eax
inc ebx

12. Immediate addressing שימושים: קבועים קוד מכונה: אסמבלי:
המשתנה חלק מהפקודה
אסמבלי:
מספר
דוגמה:
שפת מכונה אסמבלי
add ax, 0x4501
little endian!

13. רוב המידע מאוחסן בזיכרון הראשי
ארגון הזיכרון
רוב המידע מאוחסן בזיכרון הראשי
שאלנו:
מהי היחידה הבסיסית אליה ניתן לפנות?
בתים / מלים
כיצד מלים ממופות לבתים?
Big endian / Little endian
מהו מרחב הכתובות? או מהם מרחבי הכתובות?
32 ביטים / Segmented

14. Absolute (direct) addressing
שימושים:
משתנים פשוטים (גלובליים).
בגלל הגישה לזיכרון – השיטה מהשיטות הקודמות.
קוד מכונה:
כתובת המשתנה בזיכרון היא חלק מהפקודה
אסמבלי:
הכתובת מופיעה כמספר או כ- Label
(ב- NASM – בתוך סוגריים מרובעים, בשפות אסמבלי אחרות – ללא סוגריים)
דוגמה:
שפת מכונה אסמבלי
inc word [my_string]
FF inc word [0x1000]

15. Absolute (direct) addressing
שימושים: משתנים פשוטים (גלובליים)
דוגמה:
שפת C
int x=0;
x++;
אסמבלי (עשוי להיכתב בצורה הבאה, בהתעלם מ- sections)
x: dd ; NOT a variable definition!!!
inc dword [x]

16. Register indirect addressing
השיטה:
המשתנה נמצא בזיכרון. כתובתו נמצאת ברגיסטר
שימושים:
גישה ע"י מצביע – pointer (המצביע נמצא ברגיסטר)
אסמבלי:
הכתובת מופיעה כרגיסטר בסוגריים מרובעים
(הערה: ניתן להשתמש רק ברגיסטרים של 32 ביט)
register
memory
add1
משתנה
add1

17. Register indirect addressing
השיטה:
המשתנה נמצא בזיכרון, כתובתו נמצאת ברגיסטר
שימושים:
גישה ע"י מצביע – pointer (המצביע נמצא ברגיסטר)
אסמבלי:
הכתובת מופיעה כרגיסטר בסוגריים מרובעים
דוגמה:
אסמבלי
inc byte [ebx]
אם הערך ב- ebx הוא 0x104
מגדילים ב-1 את ה-byte הנמצא בכתובת 0x104 בזיכרון

18. Register indirect addressing
שימושים:
גישה ע"י מצביע – pointer (המצביע נמצא ברגיסטר)
רשימות של משתנים (arrays)
דוגמה:
שפת C
*p = *p + 1;
אסמבלי (בהנחה שהמצביע p נמצא ברגיסטר ebx)
inc byte [ebx]
כתובת המשתנה נקראת – כתובת אפקטיבית (EA - Effective Address)
במסמכי אפיון - מציינים לעתים משוואה לחישובה.
כאן:
EA = [ebx]

19. Register vs. Register Indirect
שימו לב:
Register addressing mode
p++;
inc eax;
Register indirect addressing
*p = *p+1;
inc [eax];

20. Displacement addressing
השיטה:
המשתנה נמצא בזיכרון. כתובתו מוזזת במרחק קבוע מהכתובת המוגדרת ע"י הרגיסטר: EA = [reg] + displacement
שימושים:
גישה ל- structure
אסמבלי:
מוגדר הרגיסטר ומרחק התזוזה
register
memory
add1
add1
displacement
משתנה

21. Displacement addressing
השיטה:
המשתנה נמצא בזיכרון. כתובתו מוזזת במרחק קבוע מהכתובת המוגדרת ע"י הרגיסטר: EA = [reg] + displacement
שימושים:
גישה ל- structure
אסמבלי:
מוגדר הרגיסטר ומרחק התזוזה
דוגמה:
אסמבלי
inc byte [ebx + 0x10]
אם הערך ב- ebx הוא 0x104
מגדילים ב-1 את ה-byte הנמצא בכתובת 0x114 בזיכרון

22. Displacement addressing
שימושים:
גישה ל- structure
דוגמה:
שפת C
struct foo {int x; int y; char z;};
p = & foo; /* assume correct type */
p -> z++;
אסמבלי
mov ebx, [p]
inc byte [ebx + 8]

23. Relative addressing
השיטה:
המשתנה נמצא בזיכרון. כתובתו מוזזת במרחק קבוע מהכתובת המוגדרת ע"י מונה התוכנית (PC): EA = [PC] + displacement
שימושים:
קפיצה מותנית, קוד שאינו תלוי מיקום
אסמבלי:
מוגדר מרחק התזוזה כמספר או כ- Label
דוגמה:
שפת מכונה אסמבלי
jnz next ; =jnz $+4
inc eax
66F7D next: neg eax

24. Indexed addressing (with displacement) EA = myarray+reg*index השיטה:
שימושים:
גישה למערך (Array)
אסמבלי:
מוגדר רגיסטר, כופל (1, 2, או 4) וכתובת בסיס (מחושב בבתים)
register
register x index
myarray
Addr
Addr
משתנה

25. Indexed addressing (with displacement) EA = reg*index + displacement
השיטה:
EA = reg*index + displacement
שימושים:
גישה למערך (Array)
אסמבלי:
מוגדר רגיסטר, כופל (1, 2, או 4) וכתובת בסיס (מחושב בבתים)
דוגמה:
inc dword [myarray + ebx*4]
אם הערך של ebx הוא 5, מעלים את ערך המלה הכפולה הנמצאת בכתובת myarray+20 בזיכרון.

26. Indexed addressing (with displacement) EA = reg*index + displacement
השיטה:
EA = reg*index + displacement
גרסאות:
ללא Displacement
inc dword [ebx*4]
Indexed עם Indirect
inc dword [ebx*4 + eax]
Indexed עם Indirect ןעם Displacement
inc dword [myarray + ebx*4 +eax]

27. לעתים עדיף לא להשתמש בשיטה זו:
לא תמיד נשתמש בכל החישוב, עבור כל איבר
למשל בתמונות
ניתן להתקדם לאורך שורה ע"י +1
ניתן להתקדם לאורך עמודה ע"י + רוחב שורה y
xxx

28. Auto-increment & Auto-decrement
שיטה:
Auto-increment לאחר הפעולה
Auto-decrement לפני הפעולה
680x0 Assembly: קידום הפוינטר לפני או אחרי הגישה
MOVI.B #5, -(A7) ; decrement pointer then move immediate 5
MOVI.B (A7)+, D ; increment pointer then move to D0
שפת C:
c=*p++;

29. Auto-increment & Auto-decrement
80x86 Assembly: מימוש המחסנית
push 5
חיקויים של 80x86 (לא במקורי):
mov –[esp], 5

30. Double indirect addressing modes
שיטה: המשתנה נמצא בכתובת המוגדרת ע"י המידע הנמצא במקום בזיכרון עליו מצביע הרגיסטר VAX: inc *(r1) קיימות שיטות נוספות – מסובכות יותר ופחות אנו לא נעסוק ב- memory segments r1
add1
add1
add2
add2
משתנה

31. סיכום ביניים שיטת המיעון מוגדרת בפקודה שיטות המיעון - תלויות מכונה
מידע יכול להישמר ברגיסטרים או בזיכרון
לא כל שיטות המיעון, ולא כל שילוביהן מותרים עבור כל פקודה!
רוב המידע מאוחסן בזיכרון הראשי
80x86/Linux: גישה לבתים
מיפוי מלים לפי little endian
מרחב כתובות 232

32. כל שיטת מיעון מתאימה לסוג מסוים של גישה למידע
Addressing modes
Register inc eax
Immediate add ax, 0x4501
Direct (absolute) inc word [0x1000]
Register indirect inc byte [ebx]
Displacement (offset) inc byte [ebx + 0x10]
Relative jnz next
Indexed inc dword [myarray + ebx*4]
Indirect
Auto-increment/ auto-decrement …
כל שיטת מיעון מתאימה לסוג מסוים של גישה למידע

33. Addressing modes
32 bit addressing modes

34. פרוצדורות, פונקציות ומנשקים לשפות עיליות
פרוצדורות, פונקציות ומנשקים לשפות עיליות

35. במה נעסוק למה וכיצד יוצרים תכניות מודולאריות
כיצד מתממשקים עם שפות עיליות, כדוגמת C
פרוצדורות ופונקציות
סוגי מידע ודרכים לשמירת ולהעברת מידע
Activation frame
Calling conventions
העברת ערך
העברת כתובת
מחסנית
אסמבלי, C, ועוד

36. פונקציות ופרוצדורות
פונקציות ופרוצדורות – דוגמאות לתת-תכניות בשפות עיליות פרוצדורות – לא מחזירות ערך, אינן חייבות להסתיים פונקציות – פרוצדורות המחזירות תוצאה התכנית הקוראת (לפרוצדורה/פונקציה) והפרוצדורה /פונקציה חייבות להסכים על צורת העברת המידע ביניהן. Calling convention - "הכללים המוסכמים" להעברת המידע

37. פונקציות ופרוצדורות
מודולאריות: חלקי תכנית המבצעים פעולות מוגדרות ניתנים לשימוש חוזר ע"י קריאה מחלקים שונים לאורך התכנית
X0, X1, Y0
שרטוט קו אופקי
X0- X1 , Y0
שרטוט קו אופקי
Xi- Xj , Yk
CALL
X0, X1, Y1
שרטוט קו אופקי
X0- X1 , Y1
CALL
X0, Y0, Y1
שרטוט קו אנכי
X0, Y0 – Y1
שרטוט קו אנכי
Xn, Ym – Yl
CALL
שרטוט קו אנכי
X1 , Y0 – Y1
X0, Y0, Y1
CALL

38. אחסון מידע בשפות עיליות סוגים שונים של אחסון מידע:
משתנים גלובליים (global variables)
משתנים מקומיים (local variables)
פרמטרים/ארגומנטים של פונקציות/פרוצדורות
הערכים המוחזרים
Dynamically allocated data

39. משתנים גלובליים ב-C: int x=40; באסמבלי: X DD 40
משתנה גלובלי - משתנה המוגדר בד"כ בתחילת התכנית והיכול לשמש בכל חלקיה.
לכל משתנה גלובלי יכולה להיות כתובת קבועה בזיכרון.
ב-C:
int x=40;
באסמבלי:
X DD 40
הכתובת של X בזיכרון תלויה בערך המונה כשמעבדים שורה זו.
זה לא משתנה!!! אין בדיקת type בכתיבה. ניתן "לדרוך" על מקום זה.

40. משתנים מקומיים
משתנים מקומיים – משמשים בחלקים מסוימים של התכנית בלבד.
ערכים ומשתנים מקומיים זקוקים לשם ייחודי כדי למנוע התנגשויות.
ב-C:
x=foo(x, &y);
קריאה לפונקציה
foo(int a, int *b){
int c= *b;
return(c) }
הפונקציה
ערך מוחזר

41. ניתן להפעיל תת-תכנית ע"י קפיצה (JMP)
החזרה בעייתית
מה קורה אם כתובת החזרה קבועה?
הפונקציה חוזרת תמיד לאותו מקום בקוד
לא ניתן לקרוא לפונקציה/פרוצדורה ממקומות שונים בתכנית
לא ניתן לבצע רקורסיה
לא ניתן לבצע threading

42. Activation frame
Activation frame - מסגרת המאותרת עבור כל הפעלה של פונקציה.
כוללת:
כתובת חזרה
מצבי מכונה נוספים (דגלים)
ארגומנטים של הפונקציה
משתנים מקומיים
בשפות מסוימות – nested scope
כיצד?
הפתרון הפשוט – לשמור את המסגרת במחסנית.

43. Calling conventions כיצד קוראים לפונקציה? אפשרות 1 (באסמבלי):
ארגומנטים - ברגיסטרים מוסכמים
ערכים מוחזרים - ברגיסטר מוסכם (או אפילו בדגלים)
מהירות אופטימאלית (במקרים רבים)
קשה להכליל
לא ניתן להעברה
מספר הרגיסטרים קטן

44. Calling conventions כיצד קוראים לפונקציה? אפשרות 2:
ארגומנטים - במחסנית
ערכים מוחזרים – ברגיסטרים
די מהיר
ניתן להעברה במידה סבירה
מתאים לשפות עיליות עם ערך מוחזר יחיד
ברוב הקומפיילרים של C

45. Calling convention for C
1. מה מעבירים לפונקציה?
Call by value – השיטה הפשוטה והכללית בשפות עיליות:
מספר משתנה של ארגומנטים - במחסנית
ערכים מוחזרים – ברגיסטרים
מאפשרת מספר משתנה של ארגומנטים

46. Call by value 2. PUSH לכן: הארגומנט הראשון תמיד בראש המחסנית TOS
הערכים נדחפים למחסנית בסדר הפוך
לכן: הארגומנט הראשון תמיד בראש המחסנית TOS
מה קורה אם הפונקציה מצפה ל-k ארגומנטים, אבל קוראים לפונקציה עם n ארגומנטים, ו- n>k?
הפונקציה תעבוד כראוי, ולא תתייחס כלל לארגומנטים המיותרים
מה עושים אם רוצים לתמוך במספר משתנה של ארגומנטים (nargs)?
דוחפים את מספר הארגומנטים אחרי הארגומנט השמאלי ביותר

47. Call by value 3. ערכים מוחזרים - ברגיסטרים VAX: אינטל 80x86:
AL, AX, EAX
מוטורולה 680x0:
D0 – למידע (data), A0 – למצביע (Pointer)
VAX: r0

48. תזכורת: המחסנית מקום בזיכרון המשמש לאחסון זמני של data וכתובות
גודל כל "תא" 16 או 32 ביט (word / dword)
ESP מצביע על ה- Byte התחתון של הערך האחרון שנכנס
גודל המחסנית (במקרה שלנו) 232
PUSH
POP

49. PUSH & POP
PUSH
כיוון ה- stack pointer למקום המתאים, בהתאם לגודל האופרנד/המשתנה esp=esp-2) או (esp=esp-4
הכנסת הערך החדש לפי – little endian כך ש- esp מצביע על ה- byte התחתון
POP
הוצאת הערך מהמחסנית
העלאת ה- esp בהתאם לגודל האופרנד

50. חשוב לנהל נכון את המחסנית כדי שהתכנית תתקדם כפי שאנו רוצים!!!
CALL & RET
CALL
קפיצה בלתי-מותנית לתת-התכנית
PUSH לכתובת הפקודה הבאה
RET
POP של הכתובת
ביצוע הפקודה הבאה
חשוב לנהל נכון את המחסנית כדי שהתכנית תתקדם כפי שאנו רוצים!!!

51. דוגמה sub esp, 8 push dword y push dword [x] call foo add esp, 16
mov [x], eax
; align stack
; כתובת (immediate mode)
; תוכן (absolute mode) ;
; ניקוי המחסנית
; השמת הערך החוזר
Call by value!!
foo(int a, int *b){
int c= *b;
return(c) }

52. foo(int a, int *b){ int c= *b; return(c) } sub esp, 8 push dword y
0xFFF0000
xxxxxxxx -
0xFFE0000 4
sub esp, 8
push dword y
push dword [x]
call foo
add esp, 16
mov [x], eax 1 2 3
esp 1 4 y
esp
foo(int a, int *b){
int c= *b;
return(c) } 2
[x]
esp 3

53. The called C function שומרת הרגיסטרים המשמשים בפונקציה
משתנים מקומיים – ברגיסטרים ובמחסנית
אם פנוי, משתמשים ברגיסטר ebp כדי לפשט הגישה
שומרים את ערכו הקודם, מציבים בו את esp, ומשתני הפונקציה במחסנית ממוקמים ביחס אליו
משתני ביניים – במחסנית
לחזרה:
העברת ערך לרגיסטר התוצאה
RET
המשתנים המקומיים "נעלמים" (עדיין במחסנית)

54. foo: ; התרגום לאסמבלי של הפונקציה
push ebp ; bp הארגומנטים מתרחקים ב- 1 מ-
mov ebp, esp
sub esp, lo ; allocation, lo=size of locals, by complier!
push ebx ; push some registers
… ; תלוי קונבנציה
mov ebx, [ebp+12] ; get 2nd arg (pointer b)
mov ebx, [ebx] ; dereference! (the value at b)
mov [ebp-4], ebx ; initialize c local
; function code
mov eax, ; return value
pop ebx ; pop registers
mov esp, ebp ; התחלת "ניקוי"
pop ebp ; חזרה לתכנית הראשית
ret
Leave ניתן לביצוע גם ע"י פקודת

55. y [x] ebp &y -> *b ebx foo: push ebp mov ebp, esp sub esp, lo
0xFFF0000
xxxxxxxx -
0xFFE0000
8 Byte alignment
ebp
esp
foo:
push ebp
mov ebp, esp
sub esp, lo
push ebx …
mov ebx, [ebp+12]
mov ebx, [ebx]
mov [ebp-4], ebx
...
mov eax, ...
pop ebx
mov esp, ebp
pop ebp
ret 4 1
esp
ebp
+12 y 2
esp 5
[x] 3
esp
ebp 3
esp
ebp
&y -> *b lo 4
esp
ebp
- 4 5
esp
ebx

56. שפות עיליות נוספות PASCAL קטגוריות שונות של ארגומנטים (var arguments)
ניתן לממש ע"י העברת pointers
PUSH מתחיל מהשמאלי ביותר
Intel 80x86 (not in C, exists in PASCAL)
הפרוצדורה יכולה לבצע ניקוי בעצמה:
RET value
העברת פרמטרים נוספים:
Optional arguments
Keyword arguments

57. פקודות לתמיכה בשפות עיליות
Motorola 680x0
LINK An, #d ; push An
move SP to An
SP=SP-d
UNLK ; move An to SP
pop An

58. פקודות לתמיכה בשפות עיליות
Intel 80486
BOUND reg, addr
השוואת רגיסטר לגבולות
INT 5
אם מחוץ לגבולות,
addr ו- addr+2 (או addr+4) מכילים הגבולות

59. LEAVE & ENTER
reserve and remove data from the top of the stack while setting up a stack frame pointer in bp/ebp/rbp.
However, direct setting, or addition and subtraction to the sp/esp/rsp register is also supported, so the enter/leave instructions are generally unnecessary.