שפת C - קוד
Functions & Calling Conventions
קטעי קוד ב-C על inline, מצביעים לפונקציות ומוסכמות קריאה, עם קביעת הפלט או התוצאה.
בחרו את הרמה שמתאימה לכם ואת הסט שתרצו לתרגל
חומר לימוד
Functions & Calling Conventions: מעקב, מחסנית ומצביעים לפונקציות
דמיינו את המבחן: לפניכם קטע C של כמה שורות, ומתחתיו ארבע תשובות אפשריות לפלט או לתוצאת הקומפילציה. אין מחשב להריץ עליו, ולכן הכול תלוי ביכולת שלכם לנהל בראש את מה שהמעבד היה עושה: איזו פונקציה פעילה בכל רגע, מה שמור בכל משתנה ומה כל קריאה מחזירה.
- שיטת המעקב: טבלת מעקב, ההבדל בין העברת עותק להעברת כתובת, וחילוק שלמים והמרות בכניסה לפונקציה.
- המחסנית: מסגרת לכל קריאה, מעקב אחרי רקורסיה, משתנה מקומי מול
staticמול גלובלי, וגלישת מחסנית או כתיבה מעבר למערך. - מצביעים לפונקציות: קריאת הצהרות עם סוגריים, החלפת יעד, פונקציות callback, טבלאות שליחה,
struct, פונקציות עם ארגומנטים משתנים והחזרת מצביע לפונקציה. - פונקציות
inline: מתי הקומפיילר מטמיע קוד, ארבעה הבדלים מול מאקרו, ולמהinlineבליstaticמוביל לשגיאת קישור. - מוסכמות קריאה ב-x86 וב-x86-64:
cdecl,stdcallו-fastcall, חישוב היסטים במחסנית, עיטור שמות ב-MSVC, ומוסכמות System V מול Windows x64. - קריאות מערכת (System calls): ההבדל בין
writeו-readלפונקציות ספרייה, טיפול בשגיאות עםerrno, אוגריsyscall, חציצה ב-printfויצירת תהליכים עםfork.
המטרה היא שתדעו לקרוא קוד C מורכב ולחזות מה יקרה בזיכרון ובפלט בלי להריץ אותו, כבר ביום המבחנים הראשון.
gcc מקמפל ל-Linux x86-64, שבו int הוא 4 בתים ואילו long ומצביע הם 8. השמות __cdecl, __stdcall ו-__fastcall שייכים ל-x86 של 32 סיביות. פלט שמופיע ליד תוכנית הוא תוצאה של הרצה אמיתית; כשהתרחיש מסתיים בקריסה, כשיש בו התנהגות לא מוגדרת או כשעוקבים אחריו ביד בלבד, לא מוצג פלט.שיטת המעקב אחרי קוד
טבלת מעקב: שורה אחר שורה
נסו לעקוב בראש אחרי קריאה שבתוכה קריאה נוספת, כמו chain(delta, 8, 3) שנראית בהמשך: מהר מאוד החוטים נקרעים. טבלת מעקב פותרת את זה, כי כל משתנה מקבל עמודה וכל צעד שמשנה ערך מקבל שורה, כך שהערך הנוכחי תמיד כתוב מולכם.
הכללים הבאים מסודרים לפי השלבים שבהם משתמשים בהם:
- איפה מתחילים: ב-
main, גם אם פונקציות עזר כתובות מעליה. עד שמישהו קורא להן הן רק הגדרות. - מה קורה בקריאה: בכל כניסה לפונקציה נפתחת טבלה חדשה, והפרמטרים בה הם עותקים של הערכים שנשלחו. כשהפונקציה חוזרת הטבלה נזרקת, ורק ערך ההחזרה עובר הלאה.
- קריאה בתוך ארגומנט: בביטוי כמו
show(total(x), y)מריצים קודם אתtotal(x), כיshowלא יכולה להתחיל בלי הערך שלה. - לולאה: כל סיבוב מקבל שורה משלו ובה המונה כפי שהוא ברגע שהסיבוב מתחיל. בלי זה קל לטעות בכמות הסיבובים או בערך האחרון של המונה.
- בסוף: קראו שוב את הפורמט של
printf. לעיתים קרובות החישוב נכון והתשובה שגויה בגלל רווח, ירידת שורה (\n) או סדר הערכים.
תרחיש 1: קריאה מקוננת בתוך ביטוי
#include <stdio.h>
int delta(int left, int right) { return left - right; }
int prod(int left, int right) { return left * right; }
int chain(int (*fn)(int, int), int first, int second) {
return fn(first, fn(first, second));
}
int main(void) {
printf("%d %d\n", chain(delta, 8, 3), chain(prod, 3, 4));
return 0;
}3 36| מסגרת פעילה | ערכי הפרמטרים | מה היא עושה או מחזירה |
|---|---|---|
chain(delta, 8, 3) | first = 8, second = 3 | מחשבת קודם את delta(8, 3) |
delta(8, 3) (הפנימית) | left = 8, right = 3 | מחזירה 5 |
delta(8, 5) (החיצונית) | left = 8, right = 5 | מחזירה 3, וזה גם ערך ההחזרה של chain |
chain(prod, 3, 4) | first = 3, second = 4 | מחשבת קודם את prod(3, 4) |
prod(3, 4) (הפנימית) | left = 3, right = 4 | מחזירה 12 |
prod(3, 12) (החיצונית) | left = 3, right = 12 | מחזירה 36, וזה גם ערך ההחזרה של chain |
fn כאן הוא מצביע לפונקציה, נושא שנפרט בהמשך הפרק. לצורך המעקב מספיק לקרוא כל fn(x, y) כקריאה ל-delta או ל-prod, לפי מה שהועבר.
טעויות נפוצות
- בקריאה מקוננת אפשר להעריך קודם את הפונקציה החיצונית. הפונקציה החיצונית זקוקה לערך המוחזר מהפנימית כאחד הארגומנטים שלה, ולכן הפנימית חייבת לרוץ קודם.
- בלולאה מספיק לעקוב אחרי שתי איטרציות ולהסיק את ההמשך. קפיצה כזו מפספסת שינויי תנאי או הצטברות שונה בסוף הלולאה; יש לרשום כל איטרציה עד שתנאי העצירה מתקיים.
- התנאים
i < nו-i <= nמבצעים אותו מספר איטרציות. כאשר מתחילים מ-0, התנאיi < nרץnפעמים, ואילוi <= nרץn + 1פעמים.
בדקו את עצמכם
בקוד שבתרחיש למעלה, מה היה הפלט אילו main הייתה קוראת ל-chain(delta, 10, 6)?
6. הקריאה הפנימית delta(10, 6) מחזירה 4, והחיצונית delta(10, 4) מחזירה 6.
העברה לפי ערך ומצביע כפרמטר
נפתח בתקלה מוכרת: כותבים swap(int a, int b), קוראים לה מ-main, ושום דבר לא זז. הסיבה היא מנגנון ההעברה של C, והוא מופיע כמעט בכל שאלת מעקב.
#include <stdio.h>
void swap_copies(int first, int second) {
int hold = first;
first = second;
second = hold;
}
void swap_cells(int *first, int *second) {
int hold = *first;
*first = *second;
*second = hold;
}
int main(void) {
int lo = 3, hi = 8;
swap_copies(lo, hi);
printf("%d %d\n", lo, hi);
swap_cells(&lo, &hi);
printf("%d %d\n", lo, hi);
return 0;
}3 8
8 3בקריאה הראשונה הוחלפו שני עותקים מקומיים שנעלמו עם החזרת הפונקציה. בקריאה השנייה הפונקציה קיבלה את הכתובות של lo ושל hi, ולכן כתבה לתאים שלהם עצמם.
הרעיון: בכל קריאה הערכים שנשלחו נכנסים לתאים חדשים שנפתחים במסגרת של הפונקציה הנקראת, והתאים האלה נעלמים עם המסגרת. כך מתנהגים כל הארגומנטים ב-C, וזה נקרא העברה לפי ערך (pass by value).
כדי להגיע למשתנה של הקורא צריך אפוא לשלוח אליו את הכתובת, בצורה &lo, והפונקציה כותבת דרך המצביע שהתקבל, בצורה *first. הכתובת עצמה נכנסת לתא חדש, בדומה לצילום של פתק עם כתובת רחוב: הצילום נזרק, אבל מי שהלך לפיו הגיע לאותו בית.
תרחיש 2: שינוי עותק מול שינוי דרך כתובת
#include <stdio.h>
void boost_copy(int val) {
val += 20;
printf("inside boost_copy: %d\n", val);
}
void boost_ptr(int *ptr) {
*ptr += 20;
}
int main(void) {
int score = 5;
boost_copy(score);
printf("after copy: %d\n", score);
boost_ptr(&score);
printf("after ptr: %d\n", score);
return 0;
}inside boost_copy: 25
after copy: 5
after ptr: 25ב-main יושב score עם 5. בקריאה הראשונה נוצר תא חדש בשם val שמתחיל ב-5, גדל ל-25 ונעלם, בלי שנגעו ב-score.
בקריאה השנייה ptr מחזיק את הכתובת של score, ולכן *ptr += 20 נוחת ישר בתא של score ומשאיר בו 25.
טעויות נפוצות
- אם פונקציה משנה פרמטר מסוג
int, השינוי נשמר גם במשתנה המקורי ב-main. הפרמטר הוא עותק עצמאי שנעלם כשהפונקציה מסתיימת, ואינו מחובר למשתנה המקורי. - פונקציית
swap(int a, int b)מחליפה את שני המשתנים שהועברו לה. ללא העברת כתובות (int *) הפונקציה מחליפה רק את העותקים המקומיים שלה. - פונקציה שמקבלת
int *לא יכולה להשפיע על משתני הקורא, כי גם המצביע עצמו מועבר כעותק. העותק של הכתובת עדיין מציין את התא של הקורא, ולכן כתיבה דרכו (*p = ...) משנה את המשתנה שלו.
בדקו את עצמכם
נתונה הפונקציה void shift(int *dst, int step) { *dst += step; step += 10; }. אם p = 3 ו-q = 4 ונקרא shift(&p, q), מה יהיו הערכים של p ו-q לאחר מכן?
p יהיה 7 ו-q יישאר 4. המשתנה p עודכן דרך המצביע dst, ואילו step היה עותק של q.
חילוק שלמים והמרה לטיפוס הפרמטר
הדפיסו scale5(3.85) ותקבלו 15, לא 19. ההפתעה נובעת משני כללים שכדאי להכיר בנפרד, ושניהם חוזרים בשאלות מעקב.
הכלל הראשון: כשלפונקציה יש הצהרה מוקדמת (prototype), כל ארגומנט מומר לטיפוס הפרמטר בנקודת הקריאה. אם שולחים double לפרמטר int, החלק שאחרי הנקודה העשרונית פשוט נחתך, בלי עיגול: 8.97 הופך ל-8, לא ל-9.
הכלל השני נוגע ל-/: כששני האופרנדים שלמים, התוצאה שלמה והשארית נזרקת, ולכן 17 / 5 הוא 3 ולא 3.4. די באופרנד אחד מסוג double כדי שהחילוק יהיה ממשי: 17.0 / 5 נותן 3.4.
תרחיש 3: חיתוך חלק עשרוני בכניסה לפונקציה
#include <stdio.h>
int scale5(int val) {
return val * 5;
}
int main(void) {
printf("%d\n", 17 / 5);
printf("%.1f\n", 17.0 / 5);
printf("%d\n", scale5(3.85));
printf("%d\n", scale5(8.97));
return 0;
}3
3.4
15
40ב-scale5(3.85) הארגומנט נחתך ל-3 עוד לפני שהגוף רץ, ולכן מחושב 3 * 5. באותו אופן scale5(8.97) מחשבת 8 * 5 = 40 ולא 45.
ההבחנה חשובה כשמשווים פונקציה למאקרו (#define, החלפת טקסט שנלמדת בהמשך): מאקרו לא ממיר דבר, והיה מחשב עם 3.85 עצמו.
טעויות נפוצות
- התוצאה של
19 / 5היא4, כי3.8מתעגל כלפי מעלה. בחילוק שלמים כל מה שאחרי הנקודה נחתך, ולכן התוצאה היא3. - המרה מ-
doubleל-intמעגלת את המספר לשלם הקרוב. ההמרה רק מסירה את החלק העשרוני, ולכן8.97הופך ל-8. - פונקציה עם פרמטר
intמקבלת את הערך3.85ומשתמשת בו בחישוב לפני החיתוך. החיתוך ל-intמתבצע כבר בהעברת הארגומנט בכניסה לפונקציה.
בדקו את עצמכם
נתונה הפונקציה int dec2(int x) { return x - 2; }. מה תחזיר הקריאה dec2(4.95)?
2. הארגומנט 4.95 מומר ל-4 בכניסה לפונקציה, ו-4 - 2 = 2.
המחסנית ומסגרות הקריאה
מסגרת חדשה לכל קריאה
נתחיל מהרגע שבו הביצוע מגיע לקריאה calc(7). ההוראה call דוחפת למחסנית את הכתובת שאליה צריך לחזור, ואחריה הריצה קופצת לקוד של calc.
מכאן calc בונה לעצמה מסגרת מחסנית (stack frame), יחידת זיכרון פרטית לקריאה הזו. בתוכה יושבים כתובת החזרה שנדחפה זה עתה, גיבוי של אוגרים שהפונקציה עומדת לשנות, המשתנים המקומיים שלה וגם ארגומנטים שלא היה להם מקום באוגרים.
main called calc(7); stack grows toward lower addresses
(schematic drawing, the addresses are invented)
address contents owner
0x7fff0060 ... locals of main ... main's frame
0x7fff0058 return address (into main) calc's frame
0x7fff0050 n = 7 (local variable) calc's frame <- RSP (top of the stack)
0x7fff0048 (not used yet)
calc returns -> RSP moves back up, calc's frame is gone, main continues after the callכשמסתכלים על כל המסגרות יחד רואים את המחסנית (call stack), ולכל thread יש אחת משלו. המסגרת האחרונה שנפתחה היא הראשונה שנסגרת (LIFO), ולכן main בתחתית והפונקציה שרצה כרגע בראש.
ב-x86 וב-x86-64 הראש נמצא בכתובת הנמוכה ביותר, והאוגר RSP (ב-32 סיביות ESP) מצביע עליו. פתיחת מסגרת היא בעיקר הורדה של RSP, וסגירתה היא החזרתו למקומו, ולכן אין צורך בניהול זיכרון נפרד.
כיוון שהמסגרת חדשה בכל קריאה, גם המשתנים האוטומטיים שבה מתחילים מחדש. אתחול שכתוב בהגדרה ירוץ שוב בכל כניסה, ומשתנה בלי אתחול מחזיק ערך שרירותי שנשאר באותו מקום במחסנית (ערך זבל, indeterminate).
קריאה של ערך כזה לפני שכתבו אליו היא התנהגות לא מוגדרת (undefined behavior), ובשום אופן לא 0 מובטח.
טעויות נפוצות
- משתנים מקומיים מאותחלים אוטומטית ל-
0אם לא כתבנו ערך התחלתי. רק משתנים גלובליים ומשתניstaticמתאפסים אוטומטית; משתנים מקומיים רגילים מתחילים עם זבל מהמחסנית. - בארכיטקטורת x86 המחסנית צומחת לכיוון כתובות גבוהות. ב-x86 וב-x86-64 דחיפה למחסנית מקטינה את
RSP/ESP, כלומר היא צומחת כלפי כתובות נמוכות. - קריאות חוזרות לאותה פונקציה חולקות את אותה מסגרת מחסנית. כל קריאה יוצרת מסגרת חדשה ועצמאית משלה, שנשמרת עד שהקריאה הספציפית חוזרת.
בדקו את עצמכם
main קוראת ל-alpha, ממתינה ש-alpha תחזור, ואז קוראת ל-beta. כמה מסגרות קיימות במחסנית בזמן ש-beta רצה?
שתי מסגרות: של main ושל beta. המסגרת של alpha כבר שוחררה כש-alpha הסתיימה.
מעקב אחרי רקורסיה
ברקורסיה אין מנגנון מיוחד: זו קריאה רגילה לפונקציה שכבר פעילה. כל הפעלה מקבלת מסגרת עצמאית עם עותקים משלה של הפרמטרים והמשתנים, והמסגרות יושבות זו מעל זו בלי לדרוס אחת את חברתה.
מה שקובע את סדר הפלט הוא מקום ההדפסה ביחס לקריאה הרקורסיבית. אפשר לחשוב על בנייה ועל פירוק של ערימה: שורה שלפני הקריאה רצה בזמן הבנייה, ושורה שאחריה רצה בזמן הפירוק, כשהמסגרת העמוקה ביותר מסיימת ראשונה.
| מקום ההדפסה | מתי היא רצה | סדר הפלט |
|---|---|---|
| לפני הקריאה הרקורסיבית | בדרך למטה, בזמן הבנייה | לפי סדר פתיחת הקריאות |
| אחרי הקריאה הרקורסיבית | רק אחרי שהקריאה הפנימית חזרה | הפוך (LIFO): העמוקה ביותר ראשונה |
שיטה מעשית בשני שלבים. ראשית משרטטים את שרשרת הקריאות עד קריאת הבסיס, עם הערכים של כל מסגרת; אחר כך חוזרים על השרשרת מהסוף להתחלה ומבצעים בכל מסגרת את מה שנשאר אחרי הקריאה.
מכאן כלל שימושי: כשיש הדפסה משני צידי הקריאה הרקורסיבית, הפלט הוא רצף ישר ואחריו אותו רצף בסדר הפוך.
תרחיש 4: אותו מספר, שני סדרי הדפסה
#include <stdio.h>
void spell(unsigned n) {
if (n >= 10)
spell(n / 10);
printf("%u", n % 10);
}
void spell_rev(unsigned n) {
printf("%u", n % 10);
if (n >= 10)
spell_rev(n / 10);
}
int main(void) {
spell(4079);
printf("\n");
spell_rev(4079);
printf("\n");
return 0;
}4079
9704| הקריאה | n % 10 | התור שלה ב-spell | התור שלה ב-spell_rev |
|---|---|---|---|
spell(4079) | 9 | רביעית | ראשונה |
spell(407) | 7 | שלישית | שנייה |
spell(40) | 0 | שנייה | שלישית |
spell(4) | 4 | ראשונה | רביעית |
בשתי הגרסאות הקריאות נפתחות באותו סדר, מ-4079 ועד 4. ב-spell ההדפסה ממתינה לחזרת הפנימית, ולכן הספרה 4 יוצאת ראשונה והמספר מודפס בסדר הנכון.
ב-spell_rev ההדפסה קודמת לקריאה, ולכן הספרות יוצאות לפי סדר הפתיחה, מהסוף להתחלה: 9704.
תרחיש 5: הדפסה לפני הקריאה ואחריה, וקריאת בסיס שמדפיסה
#include <stdio.h>
void zigzag(int k) {
if (k == 0) {
printf("*");
return;
}
printf("%d<", k);
zigzag(k - 1);
printf(">%d", k);
}
int main(void) {
zigzag(3);
printf("\n");
return 0;
}3<2<1<*>1>2>3כל מסגרת מדפיסה k< בדרך למטה. zigzag(0) היא קריאת הבסיס, והיא מדפיסה * לפני ה-return, ולכן אי אפשר לדלג עליה במעקב.
אחרי ש-zigzag(0) מסתיימת, המסגרות נסגרות מהחדשה אל הישנה. המסגרת של k = 1 סוגרת ראשונה ומוסיפה >1, אחריה k = 2 ובסוף k = 3, ולכן הסוגרים מופיעים בסדר הפוך לפותחים.
תרחיש 6: ערך חזרה שנזרק מול ערך שמצטבר
#include <stdio.h>
int wasted(int k) {
int own = k * 4;
if (k > 1)
wasted(k - 1);
return own;
}
int gathered(int k) {
if (k <= 1)
return 1;
return k * gathered(k - 1);
}
int main(void) {
printf("%d %d\n", wasted(3), gathered(4));
return 0;
}12 24ב-wasted הקריאה wasted(k - 1) מתבצעת, אבל המספר שהיא מחזירה נזרק כי אף משתנה לא קולט אותו. כל מסגרת מחזירה את ה-own שלה, ולכן wasted(3) נותנת 3 * 4 = 12.
ב-gathered הערך החוזר נכנס לחישוב והתוצאה נבנית בדרך חזרה: 4 * 3 * 2 * 1 = 24.
טעויות נפוצות
- פלט של פונקציה רקורסיבית מופיע תמיד בסדר שבו הקריאות נפתחו. רק שורת הדפסה שקודמת לקריאה הרקורסיבית יוצאת לפי סדר הפתיחה; שורה שאחריה יוצאת בסדר ההפוך.
- אם יש משתנה מקומי אחד בקוד, כל הקריאות משנות ומדפיסות אותו עותק. לכל מסגרת מחסנית מוקצה עותק נפרד של המשתנים המקומיים.
- הפונקציה מחזירה תמיד את התוצאה של הקריאה הפנימית העמוקה ביותר. אם הקורא לא שומר את מה שהקריאה הפנימית החזירה, כל מסגרת מוסרת את הביטוי של ה-
returnשלה, ולא ערך שהגיע מלמטה. - אפשר לדלג במעקב על קריאת הבסיס שבה תנאי העצירה מתקיים. אם קריאת הבסיס מדפיסה משהו לפני ה-
return, השמטתה משנה את הפלט.
בדקו את עצמכם
נתונה void edge(int lvl) { if (lvl < 1) return; printf("%d", lvl); edge(lvl - 1); printf("%d", lvl); }. מה תדפיס הקריאה edge(3)?
321123. בדרך למטה מודפסים 3, 2, 1; הקריאה edge(0) חוזרת בלי להדפיס; ובדרך חזרה מודפסים 1, 2, 3.
משתנה מקומי, משתנה static ומשתנה גלובלי
השאלה שמבדילה בין שלושת הסוגים היא מה נשאר מהמשתנה אחרי שהפונקציה חוזרת. לא כל משתנה שנכתב בתוך גוף של פונקציה יושב במחסנית:
| סוג | מה נשאר אחרי החזרה | היכן מאוחסן | הערך הראשוני | מספר עותקים |
|---|---|---|---|---|
מקומי רגיל, כמו int a = 0; | כלום, התא נמחק עם המסגרת | במסגרת של הקריאה, במחסנית | נקבע מחדש בכל קריאה | אחד לכל הפעלה שעוד לא חזרה |
מקומי עם static, כמו static int s = 0; | הערך האחרון, זמין לקריאה הבאה | באזור הנתונים (.data או .bss), מחוץ למחסנית | נקבע פעם אחת בלבד, לפני תחילת הריצה | עותק יחיד |
| גלובלי, מחוץ לכל פונקציה | הערך נשמר עד סוף התוכנית | באזור הנתונים (.data או .bss), מחוץ למחסנית | נקבע פעם אחת בלבד, לפני תחילת הריצה | עותק יחיד, משותף לכל הפונקציות |
אזור הנתונים הוא זיכרון שקיים לאורך כל הריצה, בנפרד מהמחסנית ומה-heap.
static מקומי נותן לפונקציה זיכרון פרטי: אף פונקציה אחרת לא יכולה להזכיר את שמו, אבל ערכו שורד בין קריאות. לכן השורה static int calls = 0; לא מאפסת בכל כניסה, אלא קובעת ערך התחלתי פעם אחת.
משתנה גלובלי דומה ללוח מודעות משותף: כל פונקציה יכולה לכתוב עליו, וכל כתיבה נראית לכל השאר בקריאה הבאה.
תרחיש 7: static, גלובלי ומקומי באותה רקורסיה
#include <stdio.h>
int calls_made = 0;
int accumulate(int k) {
static int acc = 0;
int fresh = 0;
calls_made++;
fresh++;
acc += k * 2;
if (k > 1)
accumulate(k - 1);
return acc * 10 + fresh;
}
int main(void) {
int r1 = accumulate(3);
int r2 = accumulate(2);
printf("%d %d %d\n", r1, r2, calls_made);
return 0;
}121 181 5accumulate(3) מוסיפה ל-acc את 3 * 2 = 6. הקריאות הפנימיות accumulate(2) ו-accumulate(1) מוסיפות 4 ואחר כך 2, כך ש-acc מגיע ל-12 עוד לפני שהמסגרת החיצונית חוזרת, ובה fresh הוא 1, ולכן הערך החוזר הוא 12 * 10 + 1 = 121.
הקריאה accumulate(2) שמ-main ממשיכה מ-acc = 12: מתווספים 4 ו-2 והסכום 18, ולכן 181. calls_made ספר שלוש קריאות בפעם הראשונה ושתיים בשנייה, חמש בסך הכול, ואילו fresh מתחיל מ-0 בכל מסגרת חדשה.
טעויות נפוצות
- השורה
static int c = 0;מאפסת אתcבכל קריאה מחדש. אתחול של משתנהstaticקורה פעם אחת בלבד עבור כל התוכנית, לא בכל כניסה לפונקציה. - משתנה
staticמקומי מאוחסן במחסנית של הפונקציה, וגלובלי במחסנית שלmain. שניהם יושבים באזור הנתונים (.dataאו.bss) ולא במחסנית. - הפעולה
g += 4מציבה4בתוך המשתנה הגלובליg. אופרטור+=מוסיף4לערך הקיים שלg, ואינו מחליף אותו.
בדקו את עצמכם
בפונקציה מוגדרים int a = 1; ו-static int b = 1;. בכל קריאה מתבצע a *= 3; b *= 3; return a + b;. מה יחזירו שלוש קריאות עוקבות?
6, 12, 30. המשתנה a מחושב בכל פעם כ-3, ואילו b מתקדם ל-3, 9, 27.
גלישת מחסנית וכתיבה מעבר למערך
נפתח בחשבון. נניח מחסנית של 8MB, שהיא ברירת המחדל ל-thread הראשי בלינוקס (אפשר לבדוק אותה עם ulimit -s, ואפשר לשנות), לעומת 1MB בווינדוס. מסגרת קטנה של כ-100 בתים מאפשרת בערך שמונים אלף קריאות פעילות, ואילו מסגרת של 2400 בתים מאפשרת רק כ-3,400.
החשבון תקף כי מסגרת נעלמת רק כשהקריאה שלה חוזרת, ובירידה ברקורסיה אף מסגרת עדיין לא חזרה. הצריכה היא מספר הקריאות הפעילות כפול גודל מסגרת אחת, ומכאן שלוש דרכים לחצות את הגבול: רקורסיה בלי תנאי עצירה, רקורסיה עמוקה מאוד, ומערך מקומי גדול שמנפח כל מסגרת.
ברגע שקריאה חדשה מנסה לפתוח מסגרת מעבר לגבול, היא נוגעת באזור מוגן שמונח מתחת למחסנית (guard page). בלינוקס התהליך מקבל SIGSEGV, ובווינדוס נזרקת חריגה STATUS_STACK_OVERFLOW עם הקוד 0xC00000FD.
שימו לב שהמחסנית לא נמשכת לתוך ה-heap, והקומפיילר אינו מזהה את הבעיה בזמן הקומפילציה: קוד כזה מתקמפל, ורק הריצה נכשלת.
תרחיש 8: כמה קריאות נכנסות במחסנית
#include <stdio.h>
double weigh(int depth) {
double samples[300];
for (int i = 0; i < 300; i++)
samples[i] = depth + i;
if (depth == 0)
return samples[0];
return samples[299] + weigh(depth - 1);
}
int main(void) {
printf("%.0f\n", weigh(50000));
return 0;
}המערך samples מכיל 300 ערכי double, כלומר 2400 בתים, ולכן מסגרת אחת של weigh תופסת קצת יותר מזה (הגודל המדויק משתנה בין קומפיילרים). בערך 3,400 מסגרות כאלה ממלאות 8MB, וההזמנה כאן היא ל-50,001 קריאות פעילות.
הקריסה קורית בירידה, הרבה לפני שמגיעים ל-printf, ולכן אין פלט. בהרצה על Windows התהליך הסתיים בקוד 0xC00000FD; בלינוקס מצפים ל-SIGSEGV. התוצאה מניחה קומפילציה בלי אופטימיזציה (gcc -O0), כי קומפיילר שמבצע אופטימיזציה רשאי לשנות את מבנה הקריאות.
הבעיה השלישית שונה: אין כאן עומק אלא אינדקס שחורג מגבול מערך מקומי. C לא בודקת אינדקסים בזמן ריצה, ולכן הכתיבה פשוט נוחתת בכתובת הבאה, וזו התנהגות לא מוגדרת.
בכתובות הסמוכות יושבים משתנים אחרים של אותה מסגרת, ואחריהם גם כתובת החזרה השמורה, ופגיעה בה נקראת stack smashing.
התוצאה לא צפויה: אולי קריסה, אולי כלום. קיימת גם הגנה בשם stack canary, ערך שמור שהקומפיילר מניח לפני כתובת החזרה ובודק לפני החזרה מהפונקציה; אם הוא השתנה, התוכנית נעצרת בהודעה stack smashing detected (למשל עם gcc -fstack-protector).
תרחיש 9: כתיבה מעבר לגבול של מערך מקומי
#include <stdio.h>
void load_levels(void) {
int levels[5];
for (int i = 0; i <= 8; i++)
levels[i] = i * 10;
printf("%d\n", levels[4]);
}
int main(void) {
load_levels();
printf("end\n");
return 0;
}המערך levels מכיל 5 מספרים, אבל התנאי i <= 8 כותב תשעה, ארבעה מהם מחוץ לגבול. זו טעות מוכרת של גבול עליון שגוי. הקוד מתקמפל, לכל היותר עם אזהרה, כי האינדקס נקבע רק בהרצה, ושם מתרחש הנזק.
אפשר שהתוכנית תדפיס 40 ו-end בהרצה אחת ותקרוס באחרת, או שהמסגרת הפגועה תעצור אותה רק בחזרה מהפונקציה. לכן אין פלט מוצג, והתשובה הנכונה בשאלה היא תמיד התנהגות לא מוגדרת.
טעויות נפוצות
- המסגרת של הקורא משתחררת לפני שהקריאה הרקורסיבית הבאה נפתחת. הקורא חייב להמתין לסיום הפונקציה שזימן, ולכן כל המסגרות מצטברות במקביל.
- אם המחסנית מתמלאת, היא פשוט ממשיכה לתוך אזור ה-heap. המחסנית מוגבלת בגודלה ופגיעה בדף השמירה עוצרת את התוכנית מיד.
- רקורסיה אינסופית נחסמת בשגיאת קומפילציה. הקומפיילר מקמפל קוד כזה ללא התנגדות; הגלישה מתגלה רק בזמן ריצה.
- כתיבה של בית אחד מעבר לסוף מערך תמיד גורמת לקריסה מיידית, או לחלופין מתעלמים ממנה. הכתיבה פוגעת בזיכרון אמיתי סמוך ועלולה לדרוס נתונים או לחלוף בלי סימן - זו התנהגות לא מוגדרת.
בדקו את עצמכם
פונקציה רקורסיבית מגדירה מערך מקומי של 2000 בתים ונקראת לעומק 5000 בסביבה עם מחסנית של 8MB. האם התוכנית תקרוס?
כן. 5000 מסגרות שכל אחת גדולה מ-2000 בתים דורשות יותר מ-10,000,000 בתים, ו-8MB הם בערך 8.4 מיליון בתים.
מצביעים לפונקציות: int (*f)(int, int)
קריאת ההצהרה: איפה הסוגריים
כשפונקציה מקומפלת, הקוד שלה נטען לאזור כלשהו בזיכרון, ולכן יש לה כתובת. משתנה שמחזיק כתובת כזו הוא מצביע לפונקציה.
נבנה את ההצהרה על f צעד אחר צעד. מתחילים בשם ועוטפים אותו כדי שיהיה מצביע, (*f); מצמידים רשימת פרמטרים, (*f)(int, int), כדי שהמצביע יצביע על פונקציה; ובסוף מקדימים את טיפוס ההחזרה: int (*f)(int, int);.
מה קורה בלי הסוגריים? ב-int *f(int, int); רשימת הפרמטרים נצמדת ל-f לפני הכוכבית, כי לה קדימות. לכן f נקרא כפונקציה, והכוכבית נשארת אצל int ואומרת שהפונקציה מחזירה int *.
| הצהרה | איך קוראים אותה |
|---|---|
double (*conv)(double); | conv הוא מצביע לפונקציה שמקבלת double ומחזירה double |
double *conv(double); | conv היא פונקציה רגילה שמחזירה double * |
float (*handlers[4])(float); | מערך של 4 מצביעים, שכל אחד מהם מצביע לפונקציה מהצורה הזו |
void (*on_done)(int); | מצביע לפונקציה שמקבלת int ואינה מחזירה ערך |
בנוסף, יש כמה עובדות על שימוש במצביע כזה, והטבלה הבאה מסכמת אותן:
| ביטוי | מה נכון לגביו |
|---|---|
f = sum2; מול f = &sum2; | זהים: שם פונקציה בתוך ביטוי הופך לכתובתה, ולכן ה-& אופציונלי |
f(2, 3) מול (*f)(2, 3) | אותה קריאה בדיוק |
sizeof f | 8 בתים ב-x86-64, כי נמדדת כתובת ולא הפונקציה שהיא מובילה אליה; גם גוף ארוך או עשרה פרמטרים לא משנים זאת |
f == sum2 | 1 כש-f מחזיק את sum2, ו-0 כשהוא מחזיק פונקציה אחרת |
תרחיש 10: פונקציה שמחזירה מצביע מול מצביע לפונקציה
#include <stdio.h>
int *pick_max(int *first, int *second) {
return *first > *second ? first : second;
}
int sum2(int p, int q) {
return p + q;
}
int main(void) {
int left = 4, right = 11;
int (*calc)(int, int) = sum2;
int *winner = pick_max(&left, &right);
*winner = 50;
printf("%d %d %d\n", left, right, calc(left, right));
return 0;
}4 50 54pick_max(&left, &right) משווה בין 4 ל-11 ומחזירה את הכתובת של right, ולכן winner הוא בעצם שם נוסף ל-right, וההשמה *winner = 50 כותבת אליו.
calc הוא מצביע לפונקציה, ולכן calc(left, right) היא למעשה sum2(4, 50) שמחזירה 54. הטעות הנפוצה היא לחשוב שהשניים מאותו סוג: הראשונה פונקציה שמחזירה מצביע, והשני מצביע שמריץ פונקציה.
תרחיש 11: גודל מצביע לפונקציה והשוואת כתובות
#include <stdio.h>
int add4(int v) { return v + 4; }
int flip(int v) { return -v; }
int main(void) {
int (*fn)(int) = add4;
int out = fn(5);
fn = &flip;
out = (*fn)(out);
printf("%d %d %d\n", out, fn == flip, fn == add4);
printf("%zu\n", sizeof fn);
return 0;
}-9 1 0
8| שורה | מה קורה | ערך |
|---|---|---|
fn(5) | fn מחזיק את add4, והיא רצה | 9 |
fn = &flip; | fn עובר ל-flip (ה-& אופציונלי) | ללא ערך |
(*fn)(out) | מריצה את flip(9) | -9 |
fn == flip ו-fn == add4 | השוואת הכתובות ש-fn מחזיק | 1 ו-0 |
sizeof fn | גודל כתובת ב-x86-64 | 8 |
טעויות נפוצות
- ההצהרה
int *f(int, int)מגדירה מצביע לפונקציה. ללא סוגריים סביב*f, הכוכבית שייכת לטיפוס ההחזרה וזו הצהרה על פונקציה שמחזירהint *. - הגודל
sizeofשל מצביע לפונקציה נקבע לפי מספר הפרמטרים או לפי טיפוס ההחזרה. מצביע לפונקציה מחזיק כתובת בלבד, ולכן גודלו ב-x86-64 הוא תמיד 8 בתים. - חייבים לכתוב
&לפני שם הפונקציה בזמן השמה למצביע. שם הפונקציה מומר אוטומטית למצביע אליה גם ללא&. - כל שני מצביעים לפונקציה מאותו טיפוס שווים זה לזה, או שמצביע לעולם אינו שווה לשם פונקציה. השוואת
==בודקת שוויון של כתובות הזיכרון בפועל.
בדקו את עצמכם
מה מצהירה השורה long *(*factories[5])(void);?
factories הוא מערך של 5 איברים. כל איבר הוא מצביע לפונקציה בלי פרמטרים שמחזירה long *.
השמה, קריאה והחלפת היעד
מצביע לפונקציה הוא משתנה, ולכן ההבדל בין act(v) לקריאה ישירה הוא רק במי שמחליט איזה קוד ירוץ. בקריאה ישירה זה השם שכתוב בקוד, ובקריאה דרך מצביע זה הערך שהמצביע מחזיק ברגע ההרצה.
אם בין שתי קריאות שמתם בו פונקציה אחרת, הקריאה השנייה תריץ את החדשה. לכן במעקב מוסיפים עמודה שרושמת על מה המצביע מצביע בכל צעד, ולא מניחים שהוא נשאר כפי שהיה.
מצביע שהוא NULL או שלא קיבל ערך לא מוביל לשום קוד אמיתי, ולכן קריאה דרכו היא התנהגות לא מוגדרת, ובלינוקס היא נגמרת בדרך כלל ב-SIGSEGV. אותה הגדרה חלה כשהטיפוס של המצביע לא מתאים לחתימה האמיתית של הפונקציה.
תרחיש 12: יעד שמתחלף לפי התוצאה
#include <stdio.h>
typedef int (*rule_fn)(int);
int plus_seven(int n) { return n + 7; }
int half_it(int n) { return n / 2; }
int main(void) {
rule_fn act = plus_seven;
int v = 5;
for (int step = 1; step <= 4; step++) {
v = act(v);
act = (v % 2 == 0) ? half_it : plus_seven;
}
printf("%d\n", v);
return 0;
}10| צעד | הפונקציה שבמצביע | v לפני | v אחרי | המצביע לצעד הבא |
|---|---|---|---|---|
| 1 | plus_seven | 5 | 12 | half_it (12 זוגי) |
| 2 | half_it | 12 | 6 | half_it (6 זוגי) |
| 3 | half_it | 6 | 3 | plus_seven (3 אי-זוגי) |
| 4 | plus_seven | 3 | 10 | half_it |
אחרי צעד 2 המצביע נשאר על half_it, ולכן צעד 3 משתמש בו שוב. אחרי צעד 3 הוא חוזר ל-plus_seven, ולכן צעד 4 משתמש בה.
תרחיש 13: מצביע לפונקציה שמשנה משתנה של הקורא
#include <stdio.h>
int grow(int *p) {
*p += 3;
return *p;
}
int main(void) {
int v = 1;
int (*fp)(int *) = grow;
int first = fp(&v);
grow(&v);
printf("%d %d\n", first, v);
return 0;
}4 7fp(&v) מריצה את grow ומגדילה את v ל-4, ו-first שומר עותק של הערך הזה. הקריאה הישירה grow(&v) מגדילה את v שוב ל-7, בעוד first נשאר 4.
טעויות נפוצות
- אחרי שהמצביע עודכן לפונקציה חדשה, הקריאות ממשיכות להריץ את הפונקציה הקודמת. המצביע נקרא מחדש בכל קריאה ומריץ את הכתובת העדכנית השמורה בו.
- קריאה דרך מצביע לפונקציה רק מעבירה את הארגומנט הלאה בלי לחשב. הקריאה מפעילה את גוף הפונקציה המוצבעת ומחזירה את תוצאתה.
- אפשר להפעיל את
plus_sevenואתhalf_itבסדר ההפוך ולקבל אותה תוצאה. הסדר משנה את התוצאה: מ-5,plus_sevenואחריהhalf_itנותנות6, וההפוך נותן9.
בדקו את עצמכם
בתרחיש הראשון למעלה, מה היה הפלט אילו act היה מאותחל ל-half_it במקום ל-plus_seven?
4. הצעדים: half_it(5) = 2 (זוגי, נשאר half_it), half_it(2) = 1 (אי-זוגי, עובר ל-plus_seven), plus_seven(1) = 8 (זוגי, עובר ל-half_it) ו-half_it(8) = 4.
מצביע לפונקציה כפרמטר (callback)
איך qsort יודעת לסדר מערך מכל טיפוס? היא לא יודעת להשוות בעצמה, ולכן מקבלת מכם פונקציית השוואה וקוראת לה בכל פעם שצריך להחליט מי קודם. פונקציה שנשלחת כך נקראת callback, והפרמטר שמקבל אותה הוא מצביע לפונקציה.
#include <stdio.h>
#include <stdlib.h>
int by_last_digit(const void *x, const void *y) {
return (*(const int *)x % 10) - (*(const int *)y % 10);
}
int main(void) {
int arr[5] = { 23, 41, 15, 7, 38 };
qsort(arr, 5, sizeof(int), by_last_digit);
for (int i = 0; i < 5; i++)
printf("%d%s", arr[i], i < 4 ? " " : "\n");
return 0;
}41 23 15 7 38מעבירים רק את השם by_last_digit, בלי סוגריים ובלי &, כי שם של פונקציה בתוך ארגומנט הופך לכתובתה.
qsort לא מכירה את טיפוס האיברים, ולכן פונקציית ההשוואה מקבלת שתי כתובות מטיפוס const void * וממירה אותן (cast) ל-const int * כדי לקרוא את הערכים. היא מחזירה מספר שלילי כשהראשון צריך לבוא לפני השני, אפס כשהם שווים וחיובי כשהוא צריך לבוא אחריו.
נעבור לדוגמה קטנה יותר. נניח ש-minus מקבלת שני int ומחזירה את ההפרש. אחרי merge_pair(minus, 20, 6), כשהפרמטר ב-int (*how)(int, int), המשתנה how הוא minus, והשורה how(p, q) שווה ל-minus(20, 6).
כדי לעקוב אחרי callback, כתבו ליד כל שורת קריאה בתוך הפונקציה איזו פונקציה התקבלה בפועל, ואז חשבו אותה על הערכים של אותו רגע. הסדר שבו הארגומנטים כתובים חשוב, כי פעולות כמו חיסור אינן סימטריות, כפי שמראה trail בהמשך.
תרחיש 14: מילוי מערך באמצעות callback
#include <stdio.h>
int minus(int a, int b) { return a - b; }
int times(int a, int b) { return a * b; }
void trail(int (*cb)(int, int), int seed, int step, int out[], int n) {
int cur = seed;
for (int i = 0; i < n; i++) {
cur = cb(cur, step);
out[i] = cur;
}
}
int main(void) {
int a[4], b[4];
trail(minus, 20, 3, a, 4);
trail(times, 2, 3, b, 4);
for (int i = 0; i < 4; i++)
printf("%d%s", a[i], i < 3 ? " " : "\n");
for (int i = 0; i < 4; i++)
printf("%d%s", b[i], i < 3 ? " " : "\n");
return 0;
}17 14 11 8
6 18 54 162| קריאה | out[0] | out[1] | out[2] | out[3] |
|---|---|---|---|---|
trail(minus, 20, 3, a, 4) | 17 | 14 | 11 | 8 |
trail(times, 2, 3, b, 4) | 6 | 18 | 54 | 162 |
בגוף trail הצובר cur נמצא במקום הראשון, ולכן minus מחשבת cur - step. אילו הסדר היה הפוך, step - cur הייתה נותנת כבר באיבר הראשון -17.
תרחיש 15: callback שמקבל כתובת
#include <stdio.h>
void twice(void (*fn)(int *), int *target) {
fn(target);
fn(target);
}
void triple_it(int *cell) { *cell *= 3; }
int main(void) {
int amount = 2;
twice(triple_it, &amount);
printf("%d\n", amount);
return 0;
}18twice מקבלת פונקציה שעובדת על כתובת ואת הכתובת עצמה. triple_it(&amount) רצה פעמיים, ו-amount של main עובר מ-2 ל-6 ואז ל-18.
כשפונקציה מקבלת שני מצביעים, כמו combine בשאלת הבדיקה, כל אחד נקרא בשורה משלו עם הארגומנטים שנכתבו שם. אם תחליפו ביניהם, אותם מספרים יעברו דרך פונקציות אחרות ויתקבל פלט אחר.
טעויות נפוצות
- בפעולות כמו חיסור או חילוק, סדר הארגומנטים המועברים ל-callback אינו משנה. פעולות לא קומוטטיביות מחזירות תוצאה שונה כשמחליפים בין הארגומנט הראשון לשני.
- כשמועברים שני מצביעי פונקציות, אפשר להתעלם ממי שהועבר ראשון או שני. החלפה ביניהם מריצה את הפונקציות בסדר הפוך או על ארגומנטים שגויים.
- לולאת
for (int i = 1; i <= 3; i++)רצה פעמיים. הלולאה רצה עבור1,2ו-3, כלומר שלוש איטרציות מלאות.
בדקו את עצמכם
נתונה int combine(int (*first)(int, int), int (*second)(int, int), int u, int v) { return first(u, v) + second(v, u); }. מה תחזיר combine(minus, times, 3, 5)?
13. הקריאה minus(3, 5) מחזירה -2, והקריאה times(5, 3) מחזירה 15; סכומם הוא 13.
מערך של מצביעים, typedef ו-struct
נניח שהתוכנית צריכה להפעיל אחת מכמה פעולות לפי מספר שנבחר. אפשר לכתוב switch ארוך, או לאסוף את הפונקציות במערך ולפנות אליו באינדקס: זו טבלת שליחה (dispatch table).
#include <stdio.h>
int sum_ab(int u, int v) { return u + v; }
int prod_ab(int u, int v) { return u * v; }
int diff_ab(int u, int v) { return u - v; }
int main(void) {
int (*jobs[3])(int, int) = { sum_ab, prod_ab, diff_ab };
for (int i = 0; i < 3; i++)
printf("jobs[%d](6, 4) = %d\n", i, jobs[i](6, 4));
return 0;
}jobs[0](6, 4) = 10
jobs[1](6, 4) = 24
jobs[2](6, 4) = 2ההצהרה int (*jobs[3])(int, int) מגדירה מערך של שלושה מצביעים. כדי להפעיל אחד מהם כותבים jobs[i](a, b): קודם נבחר האיבר ה-i, ואז הוא נקרא.
הספירה מתחילה מאפס, ולכן jobs[0] הוא sum_ab ו-jobs[2] הוא diff_ab, השלישית ברשימה.
במקום לחזור על התחביר המסורבל, נותנים לו שם קצר: אחרי typedef int (*unary_op)(int); הכינוי unary_op משמש כמו כל טיפוס, למשל unary_op stages[3]; או unary_op one = bump1;.
גם struct יכול להחזיק מצביע לפונקציה כאחד משדותיו. כל עצם נושא איתו את הפעולה שלו, ובקריאה obj.run(...) (או p->run(...) דרך מצביע) מופעלת הפעולה של אותו עצם. התוצאה היא התנהגות שונה לכל עצם, מעין פולימורפיזם בתוך C.
תרחיש 16: מערך פונקציות בלולאה רגילה ובקן לולאות
#include <stdio.h>
typedef int (*unary_op)(int);
int bump1(int num) { return num + 1; }
int square_it(int num) { return num * num; }
int halve(int num) { return num / 2; }
int main(void) {
unary_op stages[3] = { square_it, bump1, halve };
int a = 4;
for (int idx = 0; idx < 3; idx++)
a = stages[idx](a);
printf("%d\n", a);
int b = 2;
for (int outer = 0; outer < 2; outer++)
for (int inner = 0; inner < 2; inner++)
b = stages[inner](b);
printf("%d\n", b);
return 0;
}8
26הלולאה הראשונה מפעילה כל אחד משלושת האיברים של stages פעם אחת, לפי האינדקס: 4 הופך ל-16, אחר כך ל-17, ובחילוק שלמים ל-8.
בלולאה המקוננת רק inner קובע איזה איבר בטבלה יופעל, ו-outer קובע כמה פעמים עוברים על שני האיברים הראשונים. הסדר הוא stages[0], stages[1], stages[0], stages[1], ולכן 2 הופך ל-4, ל-5, ל-25 ולבסוף ל-26.
תרחיש 17: מצביע לפונקציה בתוך struct ופונקציה עם ארגומנטים משתנים
#include <stdio.h>
#include <stdarg.h>
int sum_ab(int u, int v) { return u + v; }
int prod_ab(int u, int v) { return u * v; }
struct op_entry {
const char *label;
int (*run)(int, int);
};
int count_above(int n, int limit, ...) {
va_list args;
va_start(args, limit);
int hits = 0;
for (int idx = 0; idx < n; idx++)
if (va_arg(args, int) > limit)
hits++;
va_end(args);
return hits;
}
int main(void) {
struct op_entry menu[2] = { { "sum", sum_ab }, { "prod", prod_ab } };
printf("%s=%d\n", menu[1].label, menu[1].run(5, 6));
int (*vptr)(int, int, ...) = count_above;
printf("%d\n", vptr(4, 15, 8, 22, 16, 15));
return 0;
}prod=30
2ב-menu[1] נשמרה prod_ab בשדה run, ולכן menu[1].run(5, 6) מחזירה 30. מה שקובע איזו פונקציה תרוץ הוא מה שאותחל בשדה, לא התווית label.
בקריאה vptr(4, 15, 8, 22, 16, 15) יש שישה ארגומנטים, אף שלפונקציה count_above יש רק שני פרמטרים קבועים. זה אפשרי כי היא variadic, כלומר מוצהרת עם ... אחרי הפרמטרים הקבועים.
נעקוב אחריה. הערך n הוא 4, ו-va_start(args, limit) מעגן את הקריאה בפרמטר הנקוב האחרון, limit, שהוא 15.
ארבע הקריאות ל-va_arg(args, int) מחזירות לפי הסדר 8, 22, 16 ו-15, ורק 22 ו-16 גדולים מ-15, ולכן התוצאה 2. אחר כך va_end סוגרת את הסריקה. כדי להצביע על פונקציה כזו, טיפוס המצביע חייב לחזור על ה-..., ולכן vptr מוצהר כ-int (*vptr)(int, int, ...); בלי ה-... הטיפוס לא היה תואם.
טעויות נפוצות
- במערך
jobs, האיברjobs[2]הוא השני ברשימה. המקום הראשון הואjobs[0], ולכןjobs[2]נמצא שני צעדים אחרי ההתחלה, כלומר במקום השלישי. - שם השדה
labelב-structקובע איזו פונקציה תופעל. מה שקובע בפועל הוא כתובת הפונקציה שהוכנסה לשדה המצביעrun. - בלולאה מקוננת מריצים את כל האיטרציות של
stages[0]לפני שעוברים ל-stages[1]. הלולאה הפנימית משלימה מחזור מלא בכל צעד בודד של הלולאה החיצונית. - בפונקציה variadic הלולאה מדלגת על הארגומנט האחרון. לולאה של
idx < nקוראת בדיוקnארגומנטים מהרשימה, כולל האחרון.
בדקו את עצמכם
נתונים unary_op arr[3] = { bump1, square_it, halve }; ו-int val = 3;. לאחר for (int idx = 0; idx < 3; idx++) val = arr[idx](val);, מה יהיה ערכו של val?
8. מתבצע bump1(3) = 4, אחר כך square_it(4) = 16, ולבסוף halve(16) = 8.
פונקציה שמחזירה מצביע לפונקציה
לפעמים הפונקציה צריכה לבחור בזמן ריצה איזה חישוב להעביר לקורא, למשל תעריף משלוח לפי דרגה. אז היא מחזירה מצביע לפונקציה, וקל יותר להתחיל מהצורה עם כינוי: typedef int (*rate_fn)(int); ואחריו rate_fn pick_rate(int tier).
בלי הכינוי מחליפים את rate_fn בצורת המצביע המלאה, והשם של הפונקציה עם רשימת הפרמטרים שלה נכנס למקום שבו היה שם המשתנה: מ-int (*p)(int) מקבלים int (*pick_rate(int tier))(int).
הביטוי pick_rate(2)(5) מורכב משני זוגות סוגריים, ושניהם נחוצים: הראשון מחזיר פונקציה, והשני מפעיל אותה.
pick_rate(2)(5)
step 1: pick_rate(2) returns [ address of express ]
step 2: [ address of express ](5) runs express(5) gives 70תרחיש 18: בחירת תעריף מטבלת חיפוש
#include <stdio.h>
typedef int (*rate_fn)(int);
int flat_fee(int kg) { return 50; }
int per_kg(int kg) { return kg * 8; }
int express(int kg) { return kg * 8 + 30; }
rate_fn rates[3] = { flat_fee, per_kg, express };
int (*pick_rate(int tier))(int) {
if (tier < 0 || tier > 2)
return flat_fee;
return rates[tier];
}
rate_fn pick_rate_alias(int tier) {
return pick_rate(tier);
}
int main(void) {
printf("%d %d\n", pick_rate(1)(5), pick_rate(2)(5));
rate_fn r = pick_rate_alias(9);
printf("%d\n", r(100));
return 0;
}40 70
50| ביטוי | מה הבוחרת מחזירה | ההפעלה | תוצאה |
|---|---|---|---|
pick_rate(1)(5) | per_kg | per_kg(5) | 40 |
pick_rate(2)(5) | express | express(5) | 70 |
pick_rate_alias(9) ואחר כך r(100) | flat_fee (9 מחוץ לטווח) | flat_fee(100) | 50 |
טעויות נפוצות
pick_rateהיא משתנה מצביע שמקבל מספר.pick_rateהיא פונקציה שמקבלת מספר ומחזירה מצביע לפונקציה.- המספר שנשלח ל-
pick_rateנכנס לחישוב המחיר עצמו. הוא רק בוחר איזו פונקציה תחזור; הנתונים לחישוב נשלחים בזוג הסוגריים השני. - הקריאה
pick_rate(1)(5)מחזירה את הכתובת שלper_kgולא מפעילה אותה. הסוגריים השניים מפעילים את הפונקציה שהוחזרה, והתוצאה היא מספר.
בדקו את עצמכם
בתרחיש למעלה, מה תחזיר הקריאה pick_rate(7)(2)?
50. הערך 7 מחוץ לטווח הטבלה, ולכן הבוחרת מחזירה את flat_fee, שמתעלמת מהארגומנט שלה.
פונקציות inline
מה inline עושה ומה היא אינה משנה
תלמידים רבים מניחים שסימון פונקציה ב-inline משנה את התנהגותה בזמן ריצה או כופה על הקומפיילר (מהדר) לנהוג בדרך מסוימת. בפועל חל כלל יסוד הפוך: inline לעולם אינה משנה את הערך שהתוכנית מחשבת, משום שהיא משמרת במלואם את כללי השפה של פונקציה רגילה.
מה שרואה הקורא אינו תלוי בהטמעה. אם קוראים ל-f(a++), המשתנה a גדל פעם אחת בדיוק, הערך מומר לטיפוס הפרמטר, ושם בתוך הגוף מפנה למה שהיה גלוי בנקודה שבה f נכתבה, ולא בנקודה שבה היא נקראת.
מה הקומפיילר חוסך כשהוא מטמיע? הוא מוותר על כל התשתית של קריאה: העברת הארגומנטים, ה-call, החזרה ב-ret ובניית מסגרת המחסנית ופירוקה.
בנוסף, הגוף שהודבק נחשף לאופטימיזציות יחד עם הקוד שמסביבו. זה רווח ביצועי בלבד, ו-inline בתקן C99 היא בקשה (הטמעה, inlining) ולא הוראה.
הבקשה אינה כופה דבר. פונקציה שסומנה עשויה להישאר קריאה רגילה, ופונקציה שלא סומנה עשויה להיות מוטמעת. ב-gcc עם -O0 שום פונקציה אינה מוטמעת, אלא אם צורפה לה __attribute__((always_inline)).
איך בודקים? קוראים את הפלט של הקומפיילר ולא את הפלט של התוכנית: gcc -S נותן אסמבלי, ו-objdump -d מפרק קובץ אובייקט. מחפשים שם call אל שם הפונקציה; היעדרו פירושו שהגוף הודבק. כמה בדיקות מפתות שאינן מועילות:
- הרצת התוכנית: הפלט זהה בשני המצבים.
gcc -E: הוא מפסיק בפרה-מעבד (מאקרו ו-#include), שאינו מטמיע פונקציות.-Wall: היא אינה מדווחת על הטמעות.-Winline: היא מתריעה בכיוון ההפוך, על פונקצייתinlineשלא הוטמעה.
/* ex2_asm.c */
static inline int half_plus(int v) { return (v >> 1) + 5; }
int adjust(int n) { return half_plus(n) * 2; }
$ gcc -O0 -S -masm=intel ex2_asm.c -> adjust contains: call "half_plus"
$ gcc -O2 -S -masm=intel ex2_asm.c -> adjust:
sar ecx
lea eax, 10[rcx+rcx]
ret (no call: half_plus was inlined)ברשימה שלמעלה הערך n ב-RCX כי היא הופקה ב-gcc ל-Windows x64 (בלינוקס יופיע EDI). בשני המקרים רואים אותו דבר: ב--O2 אין call.
בנוגע למשתנה static בתוך פונקציית static inline: אין מצב שבו כל אתר קריאה מוטמע מקבל משתנה משלו. קיים תא זיכרון אחד, וכל הקריאות, מוטמעות או עקיפות, קוראות וכותבות אליו.
ומה קורה כשלוקחים כתובת של פונקציית inline, למשל fp = f? המצביע חייב להצביע על קוד ממשי, ולכן הקומפיילר פולט גוף רגיל (out-of-line) נוסף על ההטמעות. עם static inline הגוף הזה נשאר בתוך הקובץ: הכלי nm ידווח עליו באות t קטנה (סמל מקומי), והלינקר לא יציע אותו לקבצי .c אחרים.
תרחיש 19: מצביע לפונקציה ומשתנה static בתוך static inline
#include <stdio.h>
static inline int accum_mul(int factor) {
static int acc = 2;
acc *= factor;
return acc;
}
int main(void) {
int (*fn)(int) = accum_mul;
int v1 = accum_mul(3);
int v2 = fn(5);
int v3 = accum_mul(2);
printf("out: %d %d %d\n", v1, v2, v3);
return 0;
}out: 6 30 60למרות שלקחנו מצביע ל-accum_mul ושילבנו קריאות ישירות עם קריאה עקיפה דרך fn, כולן מעדכנות את אותו acc יחיד: 2 * 3 = 6, אחר כך 6 * 5 = 30, ולבסוף 30 * 2 = 60.
טעויות נפוצות
- הרצת התוכנית או הפקת פלט
gcc -Eמוכיחות אם הקומפיילר הטמיע פונקציה. התוצאה בריצה זהה לחלוטין, ו--Eעוצר בשלב הפרה-מעבד. רק בדיקת האסמבלי (-Sאוobjdump -d) חושפת אם נותרה הוראתcall. - אי אפשר לשמור כתובת של פונקציית
inlineבמצביע לפונקציה. הפעולה חוקית לגמרי; הקומפיילר פשוט מפיק עותק רגיל בקובץ האובייקט לצורך הכתובת. - העותק הרגיל שנוצר עבור
static inlineחשוף לקבצים אחרים בלינקר. המילהstaticמשאירה את הסמל מקומי לקובץ (tקטנה ב-nm). - כל מופע מוטמע של
static inlineמקבל עותק נפרד של משתנהstaticפנימי. ישנו עותק יחיד של המשתנה, וכל הקריאות ניגשות אליו. - המילה
inlineמחייבת את הקומפיילר לבצע הטמעה בכל מצב. זו המלצה בלבד; ב--O0ב-gccאין הטמעה כלל ללאalways_inline.
בדקו את עצמכם
נתונה static inline int pool(int take) { static int stock = 50; stock -= take; return stock; }. קוראים ל-pool(12) ואז ל-pool(18). מה תחזיר הקריאה השנייה?
20. יש עותק יחיד של stock: לאחר הקריאה הראשונה ערכו 50 - 12 = 38, ולאחר השנייה 38 - 18 = 20.
inline מול מאקרו: ארבעה הבדלים מכריעים
החלפת פונקציה קטנה במאקרו #define נראית לעיתים כקיצור דרך תמים, אך מובילה לבאגים מפתיעים בחישוב, בקדימות ובשמות משתנים. הסיבה לכך היא שמאקרו מטופל בידי הפרה-מעבד בהחלפת טקסט עיוורת לפני שהקומפיילר רואה טיפוסים או היקפים, בעוד static inline מספקת את ביצועי ההטמעה עם כל ערבויות הבטיחות של פונקציה.
נתחיל בשני הבדלים שמקורם בשלב התרגום: בדיקת טיפוסים והיקף שמות (scope). למאקרו אין חתימה ואין טיפוסי פרמטרים, והוא אינו יוצר היקף משלו, ולכן שמות בתוכו נפתרים במקום ההרחבה.
תרחיש 20: המרת טיפוסים ופתרון שמות בהיקף
#include <stdio.h>
#define FIFTH_M(n) ((n) / 5)
static inline int fifth_f(int n) {
return n / 5;
}
int main(void) {
printf("%.2f %d\n", FIFTH_M(12.0), fifth_f(12.0));
printf("%d\n", fifth_f(19.9));
return 0;
}2.40 2
3המאקרו FIFTH_M(12.0) הופך ל-((12.0) / 5), שהוא חילוק ב-double המניב 2.40. לעומת זאת, הפרמטר של fifth_f הוא int, ולכן 12.0 נחתך ל-12 (12 / 5 = 2) ו-19.9 נחתך ל-19 (19 / 5 = 3).
#include <stdio.h>
int offset = 10;
#define ADD_OFF_M(v) ((v) + offset)
static inline int add_off_f(int v) {
return v + offset;
}
int main(void) {
int offset = 200;
printf("%d %d\n", ADD_OFF_M(5), add_off_f(5));
return 0;
}205 15כאשר ADD_OFF_M(5) מורחב בתוך main, המשתנה המקומי offset (200) מסתיר את הגלובלי ומודפס 205. הפונקציה add_off_f נצמדת להיקף שבו הוגדרה, ולכן היא מחברת את offset הגלובלי (10) ומחזירה 15.
ההבדל השלישי נוגע לסוגריים וקדימות אופרטורים. מאחר שמאקרו מדביק מחרוזות גולמיות, ביטוי חיצוני או אופרטור בתוך הארגומנט עלולים להישאב לסדר פעולות שונה מזה שהתכוונתם אליו, אלא אם עוטפים גם כל פרמטר וגם את המאקרו כולו בסוגריים.
תרחיש 21: ערבוב קדימות אופרטורים במאקרו חסר סוגריים
#include <stdio.h>
#define MUL10(a) a * 10
#define SUB1(a) a - 1
static inline int sub1(int a) {
return a - 1;
}
int main(void) {
printf("%d\n", MUL10(4 + 1));
printf("%d %d\n", SUB1(9) * 2, sub1(9) * 2);
return 0;
}14
7 16MUL10(4 + 1) מתרחב ל-4 + 1 * 10, כלומר 14 במקום 50, ו-SUB1(9) * 2 הופך ל-9 - 1 * 2, כלומר 7. הפונקציה sub1(9) מחזירה ערך גמור (8), ולכן 8 * 2 = 16 גם אחרי הטמעה; כדי לתקן את המאקרו יש לכתוב #define MUL10(a) ((a) * 10).
ההבדל הרביעי הוא ארגומנטים עם תופעות לוואי כמו i++. בפונקציית inline הארגומנט מוערך פעם אחת בלבד לפני הכניסה לגוף; במאקרו, לעומת זאת, כל הופעה של הפרמטר בגוף משכפלת את הארגומנט ומריצה את תופעת הלוואי מחדש.
כאן מסתתר דיוק חשוב למבחנים: במאקרו מבוסס תנאי משולש כמו #define PICK_MIN(a, b) ((a) < (b) ? (a) : (b)), הקריאה PICK_MIN(x++, cap) מוגדרת היטב בתקן C משום שלאופרטור ?: יש נקודת רצף (sequence point) בין בדיקת התנאי לבין הערכת הענף הנבחר. לעומת זאת, מאקרו שמכפיל פרמטר ללא נקודת רצף, כמו #define CUBE(k) ((k) * (k) * (k)) עם CUBE(k++), משנה את k כמה פעמים באותו ביטוי ויוצר התנהגות לא מוגדרת (UB).
תרחיש 22: הערכה בודדת ב-inline מול הכפלת תופעת לוואי במאקרו
#include <stdio.h>
#define PICK_MIN(u, v) ((u) < (v) ? (u) : (v))
static inline int pick_min(int u, int v) {
return u < v ? u : v;
}
int main(void) {
int x = 3, y = 3, cap = 10, hi = 15;
int r1 = PICK_MIN(x++, cap);
int r2 = pick_min(y++, cap);
int r3 = PICK_MIN(hi++, 8);
printf("%d %d %d %d\n", r1, x, r2, y);
printf("%d %d\n", r3, hi);
return 0;
}4 5 3 4
8 16בקריאה PICK_MIN(x++, cap) התנאי 3 < 10 מתקיים ו-x גדל ל-4, ואז הענף הנבחר (x++) מחזיר 4 ומקדם את x שוב ל-5. בפונקציה pick_min(y++, cap) הארגומנט מוערך פעם אחת (3), y עולה ל-4 בלבד, ומוחזר 3.
בקריאה PICK_MIN(hi++, 8) התנאי 15 < 8 שקרי: hi גדל בתנאי ל-16, אך נבחר הענף (8) שאינו מזכיר את hi, ולכן hi מקודם פעם אחת בלבד.
| מנגנון ההבדל | התנהגות ב-static inline | התנהגות במאקרו (#define) |
|---|---|---|
| טיפוסים והמרות | נבדק ומומר לטיפוס הפרמטר (כמו 2.5 ל-2 עבור int) | ללא טיפוסים: 2.5 נשאר double בהרחבה |
| היקף שמות (Scope) | נפתר לפי מקום ההגדרה של הפונקציה | נפתר לפי מקום ההרחבה אצל הקורא |
| קדימות אופרטורים | ערכים מוגמרים, ללא זליגת קדימות | חובה לעטוף בסוגריים כל פרמטר ואת הביטוי כולו |
תופעות לוואי (i++) | הארגומנט מוערך בדיוק פעם אחת | מוערך בכל מופע בנתיב הביצוע (ועלול לגרום ל-UB) |
טעויות נפוצות
- המאקרו
PICK_MIN(x++, cap)גורם להתנהגות לא מוגדרת בדומה ל-CUBE(x++). לאופרטור?:יש נקודת רצף אחרי התנאי, בשונה מביטוי כמו((x++) * (x++)). - המאקרו מחשב קודם את הארגומנט לפני ההדבקה בגוף. הפרה-מעבד רק מחליף טקסט בטקסט, בלי לחשב ובלי להוסיף סוגריים.
- פונקציית
inlineניגשת למשתנים מקומיים של הפונקציה הקוראת. היא מצייתת להיקף הלקסיקלי שבו היא עצמה הוגדרה. - פונקציית
inlineמוערכת פעמיים אם הפרמטר מופיע פעמיים בגוף. כל ארגומנט של פונקציה מוערך פעם אחת בלבד לפני הקריאה, גם כשהגוף מוטמע. - מאקרו הופך
7.0ל-intאם מעבירים אותו להדפסה עם%d. למאקרו אין פרמטרים עם טיפוס, ולכן החילוק נשארdouble.
בדקו את עצמכם
בהמשך לתרחיש למעלה, אם k = 2 ומבצעים res = PICK_MIN(k++, 9), מה יהיו res ו-k בסוף?
res = 3 ו-k = 4. התנאי 2 < 9 אמת ומקדם את k ל-3, ולאחר מכן הענף (k++) מחזיר 3 ומקדם את k ל-4.
inline בלי static: למה הקישור נכשל
הקוד עובר קומפילציה בלי אף אזהרה, אבל הלינקר (ld) עוצר עם undefined reference - ובדגל -O2 הבעיה לעיתים נעלמת. התופעה הזו מתרחשת כשכותבים פונקציית inline בלי static ובלי extern.
תרחיש 23: כשל קישור ב-inline עירומה לעומת static inline במצב -O0
/* gcc -std=c11 -O0 ex6_link_err.c */
#include <stdio.h>
inline int triple(int n) {
return n * 3;
}
int main(void) {
printf("%d\n", triple(4));
return 0;
}C:/.../ld.exe: ...:(.text+0x13): undefined reference to `triple'
collect2.exe: error: ld returned 1 exit statusזו תלות מסוכנת בדגלי אופטימיזציה: ב--O2 סביר שהקריאה תוטמע והקוד ייבנה, אבל זה לא מובטח, ואסור לסמוך על כך; ב--O0 הקריאה נשארת והבנייה נכשלת. הוספת static פותרת את הבעיה באופן קבוע:
#include <stdio.h>
static inline int triple(int n) {
return n * 3;
}
int main(void) {
printf("%d\n", triple(4));
return 0;
}12נתחיל ממה שהלינקר צריך: לכל סמל שקובץ אובייקט מפנה אליו חייב להיות גוף אחד בדיוק באחד הקבצים. הגדרה static inline מספקת גוף פנימי לקובץ בכל פעם שהקומפיילר זקוק לו. לעומתה, הגדרה עם inline בלבד (בלי static ובלי extern, מ-C99 ואילך) נקראת *הגדרת inline* (inline definition): היא רק מתירה הטמעה בקובץ הזה ואינה מייצאת גוף.
מכאן התרחיש: כשהקומפיילר מחליט שלא להטמיע, למשל ב--O0, נשארת הוראת call אל סמל שאין לו גוף באף מקום. הקומפילציה מצליחה, והלינקר הוא שמדווח undefined reference.
אפשר לשלול שתי טעויות נפוצות: זו אינה שגיאת קומפילציה, וגם לא multiple definition: אף גוף חיצוני לא נוצר. באיזו דרך מתקנים?
- להפוך ל-
static inline, כמקובל בקובץ כותרת: כל קובץ.cיפיק גוף פרטי משלו כשיצטרך, וההגדרות לא יתנגשו. - להשאיר
inlineבכותרת ולהצהירextern inline int triple(int);בקובץ.cאחד בלבד, וכך נוצר הגוף החיצוני היחיד.
gnu89 הישן הכללים היו הפוכים, אך בדיאלקטים המוגדרים כברירת מחדל בגרסאות gcc המודרניות (כגון gnu17 ו-gnu23), וכן תחת -std=c99, -std=c11 ו--std=c23, חלים כללי C99 שהוסברו כאן.טעויות נפוצות
- בנייה כזו נכשלת בשגיאת קישור מסוג
multiple definition. הפוך: לא נוצרת אף הגדרה חיצונית בקובץ האובייקט, ולכן מתקבלתundefined reference. - שימוש ב-
inlineללאstaticהוא שגיאת תחביר בקומפילציה. הקוד תקני ועובר קומפילציה בהצלחה; הכישלון מופיע אצל הלינקר אם נותרה קריאה. - התוכנית נבנית ומתרסקת בזמן ריצה. קובץ ההרצה כלל אינו נוצר משום שהלינקר עוצר את הבנייה.
בדקו את עצמכם
בקובץ C יחיד מופיעה inline int quadruple(int n) { return n * 4; } ו-main שקוראת ל-quadruple(5). מקמפלים עם gcc -std=c99 -O0. מה יקרה?
הקומפילציה תצליח, אך שלב הקישור ייכשל עם undefined reference to quadruple, כי ב--O0 אין הטמעה וההגדרה היא inline בלבד.
מוסכמות קריאה ב-x86 של 32 סיביות
החוזה שבין הקורא לנקראת
דמיינו קריאה לפונקציית __stdcall דרך מצביע שהוצהר כ-__cdecl. הקורא, שמאמין ב-cdecl, מסיר את הארגומנטים אחרי החזרה, אבל הנקראת כבר הסירה אותם בעצמה ב-ret N (הוראה זו מוסברת בהמשך). ההסרה הכפולה מזיזה את ESP מעבר למה שנדחף.
התוצאה היא התנהגות לא מוגדרת ובדרך כלל קריסה. מוסכמת קריאה (calling convention) היא החוזה הבינארי שמונע התנגשות כזו בין הקוד הקורא (caller) לפונקציה הנקראת (callee).
לפני שנפרט את הכללים, זכרו הבחנה חשובה: המוסכמה קובעת אך ורק כיצד הנתונים עוברים ואיך המחסנית מנוקה, ולא מה הפונקציה מחשבת. פונקציה כמו calc(4, 5) תחזיר את אותו ערך מספרי בדיוק תחת כל מוסכמה.
כדי לראות מה החוזה מכסה, התבוננו בקריאה אחת, r = calc(7, 8), ושאלו ארבע שאלות:
- איפה
7ו-8נמצאים ברגע ה-call, ובאיזה סדר הונחו: במחסנית או באוגרים? - מי מסיר אותם אחרי החזרה: הקורא או הנקראת?
- איזה אוגר שהקורא החזיק לפני הקריאה מובטח שישרוד, ואילו מותר לנקראת לדרוס?
- באיזה אוגר מחכה
r?
רשימת השאלות הזו היא ארבעת סעיפי החוזה: מיקום וסדר, אחריות הניקוי, שמירת אוגרים וערך ההחזרה. המילים __cdecl, __stdcall ו-__fastcall הן הרחבות של Microsoft ל-x86 של 32 סיביות, ואינן חלק מתקן C. ב-gcc וב-clang כותבים אותן כמאפיינים, למשל __attribute__((stdcall)), ו-MinGW מכירה גם את הצורה עם הקו התחתון הכפול.
ואם לא מציינים דבר? ב-x86 של 32 סיביות ברירת המחדל לפונקציות C היא cdecl.
cdecl: הקורא מסיר את הארגומנטים
איך פונקציה כמו printf מסוגלת לקבל שני ארגומנטים בקריאה אחת ושישה ארגומנטים בקריאה אחרת בלי להרוס את המחסנית? ב-cdecl, הצד הקורא הוא שמנקה את המחסנית מיד לאחר החזרה, מפני שרק הוא יודע כמה בתים דחף באותה קריאה.
כאשר מגיע תור הנקראת להסתיים, היא מבצעת ret רגיל (ללא מספר) ששולף מהמחסנית רק את כתובת החזרה. מיד כשהשליטה חוזרת לקורא, הוא מריץ הוראה כמו add esp, 12 (למשל עבור שלושה פרמטרים מסוג int, בני 4 בתים כל אחד) כדי להסיר את הארגומנטים.
העברת הארגומנטים עצמם ב-cdecl נעשית כולה על גבי המחסנית בסדר מימין לשמאל: הארגומנט האחרון נדחף ראשון, והראשון נדחף אחרון, כך שברגע שהוראת call דוחפת את כתובת החזרה, הארגומנט הראשון נמצא בכתובת הנמוכה ביותר, צמוד אליה.
; caller, 32-bit x86, cdecl: res = sum_diff(15, 25, 4);
push 4 ; 3rd argument pushed first
push 25 ; 2nd argument
push 15 ; 1st argument pushed last
call _sum_diff ; pushes return address and jumps
add esp, 12 ; caller cleans 12 bytes (3 x 4)
_sum_diff: ; int __cdecl sum_diff(int a, int b, int c)
mov eax, [esp+4] ; a
add eax, [esp+8] ; + b
sub eax, [esp+12] ; - c
ret ; plain ret pops only return addressטעויות נפוצות
retללא פרמטר מנקה גם את הארגומנטים מהמחסנית.retרגיל שולף רק את כתובת החזרה (4 בתים ב-32 סיביות).- ב-
cdeclהפונקציה הנקראת מנקה את המחסנית בסיום. ניקוי בידי הנקראת מאפיין אתstdcallו-fastcall; ב-cdeclהקורא מבצעadd esp, N. printfעובדת עם מספר משתנה של ארגומנטים כי היא סופרת אותם ומנקה בעצמה. היא אינה מנקה; כל אתר קריאה דוחף כמות משלו ומנקה אחריה עםadd esp, N.- מערכת ההפעלה או ספריית C מנקות את הארגומנטים אחרי הקריאה. הניקוי מבוצע ישירות על ידי הוראת
add esp, Nבקוד של הקורא בזמן ריצה.
בדקו את עצמכם
פונקציית cdecl ב-32 סיביות מקבלת ארבעה פרמטרים מסוג int. איזו הוראה ייצר הקומפיילר אצל הקורא מיד אחרי ה-call?
add esp, 16. ארבעה משתני int תופסים 4 * 4 = 16 בתים, והקורא מסיר אותם.
stdcall: הנקראת מנקה את המחסנית
אם כל קריאה ב-cdecl מחייבת הוספת add esp, N אצל הקורא, אפשר להקטין את נפח קוד המכונה על ידי העברת הניקוי אל תוך הפונקציה הנקראת. זוהי גישת stdcall, המוסכמה שבה מוכרזות פונקציות Win32 API (באמצעות המאקרואים WINAPI ו-CALLBACK), בעוד cdecl נשארת ברירת המחדל של שפת C.
הארגומנטים עדיין נדחפים למחסנית מימין לשמאל בדיוק כמו ב-cdecl, אך הפונקציה מסתיימת בהוראה ret N. הוראה זו שולפת את כתובת החזרה, קופצת אליה, ומוסיפה N בתים ל-ESP בפעולה אחת.
המחיר של קיצור אתרי הקריאה הוא ש-N חייב להיות קבוע כבר בזמן הקומפילציה. לכן stdcall אינה תומכת בפונקציות עם מספר משתנה של ארגומנטים (ב-MSVC פונקציה variadic שסומנה stdcall מומרת בשקט ל-cdecl).
; gcc -m32 -O1 -S -masm=intel
; int __attribute__((stdcall)) diff2(int x, int y) { return x * 2 - y; }
_diff2@8:
mov eax, DWORD PTR [esp+4]
add eax, eax
sub eax, DWORD PTR [esp+8]
ret 8 ; callee removes 8 bytes (2 ints)
; int __attribute__((stdcall)) add4(int n1, int n2, int n3, int n4) { return n1 + n2 + n3 + n4; }
_add4@16:
mov eax, DWORD PTR [esp+8]
add eax, DWORD PTR [esp+4]
add eax, DWORD PTR [esp+12]
add eax, DWORD PTR [esp+16]
ret 16 ; callee removes 16 bytes (4 ints)| גודל הארגומנטים | הוראת סיום (Intel) | הוראת סיום (AT&T) |
|---|---|---|
1 int (4 בתים) | ret 4 | ret $4 |
2 int (8 בתים) | ret 8 | ret $8 |
3 int (12 בתים) | ret 12 | ret $12 |
5 int (20 בתים) | ret 20 | ret $20 |
טעויות נפוצות
- המספר
Nב-ret Nמציין כמה פרמטרים יש לפונקציה.Nסופר בתים (4 בתים לכלint), לא את מספר הפרמטרים. - ב-
stdcallהצד הקורא מסיר את הארגומנטים מהמחסנית. הנקראת מנקה בעצמה באמצעותret N. - אפשר להצהיר על
printfכ-stdcall.Nקבוע בהוראת ה-ret, ולכן אינו מתאים למספר משתנה של ארגומנטים.
בדקו את עצמכם
באיזו הוראה תסתיים הפונקציה int __stdcall calc3(int n1, int n2, int n3)?
ret 12. שלושה פרמטרים מסוג int תופסים 3 * 4 = 12 בתים, והנקראת מסירה אותם.
fastcall: העברת שני ארגומנטים ב-ECX וב-EDX
ניקח קריאה calc(11, 22, 33, 44) עם ארבעה int ב-fastcall. 11 נכנס ל-ECX ו-22 ל-EDX, בלי שום כתיבה לזיכרון. רק 33 ו-44 נדחפים למחסנית, בסדר מימין לשמאל.
הכלל: שני הפרמטרים הראשונים, אם הם שלמים או מצביעים ברוחב של עד 32 סיביות, מקבלים את שני האוגרים האלה, וזה ב-MSVC וב-gcc ל-32 סיביות.
לא מקבלים את השלישי באוגר, ולא EAX: אוגר זה פנוי לערך ההחזרה. ומה לגבי מהירות? הפחתת הגישות לזיכרון מועילה בעיקר בפונקציות קטנות, אך הרווח צנוע ואינו מובטח.
בסיום, הנקראת היא שמנקה, ב-ret N, בדומה ל-stdcall, ולכן אין תמיכה בפונקציות variadic. בדוגמה למעלה הקורא דחף שני int בלבד, כלומר 8 בתים, ו-N יהיה 8: הוא סופר את מה שהיה במחסנית ולא את 11 ו-22.
; gcc -m32 -O1 -S -masm=intel
; int __attribute__((fastcall)) blend4(int n1, int n2, int n3, int n4)
; { return (n1 + n2) * n3 - n4; }
@blend4@16:
lea eax, [ecx+edx] ; n1 in ECX, n2 in EDX
imul eax, DWORD PTR [esp+4] ; n3 on stack
sub eax, DWORD PTR [esp+8] ; n4 on stack
ret 8 ; cleans only n3 and n4 (8 bytes)| חתימת int ב-fastcall | אוגרים | במחסנית | הוראת סיום |
|---|---|---|---|
2 פרמטרים (p1, p2) | ECX, EDX | אין | ret |
3 פרמטרים (p1..p3) | ECX, EDX | p3 (4 בתים) | ret 4 |
4 פרמטרים (p1..p4) | ECX, EDX | p3, p4 (8 בתים) | ret 8 |
6 פרמטרים (p1..p6) | ECX, EDX | p3..p6 (16 בתים) | ret 16 |
| תכונה | cdecl | stdcall | fastcall |
|---|---|---|---|
| אחראי ניקוי | הקורא (add esp, N) | הנקראת (ret N) | הנקראת (ret N) |
| מספר משתנה (variadic) | נתמך | לא נתמך | לא נתמך |
| העברת פרמטרים | כולם במחסנית (ימין לשמאל) | כולם במחסנית (ימין לשמאל) | ECX, EDX, והיתר במחסנית (ימין לשמאל) |
טעויות נפוצות
- המספר
Nב-ret Nב-fastcallכולל גם את שני הארגומנטים שבאוגרים.ret Nמסיר בתים רק מהמחסנית, ולכן סופר רק מהארגומנט השלישי ומעלה. - הארגומנט הראשון ב-
fastcallעובר ב-EAXאו ב-EDX. הסדר הקבוע הוא ראשון ב-ECXושני ב-EDX;EAXמיועד לתוצאה. - שני הארגומנטים הראשונים עוברים ב-
RDIו-RSI, או שגם השלישי עובר באוגר. ב-fastcallיש שני אוגרי ארגומנטים בלבד;RDIו-RSIשייכים ל-System V ב-64 סיביות.
בדקו את עצמכם
קוראים ל-int __fastcall step5(int n1, int n2, int n3, int n4, int n5) עם step5(5, 10, 15, 20, 25). היכן יושבים 10 ו-15, ומהי הוראת הסיום?
10 עובר ב-EDX, 15 יושב במחסנית, והפונקציה מסתיימת ב-ret 12 (עבור 15, 20, 25).
פריסת המחסנית ומיקום הארגומנטים ביחס ל-EBP
כשעוצרים בדיבאגר בתוך פונקציית cdecl מיד אחרי הפרולוג, הארגומנט הראשון מופיע ב-[ebp+8]. הסיבה מתבררת כשעוקבים אחרי שלושת השלבים שקרו עד אותו רגע:
- הקורא דוחף ארגומנטים מימין לשמאל, כך שהארגומנט הראשון נדחף אחרון.
callדוחפת את כתובת החזרה, ולכן מיד בכניסה (לפני הפרולוג)[esp]הוא כתובת החזרה ו-[esp+4]הוא הארגומנט הראשון.push ebpשומר את ה-EBPשל הקורא בעוד 4 בתים, ו-mov ebp, espמקבע עליו את בסיס המסגרת.
כך נוצרת מפת כתובות יציבה סביב EBP (מהכתובת הנמוכה לגבוהה, בדוגמה של ארבעה פרמטרי int בפונקציה quad_sum(p1, p2, p3, p4)):
| מיקום ביחס ל-EBP | תוכן התא |
|---|---|
[ebp-4] | בדרך כלל המשתנה המקומי הראשון |
[ebp] | ה-EBP השמור של הקורא |
[ebp+4] | כתובת החזרה שנדחפה על ידי call |
[ebp+8] | p1 (הארגומנט הראשון, k=1) |
[ebp+12] | p2 (הארגומנט השני, k=2) |
[ebp+16] | p3 (הארגומנט השלישי, k=3) |
[ebp+20] | p4 (הארגומנט הרביעי, k=4) |
הארגומנט ה-k (בספירה מ-1, עבור int של 4 בתים) יושב בהיסט 4 + 4k מעל EBP. אין במחסנית מקום שהוקצה לערך ההחזרה, מפני שהתוצאה חוזרת באוגר EAX.
; gcc -m32 -O0 -S -masm=intel
; int __attribute__((cdecl)) quad_sum(int p1, int p2, int p3, int p4)
; { return p1 + p2 * 2 + p3 + p4; }
_quad_sum:
push ebp
mov ebp, esp
mov eax, DWORD PTR [ebp+12] ; p2
lea edx, [eax+eax] ; p2 * 2
mov eax, DWORD PTR [ebp+8] ; p1
add edx, eax
mov eax, DWORD PTR [ebp+16] ; p3
add edx, eax
mov eax, DWORD PTR [ebp+20] ; p4
add eax, edx
pop ebp
retטעויות נפוצות
- בכניסה לפונקציה, התא שמעל כתובת החזרה הוא ה-
EBPהשמור.EBPנדחף רק בפרולוג; מיד בכניסה, מעל כתובת החזרה ([esp]) נמצא הארגומנט הראשון ([esp+4]). - הארגומנט הראשון נמצא ב-
[ebp+4]. ב-[ebp+4]יושבת כתובת החזרה; הארגומנט הראשון הוא ב-[ebp+8]. - הארגומנט האחרון צמוד ל-
EBP. בגלל דחיפה מימין לשמאל, האחרון נדחף ראשון ולכן יושב בכתובת הגבוהה והרחוקה ביותר.
בדקו את עצמכם
בפונקציית cdecl עם פרולוג קלאסי ושישה פרמטרי int, באיזה היסט מ-EBP נמצא הארגומנט השלישי?
[ebp+16]. לפי ההיסט 4 + 4 * 3 = 16.
מעקב אחרי ESP לאורך קריאה וחזרה
בארכיטקטורת x86 המחסנית גדלה כלפי כתובות נמוכות, ולכן כל הוספה אליה מורידה את ESP וכל הסרה מעלה אותו. ספציפית, push של 4 בתים ו-call (שדוחפת כתובת חזרה בת 4 בתים) מקטינים את ESP ב-4 כל אחד.
בצד החזרה, ret רגיל מעלה את ESP ב-4 (חוזר לערך שלפני ה-call ומותיר את הארגומנטים במחסנית), add esp, N מעלה אותו ב-N, ואילו ret N של stdcall מעלה אותו ב-4 + N בפעולה אחת.
תרחיש 24: מעקב ESP בקריאת stdcall ולאחריה cdecl
; Initial ESP = 0x8000
; pair_s: __stdcall, 2 int arguments
; pair_c: __cdecl, 2 int arguments
push 40
push 30
call pair_s
push 20
push 10
call pair_c
add esp, 8| שלב ביצוע | ESP בסיום השלב | משמעות |
|---|---|---|
push 40 ואז push 30 | 0x7FF8 | נדחפו שני ארגומנטים של pair_s (ירידה של 8 בתים) |
call pair_s | 0x7FF4 | נדחפה כתובת החזרה בכניסה ל-pair_s |
ret 8 של pair_s | 0x8000 | stdcall: שולפת את כתובת החזרה (4) ומסירה את שני הארגומנטים (8) |
push 20 ואז push 10 | 0x7FF8 | נדחפו שני ארגומנטים של pair_c |
call pair_c | 0x7FF4 | נדחפה כתובת החזרה בכניסה ל-pair_c |
ret של pair_c | 0x7FF8 | cdecl: שולפת רק את כתובת החזרה; 8 הבתים של הארגומנטים נותרים |
add esp, 8 | 0x8000 | הקורא מנקה את הארגומנטים ומשיב את ESP לבסיס |
אם הקורא היה מדלג על add esp, 8 אחרי pair_c, מצביע המחסנית היה נשאר מוסט ב-8 בתים כלפי מטה (0x7FF8) ומשבש כל פנייה עוקבת למחסנית.
טעויות נפוצות
- מיד אחרי
retשלcdecl,ESPכבר חוזר לערך שהיה לפני הדחיפות. הוא חוזר רק לאחר שהקורא מבצעadd esp, N. pushמגדיל את הערך שלESP. המחסנית גדלה כלפי כתובות נמוכות, ולכןpushמקטין אתESP.- אחרי
ret Nשלstdcallהקורא צריך לבצע גםadd esp, N.ret Nכבר ניקתה את הארגומנטים; ניקוי נוסף ישבש את המחסנית.
בדקו את עצמכם
נתון ESP = 0x4000. הקורא מבצע push 12, push 5 ו-call fn, כאשר fn היא פונקציית stdcall עם שני int. מה יהיה ESP מיד אחרי ש-ret 8 של fn מסתיימת?
0x4000. שני ה-push-ים הורידו אותו ב-8, call הורידה ב-4 (ל-0x3FF4), ו-ret 8 העלתה אותו ב-4 + 8 = 12 בחזרה ל-0x4000.
ערך ההחזרה ואוגרים שמורים (caller-saved מול callee-saved)
בכל שלוש מוסכמות ה-32 סיביות (cdecl, stdcall, fastcall), האוגרים הכלליים מחולקים לשתי קבוצות אחריות בין הקורא לנקראת:
הכלל פשוט: מי שמשתמש באוגר מהקבוצה השמורה חייב להחזיר אותו כפי שמצא; האוגרים האחרים הוא רשאי לדרוס.
| קבוצה | אוגרים | מי נושא באחריות |
|---|---|---|
callee-saved | EBX, ESI, EDI, EBP | הנקראת: אם היא נוגעת בהם, היא דוחפת אותם בכניסה ומשחזרת לפני ret |
caller-saved | EAX, ECX, EDX | הקורא: הנקראת דורסת אותם חופשי, ולכן ערך שהקורא צריך אחרי הקריאה נשמר אצלו לפני ה-call |
; gcc -m32 -O1 -S -masm=intel
; int helper(int v);
; int __attribute__((cdecl)) sum_calls(int x, int y)
; { int r = helper(x); return r + helper(y); }
_sum_calls:
push ebx ; save callee-saved EBX
sub esp, 4
mov eax, DWORD PTR [esp+12]
mov DWORD PTR [esp], eax
call "_helper"
mov ebx, eax ; keep r safe across second call
mov eax, DWORD PTR [esp+16]
mov DWORD PTR [esp], eax
call "_helper"
add eax, ebx
add esp, 4
pop ebx ; restore EBX before ret
retלעומת EBX שנשמר כאן, אילו הפונקציה הייתה משתמשת רק ב-ECX וב-EDX ולא מבצעת קריאות ביניים, לא היה צורך ב-push וב-pop כלל.
ומה לגבי מקום ערך ההחזרה? גודל הטיפוס וסוגו קובעים את האוגר. שלם של 64 סיביות (long long) אינו נכנס באוגר יחיד של 32 סיביות, ולכן החזרתו ב-EAX בלבד הייתה קוטעת את החצי העליון; לכן הוא מתפצל לצמד EDX:EAX.
| טיפוס ערך ההחזרה | אוגר ההחזרה ב-32 סיביות |
|---|---|
int, מצביע, וכל שלם עד 32 סיביות | EAX |
שלם של 64 סיביות (long long) | הצמד EDX:EAX (32 סיביות נמוכות ב-EAX, גבוהות ב-EDX) |
float ו-double | ST(0) (ראש מחסנית יחידת הנקודה הצפה x87) |
טעויות נפוצות
- פונקציה נקראת יכולה לשנות את
EBX,ESIאוEDIבלי לשחזר אותם. אלו אוגריcallee-saved; חובה לשמור ולשחזר אותם. - ערך
long longחוזר ב-EAXבלבד, או עם חצי עליון ב-ECX. הוא חוזר בצמדEDX:EAX: נמוך ב-EAXוגבוה ב-EDX. - האוגר
ST(0)משמש להחזרת שלמים בני 64 סיביות.ST(0)מיועד ל-floatול-double.
בדקו את עצמכם
פונקציה ב-32 סיביות מחזירה float, והקורא מחזיק נתון חשוב ב-EDI לפני הקריאה. היכן תחזור התוצאה, ומי אחראי לשמירת EDI?
התוצאה תחזור ב-ST(0), והפונקציה הנקראת אחראית לשמור ולשחזר את EDI אם היא משתמשת בו.
עיטור שמות (Name Decoration) ב-MSVC
נניח שהלינקר של MSVC מדפיס error LNK2019: unresolved external symbol _compute@12 referenced in function _main. השם המוזר _compute@12 אינו טעות הקלדה, אלא עיטור שם (name decoration) שמפיק הקומפיילר בקובץ האובייקט עבור x86 של 32 סיביות (וכך גם MinGW gcc -m32).
איך מפענחים אותו? הקו התחתון הוא התחילית, ואחריו @12. פירוש הדבר שהקורא ניסה להפעיל את compute כפונקציית stdcall שמקבלת 12 בתים, למשל שלושה int.
אם ההגדרה האמיתית שונה (למשל _compute@8), השמות לא ייפגשו.
זו בדיוק מטרת העיטור: חוסר התאמה בחתימה מתגלה כשגיאת קישור, ולא כמחסנית שנהרסת בריצה. ל-cdecl אין סיומת כי הקורא מנקה, ולכן שום גודל אינו צריך לעבור דרך השם.
שימו לב שהמספר הוא בתים. וב-fastcall, שצורתו @name@N, הוא כולל גם ארגומנטים שעוברים ב-ECX וב-EDX: פונקציה עם שני int מסתיימת ב-ret פשוט, אך שמה @name@8.
| מוסכמה | כלל העיטור | פרמטר int אחד (4 בתים) | ארבעה פרמטרי int (16 בתים) |
|---|---|---|---|
cdecl | תחילית _ בלבד | _fn | _fn |
stdcall | תחילית _ וסיומת @N | _fn@4 | _fn@16 |
fastcall | תחילית @ וסיומת @N | @fn@4 | @fn@16 |
טעויות נפוצות
- לפונקציית
fastcallעם שניintיהיה השם@fn@0כי שניהם באוגרים. בעיטור@name@N, המספרNסופר את כל הארגומנטים כולל אלו שבאוגרים (@fn@8). - פונקציית
stdcallעם שני פרמטריintתקבל את השם_fn@2. המספר מייצג בתים (2 * 4 = 8), כלומר_fn@8. - ב-
cdeclהשם מעוטר עם@N, או ש-fastcallמתחיל בקו תחתון. ל-cdeclיש רק_fnללא מספר, ו-fastcallמתחיל ב-@.
בדקו את עצמכם
מה יהיה השם המעוטר ב-MSVC 32-bit עבור int __fastcall ping(int a, int b)?
@ping@8. תחילית @ של fastcall, וסך הכול 2 * 4 = 8 בתים כולל a ו-b שעברו באוגרים.
מוסכמות קריאה ב-x86-64
System V AMD64 ABI: המוסכמה בלינוקס
המעבר מ-32 סיביות אל x86-64 שם קץ לריבוי המוסכמות: במקום לבחור בין cdecl, stdcall ו-fastcall, כל מערכת הפעלה כופה מוסכמה אחידה. בלינוקס וב-macOS זוהי מוסכמת System V AMD64 ABI.
בהעברת ארגומנטים, System V מפרידה בין שני מונים עצמאיים: ששת השלמים או המצביעים הראשונים נכנסים לפי הסדר אל RDI, RSI, RDX, RCX, R8 ו-R9, ואילו ערכי נקודה צפה (float, double) נכנסים אל XMM0 עד XMM7 בלי לצרוך את תור השלמים. רק ארגומנטים מעבר לכך נדחפים למחסנית - ולכן קריאה עם שישה int בלינוקס אינה דוחפת דבר למחסנית.
מבחינת מחסנית, אוגרים והחזרה: הקורא מנקה את המחסנית ודואג ש-RSP יהיה מיושר לכפולה של 16 בתים ממש לפני הוראת call. התוצאה חוזרת ב-RAX (וב-RDX עבור 128 סיביות) או ב-XMM0 בנקודה צפה; RBX, RBP ו-R12 עד R15 הם callee-saved, ואילו RDI ו-RSI הם caller-saved.
; gcc -O1 -S -masm=intel (System V forced with sysv_abi)
; long long pick_fourth(long long p1, long long p2, long long p3, long long p4, long long p5, long long p6) { return p4; }
pick_fourth:
mov rax, rcx ; p4, the 4th integer argument, arrives in RCX
ret| מיקום ארגומנט שלם | Windows x64 | System V (לינוקס / macOS) |
|---|---|---|
| 1 | RCX | RDI |
| 2 | RDX | RSI |
| 3 | R8 | RDX |
| 4 | R9 | RCX |
| 5 | מחסנית | R8 |
| 6 | מחסנית | R9 |
| 7 ומעלה | מחסנית | מחסנית |
טעויות נפוצות
- בלינוקס x86-64 רק ארבעה ארגומנטים שלמים עוברים באוגרים. שישה שלמים עוברים באוגרים ב-System V; מגבלת ארבעת האוגרים שייכת ל-Windows x64.
- בלינוקס הארגומנט הראשון הוא
RCXאו שהשלישי הואR8. הסדר ב-System V הואRDI,RSI,RDX,RCX,R8,R9: השלישי הואRDXוהרביעי הואRCX.
בדקו את עצמכם
בלינוקס x86-64, באיזה אוגר עובר הפרמטר p3 בחתימה long fn(long p1, long p2, long p3, long p4)?
ב-RDX (השלישי בסדר RDI, RSI, RDX, RCX).
Windows x64: מיקום קבוע ו-shadow space
בניגוד להפרדת המונים של לינוקס, ב-Windows x64 (ב-MSVC וב-MinGW כאחד) המיקום הסידורי ברשימת הפרמטרים קובע איזה אוגר ייבחר, ורק ארבעת הפרמטרים הראשונים זוכים לעבור באוגרים. כך למשל, אם הפרמטר השני הוא double הוא תופס את XMM1 (ומדלג על XMM0), ואם הפרמטר השלישי הוא int הוא תופס את R8 (ומדלג על RCX ו-RDX).
| מיקום ברשימת הפרמטרים | שלם או מצביע | נקודה צפה (float / double) |
|---|---|---|
| מקום 1 | RCX | XMM0 |
| מקום 2 | RDX | XMM1 |
| מקום 3 | R8 | XMM2 |
| מקום 4 | R9 | XMM3 |
| מקום 5 ומעלה | מחסנית | מחסנית |
מה קורה במחסנית אצל הקורא? לפני ה-call הוא שומר 32 בתים פנויים (shadow space, ארבעה תאים של 8 בתים), במקום שבו הנקראת יכולה לשפוך את ארבעת האוגרים. הפרמטר החמישי מונח ישר מעליהם, ולכן בכניסה לפונקציה הוא ב-[rsp+40]: 8 בתים של כתובת חזרה ועוד 32.
אחרי החזרה הקורא הוא שמנקה, והתוצאה ממתינה ב-RAX או ב-XMM0.
בנוגע לשמירת אוגרים, ב-Windows נשמרים על ידי הנקראת RBX, RBP, RDI, RSI ו-R12 עד R15. ההבדל מלינוקס הוא ש-RDI ו-RSI כאן ברשימה, בעוד שב-System V הנקראת דורסת אותם חופשי.
תרחיש 25: חתימה מעורבת אחת בשתי מוסכמות ה-64 סיביות
/* ex7_x64.c, gcc -O1 -S -masm=intel */
double __attribute__((ms_abi)) mix_win(double a, int b, int c, double d, int e)
{ return a + b + c + d + e; }
double __attribute__((sysv_abi)) mix_sysv(double a, int b, int c, double d, int e)
{ return a + b + c + d + e; }mix_win: ; Windows x64
pxor xmm1, xmm1
cvtsi2sd xmm1, edx ; b in EDX (slot 2)
addsd xmm1, xmm0 ; a in XMM0 (slot 1)
pxor xmm0, xmm0
cvtsi2sd xmm0, r8d ; c in R8 (slot 3)
addsd xmm1, xmm0
addsd xmm1, xmm3 ; d in XMM3 (slot 4)
pxor xmm0, xmm0
cvtsi2sd xmm0, DWORD PTR 40[rsp] ; e on stack: 8 (ret) + 32 (shadow)
addsd xmm0, xmm1
ret
mix_sysv: ; System V (Linux)
pxor xmm2, xmm2
cvtsi2sd xmm2, edi ; b in EDI (1st int)
addsd xmm2, xmm0 ; a in XMM0 (1st fp)
pxor xmm0, xmm0
cvtsi2sd xmm0, esi ; c in ESI (2nd int)
addsd xmm2, xmm0
addsd xmm2, xmm1 ; d in XMM1 (2nd fp)
pxor xmm0, xmm0
cvtsi2sd xmm0, edx ; e in EDX (3rd int)
addsd xmm0, xmm2
retשימו לב להבדל במחסנית: ב-Windows x64 הפרמטר החמישי e מונח במחסנית מעל ה-shadow space (40[rsp]), ואילו ב-System V שלושת השלמים (b, c, e) ושני הממשיים (a, d) נכנסים כולם באוגרים. באותו אופן, אם תעבירו שישה פרמטרים מסוג int, ב-Windows שניים מהם ישבו במחסנית ובלינוקס אף לא אחד.
טעויות נפוצות
- ב-Windows x64 מונים שלמים ונקודה צפה בנפרד. הספירה הנפרדת שייכת ל-System V; ב-Windows המיקום הכולל ברשימה קובע.
- ארגומנטים מסוג
floatו-doubleעוברים במחסנית. הם עוברים באוגריXMM; העברת כל הפרמטרים במחסנית מאפיינת אתcdeclב-32 סיביות. - הפרמטר השלישי ב-Windows x64 עובר ב-
RDX.RDXמוקצה למקום השני; השלישי עובר ב-R8.
בדקו את עצמכם
ב-Windows x64, באיזה אוגר עובר הפרמטר p3 של void g(double p1, int p2, double p3, int p4)?
ב-XMM2. p3 יושב במקום השלישי ברשימה והוא מסוג נקודה צפה.
גורלן של __cdecl ו-__fastcall ב-64 סיביות
מדוע המילה __fastcall חסרת משמעות ב-x86-64? משום שלכל פלטפורמה שם יש מוסכמה אחת קבועה, ואין מה לבחור. קוד ישן שמכיל __cdecl או __fastcall יתקמפל, ירוץ ויחזיר את אותה תוצאה, אבל העברת הפרמטרים לא תשתנה.
בפועל: MSVC ל-x64 מקבל את שתי המילים בשתיקה ופועל לפי Windows x64, כך שהפרמטר השלישי נשאר ב-R8 אפילו תחת __fastcall. gcc ל-x86-64 בלינוקס מזהיר שהמאפיין אינו נתמך בפלטפורמה, ואז מפיק קוד System V.
טעויות נפוצות
- הוספת
__fastcallב-x86-64 גורמת לשגיאת קומפילציה או כופה שימוש ב-ECXו-EDX. הקומפיילרים מתעלמים ממנה (לכל היותר עם אזהרה) ומשתמשים במוסכמת הפלטפורמה. - במצב זה
__fastcallמעבירה את כל הארגומנטים במחסנית. מוסכמת 64 הסיביות של מערכת ההפעלה היא שקובעת.
בדקו את עצמכם
מקמפלים את int __fastcall gate(int n1, int n2, int n3, int n4) ב-MSVC ל-x64. באיזה אוגר יגיע n4?
ב-R9. __fastcall מבוטלת, ו-n4 הוא הארגומנט הרביעי במוסכמת Windows x64.
קריאות מערכת (System call)
עטיפה דקה מול פונקציית ספרייה
תלמידים רבים מניחים שכל פונקציה בספרייה התקנית של C פונה ישירות למערכת ההפעלה, וזה אינו נכון: רוב הפונקציות האלה רצות כולן במצב משתמש (user mode). תוכנית במצב הזה אינה יכולה לגעת בעצמה בדיסק, ברשת או ביצירת תהליכים, ולכן היא מבקשת זאת מהגרעין (kernel) באמצעות קריאת מערכת (system call).
הפעלת קריאת מערכת מחליפה את מצב המעבד למצב גרעין ומחזירה אותו למצב משתמש בסיום, ולכן מחיר הביצוע שלה גבוה בהרבה מקריאה רגילה לפונקציה. בקוד C אינכם כותבים את הוראת המעבד המיוחדת בעצמכם, אלא מפעילים פונקציית עטיפה של libc.
- קבצים והתקנים:
open,read,write,close(וכןchdirלשינוי תיקיית עבודה). - תהליכים:
fork,execve,exit,getpid,getppid. - ניהול זיכרון מהגרעין:
brk,mmap. - תקשורת ורשת:
socket.
| סוג הפונקציה | דוגמאות נפוצות | איך היא עובדת |
|---|---|---|
| פונקציית ספרייה טהורה | strlen, memcpy | מבצעת את כל העבודה במצב משתמש, ללא שום פנייה לגרעין. |
| מנהל זיכרון בספרייה | malloc | מקצה בלוקים מזיכרון שכבר שמור אצלה, ופונה לגרעין (brk או mmap) רק מדי פעם כשחסר מקום. |
קלט/פלט חוצץ (stdio) | printf, puts | מעצבת מחרוזת לתוך מאגר בזיכרון התהליך, וקוראת ל-write רק כאשר המאגר מתמלא או מתרוקן. |
| הרצת פקודת מעטפת | system() | אינה קריאת מערכת בעצמה, אלא פונקציית ספרייה שפותחת תהליך בן דרך fork, execve ו-wait. |
| עטיפה דקה לקריאת מערכת | open, read, write, close, chdir, getpid | טוענת אוגרים, מפעילה את הוראת syscall, ומתרגמת כישלון של הגרעין ל--1 ולעדכון errno. |
טעויות נפוצות
- הפונקציות
strlenו-memcpyפונות לגרעין כדי לעבד מחרוזות וזיכרון. אלו פעולות זיכרון טהורות שמתבצעות במלואן במצב משתמש בלי לערב את הגרעין. - עלות קריאת מערכת דומה לעלות קריאה לפונקציית C רגילה. המעבר ממצב משתמש למצב גרעין ובחזרה יקר משמעותית מקפיצה רגילה לפונקציה.
mallocמפעילה קריאת מערכת בכל הקצאה. הספרייה מנהלת מאגר זיכרון משלה ומבקשת תוספת מהגרעין (brkאוmmap) רק לעתים רחוקות.printfהיא קריאת מערכת. היא פונקצייתstdioשאוספת פלט במאגר ורק בהמשך מעבירה אותו ל-write.
בדקו את עצמכם
בבחירה בין puts, memcpy ו-chdir, איזו פונקציה היא עטיפה דקה של קריאת מערכת?
chdir. הפונקציה puts היא פונקציית stdio חוצצת, ואילו memcpy פועלת במלואה במצב משתמש.
write: בדיוק count בתים
כשקוראים ל-write, מה שחוזר אליכם הוא מספר הבתים שנמסרו לגרעין, ולא אורך של איזושהי מחרוזת. הסיבה היא שהחתימה ssize_t write(int fd, const void *buf, size_t count) (מ-<unistd.h>) אינה מקבלת מחרוזת אלא כתובת וכמות: היא מוסרת בדיוק count בתים החל מ-buf.
| שאלה | printf | write |
|---|---|---|
| איך נקבע כמה להוציא | לפי מחרוזת הפורמט ותו הסיום '\0' של כל מחרוזת | לפי הארגומנט count בלבד |
| מתי הבתים מגיעים לגרעין | בהמשך, אחרי שהמאגר של stdio מתרוקן | מיד, בלי מאגר ביניים |
| מה חוזר | מספר התווים שהודפסו | מספר הבתים שנכתבו בפועל |
הארגומנט הראשון בוחר את היעד. כל תוכנית מתחילה עם שלושה מתארי קובץ (file descriptor) פתוחים: 0 לקלט התקני (stdin), 1 לפלט התקני (stdout) ו-2 לפלט השגיאות (stderr); קובץ שתפתחו בעצמכם יקבל מספר גבוה יותר.
בחישובי היסט, s + k מצביע לבית שהאינדקס שלו k, כלומר לבית מספר k + 1 כשסופרים מאחד. אם s מצביע ל-"release-42", אז s + 8 מצביע ל-'4', ו-write(1, s + 8, 2) תוציא 42.
תרחיש 26: שני היסטים והחזרות
#include <stdio.h>
#include <unistd.h>
int main(void) {
const char *tag = "release-42";
ssize_t a = write(1, tag + 8, 2);
ssize_t b = write(1, tag, 3);
write(1, "\n", 1);
printf("returned %zd and %zd\n", a, b);
return 0;
}42rel
returned 2 and 3הקריאה הראשונה מתחילה באינדקס 8 ומוציאה שני בתים, 42. השנייה מוציאה שלושה בתים מההתחלה, rel, ושתיהן מחזירות את הכמות שביקשתם.
אף אחת מהן אינה מוסיפה שורה חדשה, ולכן הקוד כותב '\n' בנפרד. רק אחריו printf מציגה את שני הערכים החוזרים, 2 ו-3.
מכיוון ש-write היא פונקציה רגילה מבחינת הטיפוס, אפשר להעביר אותה כארגומנט לפונקציה אחרת, כל עוד המצביע מתאים לחתימה שלה:
/* POSIX / Linux signature */
static void announce(ssize_t (*sink)(int, const void *, size_t)) {
ssize_t sent = sink(1, "ping\n", 5); /* same as write(1, "ping\n", 5) */
/* sent is 5 when all five bytes were written */
}
/* call site: announce(write); */טעויות נפוצות
write(1, "Network", 4)מחזירה7, אורך המילה. היא מחזירה4, מספר הבתים שנכתבו; אורך המחרוזת אינו משתתף בחישוב.writeמוציאה את המחרוזת כולה עד התו'\0'. היא אינה מחפשת סיום: מוצאים בדיוקcountבתים, גם אם המחרוזת קצרה או ארוכה מזה.- הפלט של
writeממתין עדfflushאו עד'\n'. אין לה מאגר שלstdio, ולכן הבתים עוברים לגרעין מיד. s + 3מצביע לתו השלישי. האינדקס הראשון הוא0, ולכןs + 3הוא התו הרביעי.
בדקו את עצמכם
מה תוציא הקריאה write(1, "elephant" + 2, 4)?
epha. האינדקס 2 הוא 'e' השני, ונכתבים ארבעה בתים רצופים.
מה מחזירה write(1, "tomorrow", 3) ומה היא מדפיסה?
היא מדפיסה tom ומחזירה 3.
read, open ו-close
לכל מתאר קובץ פתוח יש מיקום נוכחי בתוך הקובץ, שאפשר לדמיין כסמן. read קוראת מהסמן ומקדמת אותו בכמות שנקראה, ולכן קריאות עוקבות מקבלות קטעים עוקבים; רק סגירה ופתיחה מחדש מחזירות את הסמן להתחלה.
החתימה היא ssize_t read(int fd, void *buf, size_t count). היא מבקשת לכל היותר count בתים, ומחזירה כמה התקבלו בפועל: מספר חיובי (אולי קטן מ-count), 0 כשהסמן כבר בסוף הקובץ (EOF), או -1 בכישלון. בקובץ רגיל read מחזירה בדיוק count בתים, אלא אם הגיעה לסוף הקובץ.
read רק מעתיקה בתים למאגר ואינה מוסיפה אליהם '\0'. כדי להדפיס את התוכן עם %s עליכם לכתוב buf[n] = '\0', ולכן המערך חייב להיות גדול ב-1 לפחות מכמות הבתים שביקשתם.
את הקובץ עצמו מקבלים בעזרת open(path, flags, mode) מ-<fcntl.h>. היא מחזירה את המתאר הפנוי הנמוך ביותר, ובתוכנית שרק התחילה זה בדרך כלל 3, כי 0 עד 2 תפוסים; בכישלון מוחזר -1. הדגלים נבחרים לפי מה שרוצים לעשות:
| דגל | מה הוא קובע |
|---|---|
O_RDONLY | פתיחה לקריאה בלבד |
O_WRONLY | פתיחה לכתיבה בלבד |
O_CREAT | יוצר את הקובץ אם אינו קיים; חובה לצרף ארגומנט שלישי mode, כמו 0600, שקובע את ההרשאות |
O_TRUNC | מרוקן קובץ קיים לפני הכתיבה |
תרחיש 27: סמן שמתקדם בקובץ של תשעה בתים
#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
int main(void) {
int out = open("notes.bin", O_WRONLY | O_CREAT | O_TRUNC, 0600);
printf("first descriptor: %d\n", out);
if (out < 0)
return 1;
write(out, "mnopqrstu", 9);
close(out);
char buf[8];
int in = open("notes.bin", O_RDONLY);
for (int i = 0; i < 4; i++) {
int n = read(in, buf, 4);
buf[n > 0 ? n : 0] = '\0';
printf("read #%d -> %d [%s]\n", i + 1, n, buf);
}
close(in);
in = open("notes.bin", O_RDONLY);
int again = read(in, buf, 2);
buf[again] = '\0';
printf("after reopen: %s\n", buf);
close(in);
return 0;
}first descriptor: 3
read #1 -> 4 [mnop]
read #2 -> 4 [qrst]
read #3 -> 1 [u]
read #4 -> 0 []
after reopen: mn| קריאה | ביקשנו | חזרו | הסמן אחרי |
|---|---|---|---|
| ראשונה | 4 | 4 (mnop) | 4 |
| שנייה | 4 | 4 (qrst) | 8 |
| שלישית | 4 | 1 (u) | 9, סוף הקובץ |
| רביעית | 4 | 0 | 9, ללא שינוי |
אחרי close ו-open | 2 | 2 (mn) | 2 |
הקריאה השלישית מחזירה 1 ולא 4, כי נשאר בית אחד בלבד; זו אינה שגיאה. רק הקריאה הרביעית, שנעשית כשהסמן כבר בסוף, מחזירה 0.
תרחיש 28: קריאה מהקלט התקני: שורה שלמה בטרמינל
/* Linux; input typed in a terminal or redirected from a file */
#include <stdio.h>
#include <unistd.h>
int main(void) {
char buf[16];
int a = read(0, buf, 5);
buf[a] = '\0';
printf("[%s] %d\n", buf, a);
int b = read(0, buf, 5);
buf[b] = '\0';
printf("[%s] %d\n", buf, b);
return 0;
}[kilob] 5
[yte
] 4הפלט למעלה מתקבל כשהקלט הוא kilobyte ואחריו Enter, כלומר 9 בתים. בטרמינל הקלט נמסר ל-read רק אחרי ש-Enter נלחץ, והקריאה הראשונה לוקחת חמישה בתים בלבד.
מה שלא נקרא נשאר ממתין: yte ושורה חדשה, ארבעה בתים, נקראים בקריאה השנייה, ולכן ה-'\n' מופיע בתוך הסוגריים. אם הייתם מקלידים hello בלבד ו-Enter (6 בתים) וקוראים עם count של 8, read הייתה מחזירה 6, פחות ממה שביקשתם. הקלט מקובץ רגיל באותו תוכן נותן את אותן תוצאות.
טעויות נפוצות
readמחזירה את גודל המאגר שהעברתם לה. היא מחזירה את מספר הבתים שנקראו בפועל, שיכול להיות קטן מ-count.- הערך שחוזר מ-
readסופר גם את'\0'בסוף.readאינה כותבת'\0'ואינה סופרת אותו; את הסיום מוסיפים ידנית. readבטרמינל צורכת את כל מה שהוקלד. היא לוקחת לכל היותרcountבתים; היתר, כולל השורה החדשה, נשאר לקריאה הבאה.- הקריאה השנייה על אותו מתאר מתחילה שוב מההתחלה. הסמן ממשיך מהמקום שבו עצרה הקודמת, עד שסוגרים ופותחים מחדש.
openמחזירה0כשהיא מצליחה לפתוח. בהצלחה מוחזר מתאר חדש (בדרך כלל3בתוכנית שרק התחילה);-1מסמן כישלון.
בדקו את עצמכם
בקובץ יש בדיוק 15 בתים, וקוראים פעמיים ברצף read(fd, buf, 10). מה מחזירה כל קריאה?
הראשונה מחזירה 10 והשנייה 5, כי רק חמישה בתים נשארו אחרי הסמן.
אחרי שהסמן הגיע לסוף הקובץ, מה תחזיר עוד קריאה?
0, סימן לסוף הקובץ.
משתמש מקליד go ו-Enter, ואז מופעלת read(0, buf, 10). מה היא מחזירה?
3: שני התווים והשורה החדשה, כי הקלט הגיע כולו והוא קצר מ-count.
כישלון: -1 ו-errno
הדפוס הנכון הוא תמיד באותו סדר: קוראים לפונקציה, בודקים אם התוצאה היא -1, ורק אז מציצים ב-errno (מ-<errno.h>), משתנה שמכיל קוד שגיאה חיובי שמסביר מה השתבש. בלי הבדיקה הראשונה הערך של errno עלול להיות שארית של כישלון ישן.
מאחורי הקלעים, הגרעין אינו מכיר את errno. בלינוקס x86-64 הוא מחזיר ב-RAX מספר שלילי בטווח -4095 עד -1: קוד השגיאה בסימן הפוך.
העטיפה ב-libc מזהה ערך כזה, שומרת את הקוד החיובי ב-errno ומחזירה לתוכנית -1. לכן אצלכם בקוד C לא תראו לעולם את -9, אלא תמיד -1.
| קריאה | מה הגרעין מחזיר | מה חוזר ל-C | errno |
|---|---|---|---|
open("/srv/missing/data.csv", O_RDONLY) | -2 (-ENOENT) | -1 | ENOENT, שערכו 2: אין קובץ או תיקייה כאלה |
close(31) כשהמתאר לא פתוח | -9 (-EBADF) | -1 | EBADF, שערכו 9: מתאר קובץ לא תקין |
read(-5, buf, 4) | -9 (-EBADF) | -1 | EBADF |
chdir("/") | 0 | 0 | ללא שינוי |
גם משמעות ההצלחה תלויה בפונקציה:
readו-write: מספר בתים,0ומעלה.open: מתאר קובץ,0ומעלה.closeו-chdir: הערך0.
נקודה שנבחנים מפספסים: הצלחה אינה מאפסת את errno. אם קריאה אחת נכשלה והבאה הצליחה, הערך הישן נשאר שם, ולכן אסור לקרוא את errno בלי שהקריאה האחרונה החזירה -1.
תרחיש 29: כישלון, הצלחה, ומה נשאר ב-errno
#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <fcntl.h>
#include <unistd.h>
int main(void) {
int fd = open("/srv/missing/data.csv", O_RDONLY);
if (fd == -1)
printf("open failed: errno=%d (%s)\n", errno, strerror(errno));
int r = close(31);
printf("close(31) -> %d, errno=%d\n", r, errno);
int ok = chdir("/");
printf("chdir -> %d, errno still %d\n", ok, errno);
return 0;
}open failed: errno=2 (No such file or directory)
close(31) -> -1, errno=9
chdir -> 0, errno still 9הפתיחה של נתיב שאינו קיים נכשלת עם ENOENT, והפונקציה strerror הופכת את הקוד לטקסט קריא. אחר כך close על מתאר שמעולם לא נפתח מחליפה את הקוד ל-EBADF.
chdir("/") מצליחה תמיד, כי תיקיית השורש קיימת, ומחזירה 0. ובכל זאת errno נשאר 9: הקריאה המוצלחת לא נגעה בו.
#include <stdio.h>
#include <errno.h>
#include <unistd.h>
int main(void) {
char c;
ssize_t n = write(55, "x", 1);
printf("write: %zd, EBADF? %d\n", n, errno == EBADF);
n = read(-1, &c, 1);
printf("read: %zd, EBADF? %d\n", n, errno == EBADF);
return 0;
}write: -1, EBADF? 1
read: -1, EBADF? 1שתי הקריאות מקבלות מתאר שאינו קיים, ולכן שתיהן מחזירות -1 עם אותו קוד.
טעויות נפוצות
0מסמן כישלון בקריאות מערכת. ב-chdirו-closeהוא הצלחה, וב-readהוא סוף קובץ; כישלון הוא-1.- כש-
writeנכשלת על מתאר לא פתוח היא מחזירה-9.-9הוא הערך הגולמי של הגרעין ב-RAX; העטיפה מחזירה-1. - אחרי קריאה מוצלחת
errnoחוזר לאפס. הוא שומר את הערך האחרון שנכתב אליו; לכן בודקים אותו רק אחרי-1.
בדקו את עצמכם
כישלון של open על קובץ חסר, ואחריו chdir("/") שמצליחה. מה ב-errno בסוף?
עדיין ENOENT, כי ההצלחה אינה משנה אותו.
מה מחזירה read(-3, buf, 4) ומה נקבע ב-errno?
-1, ו-errno הוא EBADF.
המנגנון: הוראת syscall והאוגרים
ההוראה syscall משתמשת בשני אוגרים לצרכיה: היא שומרת ב-RCX את כתובת החזרה לתוכנית, וב-R11 את דגלי המעבד. מכיוון ששניהם נדרסים, אי אפשר להעביר דרכם ארגומנט, ולכן את הארגומנט הרביעי שולחים דרך R10, ולא דרך RCX שבה משתמשת קריאת פונקציה רגילה.
| מקום | פונקציה רגילה (System V, 64 סיביות) | קריאת מערכת ב-x86-64 לינוקס | קריאת מערכת ב-x86 32 סיביות (int 0x80) |
|---|---|---|---|
| מספר הקריאה | אינו קיים | RAX | EAX |
| ארגומנט 1 | RDI | RDI | EBX |
| ארגומנט 2 | RSI | RSI | ECX |
| ארגומנט 3 | RDX | RDX | EDX |
| ארגומנט 4 | RCX | R10 | ESI |
| ארגומנט 5 | R8 | R8 | EDI |
| ארגומנט 6 | R9 | R9 | EBP |
| התוצאה | RAX | RAX | EAX |
אחרי שהאוגרים מוכנים, הוראת syscall מעבירה את המעבד למצב גרעין, והגרעין מחליט איזה שירות להפעיל לפי המספר ב-RAX. כשהוא חוזר, RAX מחזיק את התוצאה, או ערך שלילי במקרה של שגיאה.
מספר הקריאה נקבע לכל ארכיטקטורה בנפרד: את write מזמינים כ-1 ב-x86-64 וכ-4 ב-x86 של 32 סיביות, ואת getpid כ-39 ב-64 סיביות וכ-20 ב-32. ההבטחה של לינוקס היא שמספר שכבר הוקצה בארכיטקטורה אינו מוחלף בשירות אחר, כדי שקבצים ריצים ישנים ימשיכו לעבוד.
לפעמים אין ל-libc עטיפה לשירות שבגרעין, ואז פונים אליו לפי המספר בעזרת syscall(number, ...), למשל syscall(SYS_membarrier, ...), שאין לה עטיפה ב-glibc. גם gettid הייתה כזו עד גרסה 2.30, ומאז יש לה עטיפה. הפונקציה syscall עצמה היא פונקציית C רגילה, ולכן הארגומנטים שלה מגיעים לפי System V: המספר ב-RDI, והארגומנטים שלכם ב-RSI, RDX, RCX, R8, R9.
הקוד שלה מתאים אותם לגרעין, בדיוק לפי העמודות בטבלה: מעתיק את RDI ל-RAX, ואז מזיז את כל הארגומנטים מקום אחד, כך שהארגומנט הרביעי שלכם עובר מ-R8 ל-R10. רק אז מבוצעת ההוראה syscall. הארגומנט השישי שלכם כבר אינו נכנס לאוגר, כי המספר תפס מקום, ולכן הוא מגיע במחסנית והקוד טוען אותו ל-R9.
תרחיש 30: מעקב אוגרים: syscall עם ארגומנט רביעי
/* Linux x86-64; traced by hand */
#define _GNU_SOURCE
#include <sys/syscall.h>
#include <unistd.h>
int main(void) {
char chunk[8];
int fd = 5; /* assume an already open file */
syscall(SYS_pread64, fd, chunk, 4, 3);
return 0;
}הקריאה SYS_pread64 (מספרה 17) מקבלת ארבעה ארגומנטים: מתאר, מאגר, כמות והיסט בקובץ. בטבלה: מה יש באוגרים כשנכנסים לפונקציה syscall של libc, ומה ברגע שלפני ההוראה.
| אוגר | בכניסה לפונקציה syscall | ממש לפני ההוראה syscall |
|---|---|---|
RAX | ערך ישן, לא רלוונטי | 17 |
RDI | 17, מספר הקריאה | 5, המתאר |
RSI | 5 | כתובת chunk |
RDX | כתובת chunk | 4, הכמות |
RCX | 4 | אינו בשימוש; ההוראה תדרוס אותו |
R8 | 3, ההיסט | ערך של R9, לא בשימוש |
R10 | לא רלוונטי | 3, ההיסט שהועתק מ-R8 |
אחרי חזרת הגרעין, RAX מחזיק את מספר הבתים שנקראו, או קוד שגיאה שלילי.
טעויות נפוצות
- הארגומנט הרביעי של קריאת מערכת נמצא ב-
RCX, כמו בקריאה רגילה.syscallדורסת אתRCX, ולכן הארגומנט הרביעי נמצא ב-R10. - מספר הקריאה נמצא ב-
RDIברגע שההוראה מתבצעת. ב-RDIהוא נמצא רק בכניסה לפונקציהsyscallשלlibc; בהוראה עצמה הוא ב-RAX. - התוצאה חוזרת ב-
RDI. היא חוזרת ב-RAX, באותו אוגר שנשא את המספר.
בדקו את עצמכם
איזה אוגר נושא את הארגומנט החמישי בקריאת מערכת ב-x86-64 לינוקס, ואיזה את השישי?
החמישי ב-R8 והשישי ב-R9.
מדוע הארגומנט הרביעי אינו ב-RCX?
כי ההוראה syscall שומרת שם את כתובת החזרה, ולכן האוגר נדרס.
printf, חציצה ומספר קריאות write
נניח שתוכנית מדפיסה one ב-printf, אחר כך [direct] ב-write, ואתם מפנים את הפלט לקובץ. תופתעו לראות את [direct] לפני one: משהו החזיק את הטקסט של printf וגרם לו להיכתב מאוחר.
תרחיש 31: הפלט בקובץ מסודר אחרת מהקוד
/* Linux; run as ./prog > out.txt */
#include <stdio.h>
#include <unistd.h>
int main(void) {
printf("one\n");
printf("two\n");
write(1, "[direct]\n", 9);
printf("three\n");
fflush(stdout);
write(1, "[after flush]\n", 14);
printf("four\n");
return 0;
}[direct]
one
two
three
[after flush]
fourone ו-two נשארים במאגר בזיכרון התוכנית, ו-[direct] נכתב מיד. fflush מרוקן את המאגר, ולכן one, two ו-three מגיעים לקובץ אחרי [direct] ולפני [after flush].
four מחכה במאגר עד סוף התוכנית ומתרוקן ביציאה. בהרצה ישירה בטרמינל הסדר היה אחר: one, two, [direct], three, [after flush], four.
הסיבה היא ש-stdio (printf, puts ודומיהן) אוספת טקסט במאגר ופונה לגרעין, באמצעות write, רק כשהמאגר מתרוקן. כך היא חוסכת קריאות מערכת יקרות. write ישירה אינה עוברת במאגר הזה, ולכן היא עוקפת טקסט שעדיין מחכה בו.
| יעד הפלט | מצב החציצה | מתי נקראת write | שש שורות printf |
|---|---|---|---|
| טרמינל | חציצת שורות (line buffered) | בכל '\n' | שש קריאות write |
| קובץ רגיל או pipe | חציצה מלאה (fully buffered) | כשהמאגר מלא (גודלו תלוי במימוש, BUFSIZ, לרוב 4096 או 8192 בתים), ב-fflush, או ביציאה מהתוכנית (return מ-main או exit) | קריאת write אחת, ביציאה |
הכלל המדויק: כש-stdout מופנה לקובץ או ל-pipe הוא בחציצה מלאה, ולכן טקסט של printf נשאר במאגר עד fflush או עד סוף התוכנית, וכל write שבוצע לפני הריקון מופיע לפני כל הטקסט שבמאגר. מכאן: קריאות printf שלפני write יוצאות אחריו (one ו-two מתחת ל-[direct]), וקריאות printf שאחרי ה-write האחרון יוצאות לפי סדר הקוד (four).
הסדר בטוח כשאין write בין ה-printf לריקון, או כשקוראים ל-fflush(stdout) לפני כל write, או עם setvbuf לביטול החציצה. בטרמינל, בחציצת שורות, כל שורה שמסתיימת ב-'\n' יוצאת מיד והסדר נשמר.
טעויות נפוצות
- כל
printfהיא בהכרח קריאתwriteנפרדת. בהפניה לקובץ או ל-pipe יש חציצה מלאה, והמאגר נכתב בבת אחת. printfאינה פונה לגרעין כלל. בסופו של דבר היא מרוקנת את המאגר באמצעותwrite.printfמבצעתwriteנפרדת לכל תו. המאגר אוסף תווים ושורות, ושולח אותם יחד.
בדקו את עצמכם
תוכנית מדפיסה printf("hi\n") שבע פעמים. כמה קריאות write בטרמינל, וכמה כשהפלט מופנה לקובץ?
שבע בטרמינל, כי כל '\n' מרוקן, ואחת בלבד בקובץ, ביציאה מהתוכנית.
getpid, getppid ו-fork
fork() היא פונקציה יוצאת דופן: קוראים לה פעם אחת, והיא חוזרת פעמיים, בשני תהליכים שונים. היא יוצרת תהליך בן (child) שהוא עותק של התהליך שקרא לה, ושני התהליכים ממשיכים לרוץ מהשורה שאחריה.
מה שמבדיל ביניהם הוא הערך שחזר: בבן fork() מחזירה 0, ובאב היא מחזירה את ה-PID של הבן. בכישלון היא מחזירה -1 ולא נוצר תהליך חדש.
שתי העטיפות הדקות getpid() ו-getppid() מזהות מי אנחנו. הראשונה מחזירה את מזהה התהליך הנוכחי, ותמיד אותו ערך בתוך אותו תהליך; השנייה מחזירה את מזהה האב, למשל ה-shell שהפעיל את התוכנית, שהוא תמיד תהליך אחר.
תרחיש 32: זיהוי אב ובן
/* Linux; traced by hand */
#include <stdio.h>
#include <unistd.h>
#include <sys/wait.h>
int main(void) {
pid_t me = getpid();
pid_t p = fork();
if (p == 0) {
printf("child: fork gave %d, parent matches: %d\n", (int)p, getppid() == me);
return 0;
}
wait(NULL);
printf("parent: child pid positive: %d\n", p > 1);
return 0;
}הבן מקבל 0 מ-fork, ומכיוון ש-getppid() בתוכו שווה ל-getpid() שנשמר באב, ההשוואה נותנת 1. הקריאה wait גורמת לאב להמתין לבן, ולכן שתי השורות מודפסות בסדר הזה: קודם הבן, אחר כך האב, שמקבל PID חיובי.
הבעיה מתחילה כש-fork() מופיעה כמה פעמים. כל תהליך שקיים באותו רגע מריץ את fork() הבאה, ולכן מספר התהליכים מוכפל בכל קריאה: אחרי k קריאות ברצף יש 2 בחזקת k תהליכים. סדר ההדפסות של תהליכים שונים אינו מובטח.
תרחיש 33: שלוש קריאות fork בלולאה
/* Linux; traced by hand */
#include <stdio.h>
#include <unistd.h>
int main(void) {
int left = 3;
while (left-- > 0)
fork();
puts("x");
return 0;
}| אחרי איטרציה | תהליכים |
|---|---|
| התחלה | 1 |
| 0 | 2 |
| 1 | 4 |
| 2 | 8 |
כל שמונת התהליכים מגיעים ל-puts, ולכן x מודפס 8 פעמים. אילו היו שתי איטרציות בלבד, היו 4 שורות, ולא 3 או 2.
תרחיש 34: fork בתוך תנאי
/* Linux; traced by hand */
#include <stdio.h>
#include <unistd.h>
int main(void) {
if (fork() > 0)
fork();
puts("y");
return 0;
}אחרי ה-fork() הראשון יש אב ובן. רק האב מקבל ערך חיובי ונכנס לגוף ה-if, ושם הוא יוצר בן נוסף; הבן הראשון מקבל 0 ומדלג. בסך הכול 3 תהליכים, ולכן y מודפס 3 פעמים.
טעויות נפוצות
- שני
fork()רצופים יוצרים 3 תהליכים. כל תהליך קיים מריץ את הבאה, ולכן יש 4. getppid()שווה ל-getpid(). האב הוא תהליך אחר, ולכן ההשוואה בתוך תהליך נותנת0.getpid()מחזירה ערך חדש בכל קריאה. בתוך תהליך אחד זה תמיד אותו ערך.
בדקו את עצמכם
תוכנית מבצעת ארבע קריאות fork() ברצף ואחריהן printf("A\n"). כמה פעמים מודפס A?
16, כי 2 בחזקת 4.
מה מחזירה fork() בבן ומה באב?
בבן 0, ובאב ה-PID של הבן.
סיכום
סיימנו את כל הנושא של פונקציות, מוסכמות קריאה וקריאות מערכת. כדי לגשת לשאלות המבחן בביטחון, רכזנו עבורכם את העקרונות המרכזיים לפי ארבע קבוצות:
- מעקב, מסגרות ורקורסיה: מתחילים תמיד מ-
main, מעריכים ארגומנטים לפני כניסה לפונקציה, ופותחים לכל קריאה מסגרת מחסנית נפרדת שמשתחררת רק בחזרה. פרמטרים עוברים לפי ערך (שינוי משתנה חיצוני דורש מצביע), חילוק שלמים או העברתdoubleלפרמטרintחותכים שארית, והדפסה אחרי קריאה רקורסיבית יוצאת בסדר הפוך. משתנה מקומיstaticהוא עותק אחד שמאותחל פעם אחת, יושב באזור הנתונים ושומר ערך בין קריאות; רקורסיה אינסופית גורמת לגלישת מחסנית (segfault בלינוקס), וכתיבה מעבר לגבול מערך היא התנהגות לא מוגדרת: היא עלולה לקרוס או להיראות תקינה. - מצביעים לפונקציות ו-
inline: בהצהרהint (*fp)(int, int)הסוגריים חיוניים (בלעדיהם זו פונקציה שמחזירהint *), וגודל המצביע הוא גודל כתובת (8 בתים ב-64 סיביות); מערך מצביעים מופעל עםarr[i](x, y)החל מאינדקס0. המילהinlineהיא רמז למהדר בלבד ואינה משנה את התוצאה או מבודדת משתנהstaticמקומי. מול מאקרו היא מונעת הערכה כפולה וקדימות שגויה ואוכפת טיפוסים והיקף, אך ב-C99 הגדרה שלinlineללאstaticאוexternעלולה להוביל לשגיאת קישור (undefined reference) ב--O0. - מוסכמות קריאה (32 ו-64 סיביות): ב-32 סיביות
cdeclמעבירה במחסנית מימין לשמאל כשהקורא מנקה (add esp, N, מאפשרprintf, שם_f);stdcallמעביר גם הוא מימין לשמאל ומנקה בנקראת (ret N, שם_f@N);fastcallשולחת שניים ראשונים ב-ECX, EDXוהשאר במחסנית כשהנקראת מנקה (שם@f@N). במסגרת x86[ebp]הוא EBP השמור,[ebp+4]כתובת החזרה ו-[ebp+8]הארגומנט הראשון; ערך חוזר ב-EAX(אוEDX:EAXל-64 ביט ו-ST(0)לממשיים), בעודEAX, ECX, EDXניתנים לדריסה ו-EBX, ESI, EDI, EBPנשמרים. ב-64 סיביות System V (לינוקס) מעבירה שלמים ב-RDI, RSI, RDX, RCX, R8, R9וממשיים בנפרד ב-XMM0..XMM7, ואילו Windows x64 ממפה ארבעה מקומות ראשונים לפי סדר (RCX, RDX, R8, R9אוXMM0..XMM3) עם 32 בתים של shadow space. - קריאות מערכת וחציצה: ב-x86-64 לינוקס מספר הקריאה נכנס ל-
RAXוהארגומנטים ל-RDI, RSI, RDX, R10, R8, R9(R10במקוםRCXשנדרס), והתוצאה חוזרת ב-RAX.writeכותבת בדיוקcountבתים ו-readקוראת עדcountבתים בלי'\0'; כישלון מחזיר-1מהעטיפה ומעדכן אתerrno.printfחוצצת בזיכרון (ובהפניה לקובץ מרוקנת בקריאתwriteאחת ביציאה), ו-kקריאותfork()רצופות מולידות2^kתהליכים.
write ישירה או דרך printf חוצצת, בדקו אם מתבצעת המרת טיפוסים בכניסה לפונקציה, ואם מופיעה inline ב-C99 שימו לב אם יש static ומהי רמת האופטימיזציה.