דלגו לתוכן הראשי
גאמא קוד

שפת 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 מורכב ולחזות מה יקרה בזיכרון ובפלט בלי להריץ אותו, כבר ביום המבחנים הראשון.

בשאלות מניחים, אלא אם נכתב אחרת, שזה 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: קריאה מקוננת בתוך ביטוי
C
#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, והוא מופיע כמעט בכל שאלת מעקב.

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: שינוי עותק מול שינוי דרך כתובת
C
#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: חיתוך חלק עשרוני בכניסה לפונקציה
C
#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), יחידת זיכרון פרטית לקריאה הזו. בתוכה יושבים כתובת החזרה שנדחפה זה עתה, גיבוי של אוגרים שהפונקציה עומדת לשנות, המשתנים המקומיים שלה וגם ארגומנטים שלא היה להם מקום באוגרים.

Text
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: אותו מספר, שני סדרי הדפסה
C
#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: הדפסה לפני הקריאה ואחריה, וקריאת בסיס שמדפיסה
C
#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: ערך חזרה שנזרק מול ערך שמצטבר
C
#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, גלובלי ומקומי באותה רקורסיה
C
#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 5

accumulate(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: כמה קריאות נכנסות במחסנית
C
#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: כתיבה מעבר לגבול של מערך מקומי
C
#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 f8 בתים ב-x86-64, כי נמדדת כתובת ולא הפונקציה שהיא מובילה אליה; גם גוף ארוך או עשרה פרמטרים לא משנים זאת
f == sum21 כש-f מחזיק את sum2, ו-0 כשהוא מחזיק פונקציה אחרת
תרחיש 10: פונקציה שמחזירה מצביע מול מצביע לפונקציה
C
#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 54

pick_max(&left, &right) משווה בין 4 ל-11 ומחזירה את הכתובת של right, ולכן winner הוא בעצם שם נוסף ל-right, וההשמה *winner = 50 כותבת אליו.

calc הוא מצביע לפונקציה, ולכן calc(left, right) היא למעשה sum2(4, 50) שמחזירה 54. הטעות הנפוצה היא לחשוב שהשניים מאותו סוג: הראשונה פונקציה שמחזירה מצביע, והשני מצביע שמריץ פונקציה.

תרחיש 11: גודל מצביע לפונקציה והשוואת כתובות
C
#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-648
טעויות נפוצות
  • ההצהרה int *f(int, int) מגדירה מצביע לפונקציה. ללא סוגריים סביב *f, הכוכבית שייכת לטיפוס ההחזרה וזו הצהרה על פונקציה שמחזירה int *.
  • הגודל sizeof של מצביע לפונקציה נקבע לפי מספר הפרמטרים או לפי טיפוס ההחזרה. מצביע לפונקציה מחזיק כתובת בלבד, ולכן גודלו ב-x86-64 הוא תמיד 8 בתים.
  • חייבים לכתוב & לפני שם הפונקציה בזמן השמה למצביע. שם הפונקציה מומר אוטומטית למצביע אליה גם ללא &.
  • כל שני מצביעים לפונקציה מאותו טיפוס שווים זה לזה, או שמצביע לעולם אינו שווה לשם פונקציה. השוואת == בודקת שוויון של כתובות הזיכרון בפועל.
בדקו את עצמכם
מה מצהירה השורה long *(*factories[5])(void);?

factories הוא מערך של 5 איברים. כל איבר הוא מצביע לפונקציה בלי פרמטרים שמחזירה long *.

חזרה לתוכן העניינים

השמה, קריאה והחלפת היעד

מצביע לפונקציה הוא משתנה, ולכן ההבדל בין act(v) לקריאה ישירה הוא רק במי שמחליט איזה קוד ירוץ. בקריאה ישירה זה השם שכתוב בקוד, ובקריאה דרך מצביע זה הערך שהמצביע מחזיק ברגע ההרצה.

אם בין שתי קריאות שמתם בו פונקציה אחרת, הקריאה השנייה תריץ את החדשה. לכן במעקב מוסיפים עמודה שרושמת על מה המצביע מצביע בכל צעד, ולא מניחים שהוא נשאר כפי שהיה.

מצביע שהוא NULL או שלא קיבל ערך לא מוביל לשום קוד אמיתי, ולכן קריאה דרכו היא התנהגות לא מוגדרת, ובלינוקס היא נגמרת בדרך כלל ב-SIGSEGV. אותה הגדרה חלה כשהטיפוס של המצביע לא מתאים לחתימה האמיתית של הפונקציה.

תרחיש 12: יעד שמתחלף לפי התוצאה
C
#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 אחריהמצביע לצעד הבא
1plus_seven512half_it (12 זוגי)
2half_it126half_it (6 זוגי)
3half_it63plus_seven (3 אי-זוגי)
4plus_seven310half_it

אחרי צעד 2 המצביע נשאר על half_it, ולכן צעד 3 משתמש בו שוב. אחרי צעד 3 הוא חוזר ל-plus_seven, ולכן צעד 4 משתמש בה.

תרחיש 13: מצביע לפונקציה שמשנה משתנה של הקורא
C
#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 7

fp(&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, והפרמטר שמקבל אותה הוא מצביע לפונקציה.

C
#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
C
#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)1714118
trail(times, 2, 3, b, 4)61854162

בגוף trail הצובר cur נמצא במקום הראשון, ולכן minus מחשבת cur - step. אילו הסדר היה הפוך, step - cur הייתה נותנת כבר באיבר הראשון -17.

תרחיש 15: callback שמקבל כתובת
C
#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;
}
פלט
18

twice מקבלת פונקציה שעובדת על כתובת ואת הכתובת עצמה. 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).

C
#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: מערך פונקציות בלולאה רגילה ובקן לולאות
C
#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 ופונקציה עם ארגומנטים משתנים
C
#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) מורכב משני זוגות סוגריים, ושניהם נחוצים: הראשון מחזיר פונקציה, והשני מפעיל אותה.

Text
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: בחירת תעריף מטבלת חיפוש
C
#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_kgper_kg(5)40
pick_rate(2)(5)expressexpress(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 שלא הוטמעה.
Text
/* 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
C
#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: המרת טיפוסים ופתרון שמות בהיקף
C
#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).

C
#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: ערבוב קדימות אופרטורים במאקרו חסר סוגריים
C
#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 16

MUL10(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 מול הכפלת תופעת לוואי במאקרו
C
#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.

חזרה לתוכן העניינים

מוסכמות קריאה ב-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 דוחפת את כתובת החזרה, הארגומנט הראשון נמצא בכתובת הנמוכה ביותר, צמוד אליה.

Assembly
; 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).

Assembly
; 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 4ret $4
2 int (8 בתים)ret 8ret $8
3 int (12 בתים)ret 12ret $12
5 int (20 בתים)ret 20ret $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.

Assembly
; 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, EDXp3 (4 בתים)ret 4
4 פרמטרים (p1..p4)ECX, EDXp3, p4 (8 בתים)ret 8
6 פרמטרים (p1..p6)ECX, EDXp3..p6 (16 בתים)ret 16
תכונהcdeclstdcallfastcall
אחראי ניקויהקורא (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]. הסיבה מתבררת כשעוקבים אחרי שלושת השלבים שקרו עד אותו רגע:

  1. הקורא דוחף ארגומנטים מימין לשמאל, כך שהארגומנט הראשון נדחף אחרון.
  2. call דוחפת את כתובת החזרה, ולכן מיד בכניסה (לפני הפרולוג) [esp] הוא כתובת החזרה ו-[esp+4] הוא הארגומנט הראשון.
  3. 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.

Assembly
; 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
Assembly
; 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 300x7FF8נדחפו שני ארגומנטים של pair_s (ירידה של 8 בתים)
call pair_s0x7FF4נדחפה כתובת החזרה בכניסה ל-pair_s
ret 8 של pair_s0x8000stdcall: שולפת את כתובת החזרה (4) ומסירה את שני הארגומנטים (8)
push 20 ואז push 100x7FF8נדחפו שני ארגומנטים של pair_c
call pair_c0x7FF4נדחפה כתובת החזרה בכניסה ל-pair_c
ret של pair_c0x7FF8cdecl: שולפת רק את כתובת החזרה; 8 הבתים של הארגומנטים נותרים
add esp, 80x8000הקורא מנקה את הארגומנטים ומשיב את 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-savedEBX, ESI, EDI, EBPהנקראת: אם היא נוגעת בהם, היא דוחפת אותם בכניסה ומשחזרת לפני ret
caller-savedEAX, ECX, EDXהקורא: הנקראת דורסת אותם חופשי, ולכן ערך שהקורא צריך אחרי הקריאה נשמר אצלו לפני ה-call
Assembly
; 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 ו-doubleST(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.

Assembly
; 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 x64System V (לינוקס / macOS)
1RCXRDI
2RDXRSI
3R8RDX
4R9RCX
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)
מקום 1RCXXMM0
מקום 2RDXXMM1
מקום 3R8XMM2
מקום 4R9XMM3
מקום 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 סיביות
C
/* 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; }
Assembly
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.

שאלהprintfwrite
איך נקבע כמה להוציאלפי מחרוזת הפורמט ותו הסיום '\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: שני היסטים והחזרות
C
#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 היא פונקציה רגילה מבחינת הטיפוס, אפשר להעביר אותה כארגומנט לפונקציה אחרת, כל עוד המצביע מתאים לחתימה שלה:

C
/* 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: סמן שמתקדם בקובץ של תשעה בתים
C
#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
קריאהביקשנוחזרוהסמן אחרי
ראשונה44 (mnop)4
שנייה44 (qrst)8
שלישית41 (u)9, סוף הקובץ
רביעית409, ללא שינוי
אחרי close ו-open22 (mn)2

הקריאה השלישית מחזירה 1 ולא 4, כי נשאר בית אחד בלבד; זו אינה שגיאה. רק הקריאה הרביעית, שנעשית כשהסמן כבר בסוף, מחזירה 0.

תרחיש 28: קריאה מהקלט התקני: שורה שלמה בטרמינל
C
/* 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.

קריאהמה הגרעין מחזירמה חוזר ל-Cerrno
open("/srv/missing/data.csv", O_RDONLY)-2 (-ENOENT)-1ENOENT, שערכו 2: אין קובץ או תיקייה כאלה
close(31) כשהמתאר לא פתוח-9 (-EBADF)-1EBADF, שערכו 9: מתאר קובץ לא תקין
read(-5, buf, 4)-9 (-EBADF)-1EBADF
chdir("/")00ללא שינוי

גם משמעות ההצלחה תלויה בפונקציה:

  • read ו-write: מספר בתים, 0 ומעלה.
  • open: מתאר קובץ, 0 ומעלה.
  • close ו-chdir: הערך 0.

נקודה שנבחנים מפספסים: הצלחה אינה מאפסת את errno. אם קריאה אחת נכשלה והבאה הצליחה, הערך הישן נשאר שם, ולכן אסור לקרוא את errno בלי שהקריאה האחרונה החזירה -1.

תרחיש 29: כישלון, הצלחה, ומה נשאר ב-errno
C
#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: הקריאה המוצלחת לא נגעה בו.

C
#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)
מספר הקריאהאינו קייםRAXEAX
ארגומנט 1RDIRDIEBX
ארגומנט 2RSIRSIECX
ארגומנט 3RDXRDXEDX
ארגומנט 4RCXR10ESI
ארגומנט 5R8R8EDI
ארגומנט 6R9R9EBP
התוצאהRAXRAXEAX

אחרי שהאוגרים מוכנים, הוראת 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 עם ארגומנט רביעי
C
/* 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
RDI17, מספר הקריאה5, המתאר
RSI5כתובת chunk
RDXכתובת chunk4, הכמות
RCX4אינו בשימוש; ההוראה תדרוס אותו
R83, ההיסטערך של 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: הפלט בקובץ מסודר אחרת מהקוד
C
/* 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]
four

one ו-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: זיהוי אב ובן
C
/* 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 בלולאה
C
/* 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
02
14
28

כל שמונת התהליכים מגיעים ל-puts, ולכן x מודפס 8 פעמים. אילו היו שתי איטרציות בלבד, היו 4 שורות, ולא 3 או 2.

תרחיש 34: fork בתוך תנאי
C
/* 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 ומהי רמת האופטימיזציה.