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

שפת C - קוד

Build Tools & Linking Process

קטעי קוד ופקודות בנייה: קישור בין קבצים, ספריות, #if, Makefile והצהרות extern ו-static.

בחרו את הרמה שמתאימה לכם ואת הסט שתרצו לתרגל

חומר לימוד

Build Tools & Linking Process: מהפרה-פרוססור ועד Make

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

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

  • שלבי הבנייה והפרה-פרוססור: תפקיד הדגלים -E, -S, -c, -I ו--D, ההבדל בין #if ל-#ifdef ו-#ifndef, ושימוש ב-#error, #pragma ומאקרו מובנים.
  • שומרי הכללה: איך #ifndef ו-#pragma once מגינים מפני הכללה חוזרת באותו קובץ מקור, ולמה הם אינם מונעים התנגשות multiple definition בשלב הקישור.
  • קישוריות, טבלת סמלים ו-inline: ההבחנה בין הצהרה להגדרה, static, extern, סמלי weak ו-strong, פענוח פלט של nm והתנהגות inline מול static inline.
  • ספריות ו-Makefile: יצירה וסריקת סדר של ספריות .a, בנייה וטעינה בזמן ריצה של ספריות .so עם -fPIC ו--shared, וחיזוי פעולת make לפי חותמות זמן, משתנים אוטומטיים, := מול = ו-.PHONY.
נקודת המוצא: אתם מכירים כתיבת פונקציות, משתנים מקומיים וגלובליים ושימוש ב-printf. הדוגמאות מניחות gcc בסביבת Linux x86-64 ותקן C99 או C11, אלא אם צוין אחרת. הפלטים המצורפים נלכדו ב-gcc 16 על Windows (MinGW), והיכן שיש הבדל מול Linux נאמר במפורש.

שלבי הבנייה: מהקוד הגולמי ועד קובץ ההרצה

ארבעת השלבים והדגלים שעוצרים ביניהם

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

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

תחנהמה היא עושהמה היא מוציאהדגל שעוצר מיד אחריה
עיבוד מקדים (preprocessing)מבצעת את שורות ה-#: מדביקה כותרות ומחליפה מאקרוטקסט C טהור, בסיומת .i-E, והטקסט מודפס למסך (או נשמר עם -o report.i)
הידור (compilation)בודקת תחביר וטיפוסים ומתרגמת לאסמבליreport.s-S
הרכבה (assembling, התוכנית as)הופכת אסמבלי לקוד מכונה, בלי כתובות סופיותקובץ אובייקט report.o-c
קישור (linking, התוכנית ld)מחברת קובצי אובייקט וספריות לתוכנית אחתקובץ הרצהאין: זה מה ש-gcc עושה כשלא מבקשים ממנו לעצור

הדגלים האלה מאפשרים גם להציץ בתוצרי הביניים. gcc -E מראה בדיוק מה המהדר מקבל, והוא הכלי הטוב ביותר להבנת מאקרו שהתנהג בצורה מפתיעה.

תרחיש 1: אילו קבצים נשארים בתיקייה

בכל אחת משלוש הריצות הבאות התחלנו מתיקייה נקייה שבה יש רק app.c:

Bash
# fresh folder, only app.c
$ gcc -c app.c ; ls
app.c
app.o

# fresh folder again
$ gcc -S app.c ; ls
app.c
app.s

# fresh folder again
$ gcc -save-temps -c app.c ; ls
app.c
app.i
app.o
app.s
  1. בבנייה רגילה קובצי .i ו-.s אינם נשמרים. הם מופיעים רק כשעוצרים מיד אחריהם עם -E או -S, או כשמוסיפים -save-temps, שמשאיר את כל תוצרי הביניים (.i, .s, .o) בלי לעצור את הבנייה.
  2. -c מייצר קובץ אובייקט ותו לא. קובץ הרצה אינו נוצר.
  3. קובץ הרצה נוצר רק כשהקישור רץ, ושמו a.out אם לא בחרתם שם בעזרת -o (ב-Windows הוא a.exe).

עכשיו לשאלה שבגללה כל זה חשוב: מי דיבר. הטבלה ממיינת את ההודעות הנפוצות לפי התחנה שמדפיסה אותן.

תחילת ההודעהמי מדפיס אותהמה קרה
fatal error: x.h: No such file or directoryהפרה-פרוססורהכותרת לא נמצאה באף אחת מתיקיות החיפוש
#error ...הפרה-פרוססורההוראה נמצאת בענף שלא נמחק, ולכן הופעלה
undeclared, redefinition of ..., incomplete typeהמהדרתקלה בתוך קובץ .c אחד: שם שלא הוצהר, הגדרה כפולה או טיפוס שלא הוגדר עד הסוף
undefined reference to ...הלינקרביקשו סמל ואף קובץ אובייקט או ספרייה אינם מגדירים אותו
multiple definition of ...הלינקריותר מקובץ אובייקט אחד מגדיר את אותו שם גלובלי
cannot find -lnameהלינקרהספרייה libname לא נמצאה בתיקיות שהלינקר מחפש בהן
error while loading shared librariesהטוען הדינמי, כשהתוכנית עולההבנייה הסתיימה בהצלחה, אבל ה-.so לא נמצא בזמן הריצה
כשקישור נכשל, קראו את ההודעות מלמעלה למטה והתעלמו מהשורה האחרונה, collect2: error: ld returned 1 exit status. היא רק מציינת ש-ld יצא עם קוד שגיאה, והסיבה האמיתית כתובה בהודעות שלפניה.
בדקו את עצמכם
הבנייה נכשלה עם undefined reference to 'lookup'. מי הדפיס את ההודעה, ומה יקרה אם תריצו gcc -c על כל אחד מקובצי המקור בנפרד?

הלינקר הדפיס אותה. כל קובץ יעבור -c בהצלחה, כי המהדר מסתפק בהצהרה על lookup, והחוסר מתגלה רק כשהאובייקטים מקושרים יחד.

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

יחידת תרגום: כל קובץ מקור עומד לבדו

כשהפרויקט מחולק לכמה קבצים, gcc מריץ את העיבוד המקדים ואת ההידור על כל קובץ .c בנפרד, כאילו הוא כל מה שקיים. הקובץ אחרי שהכותרות הודבקו לתוכו נקרא יחידת תרגום (translation unit), והוא הופך לקובץ אובייקט משלו.

דמיינו שני מהדרים שאינם יודעים זה על זה: האחד קורא את stock.c והשני את order.c. מכאן נגזר בדיוק מי יכול לגלות איזו תקלה:

מי רץמה הוא רואהעל מה הוא יכול להתלונן
המהדר, על קובץ .c אחדרק את הקובץ הזה ואת הכותרות שהודבקו לתוכותחביר, טיפוסים, שם שלא הוצהר והגדרה כפולה בתוך אותו קובץ
הלינקראת כל קובצי האובייקט והספריות יחדundefined reference (סמל בלי אף הגדרה) ו-multiple definition (שתי הגדרות גלובליות לאותו שם)

בגלל זה הצהרה (prototype) מספיקה למהדר. כשהוא רואה int fee(int); הוא מקבל את הקריאה, משאיר את הסמל fee פתוח, והגוף יכול לשבת בקובץ אחר לגמרי.

תרחיש 2: שני קבצים נקיים שאינם מתיישבים
C
// a.c
int mode = 1;

// b.c
int mode = 2;
int main(void) { return mode; }
Bash
$ gcc -c a.c
$ gcc -c b.c
$ gcc a.o b.o -o prog 2>&1 | grep -o "multiple definition.*"
multiple definition of `mode'; a.o:a.c:(.data+0x0): first defined here
$ gcc b.o a.o -o prog 2>&1 | grep -o "multiple definition.*"
multiple definition of `mode'; b.o:b.c:(.data+0x0): first defined here

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

החלפת הסדר שינתה רק איזה קובץ מוזכר בהודעה כ"ראשון", והבנייה נכשלה בשני המקרים. בקובצי .c ו-.o רגילים הסדר בדרך כלל אינו משנה את התוצאה, ויוצאים מן הכלל ספריות והגדרות weak בלבד. בספריות הסדר חשוב, וב-weak נבחרת ההגדרה של הקובץ הראשון (שניהם בהמשך).

שימו לב לפרט אחד: המיקום בשורת השגיאה (a.o:a.c:(.data+0x0)) הוא כפי ש-MinGW מדפיס אותו. ב-Linux הוא יופיע בדרך כלל בלי שם קובץ המקור, כ-a.o:(.data+0x0).

טעויות נפוצות
  • אם הופיעה undefined reference, סימן שההידור נכשל. ההידור הצליח. המהדר מסתפק בהצהרה, והלינקר הוא שמדווח שלא נמצאה הגדרה.
  • שני קבצים שמגדירים אותו משתנה גלובלי נעצרים כבר בהידור. כל קובץ מהודר לבדו ורואה הגדרה אחת. הסתירה מתגלה רק בקישור, כששני האובייקטים נפגשים.
  • בסתירה בין קובצי .c מנצח הקובץ שנכתב ראשון בפקודה. הקישור נכשל בכל סדר, כפי שהוצג למעלה. הלינקר לא בוחר מנצח בין שתי הגדרות רגילות.
בדקו את עצמכם
הקובץ report.c מצהיר double avg(const int *v, int n); וקורא לה, והמימוש נמצא ב-stats.c. מה יקרה ב-gcc stats.c report.c -o r, ומה ב-gcc report.c -o r?

הפקודה הראשונה מצליחה, כי stats.o מספק את הגוף, וגם הפיכת הסדר בין שני הקבצים הייתה מצליחה. בשנייה report.c עובר הידור, והלינקר נכשל עם undefined reference to 'avg'.

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

מה gcc -c מבצע ומה הוא משאיר לשלב הבא

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

כדי לדעת מה -c עושה, הסתכלו על מה שהוא משאיר: קובץ tax.o אחד בלבד. הדגל מורה ל-gcc להפעיל שלוש תחנות ולעצור לפני הרביעית, ולכן קובץ הרצה לא נוצר, וקובצי הביניים שנוצרים בדרך אינם נשמרים (בלי -save-temps).

  • הלינקר לא נקרא, ולכן אף אחד לא שואל איפה main: קובץ שיש בו פונקציות עזר בלבד עובר -c ללא תלונה.
  • בקובץ האובייקט יש רשימה של מקומות בקוד שדורשים השלמת כתובת (רשומות relocation). קריאה לפונקציה שרק הוצהרה מוסיפה רשומה כזו, ולצידה סמל לא מוגדר (U). בשלב הזה זה לא פגם.

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

תרחיש 3: מה חסר בקובץ האובייקט
C
// tax.c
int rate_for(int bracket);               /* declared only, no body anywhere */
int owed(int income, int bracket) { return income * rate_for(bracket) / 100; }
Bash
$ gcc -c tax.c
$ nm -g tax.o
0000000000000000 T owed
                 U rate_for
$ gcc tax.o -o prog 2>&1 | grep -o "undefined reference.*"
undefined reference to `rate_for'
undefined reference to `WinMain'

הפלט נלכד ב-gcc 16 על Windows (MinGW). ב-Linux רשימת הסמלים זהה, ובשגיאה השנייה מופיע main במקום WinMain, כי זו נקודת הכניסה שהלינקר מחפש. הדגל -g ב-nm מציג רק סמלים חיצוניים, ובלעדיו MinGW מוסיף לרשימה גם סמלי מקטעים כמו .text.

קראו קודם את nm: owed מסומנת T, כלומר הוגדרה בקובץ, ו-rate_for מסומנת U, כלומר רק הוזכרה. המהדר קיבל את הקריאה כי ראה את ההצהרה בראש הקובץ, ולכן gcc -c הצליח למרות שאין main ואין גוף ל-rate_for.

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

טעויות נפוצות
  • בלי main בקובץ, gcc -c ייכשל. הדרישה ל-main שייכת לקישור, ו--c עוצר לפניו.
  • פונקציה שהוצהרה בלי להגדיר אותה מפילה את gcc -c. הקריאה נשארת פתוחה בקובץ האובייקט עם סמל U, והמהדר מסתפק בכך.
  • gcc -c מייצר גם קובץ הרצה. -c עוצר לפני הלינקר, והלינקר הוא היחיד שמייצר קובץ הרצה.
  • gcc -c משאיר אחריו גם קובץ .s. קובץ .s מופיע רק בבקשה מפורשת: -S, או -save-temps שמשאיר את כל תוצרי הביניים.
בדקו את עצמכם
הקובץ weather.c מכיל רק את int humidity(void) { return 40; }. מה תפיק gcc -c weather.c ומה תפיק gcc weather.c?

הראשונה יוצרת את weather.o. השנייה ממשיכה לקישור ונכשלת על main שחסרה, ולכן לא נוצר קובץ הרצה.

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

הפרה-פרוססור: עיבוד טקסט לפני המהדר

החלפת טקסט ומה חושף gcc -E

הפרה-פרוססור הוא עורך טקסט שרץ לפני המהדר. הוא קורא את הקובץ כרצף מילים (tokens) ומטפל רק בשורות שמתחילות ב-# ובהחלפות של מאקרו, בלי לדעת מה זה טיפוס, משתנה, פונקציה או קבוע enum.

גם חישוב אינו תפקידו כשמדובר בקוד התוכנית: ביטוי כמו 6 - 2 * 3 עובר הלאה כטקסט, והמהדר הוא שיחשב אותו. הפרה-פרוססור מחשב במקום אחד בלבד, התנאי שאחרי #if ו-#elif, ועליו נדבר בהמשך.

ההוראה #define ROWS 4 היא כלל החלפה: מהשורה שאחריה ועד סוף הקובץ (או עד #undef ROWS) כל מילה ROWS הופכת לטקסט 4. אין כאן משתנה, ולכן אין זיכרון ואין כתובת.

במאקרו עם פרמטרים, כמו #define CELLS(r, c) r * c, הארגומנטים מודבקים בדיוק כפי שנכתבו. הפרה-פרוססור לא מוסיף סוגריים, ולכן קדימות האופרטורים נקבעת רק אחר כך, בידי המהדר.

תרחיש 4: מה המהדר מקבל באמת

הקובץ grid.c:

C
#include <stdio.h>
#define COLS 6
#define CELLS(r, c) r * c
int total = CELLS(COLS - 2, 3);
const char *label = "COLS";
int main(void) { printf("%d %s\n", total, label); return 0; }
Bash
$ gcc -E grid.c | tail -n 4
# 4 "grid.c"
int total = 6 - 2 * 3;
const char *label = "COLS";
int main(void) { printf("%d %s\n", total, label); return 0; }
$ gcc grid.c -o grid && ./grid
0 COLS

ההוראה #include <stdio.h> הדביקה כותרת שלמה לפני השורות האלה, ולכן הפלט נחתך ב-tail. מה שמעניין הוא מה קרה לכל שורה:

בקובץ המקוראחרי gcc -Eהסבר
#define COLS 6שורה ריקהההוראה נצרכה. במקומה נשארים רק סימוני # שורה "קובץ" שמעידים מאיפה הטקסט הגיע
CELLS(COLS - 2, 3)6 - 2 * 3הארגומנט COLS - 2 מורחב קודם ל-6 - 2, ורק אז נכנס לגוף r * c
"COLS""COLS"מחרוזת היא יחידה אחת שהפרה-פרוססור אינו נכנס אליה
הביטוי 6 - 2 * 3נשאר כטקסטאת החישוב עושה המהדר, והכפל קודם לחיסור

לכן ההדפסה היא 0 ולא 12, כפי שהייתם מצפים מ-(6 - 2) * 3. המאקרו לא "חישב ארבע כפול שלוש" אלא הדביק מילים זו ליד זו.

ההגנה היא לעטוף בסוגריים כל פרמטר ואת הגוף כולו: #define CELLS(r, c) ((r) * (c)). סוגריים שכבר נכתבו בגוף, כמו ב-#define HALF(x) (x / 2), מועתקים כמות שהם, כך ש-HALF(8) הופך ל-(8 / 2).

כשגוף של מאקרו מזכיר מאקרו אחר, הפרה-פרוססור סורק שוב את התוצאה של ההחלפה וממשיך להחליף. בקובץ nest.c:

C
#define TICKS 8
#define SPAN (TICKS * 5)
int total = SPAN;
Bash
$ gcc -E -P nest.c
int total = (8 * 5);

הדגל -P מסיר מהפלט את סימוני השורות. SPAN הוחלף ב-(TICKS * 5), ובסריקה החוזרת נמצא בו TICKS, ולכן total יקבל מהמהדר את הערך 40.

טעויות נפוצות
  • הפלט של gcc -E מציג את התוצאה המחושבת, למשל 0. הפרה-פרוססור משאיר את 6 - 2 * 3 כטקסט, והמהדר הוא שמחשב אותו.
  • הפרה-פרוססור אינו מחשב שום דבר, גם לא ב-#if. בקוד התוכנית אין חישוב, אבל התנאי של #if ו-#elif הוא ביטוי שלם שהוא כן מחשב, במספרים שלמים.
  • החלפת פרמטרים עוטפת אוטומטית את הארגומנט בסוגריים. ההחלפה היא הדבקת טקסט. רק סוגריים שכתבתם בעצמכם מופיעים.
  • שורת #define ושם המאקרו נשארים בפלט של -E. ההוראה נצרכת, וכל מופע של השם מחוץ למחרוזות מוחלף.
  • מאקרו שכתוב בתוך מחרוזת מוחלף גם הוא. מחרוזת נשארת בדיוק כפי שנכתבה, והפרה-פרוססור לא פותח אותה.
בדקו את עצמכם
נתונים #define DIFF(a, b) a - b והשורה int d = DIFF(9, 2 + 1) * 2;. איך תיראה השורה בפלט של gcc -E, ומה ערכו של d?

השורה תהפוך ל-int d = 9 - 2 + 1 * 2;. הכפל קודם, ולכן d שווה 9 - 2 + 2 = 9 ולא 12.

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

#include וסדר החיפוש של כותרות

שורת #include נראית כמו חיבור לספרייה, אבל היא עושה פחות: הפרה-פרוססור מעתיק את תוכן הקובץ למקום השורה ומסיים. מה שמגיע כך הוא הצהרות, טיפוסים ומאקרו, והגופים של הפונקציות מגיעים רק מהלינקר.

השאלה שמבחנים אוהבים היא איפה מחפשים את הקובץ, והתשובה תלויה בצורת הכתיבה:

צורהרשימת החיפוש, לפי הסדר
#include "x.h"תיקיית הקובץ שמכיל את ההוראה, אחר כך כל תיקיית -I לפי סדר הופעתן, ולבסוף תיקיות המערכת
#include <x.h>תיקיות -I ותיקיות המערכת בלבד, בלי תיקיית הקובץ המכליל

"תיקיית הקובץ המכליל" היא התיקייה שבה יושב קובץ המקור, ולא התיקייה שמתוכה הרצתם את gcc.

כדי להוסיף תיקיית חיפוש כותבים -Idir (או -I dir, שקול). הנתיב שבשורת ה-#include מוצמד לכל תיקייה ברשימה, כך ש-net/api.h נבדק כ-dir/net/api.h. דגלים אחרים לא עוזרים כאן: -L ו--l פונים ללינקר, ו--D מגדיר מאקרו.

כשהקובץ לא נמצא בשום מקום מתקבל fatal error: x.h: No such file or directory, והעיבוד נעצר.

תרחיש 5: מי הכותרת שנבחרה

הפרויקט כולל שני עותקים של knobs.h, ושלושה קובצי מקור שכוללים אותו:

Text
core/knobs.h    #define CAP 11
extra/knobs.h   #define CAP 22
core/q.c        #include "knobs.h"
core/a.c        #include <knobs.h>
lone/q.c        #include "knobs.h"      (the lone folder has no knobs.h)

הדגל -H מדפיס את הכותרות שנכללו בפועל, ו--fsyntax-only מוותר על יצירת קובץ. כך אפשר להוכיח איזה עותק נבחר, והנה ארבע ריצות מתיקיית הפרויקט:

Bash
$ gcc -H -fsyntax-only -Iextra core/q.c 2>&1 | head -n 1
. core/knobs.h
$ gcc -H -fsyntax-only -Iextra lone/q.c 2>&1 | head -n 1
. extra/knobs.h
$ gcc -H -fsyntax-only -Iextra core/a.c 2>&1 | head -n 1
. extra/knobs.h
$ gcc -H -fsyntax-only core/a.c 2>&1 | head -n 1
core/a.c:1:10: fatal error: knobs.h: No such file or directory
פקודההחיפושהתוצאה
-Iextra core/q.cמרכאות: קודם התיקייה core, ושם הכותרת קיימתCAP הוא 11, ו-extra לא נבדקת בכלל
-Iextra lone/q.cמרכאות: ב-lone אין כותרת, ולכן עוברים ל--IextraCAP הוא 22
-Iextra core/a.cסוגריים זוויתיים: core מדולגת, ונשאר רק -IextraCAP הוא 22, אף שבתיקיית הקובץ יש עותק אחר
core/a.c בלי -Iסוגריים זוויתיים ואין תיקיית -Ifatal error, והבנייה נעצרת

בכל ריצה נכנס עותק אחד בלבד, ולכן אין הגדרה כפולה של CAP. שימו לב שהריצה הראשונה מצאה את core/knobs.h אף שמתיקיית הפרויקט אין שם קובץ כזה: זו ההוכחה שהחיפוש מתחיל בתיקיית קובץ המקור.

טעויות נפוצות
  • סוגריים זוויתיים ב-#include גורמים לבדיקה ראשונה של התיקייה הנוכחית. רק הצורה עם מרכאות בודקת את תיקיית הקובץ המכליל לפני ה--I.
  • -L מוסיף תיקייה לחיפוש כותרות. -L מיועד לחיפוש ספריות בלינקר. כותרות מחפשים עם -I.
  • #include מצרף את קוד הספרייה לתוכנית. הוא מדביק טקסט של כותרת בלבד. המימושים נכנסים רק בקישור.
  • "תיקיית הקובץ" היא התיקייה שמריצים ממנה את gcc. זו תיקיית קובץ המקור עצמו, ולכן אותה פקודה יכולה למצוא כותרת בקובץ אחד ולא בקובץ אחר.
בדקו את עצמכם
הקובץ src/main.c כולל את "codec/pack.h", והכותרת נמצאת ב-vendor/codec/pack.h. איזה דגל יאפשר לבנות, ומה יקרה עם -Ivendor/codec?

הדגל -Ivendor. עם -Ivendor/codec הנתיב codec/pack.h יחופש בתוך vendor/codec, כלומר ב-vendor/codec/codec/pack.h, והבנייה תיעצר ב-fatal error.

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

הדגל -D, ערכי ברירת מחדל ו-#undef

אפשר לחשוב על -D כעל שורה שמודבקת בראש הקובץ לפני שהפרה-פרוססור מתחיל לקרוא: -DNAME=value שקול ל-#define NAME value. אם משמיטים את ה-=, הפקודה -DNAME שקולה ל--DNAME=1.

את זה אפשר להוכיח על קובץ ריק, empty.c. הדגל -dM מדפיס את כל המאקרו שמוגדרים כשהעיבוד נגמר:

Bash
$ gcc -E -dM -DWIDTH empty.c | grep "#define WIDTH "
#define WIDTH 1
$ gcc -E -dM -DWIDTH=7 empty.c | grep "#define WIDTH "
#define WIDTH 7
$ gcc -E -dM -DWIDTH=7 -UWIDTH empty.c | grep "#define WIDTH "

הפקודה השלישית לא מדפיסה כלום: הדגלים מעובדים לפי סדרם, ו--U ביטל את מה ש--D הגדיר. בתוך הקוד, ההוראה #undef NAME עושה את אותו דבר מהשורה שלה והלאה.

מה שבא אחרי ה-= הוא טקסט גולמי ולא ערך: -DWIDTH=8-2 מגדיר את WIDTH כרצף 8-2, ולא כמספר 6. ההקשר שבו השם מוחלף הוא שיקבע מה יחושב.

כך נראית ברירת מחדל שאפשר להחליף מבחוץ:

C
#ifndef WIDTH
#define WIDTH 5       /* fallback when the build line says nothing */
#endif

-DWIDTH=... מקדים את ההוראה הזו: בשעה שהפרה-פרוססור מגיע ל-#ifndef השם כבר קיים, והבלוק כולו מדולג.

תרחיש 6: אותו קובץ, חמש פקודות

הקובץ bar.c:

C
#include <stdio.h>
#ifndef WIDTH
#define WIDTH 5
#endif
int main(void) {
    printf("%d\n", 20 - WIDTH);
    return 0;
}
Bash
$ gcc bar.c -o bar && ./bar
15
$ gcc -DWIDTH bar.c -o bar && ./bar
19
$ gcc -DWIDTH=7 bar.c -o bar && ./bar
13
$ gcc -DWIDTH=8-2 bar.c -o bar && ./bar
10
$ gcc "-DWIDTH=(8-2)" bar.c -o bar && ./bar
14
פקודהWIDTH כשמגיעים ל-#ifndefהביטוי אחרי ההחלפהתוצאה
בלי דגללא מוגדר, ולכן מוגדר כאן כ-520 - 515
-DWIDTH1, וההגדרה של 5 מדולגת20 - 119
-DWIDTH=7720 - 713
-DWIDTH=8-2הטקסט 8-220 - 8-210
"-DWIDTH=(8-2)"הטקסט (8-2)20 - (8-2)14

בשורה הרביעית רואים שהערך הוא טקסט: 20 - 8-2 נקרא משמאל לימין כ-(20 - 8) - 2, ולכן מתקבל 10 ולא 14. הסוגריים בשורה האחרונה (שבקונסולה חובה להקיף במרכאות) מחזירים את הכוונה המקורית.

תרחיש 7: מאקרו שמוגדר מחדש אחרי #undef

הקובץ price.c:

C
#include <stdio.h>
#define PRICE 40
int first = PRICE;
#undef PRICE
#define PRICE 90
int second = PRICE;
int main(void) { printf("%d %d\n", first, second); return 0; }
Bash
$ gcc price.c -o price && ./price
40 90

ההחלפה קורית בשורה שבה המאקרו מופיע, ולא בסוף הקובץ. first נקלט עם 40 עוד לפני ה-#undef, ו-second קיבל את ההגדרה החדשה.

ביניהן, השם היה חופשי: #ifdef PRICE שהיה מוצב בין שתי השורות האלה היה שקרי.

טעויות נפוצות
  • הבלוק #ifndef X / #define X 4 / #endif מחליף את הערך של -DX=7. הדגל רץ לפני השורה הראשונה, ולכן X כבר מוגדר והבלוק מדולג.
  • כשכותבים -DX ללא שוויון, X מקבל 0 או נשאר ריק. gcc מגדיר אותו כ-1, בדיוק כמו -DX=1.
  • -DX=1+2 שווה 3. זה הטקסט 1+2, והקדימות של מה שסביב מקום ההחלפה קובעת את החישוב.
בדקו את עצמכם
בקובץ מופיע #ifndef STEP / #define STEP 5 / #endif, ובהמשך printf("%d\n", 90 - STEP * 2);. מה יודפס עם -DSTEP=1+2?

יודפס 93, כי הביטוי הוא 90 - 1+2 * 2, והכפל קודם: 90 - 1 + 4.

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

#if לעומת #ifdef ו-#ifndef

שלוש ההוראות נראות כמו שלוש דרכים לומר אותו דבר, אבל שתיים מהן שואלות אם שם קיים, והשלישית מחשבת ערך. ההבדל מתגלה בדיוק כשמאקרו מוגדר כ-0 או בלי גוף:

מצב של M#ifdef M#ifndef M#if M#if defined(M)
לא הוגדרשקראמתשקר (M נחשב 0)שקר
#define M 0אמתשקרשקראמת
#define M 1 (או כל ערך שאינו 0)אמתשקראמתאמת
#define M בלי גוףאמתשקרשגיאה: #if with no expressionאמת

כך הפרה-פרוססור קורא תנאי של #if או #elif, בסדר הזה:

  1. כל defined(NAME) (או defined NAME) מוחלף ב-1 או ב-0.
  2. מאקרו שנשארו בביטוי מוחלפים בגופם.
  3. כל מזהה שנשאר ואינו מאקרו, כולל שם של משתנה או של קבוע enum, נהפך ל-0 בשקט. רק -Wundef מוסיף אזהרה.
  4. הביטוי שהתקבל מחושב כביטוי קבוע בשלמים. מה שמצריך הכרות עם טיפוסים, כמו sizeof או cast, אינו נתמך ונגמר ב-missing binary operator.

מכאן המסקנה: קבוע enum ומשתנה (גם const int) הם בשביל הפרה-פרוססור סתם שמות לא מוכרים, כלומר 0. הם נוצרים רק בשלב ההידור, שמגיע אחריו.

כך זה נראה בפועל. בקובץ probe.c הבדיקה הראשונה משתמשת במשתנה, ולכן נחשבת 0 > 3 ונמחקת בלי הודעה. רק שתי האחרות נעצרות בשגיאה:

C
int depth = 5;
#if depth > 3
int deep_branch;
#endif
#if sizeof(long) > 4
int wide_branch;
#endif
#if (long)1 > 0
int cast_branch;
#endif
Bash
$ gcc -E -P probe.c 2>&1 | grep -E "error|branch"
probe.c:5:11: error: missing binary operator before token '('
probe.c:8:11: error: missing binary operator before token '1'
  • בשרשרת #if / #elif / #else ההכרעה היא מלמעלה למטה: התנאי הראשון שמתקיים קובע, וכל מה שאחריו, כולל #else, מושמט.
  • החלק שהושמט לא מגיע למהדר בכלל. שגיאה שכתובה בו לא מורגשת, ואין לו שום ביטוי בתוכנית הסופית.
  • כל #if, #ifdef ו-#ifndef מחייב #endif תואם.
תרחיש 8: אותם שמות, שני שלבים

הקובץ kinds.c מגדיר שלושה שמות בשלוש דרכים, ובודק את כולם גם ב-#if:

C
#include <stdio.h>
#define CAP 2
enum { LANES = 3 };
const int WAYS = 4;
int main(void) {
#if LANES == 0
    puts("lanes reads as zero");
#endif
#if WAYS == 0
    puts("ways reads as zero");
#endif
#if CAP == 2
    puts("cap is two");
#endif
    printf("%d %d %d\n", CAP, LANES, WAYS);
    return 0;
}
Bash
$ gcc kinds.c -o kinds && ./kinds
lanes reads as zero
ways reads as zero
cap is two
2 3 4
$ gcc -Wundef -c kinds.c 2>&1 | grep warning
kinds.c:6:5: warning: 'LANES' is not defined, evaluates to '0' [-Wundef]
kinds.c:9:5: warning: 'WAYS' is not defined, evaluates to '0' [-Wundef]
שםמה הואאיך #if רואה אותואיך הקוד רואה אותו
CAPמאקרו22
LANESקבוע enum03
WAYSמשתנה const int04

שורת ה-printf יושבת מחוץ לכל הוראה, ולכן היא מגיעה למהדר, והוא מכיר את שלושת השמות כמו שצריך. אותו שם קיבל ערך אחד בשלב הראשון וערך אחר בשלב השני, ו--Wundef חושף את שני המקרים שבהם הפרה-פרוססור ניחש 0.

תרחיש 9: ארבע הפקודות של בדיקה אחת

הקובץ sw.c מדפיס אות אחת על כל בדיקה שעוברת:

C
#include <stdio.h>
int main(void) {
#ifdef SW
    printf("d");
#endif
#ifndef SW
    printf("n");
#endif
#if SW
    printf("v");
#endif
#if defined(SW) && !SW
    printf("z");
#endif
    printf("\n");
    return 0;
}
Bash
$ gcc sw.c -o sw && ./sw
n
$ gcc -DSW=0 sw.c -o sw && ./sw
dz
$ gcc -DSW sw.c -o sw && ./sw
dv
$ gcc -DSW=4 sw.c -o sw && ./sw
dv
$ gcc -DSW= sw.c -o sw 2>&1 | grep error
sw.c:9:7: error: #if with no expression
sw.c:12:23: error: operator '!' has no right operand

בלי דגל, SW לא קיים: #ifndef עובר, ו-#if SW נופל כי SW נחשב 0. עם -DSW=0 השם קיים ולכן d, אבל ערכו אפס ולכן v נופל, ו-defined(SW) && !SW אמת ונותן z.

-DSW ו--DSW=4 נותנים אותו דבר, dv, כי שניהם ערך שאינו אפס. והפקודה האחרונה, -DSW= עם = ובלי ערך, מגדירה את SW כריק, ושתי הבדיקות שמחשבות ערך נשברות: זה בדיוק המצב של מאקרו בלי גוף.

תרחיש 10: שרשרת #elif בסדר הפוך

בקובץ chain.c התנאים כתובים מהרחב אל הצר, וזו טעות:

C
#include <stdio.h>
int main(void) {
#if LEVEL >= 1
    puts("level one or more");
#elif LEVEL >= 5
    puts("level five or more");
#else
    puts("level zero");
#endif
    return 0;
}
Bash
$ gcc -DLEVEL=7 chain.c -o chain && ./chain
level one or more
$ gcc -DLEVEL=0 chain.c -o chain && ./chain
level zero
$ gcc chain.c -o chain && ./chain
level zero

עם -DLEVEL=7 התנאי הראשון כבר אמת, ולכן הענף השני נמחק בלי שנבדק, אף שגם הוא היה אמת. הענף >= 5 לא יופעל לעולם. תיקון: מסדרים את התנאים מהמחמיר ביותר אל המקל ביותר.

ובלי דגל כלל, LEVEL נחשב 0 ולכן הענף של #else נבחר, בלי שום הודעה.

ענף שנמחק פשוט אינו קיים עבור המהדר, גם אם תוכנו אינו C תקין. בקובץ skip.c:

C
#include <stdio.h>
int main(void) {
#if 0
    this line is not C at all ;;
#endif
    puts("built fine");
    return 0;
}
Bash
$ gcc skip.c -o skip && ./skip
built fine
טעויות נפוצות
  • #ifdef FLAG שקרי כש-FLAG מוגדר כ-0. #ifdef בודק קיום בלבד, ולא את הערך.
  • #if FLAG אמת כש-FLAG מוגדר כ-0. #if בודק ערך, ו-0 הוא שקר.
  • מאקרו בלי גוף נחשב לא מוגדר. #define QUIET מגדיר את QUIET לכל דבר, אבל #if QUIET יסתיים בשגיאה.
  • קבוע enum, או const int, עובד בתוך #if. הפרה-פרוססור לא מכיר אותם ומחשב אותם כ-0.
  • שם שלא הוגדר בתוך #if הוא שגיאת עיבוד מקדים. הוא נחשב 0 בשקט, ורק -Wundef מזהיר.
  • בשרשרת #elif כמה ענפים נכנסים יחד. נבחר הענף הראשון שתנאו אמת, והשאר נמחקים.
בדקו את עצמכם
אחרי const int SPEED = 30; מופיע #if SPEED > 10 עם puts("fast");, ובענף #else יש puts("slow");. מה יודפס?

slow. בזמן העיבוד המקדים SPEED הוא משתנה שעוד לא קיים בשבילו, ולכן נחשב 0, ו-0 > 10 שקר.

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

#error, #pragma ומאקרו מוגדרים מראש

קוד יכול להתערב בבנייה בשתי דרכים: לעצור אותה בעזרת #error, או לבקש מהמהדר משהו מיוחד בעזרת #pragma.

#error "msg" מדפיסה את ההודעה ועוצרת את ההידור. הכישלון קורה בשלב ההידור, ולכן קובץ .o לא נוצר והלינקר אינו מגיע לשיחה: זו לא שגיאת קישור. ההוראה פועלת רק אם היא שורדת את בחירת הענפים, ובתוך ענף שנמחק אין לה השפעה.

#pragma שונה בכך שמשמעותה נקבעת על ידי המהדר ולא על ידי התקן. ב-gcc, #pragma message("text") מציגה בזמן הבנייה הודעת note, ואינה משאירה שום קוד בתוכנית.

ומה עם pragma שהמהדר לא מכיר? התקן קובע שמתעלמים ממנה בשקט, ו-gcc מוסיף אזהרה רק אם מפעילים -Wall או -Wunknown-pragmas. בקובץ pr.c יש #pragma sparkle on ו-main ריקה:

C
#pragma sparkle on
int main(void) { return 0; }
Bash
$ gcc -c pr.c
$ gcc -Wall -c pr.c 2>&1 | head -n 1
pr.c:1: warning: ignoring '#pragma sparkle on' [-Wunknown-pragmas]

המהדר גם מגדיר מראש כמה מאקרו, וחשוב להכיר את הערכים שלהם:

מאקרוערך
__STDC__1, כשהמהדר מצהיר שהוא עומד בתקן C
__STDC_VERSION__מציין את תקן השפה: 199901L ב-C99, 201112L ב-C11, 201710L ב-C17 ו-202311L ב-C23. עם -std=c90 הוא אינו מוגדר כלל
__FILE__ ו-__LINE__שם הקובץ כמחרוזת ומספר השורה הנוכחית
__DATE__ ו-__TIME__מועד ההידור, כמחרוזות
__GNUC__, __linux__, __x86_64__, _WIN32תלויים במהדר ובפלטפורמה. למשל __GNUC__ מוגדר ב-gcc
ב-gcc חדש (כמו 16), בלי -std ברירת המחדל היא C23, ולכן __STDC_VERSION__ הוא 202311L. בגרסאות קודמות ברירת המחדל הייתה C17 או C11, ולכן כשהתוצאה תלויה בתקן כדאי לציין -std במפורש.

מלכודת נפוצה: __func__ נראה כמו __FILE__ אך אינו מאקרו. את השם מצהיר המהדר בתוך כל פונקציה, בשלב שאחרי העיבוד המקדים, ולכן #ifdef __func__ נכשל אבל השימוש בו בקוד עובד. הקובץ fn.c מראה את שני הצדדים:

C
#include <stdio.h>
void probe(void) {
#ifdef __func__
    puts("macro");
#else
    puts("not a macro");
#endif
    printf("%s\n", __func__);
}
int main(void) { probe(); return 0; }
Bash
$ gcc fn.c -o fn && ./fn
not a macro
probe
תרחיש 11: שער גרסה עם #error ו-#pragma message

הקובץ needs11.c דורש C11 ומדפיס הודעה בזמן ההידור:

C
#if !defined(__STDC_VERSION__) || __STDC_VERSION__ < 201112L
#error "this file needs C11 or newer"
#endif
#pragma message("compiling needs11.c")
int main(void) { return 0; }
Bash
$ gcc -std=c11 -c needs11.c
needs11.c:4:9: note: '#pragma message: compiling needs11.c'
    4 | #pragma message("compiling needs11.c")
      |         ^~~~~~~
$ rm needs11.o
$ gcc -std=c99 -c needs11.c ; ls needs11.o
needs11.c:2:2: error: #error "this file needs C11 or newer"
    2 | #error "this file needs C11 or newer"
      |  ^~~~~
needs11.c:4:9: note: '#pragma message: compiling needs11.c'
    4 | #pragma message("compiling needs11.c")
      |         ^~~~~~~
ls: cannot access 'needs11.o': No such file or directory

ב--std=c11 התנאי __STDC_VERSION__ < 201112L שקרי ושורת ה-#error נמחקת: רק ה-note מופיע וההידור מצליח. ב--std=c99 הערך 199901L נמוך מהנדרש, השורה נשארת, ההידור נכשל ואין needs11.o. שימו לב שה-note מודפס גם בריצה הכושלת, כלומר השגיאה לא קטעה את קריאת שאר הקובץ.

תחת -std=c90 המאקרו אינו מוגדר, ולכן אותה שגיאה מופיעה. בלי החלק של defined היה מתקבל אותו דבר: שם שלא הוגדר נחשב 0, ו-0 < 201112L אמת.

ועכשיו מה שהמאקרו באמת מחזיר, תחת כל תקן. התוכנית stdver.c מדפיסה את __STDC_VERSION__, את __STDC__ ואת __LINE__:

C
#include <stdio.h>
int main(void) {
    printf("%ld %d line %d\n", (long)__STDC_VERSION__, __STDC__, __LINE__);
    return 0;
}
Bash
$ gcc -std=c99 stdver.c -o sv && ./sv
199901 1 line 3
$ gcc -std=c11 stdver.c -o sv && ./sv
201112 1 line 3
$ gcc -std=c17 stdver.c -o sv && ./sv
201710 1 line 3
$ gcc stdver.c -o sv && ./sv
202311 1 line 3

הפקודה האחרונה, ללא -std, רצה כ-C23 ב-gcc 16. ושימו לב: __STDC__ נשאר 1 בכל התקנים, ואילו 199901 ו-201112 הם ערכי __STDC_VERSION__.

טעויות נפוצות
  • #error או #pragma message מדפיסים טקסט כשהתוכנית רצה. שתיהן פועלות רק בזמן העיבוד המקדים וההידור, ואינן נכנסות לקוד המכונה.
  • #error בתוך ענף שנמחק בכל זאת עוצר את ההידור. ענף שנמחק לא מעובד כלל.
  • __STDC__ שווה 199901 ב-C99. זה ערכו של __STDC_VERSION__. הערך של __STDC__ הוא 1.
  • __func__ הוא מאקרו שהפרה-פרוססור מחליף. זה מזהה שהמהדר מגדיר בתוך הפונקציה, אחרי העיבוד המקדים.
בדקו את עצמכם
בקובץ מופיע #define LIMIT 16, אחריו #if LIMIT < 8 עם #error "too small" ו-#endif, ואחר כך #pragma message("limit accepted"). main מחזירה 0 בלי להדפיס. מה יקרה בהידור ומה בהרצה?

ההידור מצליח וההערה limit accepted מודפסת, כי 16 < 8 שקר וה-#error נמחק. בהרצה לא מודפס דבר.

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

שומרי הכללה: מניעת הדבקה כפולה בכותרת

איך שומר הכללה פועל

בפרויקט עם כמה כותרות קל ליצור "יהלום" של הכללות: main.c כולל את report.h ואת audit.h, וכל אחת מהן כוללת בעצמה את ledger.h. כך ledger.h נכנס לאותה יחידת תרגום פעמיים, ואם יש בו struct, ההגדרה שלו מופיעה פעמיים.

בתקנים עד C17 זו שגיאת redefinition of 'struct entry'. ב-C23 הכלל התרחב ומותר לחזור על הגדרה זהה של אותו struct, ולכן gcc 16 בלי -std מקמפל קוד כזה בשקט. לכן כל ההדגמות כאן של השגיאה רצות עם -std=c11.

תרחיש 12: יהלום בלי שומר

הכותרת ledger.h עדיין בלי שומר:

C
struct entry { int day; long cents; };

שתי הכותרות הבאות מוגנות כל אחת בשומר משלה. הקובץ report.h:

C
#ifndef REPORT_H
#define REPORT_H
#include "ledger.h"
struct report { struct entry first; int pages; };
#endif

הקובץ audit.h:

C
#ifndef AUDIT_H
#define AUDIT_H
#include "ledger.h"
struct audit { struct entry last; int flags; };
#endif

והקובץ main.c, שכולל את שתיהן:

C
#include <stdio.h>
#include "report.h"
#include "audit.h"
int main(void) {
    struct report r = { { 3, 250 }, 2 };
    struct audit a = { { 9, 40 }, 1 };
    printf("%ld\n", r.first.cents + a.last.cents * r.pages);
    return 0;
}
Bash
$ gcc -std=c11 main.c -o m 2>&1 | head -n 8
In file included from audit.h:3,
                 from main.c:3:
ledger.h:1:8: error: redefinition of 'struct entry'
    1 | struct entry { int day; long cents; };
      |        ^~~~~
In file included from report.h:3,
                 from main.c:2:
ledger.h:1:8: note: originally defined here
$ gcc main.c -o m && ./m
330
$ gcc -E -P main.c | grep -c "struct entry {"
2

שימו לב להתנהגות הכפולה: תחת C11 יש שגיאה, ותחת ברירת המחדל של gcc 16 אותו קוד נבנה ומדפיס 330, אף שההגדרה מופיעה פעמיים בטקסט המעובד. התיקון הנכון זהה בשני המקרים, ולכן כדאי להגן על כל כותרת.

כך נראית ledger.h עם שומר:

C
#ifndef LEDGER_H
#define LEDGER_H
struct entry { int day; long cents; };
#endif
Bash
$ gcc -std=c11 main.c -o m && ./m
330
$ gcc -E -P main.c | grep -c "struct entry {"
1

אפשר לתאר את השומר כדגל שהכותרת מרימה בעצמה. #ifndef LEDGER_H שואל אם הדגל עדיין למטה, ו-#define LEDGER_H מרים אותו.

בכניסה הראשונה הדגל למטה, ולכן התוכן נשאר והדגל עולה. בכניסה השנייה הוא כבר למעלה, וכל מה שבין #ifndef ל-#endif נמחק.

הכללהLEDGER_H כשההוראה נקראתמה נכנס לטקסט המעובד
report.h מתוך main.c, ובתוכה ledger.hלא מוגדר, ואז מוגדרstruct entry ואחריו struct report
audit.h מתוך main.c, ובתוכה ledger.hמוגדרגוף ledger.h מדולג, ונכנס רק struct audit

הדילוג מוגבל לתוך הכותרת: קובץ ה-.c שהכליל אותה ממשיך כרגיל. גם אין שגיאה על LEDGER_H שהוגדר פעמיים, כי בכניסה השנייה השורה #define LEDGER_H עצמה נמחקת עם שאר הגוף.

טעויות נפוצות
  • אסור לכלול אותה כותרת פעמיים, וזו שגיאה. זה חוקי לגמרי. השומר רק מדלג על התוכן בפעם השנייה.
  • השומר מדלג גם על שאר קובץ ה-.c שכלל את הכותרת. הדילוג מסתיים ב-#endif של הכותרת, והקובץ המכליל ממשיך כרגיל.
  • #ifndef ו-#define שני שמות לאותה פעולה. #ifndef בודק אם השם עוד לא מוגדר, ו-#define מגדיר אותו. רק השילוב ביניהם יוצר שומר.
בדקו את עצמכם
הכותרת queue.h מוגנת בשומר, ו-main.c מגיע אליה ארבע פעמים: ישירות, ודרך a.h, b.h ו-c.h. כמה עותקים של ההגדרה שלה יהיו בטקסט שמחזיר gcc -E main.c?

פעם אחת, בהכללה הראשונה. בשלוש האחרות הדגל כבר מורם והגוף מדולג.

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

שמות ייחודיים ו-#pragma once

השומר עובד רק כשלכל כותרת יש דגל משלה. נהוג לגזור את שם הדגל משם הקובץ, כמו LEDGER_H עבור ledger.h, וכך שני קבצים לא יתנגשו.

מה קורה כשהשם משותף בטעות? הקובץ gear.h:

C
#ifndef MECH_H
#define MECH_H
struct gear { int teeth; };
#endif

והקובץ spring.h, שהועתק מהראשון והשם בו נשאר:

C
#ifndef MECH_H
#define MECH_H
struct spring { int coils; };
#endif

והקובץ main.c, שכולל את שניהם ומשתמש ב-struct spring:

C
#include "gear.h"
#include "spring.h"
int main(void) {
    struct spring s;
    s.coils = 4;
    return s.coils;
}
Bash
$ gcc main.c
main.c: In function 'main':
main.c:4:19: error: storage size of 's' isn't known
    4 |     struct spring s;
      |                   ^
$ gcc -E -P main.c | head -n 2
struct gear { int teeth; };
int main(void) {

gear.h נכנסת ראשונה ומרימה את MECH_H. כש-spring.h נקראת, הדגל כבר למעלה, ולכן כל תוכנה נמחק, ו-struct spring לא מגיע למהדר כלל, כפי שרואים בפלט של -E.

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

החלופה היא #pragma once בראש הכותרת, שמגינה בלי שם. הטבלה מסכמת את ההבדלים:

תכונהשומר #ifndef#pragma once
חלק מתקן Cכןלא
צריך לבחור שםכן, והוא חייב להיות ייחודילא
מהדרים שתומכיםכל מהדר תקניgcc, clang ו-MSVC
סכנת התנגשות שמותקיימתאין

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

טעויות נפוצות
  • שתי כותרות עם אותו שם שומר גורמות לשגיאת macro redefined. ה-#define השני נמצא בתוך הגוף שנמחק, ולכן הוא לא מתבצע.
  • הגדרת struct שחסרה או כפולה מפילה את הקישור. ל-struct אין סמל בקובץ האובייקט, ולכן כל בעיה בו מתגלה כבר בהידור.
חזרה לתוכן העניינים

הגדרה בכותרת ושגיאת multiple definition

ההודעה multiple definition of 'verbosity' מגיעה מהלינקר, אף שכל קובץ מקור נראה נקי. כדי להבין מאיפה היא באה צריך לזכור שהשומר מגן רק בתוך יחידת תרגום אחת.

כל אחד מקובצי ה-.c נכנס לעיבוד מקדים משלו, שמתחיל מאפס, ובראשו אף דגל של שומר אינו מורם. לכן כותרת שמופיעה גם ב-logger.c וגם ב-main.c נכנסת לכל אחד מהם פעם אחת, והשומר לא עוזר.

תרחיש 13: משתנה שמוגדר בכותרת

הכותרת settings.h:

C
#ifndef SETTINGS_H
#define SETTINGS_H
int verbosity = 1;            /* a definition inside a header */
void note(const char *msg);
#endif

הקובץ logger.c:

C
#include <stdio.h>
#include "settings.h"
void note(const char *msg) { if (verbosity > 0) puts(msg); }

והקובץ main.c:

C
#include "settings.h"
int main(void) { note("started"); return verbosity; }
Bash
$ gcc -c logger.c
$ gcc -c main.c
$ gcc logger.o main.o -o app 2>&1 | grep -o "multiple definition.*"
multiple definition of `verbosity'; logger.o:logger.c:(.data+0x0): first defined here
$ nm -A -g logger.o main.o | grep verbosity
logger.o:0000000000000000 D verbosity
main.o:0000000000000000 D verbosity

שתי הפקודות הראשונות עברו, כי כל קובץ בנפרד מכיל הגדרה אחת. הפלט של nm מראה למה הקישור נכשל: שני קובצי האובייקט מגדירים סמל גלובלי בשם verbosity (האות D), והלינקר לא יודע איזה מהם לבחור, ולכן לא נוצר קובץ הרצה.

התיקון מעביר את ההגדרה לבעלים אחד. בכותרת נשארת הצהרה בלבד, בקובץ settings.h:

C
#ifndef SETTINGS_H
#define SETTINGS_H
extern int verbosity;
void note(const char *msg);
#endif

וההגדרה עצמה עוברת אל logger.c:

C
#include <stdio.h>
#include "settings.h"
int verbosity = 1;
void note(const char *msg) { if (verbosity > 0) puts(msg); }
Bash
$ gcc logger.c main.c -o app && ./app
started

עכשיו יש הגדרה אחת בלבד, ו-main.c רק מפנה אליה. התוכנית רצה ומדפיסה started.

אפשר לסכם איזה תוכן בטוח לכותרת לפי השאלה "מה קורה כשהוא נכנס לכמה קבצים":

מה בכותרתהאם בטוחלמה
הצהרות של משתנים (extern) ושל פונקציות (אבות טיפוס)כןהן לא יוצרות סמל, ולכן אין מה להתנגש
הגדרות struct, enum ו-typedef, ומאקרוכןהן תיאור למהדר ואין להן סמל בקובץ האובייקט
פונקציה קצרה עם static inlineכןלכל קובץ יש עותק פרטי, שהלינקר אינו רואה
משתנה גלובלי עם ערך, כמו int count = 0;לאכל קובץ מגדיר סמל גלובלי משלו
פונקציה רגילה עם גוףלאכל קובץ אובייקט מקבל הגדרה נוספת של אותו שם
טעויות נפוצות
  • שומר ההכללה בכותרת מונע multiple definition בין a.c ל-b.c. השומר פועל רק בתוך קובץ אחד, ולכל קובץ .c עיבוד מקדים משלו.
  • זו שגיאת הידור מסוג redefinition. כל קובץ רואה הגדרה אחת, ולכן ההידור מצליח. השגיאה מגיעה מהלינקר.
  • זו שגיאת undefined reference. כאן יש יותר מדי הגדרות ולא פחות מדי.
  • אפשר לסמוך על כך שכל קובץ מקבל עותק פרטי של המשתנה. בלי static זה לא נכון והקישור נכשל. רק עם static יש באמת עותק פרטי לכל קובץ.
  • אסור לשים גוף של פונקציה בכותרת. פונקציה קצרה עם static inline היא פתרון מקובל.
בדקו את עצמכם
הכותרת bounds.h, עם שומר תקין, מכילה int cap(void) { return 8; }, והיא נכללת בשלושה קבצים: p.c, q.c ו-main.c. מה ייצא מהפקודה gcc p.c q.c main.c, ומה ישתנה אם ההגדרה תהיה static int cap(void)?

הקישור ייכשל עם multiple definition of 'cap', כי בכל אחד משלושת האובייקטים יש סמל גלובלי בשם cap. עם static לכל קובץ עותק פרטי, והבנייה תצליח.

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

קישוריות: extern, static, weak ו-strong

הצהרה מול הגדרה

הצהרה והגדרה נבדלות במה שנשאר בקובץ האובייקט אחרי ההידור. הגדרה (definition) משאירה משהו ממשי: מקום בזיכרון למשתנה, או קוד לפונקציה. הצהרה (declaration) היא הודעה למהדר בלבד, שם וטיפוס, ולכן היא עצמה לא יוצרת דבר; סמל U מופיע רק אם הקוד משתמש בשם.

הקובץ defs.c מדגים את זה:

C
int a = 7;
int b;
extern int c;
int twice(int v) { return v * 2; }
int thrice(int v);
Bash
$ gcc -c defs.c
$ nm -g defs.o
0000000000000000 D a
0000000000000000 B b
0000000000000000 T twice

שלוש ההגדרות (a, b, twice) יצרו סמלים. ההצהרות על c ועל thrice לא השאירו שום זכר, כי איש לא השתמש בהן. האותיות D, B ו-T מציינות איפה הסמל יושב, ונפרט אותן בחלק על nm.

שורה ברמת הקובץמה היאהערה
int volume = 3;הגדרה של משתנה גלובלימקבל זיכרון והערך 3
int volume;הגדרה של משתנה גלובלי מאופסברירת המחדל מ-gcc 10 היא שכל קובץ מגדיר משתנה משלו, ולכן שורה כזו בשני קבצים מתנגשת בקישור
extern int volume;הצהרה בלבדהמשתנה מוגדר בקובץ אחר
int mix(int, int);הצהרה של פונקציהבלי גוף
int mix(int p, int q) { return p + q; }הגדרה של פונקציהעם גוף
תרחיש 14: אותה שורה בלי extern בשני קבצים
C
// t1.c
int total;

// t2.c
int total;
int main(void) { return total; }
Bash
$ gcc -c t1.c
$ gcc -c t2.c
$ gcc t1.o t2.o -o t 2>&1 | grep -o "multiple definition.*"
multiple definition of `total'; t1.o:t1.c:(.bss+0x0): first defined here
$ gcc -fcommon t1.c t2.c -o t && echo linked
linked

בלי extern, השורה int total; היא הגדרה, ולכן כל קובץ מגדיר משתנה משלו והקישור נכשל. עד gcc 9, או עם -fcommon, הגדרות כאלה התמזגו לסמל אחד, ולכן אותו קוד נבנה בשקט. מגרסה 10 ברירת המחדל היא -fno-common.

גם כאן המיקום בשורה (t1.o:t1.c:(.bss+0x0)) הוא כפי ש-MinGW מדפיס אותו, וב-Linux הוא יופיע בדרך כלל בלי שם קובץ המקור.

תרחיש 15: הצהרה בלי בעלים
C
// gauge.c
#include <stdio.h>
extern int reading;
int main(void) { printf("%d\n", reading); return 0; }

// sensor.c
int reading = 0;
Bash
$ gcc -c gauge.c
$ gcc gauge.o -o gauge 2>&1 | grep -o "undefined reference.*"
undefined reference to `reading'
$ gcc -c sensor.c
$ gcc gauge.o sensor.o -o gauge && ./gauge
0

ההצהרה extern int reading; מספקת שם וטיפוס, ולכן gauge.c התקמפל. אבל היא לא יוצרת משתנה ולא מאפסת דבר, ובלי sensor.o אין ללינקר למה לקשור את הקריאה.

הערך ההתחלתי 0 של גלובלי הוא תכונה של ההגדרה בלבד. ברגע שקיימת הגדרה אחת, כל ה-extern בקבצים השונים נקשרים אליה בקישור ומשקפים משתנה יחיד.

טעויות נפוצות
  • תוכנית שמצהירה extern int level; בלי שום הגדרה תדפיס 0, כי גלובליים מתאפסים. אין כאן משתנה שאפשר לאפס: ההגדרה חסרה, והקישור נכשל.
  • extern בלי הגדרה גורם לשגיאת undeclared בהידור. דווקא בגלל ההצהרה המהדר מכיר את השם. מה שחסר מתגלה רק כשהלינקר מחפש את ההגדרה.
  • הצהרת פונקציה בלי גוף גורמת ל-conflicting types. הצהרה בלי גוף תקינה כשהטיפוסים שלה זהים לאלה שבהגדרה. רק אי-התאמה ביניהם יוצרת קונפליקט.
חזרה לתוכן העניינים

static ברמת הקובץ

הוספת static להגדרה שנמצאת מחוץ לכל פונקציה הופכת אותה לפרטית לקובץ. זו קישוריות פנימית (internal linkage): הסמל נרשם בקובץ האובייקט כמקומי (אות קטנה ב-nm), ולכן הלינקר אינו מציע אותו לאף קובץ אחר.

בקובץהסמל בקובץ האובייקטמי יכול להפנות אליו מקובץ אחר
int n = 1;גלובליכל קובץ, עם extern int n;
static int n = 1;מקומי (אות קטנה ב-nm)אף קובץ
int f(void) { ... }גלובליכל קובץ שמצהיר עליה
static int f(void) { ... }מקומי (אות קטנה ב-nm)אף קובץ
  • הצהרת extern int depth; נקשרת רק להגדרה גלובלית. אם הגדרת depth היחידה שבקבצים האחרים היא static, אין ללינקר מה להציע, והתוצאה undefined reference ולא multiple definition.
  • static int depth בקובץ אחד ו-int depth גלובלי בקובץ אחר הם שני עצמים שחיים זה לצד זה, בלי התנגשות.
  • אותו שם static בשני קבצים, למשל static int hits או static int clamp(int), תקין: לכל קובץ עותק פרטי משלו. בלי static אותה כפילות הייתה נכשלת ב-multiple definition, כמו בדוגמת mode למעלה.
תרחיש 16: אותה פונקציה פנימית בשני קבצים
C
// low.c
static int clamp(int v) { return v < 0 ? 0 : v; }
int low(int v) { return clamp(v); }

// high.c
static int clamp(int v) { return v > 9 ? 9 : v; }
int high(int v) { return clamp(v); }

// main.c
#include <stdio.h>
int low(int v);
int high(int v);
int main(void) {
    printf("low: %d %d\n", low(-5), low(20));
    printf("high: %d %d\n", high(20), high(-5));
    return 0;
}
Bash
$ gcc low.c high.c main.c -o p && ./p
low: 0 20
high: 9 -5
$ gcc -c low.c ; gcc -c high.c
$ nm -A low.o high.o | grep clamp
low.o:0000000000000000 t clamp
high.o:0000000000000000 t clamp

אין multiple definition, כי שתי ה-clamp מסומנות באות קטנה: הן מקומיות, והלינקר מתייחס אליהן כאל שני עצמים זרים. כל פונקציה ציבורית קוראת ל-clamp שבקובץ שלה, ולכן low(20) נשאר 20 ואילו high(20) נחתך ל-9, ו-high(-5) לא נוגע ב--5.

תרחיש 17: שלושה מובנים לאותו שם
C
// counter.c
static int tick = 100;
int *a_tick(void) { return &tick; }
int bump_a(void) { return ++tick; }

// shared.c
int tick = 7;

// main.c
#include <stdio.h>
extern int tick;
int *a_tick(void);
int bump_a(void);
int main(void) {
    int r = bump_a();
    printf("%d %d same=%d\n", r, tick, a_tick() == &tick);
    return 0;
}
Bash
$ gcc counter.c shared.c main.c -o ticks && ./ticks
101 7 same=0

בבנייה הזו יש שני משתנים שנקראים tick. הראשון פרטי ל-counter.c, והשני גלובלי ושייך ל-shared.c, ו-extern int tick; של main.c מתחבר רק אל השני. הבדיקה same=0 מוכיחה שהכתובות שונות: bump_a העלתה את הפרטי ל-101, והגלובלי נשאר 7.

תרחיש 18: קריאה ישירה לפונקציה פנימית
C
// bad.c
int clamp(int v);
int main(void) { return clamp(50); }
Bash
$ gcc -c bad.c
$ gcc -c high.c
$ gcc bad.o high.o -o q 2>&1 | grep -o "undefined reference.*"
undefined reference to `clamp'

bad.c מתקמפל כי המהדר שלו רואה הצהרה תקינה ואין לו דרך לדעת איך clamp מוגדרת בקובץ אחר. בקישור נשאר חסר סמל גלובלי בשם clamp: זה שב-high.o מסומן באות קטנה (t), כלומר פרטי לקובץ שלו ולא מוצע החוצה. לכן התוצאה undefined reference, ולא multiple definition: הלינקר לא ראה אף הגדרה שמתחרה בה.

הדרך הנכונה לחשוף ערך פנימי היא פונקציה גלובלית שמחזירה אותו, כמו high למעלה.

טעויות נפוצות
  • שתי פונקציות static באותו שם בשני קבצים גורמות ל-multiple definition. שני הסמלים מקומיים, ולכן הלינקר אינו רואה בהם מתחרים.
  • כששני קבצים מגדירים static int slot, העותק של הקובץ שנקשר אחרון דורס את הראשון. אין דריסה: שני העותקים קיימים לצד זה, וכל אחד נגיש רק לקוד של הקובץ שלו.
  • extern בקובץ אחד מוצא משתנה static שמוגדר בקובץ אחר. הסמל הפרטי אינו מוצע לקבצים אחרים, ולכן ה-extern נשאר בלי הגדרה והקישור נכשל.
  • static בקובץ אחד ו-extern על אותו שם בקובץ אחר הם שגיאת הידור. בהידור כל קובץ נבדק לבדו ולא רואה את חברו, ולכן רק הלינקר יכול לשים לב לבעיה.
בדקו את עצמכם
ב-a.c יש static int slot = 6; ו-int get_a(void) { return slot; }. ב-b.c יש int slot = 2; ו-int get_b(void) { return slot; }. ב-main.c יש extern int slot; והצהרות על שתי הפונקציות, ו-printf("%d %d %d\n", get_a(), get_b(), slot);. מה יודפס אחרי gcc a.c b.c main.c?

6 2 2. ה-slot הסטטי פרטי ל-a.c, ואילו get_b וה-extern של main.c מתחברים למשתנה הגלובלי שב-b.c. הקישור מצליח, בלי התנגשות.

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

סמל weak מול סמל strong

הלינקר מוכן לקבל כמה הגדרות לאותו שם רק אם לכל היותר אחת מהן "חזקה". הגדרה רגילה היא strong, וב-gcc אפשר להפוך הגדרה ל-weak (חלשה) עם __attribute__((weak)), למשל __attribute__((weak)) int retries = 3;.

מה הלינקר פוגשהתוצאה
הגדרה strong אחת ועוד הגדרות weakנבחרת ה-strong, בלי שגיאה ובלי אזהרה
הגדרות weak בלבדנבחרת אחת מהן, בפועל זו שבקובץ הראשון בשורת הפקודה
שתי הגדרות strong או יותרmultiple definition, כרגיל

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

תרחיש 19: וו עם ברירת מחדל חלשה
C
// base.c
#include <stdio.h>
__attribute__((weak)) void on_start(void) { puts("default start"); }
void boot(void) { on_start(); }

// plain.c
void boot(void);
int main(void) { boot(); return 0; }

// custom.c
#include <stdio.h>
void boot(void);
void on_start(void) { puts("custom start"); }
int main(void) { boot(); return 0; }
Bash
$ gcc base.c plain.c -o p1 && ./p1
default start
$ gcc base.c custom.c -o p2 && ./p2
custom start
$ gcc custom.c base.c -o p3 && ./p3
custom start
$ sed 's/__attribute__((weak)) //' base.c > base_strong.c
$ gcc base_strong.c custom.c -o p4 2>&1 | grep -o "multiple definition of [^;]*"
multiple definition of `on_start'

boot קוראת ל-on_start בלי לדעת מי מימש אותה. ב-p1 ההגדרה היחידה היא החלשה, ולכן רצה ברירת המחדל.

ב-p2 וב-p3 הלינקר רואה גם הגדרה חלשה ב-base.o וגם הגדרה רגילה ב-custom.o, ובוחר ברגילה בשני הסדרים. אחרי שהסרנו את weak ב-p4, שתי ההגדרות נהיות strong והקישור נכשל.

תרחיש 20: רק הגדרות חלשות

בשני הקבצים הבאים level מוגדר כ-weak, ו-main.c רק מצהיר עליו ומדפיס. לכל קובץ יש גם פונקציה משלו, ובהמשך נראה למה זה חשוב:

C
// fast.c
__attribute__((weak)) int level = 11;
int fast_id(void) { return 1; }

// slow.c
__attribute__((weak)) int level = 22;
int slow_id(void) { return 2; }

// main.c
#include <stdio.h>
extern int level;
int main(void) { printf("level=%d\n", level); return 0; }
Bash
$ gcc fast.c slow.c main.c -o t1 && ./t1
level=11
$ gcc slow.c fast.c main.c -o t2 && ./t2
level=22

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

פרט של MinGW, שנבדק כאן ולא נבדק ב-Linux: gcc מוסיף לקובץ האובייקט סמל עזר בצורה .weak.<שם>.<סמל אחר שבקובץ>. אם הקובץ מכיל רק את ההגדרה החלשה, שני קבצים כאלה מייצרים אותו סמל עזר, והלינקר מדווח עליו ולא על level.
Bash
$ gcc -c fast.c ; nm -g fast.o
0000000000000000 D .weak.level.fast_id
0000000000000000 T fast_id
                 w level
# bare1.c and bare2.c hold only the weak line for level
$ gcc bare1.c bare2.c main.c -o t3 2>&1 | grep -o "multiple definition of [^;]*"
multiple definition of `.weak.level.'
טעויות נפוצות
  • בין הגדרה strong להגדרה weak הלינקר בוחר לפי הקובץ הראשון בשורת הפקודה. strong מנצחת weak בכל סדר. הסדר קובע רק כשכל ההגדרות weak.
  • weak ו-strong על אותו שם הם multiple definition. weak קיים כדי לאפשר דריסה: ההגדרה הרגילה מחליפה את החלשה בלי שגיאה.
  • משתנה שמוגדר בשני קבצים הוא שגיאת הידור. ההידור רואה כל קובץ בנפרד, ולכן כפילות בין קבצים אפשר לגלות רק בקישור.
בדקו את עצמכם
הספרייה lib.c מגדירה __attribute__((weak)) int quota = 40;. הקובץ app1.c מגדיר int quota = 15; ואת main, והקובץ app2.c מגדיר int quota = 25;. מה תהיה התוצאה של gcc lib.c app1.c app2.c?

שגיאת multiple definition of 'quota': ההגדרה החלשה של הספרייה לא מפריעה, אבל שתי ההגדרות הרגילות ב-app1.c וב-app2.c מתנגשות זו בזו.

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

קובץ אובייקט והכלי nm

מה נמצא בתוך קובץ אובייקט

הפקודה gcc -c probe.c מייצרת את probe.o, וקובץ כזה נראה כמו תוכנית אבל אי אפשר להריץ אותו: זו יחידת תרגום אחת שכבר עברה הידור והרכבה ועדיין לא קושרה לשום דבר. ב-Linux הפורמט שלו הוא ELF מסוג relocatable, ובסביבת MSVC הסיומת היא .obj.

קוד של ספריות אינו נארז בתוכו. קריאה ל-printf, למשל, נשארת שם כשם שממתין לפתרון, והלינקר הוא שימצא לו גוף.

המהדר מחלק את התוכן לחלקים (sections) לפי סוג הנתונים ולפי מה שכדאי לשמור בדיסק:

חלקמה נשמר בומה קורה בגודל הקובץ
.textהוראות המכונה של כל הפונקציותתופס מקום רגיל
.dataגלובליים וסטטיים שקיבלו ערך התחלתי שונה מאפסהערכים עצמם שמורים בקובץ
.bssגלובליים וסטטיים שלא אותחלו, או שאותחלו לאפסנרשם רק כמה בתים להקצות, בלי תוכן
.rodataמחרוזות ליטרל ומשתני const גלובלייםשמור בקובץ וממופה לקריאה בלבד
בקבצי COFF של Windows (כמו אלה ש-MinGW מפיק) חלק הקריאה בלבד נקרא .rdata ולא .rodata, והאות ש-nm נותן לנתונים שבו נשארת R. את השורה של .rdata עצמו לא תראו בפלט שבהמשך, כי הסינון שלו מסיר שורות עזר שמתחילות בנקודה.

לקובץ מצורפים, מעבר לחלקים, עוד שני מבנים שנועדו ללינקר. הראשון הוא טבלת הסמלים (symbol table): רשימה של כל שם שהקובץ מגדיר, ושל כל שם שהקוד בו משתמש בו בלי להגדיר אותו. השני הוא רשומות relocation, שמצביעות על כל מקום בקוד או בנתונים שבו חסרה כתובת סופית, כדי שהלינקר ימלא אותה.

עם הדגל -g מצטרף לקובץ גם מידע דיבאג.

כדי לא לבלבל בין שלושה סוגי קבצים, שאלו מה הלינקר עושה עם כל אחד. קובץ .o נכנס לתוכנית כולו, ספרייה סטטית .a היא ארכיון של כמה קובצי .o שממנו נשלף רק מה שנחוץ, ואילו ספרייה משותפת .so כבר עברה קישור בעצמה, ולכן התוכנית רושמת אליה הפניה בלבד והיא נטענת בזמן ההרצה.

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

לקרוא את הפלט של nm

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

האות מקודדת שני דברים בבת אחת: באיזה סוג אחסון הסמל נמצא, והאם סמל כזה נראה לקבצים אחרים.

אותמה היא אומרתדוגמה מהקוד
Uהקוד משתמש בשם אבל ההגדרה שלו נמצאת בקובץ אחר או בספרייהextern int radio_on; בשימוש, או printf
Tגוף של פונקציה בחלק הקודint poll(int n) { ... }
Dמשתנה שיש לו ערך התחלתי שאינו אפסint boot_count = 3;
Bמשתנה בלי ערך התחלתי, או עם ערך התחלתי אפסint wait_ms; או int drops = 0;
Rנתון לקריאה בלבדconst int page_size = 4096;
Cסמל common של משתנה גלובלי לא מאותחל, ב-gcc לפני גרסה 10 או עם -fcommonint wait_ms; בקומפילציה ישנה

כלל הקריאה: אות גדולה מסמנת סמל גלובלי, כלומר כזה שקבצים אחרים רשאים להתחבר אליו. אות קטנה מסמנת סמל מקומי של הקובץ, בדרך כלל בגלל static. לאות U אין צורה קטנה.

תרחיש 21: שורה אחר שורה: פלט nm של מודול סקר

הקובץ probe.c מכיל כמעט כל צירוף אפשרי של אתחול ונראות, והוא מהודר בלי אופטימיזציה:

C
#include <stdio.h>

int boot_count = 3;
int wait_ms;
int drops = 0;
static int cursor = 9;
static int stamp;
const int page_size = 4096;
static const int guard = 16;
extern int radio_on;

static void bump(void) { cursor++; stamp = cursor; }

int poll(int n) {
    bump();
    printf("%d\n", n + boot_count + wait_ms + drops + page_size + guard + radio_on + stamp);
    return n;
}
Bash
gcc -c probe.c && nm probe.o | grep -v ' \.'
פלט
0000000000000000 D boot_count
0000000000000000 t bump
0000000000000004 d cursor
0000000000000004 B drops
0000000000000004 r guard
0000000000000000 R page_size
0000000000000022 T poll
                 U printf
                 U radio_on
0000000000000008 b stamp
0000000000000000 B wait_ms

ב-MinGW nm מציג גם שורות עזר על שמות החלקים עצמם (שמות שמתחילים בנקודה), ולכן סיננו אותן עם grep. עכשיו נשאל על כל סמל שאלה אחת: מי יכול להתחבר אליו?

  • גלויים לקבצים אחרים: poll (T), boot_count (D), page_size (R, בגלל const), ושני המשתנים wait_ms ו-drops שמופיעים כ-B, כי אתחול לאפס נשמר ב-.bss בדיוק כמו היעדר אתחול.
  • נעולים בתוך הקובץ: bump (t), cursor (d), stamp (b) ו-guard (r). האות הקטנה נובעת מ-static.
  • מבוקשים מבחוץ: radio_on ו-printf (U). לסמל כזה אין אות קטנה, כי הוא תמיד הפניה החוצה.

שני תנאי הידור משנים את התמונה. עם -fcommon, שהיה ברירת המחדל לפני gcc 10, המשתנה הלא מאותחל מופיע כ-C במקום B:

Bash
gcc -c -fcommon probe.c -o old.o && nm old.o | grep wait_ms
פלט
0000000000000004 C wait_ms

ועם אופטימיזציה המהדר רשאי להשמיט סמלים מקומיים שאינם נחוצים. אחרי -O2 נעלמו bump, guard ו-stamp, ו-cursor נשאר:

Bash
gcc -O2 -c probe.c -o fast.o && nm fast.o | grep -v ' \.'
פלט
0000000000000004 D boot_count
0000000000000000 d cursor
0000000000000000 B drops
0000000000000004 R page_size
0000000000000000 T poll
                 U printf
                 U radio_on
0000000000000004 B wait_ms
טעויות נפוצות
  • משתנה גלובלי בלי ערך התחלתי מופיע כ-D D שמורה לנתונים שאותחלו לערך שונה מאפס. משתנה כזה נמצא ב-.bss ולכן הוא B (או C ב-gcc ישן).
  • משתנה const גלובלי מקבל D הוא נשמר באזור הקריאה בלבד ולכן מקבל R.
  • הצהרת extern שנמצאת בשימוש מופיעה כ-B או D הצהרה כזו אינה מקצה אחסון בקובץ, ולכן היא U.
  • פונקציה או משתנה עם static מקבלים U או אות גדולה static מגדיר אותם בתוך הקובץ ומסתיר אותם משאר הקבצים, ולכן הם מסומנים באות קטנה: t, d, b או r.
בדקו את עצמכם
בקובץ אחד כתוב int level = 3;, static int mask; (נכתב בפונקציה), extern int led; (נקרא בפונקציה) ופונקציה גלובלית void tick(void). מה האות של כל אחד מהארבעה ב-nm?

D עבור level, b עבור mask, U עבור led ו-T עבור tick.

אותו קובץ מכיל int pending; ללא אתחול, ומהדרים אותו פעם עם gcc 9 ופעם עם gcc 12 בלי דגלים נוספים. מה האות בכל אחת מהגרסאות?

ב-gcc 9 האות C (common), וב-gcc 12 האות B, כי מגרסה 10 ברירת המחדל היא -fno-common.

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

inline והלינקר

inline בלי static: למה הקישור נכשל

כותרת שמכילה inline int floor_zero(int v) { ... } מתקמפלת בשקט עם gcc -std=c11 -O0, ובכל זאת הקישור נופל עם undefined reference, אף שהגוף כתוב ממש בקובץ שנכלל.

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

שני כללים נפגשים כאן. הכלל הראשון: inline היא המלצה ולא פקודה. המהדר יכול לסרב לה, ויכול גם להטמיע פונקציה שלא סימנתם.

בבנייה ללא אופטימיזציה (-O0) הוא לא מטמיע בכלל, חוץ מפונקציות שסומנו __attribute__((always_inline)).

הכלל השני מגיע מהתקנים C99 ו-C11. פונקציה שנכתבה עם inline ללא static וללא extern נחשבת inline definition: היא מעמידה גוף לרשות המהדר להטמעה, אך לא נוצרת ממנה פונקציה רגילה שאפשר לקשר אליה (external definition).

לכן בענף של הקריאה נשארת הפניה לשם שאף קובץ אובייקט אינו מגדיר: ההידור מצליח והקישור נכשל ב-undefined reference. השגיאה אינה multiple definition, כי לא הופקה אף הגדרה חיצונית.

מצב -std=gnu89 הישן הופך את הכללים, ולכן שאלות מציינות במפורש -std=c99 או -std=c11. יש שתי דרכי תיקון:

  • לכתוב static inline, וכך כל קובץ מקבל גרסה פנימית משלו כשהוא צריך אותה.
  • להשאיר inline בכותרת, ובקובץ .c אחד בלבד להוסיף extern inline עם אותה חתימה. השורה הזו הופכת את ההגדרה באותו קובץ להגדרה חיצונית שכל הקריאות נפתרות אליה.
תרחיש 22: אותה פונקציה, ארבע בדיקות

הכותרת bounds.h מגדירה inline בלבד, הקובץ entry.c קורא לה, והקובץ bounds_def.c מוסיף את שורת ה-extern inline:

C
// bounds.h
inline int floor_zero(int v) { return v < 0 ? 0 : v; }

// entry.c
#include <stdio.h>
#include "bounds.h"
int main(void) { printf("%d\n", floor_zero(-7) + 20); return 0; }

// bounds_def.c
#include "bounds.h"
extern inline int floor_zero(int v);

ב--O0 נשארה ב-entry.o קריאה, ו-nm מציג את floor_zero כשם חסר:

Bash
gcc -std=c11 -c entry.c && nm entry.o | grep floor
פלט
                 U floor_zero

ולכן הקישור נכשל (בשורת השגיאה קוצרו ל-... נתיב של ld.exe ושם קובץ זמני):

Bash
gcc -std=c11 -O0 entry.c -o fail.exe
פלט
...:entry.c:(.text+0x13): undefined reference to `floor_zero'
collect2.exe: error: ld returned 1 exit status

שני המקרים הבאים מצליחים: -O2 מטמיע את הקריאה (אסור לסמוך על כך), והוספת bounds_def.c מספקת הגדרה חיצונית אחת, שמופיעה כ-T ב-nm:

Bash
gcc -std=c11 -O2 entry.c -o o2.exe && ./o2.exe
gcc -std=c11 -O0 entry.c bounds_def.c -o ok.exe && ./ok.exe
gcc -std=c11 -c bounds_def.c && nm bounds_def.o | grep floor
פלט
20
20
0000000000000000 T floor_zero
הפלטים כאן הם של gcc 16 של MinGW ב-Windows (ולכן .exe ו-collect2.exe). ב-Linux הודעת השגיאה זהה בעיקרה, בלי הסיומות האלה.
טעויות נפוצות
  • inline מחייב את המהדר להטמיע, ואם לא הוטמע נשאר עותק רגיל כגיבוי זו בקשה בלבד, ו--O0 אינו מטמיע. ב-C99 וב-C11 הגדרת inline לבדה אינה מייצרת עותק רגיל, וזה בדיוק מקור השגיאה.
  • הגדרת inline בכותרת היא שגיאת קומפילציה, או מובילה ל-multiple definition ההידור עובר, והשגיאה היא undefined reference של הלינקר, כי שום הגדרה חיצונית לא נוצרה.
  • הוספת inline משנה את הערך שהתוכנית מחשבת כשהבנייה מצליחה התוצאה זהה. inline משפיע על הדרך שבה הקוד נבנה ולא על מה שהוא מחשב.
בדקו את עצמכם
בקובץ יחיד מופיעים inline int abs_val(int n) { return n < 0 ? -n : n; } ו-main שמדפיסה abs_val(-6). מה תראו ב-gcc -std=c99 -O0, ומה ישתנה עם static inline?

בלי static הלינקר יחזיר undefined reference to 'abs_val'. עם static inline התוכנית תיבנה ותדפיס 6.

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

למה static inline מתאים לכותרות

הצירוף static inline מנטרל את שתי הסכנות: static מעניק לפונקציה קישוריות פנימית, ולכן אין הגדרות כפולות בין קבצים, ו-inline מאפשר למהדר להטמיע. אם הוא לא מטמיע, הקריאה נפתרת לעותק שבתוך אותו קובץ, ולכן אין הפניה לסמל חסר.

אך שימו לב לדיוק: קובץ .c מקבל עותק פרטי רק אם הוא באמת קורא לפונקציה והמהדר לא הטמיע את הקריאה (למשל ב--O0). העותק מסומן t ב-nm, וקובץ שכולל את הכותרת בלי לקרוא לפונקציה אינו מקבל שום סמל.

וכיוון שהמעבד המקדים והמהדר פועלים על כל קובץ בנפרד, מאקרו שנכתב לפני ה-#include משפיע על העותק שבקובץ הזה בלבד.

תרחיש 23: כותרת אחת, שלושה קבצים וערכי GAP שונים

הכותרת pad.h תלויה במאקרו GAP. הקובץ left.c מגדיר אותו 4 וקורא לפונקציה, panel.c מגדיר אותו 30 וקורא לה בעצמו, ו-idle.c כולל את הכותרת בלי לקרוא לה כלל:

C
// pad.h
static inline int widen(int w) { return w + GAP; }

// left.c
#define GAP 4
#include "pad.h"
int left_edge(void) { return widen(10); }

// panel.c
#include <stdio.h>
#define GAP 30
#include "pad.h"
int left_edge(void);
int main(void) {
    printf("%d %d\n", left_edge(), widen(10));
    return 0;
}

// idle.c
#define GAP 1
#include "pad.h"
int idle_only(void) { return 1; }
Bash
gcc -O0 -c idle.c left.c panel.c
nm -A idle.o left.o panel.o | grep -E "widen|idle_only|left_edge"
gcc -O0 left.c panel.c -o panel.exe && ./panel.exe
פלט
idle.o:0000000000000000 T idle_only
left.o:000000000000000f T left_edge
left.o:0000000000000000 t widen
panel.o:                 U left_edge
panel.o:0000000000000000 t widen
14 40

left.o ו-panel.o מחזיקים כל אחד widen מקומי (t), ולכן הקישור לא מתנגש, ו-left_edge מחזירה 14 בזמן ש-main מקבלת 40 מהעותק שלה. ב-idle.o אין widen בכלל, כי איש לא קרא לה.

טעויות נפוצות
  • static inline בכותרת שנכללת בשני קבצים גורמת ל-multiple definition כל עותק פנימי ואינו מיוצא ללינקר.
  • זה עובד רק כשהמהדר הטמיע את כל הקריאות הקריאה שלא הוטמעה נפתרת לעותק הפרטי של אותו קובץ, ולכן אין בעיה גם ב--O0.
  • שני הקבצים חולקים עותק אחד, עם המאקרו של אחד מהם כל קובץ מהדר את העותק שלו עם ההגדרות שלו, וכך קיבלנו 14 ו-40.
  • כל קובץ שכולל כותרת עם static inline מחזיק עותק של הפונקציה עותק נוצר רק לקובץ שמשתמש בפונקציה ולא הוטמע בו; idle.o נשאר בלעדיו.
בדקו את עצמכם
הכותרת calc.h מכילה static inline int bump(int n) { return n + 5; }. הקובץ mod.c כולל אותה ומגדיר int step(void) { return bump(3); }, ו-main.c כולל אותה ומדפיס step() + bump(1). מה יקרה בהרצה?

הקישור יצליח וההרצה תדפיס 14 (8 ועוד 6).

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

ניסוי קטן: האם הקריאה נעלמה

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

C
// ticks.c
static inline int ticks(int s) { return s * 60; }

int total(int m) { return ticks(m) + 5; }

הכלי הראשון הוא אסמבלי. הדגל -S עוצר אחרי ההידור וכותב את הקוד כטקסט, ואנחנו סופרים בו שורות call ומציגים את גוף total של ההידור המאופטם:

Bash
gcc -O0 -S ticks.c -o t0.s && grep -c call t0.s
gcc -O2 -S ticks.c -o t2.s && grep -c call t2.s
sed -n '/^total:/,/ret/p' t2.s
פלט
1
0
total:
	.seh_endprologue
	imull	$60, %ecx, %eax
	addl	$5, %eax
	ret

בבנייה בלי אופטימיזציה נשארה קריאה אחת, ובבנייה עם -O2 אין אף call: הגוף של ticks נבלע בתוך total, והכפל ב-60 והחיבור של 5 מתבצעים במקום.

אפשר לוותר על האסמבלי ולפרק את קובץ האובייקט עם objdump -d. הממצא זהה, וההוראה כבר מוצגת בקידוד המכונה שלה:

Bash
gcc -O0 -c ticks.c -o t0.o && objdump -d t0.o | grep call
gcc -O2 -c ticks.c -o t2.o && objdump -d t2.o | grep -c call
פלט
  1f:	e8 dc ff ff ff       	call   0 <ticks>
0

דרך שלישית היא להשאיר למהדר לדווח. עם -Winline בבנייה מאופטמת מקבלים אזהרה על כל קריאה לפונקציה שסומנה inline והמהדר בכל זאת השאיר. פונקציה קטנה כמו ticks תמיד מוטמעת ולכן אינה מעוררת אזהרה, ולכן בניסוי הבא נבחרה פונקציה עם לולאה והסף של המהדר הוגבל בכוונה:

C
// big.c
#include <stdio.h>
static inline int report(int a, int b) {
    for (int i = 0; i < a; i++) { printf("%d:", i); printf("%d\n", b * i + a); }
    return a * b;
}
int one(int x) { return report(x, 2); }
int two(int x) { return report(x, 3); }
Bash
gcc -O2 -Winline --param max-inline-insns-single=1 -c big.c 2>&1 | grep warning
פלט
big.c:3:19: warning: inlining failed in call to 'report': --param max-inline-insns-single limit reached [-Winline]
big.c:3:19: warning: inlining failed in call to 'report': --param max-inline-insns-single limit reached [-Winline]

שלושה כלים מוכרים אחרים אינם יכולים להכריע, וכל אחד מהם נכשל מסיבה אחרת:

כלימה הוא מציגלמה הוא לא מכריע
gcc -Eטקסט C אחרי המעבד המקדיםהשלב הזה קודם להידור, ולכן אין בפלט הוראות מכונה ואין בו call לחפש
nmשמות של סמלים וסוגםלפונקציה static אף פעם אין U, ופונקציה גלובלית נשארת T גם אחרי שכל הקריאות אליה הוטמעו
lddספריות משותפות שתוכנית מקושרת צריכההוא לא נוגע בקוד של הפונקציות, רק ברשימת הספריות

את הטענה על nm אפשר לראות בניסוי. מוחקים את static inline מאותו קובץ, כך שהפונקציה גלובלית, ומשווים -O0 ל--O2: השם נשאר T בשני המקרים, בזמן שמספר ההוראות call יורד לאפס:

Bash
sed 's/static inline //' ticks.c > plain.c
gcc -O0 -c plain.c -o p0.o && nm p0.o | grep ticks; objdump -d p0.o | grep -c call
gcc -O2 -c plain.c -o p2.o && nm p2.o | grep ticks; objdump -d p2.o | grep -c call
פלט
0000000000000000 T ticks
1
0000000000000000 T ticks
0
הפלטים נלכדו עם gcc 16 של MinGW ב-Windows x64, ולכן הארגומנט הראשון עובר ב-%ecx ויש שורות .seh_. ב-Linux x86-64 הארגומנט עובר ב-%edi ואין שורות .seh_, והמסקנה לגבי call נשארת זהה.
טעויות נפוצות
  • מחפשים call בפלט של gcc -E, או מסיקים הטמעה מכך ש-nm לא מציג U gcc -E מפיק טקסט C בלבד, ופונקציה static אינה U לעולם, כך ש-nm לא יכריע.
  • בודקים תחת -O0 אם הקריאה הוטמעה ב--O0 המהדר אינו מטמיע, חוץ מפונקציה שסומנה always_inline, ולכן שם תמצאו call.
חזרה לתוכן העניינים

ספריות סטטיות ומשותפות

ספרייה סטטית: מה נשלף ומה נשאר בחוץ

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

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

הארכיון נבנה עם ar, למשל ar rcs libtext.a tok.o blank.o fold.o, והדגלים אומרים כך:

דגלמה הוא עושה
rמוסיף קבצים לארכיון או מחליף חברים קיימים
cיוצר את הארכיון אם אינו קיים
sכותב אינדקס סמלים שהלינקר קורא, בדומה לכלי ranlib

ar מפיק תמיד ארכיון, גם אם קראתם לפלט בשם שמסתיים ב-.so. הסיומת היא רק שם ואינה הופכת אותו לספרייה משותפת. כדי לשלוף את כל החברים בכל זאת, מוסיפים לפני הספרייה את -Wl,--whole-archive.

שני דגלים משמשים לקישור ספרייה. -L dir מוסיף תיקייה לחיפוש (התיקייה הנוכחית נבדקת רק עם -L.), ו--lname נפרש כחיפוש של libname.so או libname.a; לכן את name כותבים בלי lib ובלי סיומת.

תרחיש 24: מי נכנס לתוכנית מתוך libtext.a

בארכיון שלושה חברים. tok.o מגדיר count_words וקורא ל-is_blank, blank.o מגדיר is_blank, ו-fold.o מגדיר fold_case ואיש לא צריך אותו. התוכנית reader.c קוראת רק ל-count_words:

C
// tok.c
int is_blank(int c);
int count_words(int len) { return is_blank(len) + len / 2; }

// blank.c
int is_blank(int c) { return c % 2; }

// fold.c
int fold_case(int c) { return c ^ 0x20; }

// reader.c
#include <stdio.h>
int count_words(int len);
int main(void) { printf("%d\n", count_words(9)); return 0; }
Bash
gcc -c tok.c blank.c fold.c reader.c
ar rcs libtext.a tok.o blank.o fold.o
ar t libtext.a
gcc reader.o -L. -ltext -o reader.exe && ./reader.exe
nm reader.exe | grep -E "count_words|is_blank|fold_case"
פלט
tok.o
blank.o
fold.o
5
00000001400017a0 T count_words
00000001400017d0 T is_blank
שלבמה חסר ללינקרמה קורה
1. reader.ocount_wordsנכנס תמיד, כי הוא קובץ אובייקט רגיל
2. סריקת הארכיון, החבר tok.ocount_wordsמגדיר אותו ולכן נשלף, ומוסיף חסר חדש: is_blank
3. המשך הסריקה, החבר blank.ois_blankמגדיר אותו ולכן נשלף
4. החבר fold.oאין חסריםאין לו מה לתרום, ולכן נשאר מחוץ לתוכנית

הפלט 5 הוא 1 + 9 / 2 (חלוקה שלמה). עם --whole-archive אותו ארכיון נכנס כולו, ו-fold_case מופיע בקובץ ההרצה:

Bash
gcc reader.o -L. -Wl,--whole-archive -ltext -Wl,--no-whole-archive -o reader_w.exe
nm reader_w.exe | grep -E "count_words|is_blank|fold_case"
פלט
00000001400017a0 T count_words
00000001400017f0 T fold_case
00000001400017d0 T is_blank

ושגיאה קלאסית בשם: -llibtext מחפש את liblibtext.a, ולכן נכשל, וגם -ltext בלי -L. לא ימצא ספרייה שיושבת בתיקייה הנוכחית:

Bash
gcc reader.o -L. -llibtext -o x.exe 2>&1 | grep -o "cannot find.*"
פלט
cannot find -llibtext: No such file or directory
טעויות נפוצות
  • כל הארכיון נכנס לקובץ ההרצה, או שנשלף רק החבר שהקוד הראשי קורא לו ישירות נשלפים רק חברים נחוצים (בלי --whole-archive), אבל השליפה נמשכת גם לחברים שהחברים שנשלפו צריכים.
  • ספרייה בתיקייה הנוכחית מתגלה אוטומטית, או ש--lfoo מחפש קובץ בשם foo התיקייה הנוכחית נכנסת לחיפוש רק עם -L., והדגל -l מוסיף בעצמו את lib בהתחלה ואת הסיומת בסוף.
בדקו את עצמכם
בארכיון libnet.a יש top.o (מגדיר top וקורא ל-mid), mid.o (מגדיר mid וקורא ל-leaf), leaf.o (מגדיר leaf) ו-extra.o (מגדיר extra וקורא ל-leaf). main קוראת רק ל-top. אילו חברים ייכנסו לתוכנית?

top.o, mid.o ו-leaf.o, בשרשרת של שמות חסרים. extra.o אינו פותר אף שם חסר ולכן נשאר בחוץ.

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

ספרייה משותפת: -fPIC ו--shared

נניח ששתי תוכניות שונות נשענות על libcodec. אילו הקוד שלה היה מועתק פנימה, כל תוכנית הייתה מחזיקה עותק משלה, ותיקון באג היה מחייב לבנות את שתיהן מחדש.

ספרייה משותפת (.so ב-Linux, .dll ב-Windows) פועלת אחרת: התוכנית שומרת רק את שם הקובץ, והטוען הדינמי טוען אותו בעת ההפעלה. עותק אחד של הקוד בזיכרון משרת את כל התהליכים שמשתמשים בו.

כל תהליך עשוי למפות אותה לכתובת אחרת. קוד שמכיל כתובות קבועות היה צריך תיקון בכל טעינה ולא היה אפשר לשתף אותו, ולכן כותבים אותה כקוד position-independent, כלומר קוד שאינו מניח כתובת טעינה קבועה.

Bash
gcc -fPIC -shared codec.c -o libcodec.so

שני הדגלים פועלים בשני שלבים שונים. -fPIC משפיע על ההידור: המהדר אינו כותב כתובת מוחלטת של פונקציה או משתנה בתוך ההוראות, אלא קורא אותה מטבלה שהטוען ממלא בעת הטעינה (GOT עבור נתונים ו-PLT עבור קפיצות לפונקציות), ולכן אותו קוד עובד בכל כתובת שבה הספרייה נטענה. -shared משפיע על הקישור: הפלט הוא ספרייה ולא תוכנית עם נקודת כניסה, ולכן הלינקר אינו מחפש main.

שלוש פקודות נראות קרובות ואינן מפיקות ספרייה משותפת:

פקודהמה מתקבללמה זה לא .so
ar rcs libcodec.so codec.oארכיון של קובצי .oar מייצר תמיד ארכיון, והסיומת היא שם בלבד
ld -r codec.o aux.o -o bundle.oקובץ .o אחד גדולקישור חלקי שמשאיר הפניות פתוחות לקישור הבא
gcc -static codec.c -o outניסיון לבנות קובץ הרצה סטטיב-Linux, בלי main, הוא נכשל עם undefined reference to 'main' (ב-MinGW החסר הוא WinMain)

כשבתיקייה יושבות גם libcodec.so וגם libcodec.a, הדגל -lcodec בוחר את ה-.so בלי שום שגיאת עמימות. כדי לקבל את הסטטית משתמשים ב--static, או מציינים את הקובץ המדויק עם -l:libcodec.a.

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

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

טעויות נפוצות
  • ar עם שם שמסתיים ב-.so, או ld -r, בונים ספרייה משותפת ar מפיק ארכיון תמיד, ו-ld -r מאחד קובצי .o לקובץ אובייקט אחד.
  • קיום .a ו-.so זה לצד זה גורם להתנגשות או לקישור כפול הלינקר בוחר רק אחת מהן, ומעדיף את ה-.so.
  • תוכנית שקושרה סטטית צריכה את קובץ הספרייה גם בזמן ההרצה הקוד כבר הועתק לקובץ ההרצה, ולכן אין תלות חיצונית.
חזרה לתוכן העניינים

הטוען הדינמי והחיפוש של קובץ ה-.so בזמן ההרצה

תוכנית שקושרה לספרייה משותפת שומרת רק את שם הקובץ, ולא את הנתיב שבו הלינקר מצא אותו. הדגל -L. שירת את הלינקר בזמן הבנייה ונשכח אחר כך, והתיקייה הנוכחית אינה חלק מהחיפוש בזמן ההרצה.

עוד לפני שהשורה הראשונה של main מתבצעת, הטוען הדינמי של המערכת, ld-linux-x86-64.so.2, סורק את המקומות האלה בזה אחר זה:

  1. DT_RPATH שהוטמע בקובץ בעת הקישור, אבל רק כשאין בו DT_RUNPATH.
  2. התיקיות שבמשתנה הסביבה LD_LIBRARY_PATH.
  3. DT_RUNPATH שהוטמע בקובץ בעת הקישור.
  4. המטמון /etc/ld.so.cache ש-ldconfig בונה.
  5. תיקיות ברירת המחדל של המערכת, כמו /lib ו-/usr/lib.

הדגל -Wl,-rpath,DIR יוצר DT_RPATH בשרשרת כלים ישנה ו-DT_RUNPATH בשרשרת שמפעילה כברירת מחדל את התגיות החדשות, כמו ב-Debian ו-Ubuntu. בקירוב לרמת הבחינה אפשר לזכור: קודם נתיב שהוטמע, אחר כך המשתנה, ובסוף המטמון והמערכת, אך בצורה החדשה (DT_RUNPATH) המשתנה גובר על הנתיב.

לפני ההרצה מריצים ldd ומחפשים not found, והוא מציג לכל ספרייה משותפת את המקום שבו נמצאה. קריאות לפונקציות בספרייה עוברות דרך PLT ו-GOT, וכברירת מחדל (lazy binding) הכתובת נפתרת רק בקריאה הראשונה, אלא אם קישרתם עם -z now או הרצתם עם LD_BIND_NOW.

תרחיש 26: בנייה שמצליחה, הפעלה שנעצרת לפני main

הקובץ gauge.c מגדיר פונקציה שמחזירה 31, ו-panel.c מצהיר עליה ומחזיר את הערך שלה מ-main:

C
// gauge.c
int gauge_read(void) { return 31; }

// panel.c
int gauge_read(void);
int main(void) { return gauge_read(); }
Bash
# On Linux (not run here)
gcc -fPIC -shared gauge.c -o libgauge.so
gcc panel.c -L. -lgauge -o panel
./panel
LD_LIBRARY_PATH=. ./panel ; echo $?
gcc panel.c -L. -lgauge -Wl,-rpath,. -o panel_rp && ./panel_rp ; echo $?
  • הבנייה (שורה שנייה): הלינקר מוצא את libgauge.so דרך -L., בודק ש-gauge_read מוגדרת בו, ורושם בתוכנית שצריך את libgauge.so.
  • ./panel: הטוען לא מחפש בתיקייה הנוכחית, ולכן מודפס error while loading shared libraries: libgauge.so: cannot open shared object file: No such file or directory, והתוכנית נעצרת לפני main.
  • עם LD_LIBRARY_PATH=.: התיקייה הנוכחית נכנסת לחיפוש והתוכנית מחזירה 31.
  • עם -Wl,-rpath,.: הנתיב נשמר בתוך התוכנית, ואין צורך במשתנה סביבה.

השגיאה undefined symbol הייתה מופיעה רק אם הטוען מצא את הקובץ אבל חסר בו שם, ו-segmentation fault אינו קשור לתרחיש. ההתנהגות כאן נגזרת מהכללים לעיל ולא נלכדה בהרצה.

טעויות נפוצות
  • -L. בזמן הבנייה מספיק גם להרצה, או ש-main מתחילה ונופלת רק בקריאה לפונקציה -L. משרת רק את הלינקר. הטוען נכשל עוד לפני main בהודעה על cannot open shared object file ולא undefined symbol.
בדקו את עצמכם
התוכנית agent קושרה ב-Linux עם -L./modules -lvault אל modules/libvault.so, בלי rpath, ו-LD_LIBRARY_PATH לא מוגדר. מה יקרה בהרצת ./agent, איזה כלי יחשוף את זה מראש, ואיך אפשר לתקן בלי לקשר מחדש?

הטוען ייעצר לפני main עם error while loading shared libraries עבור libvault.so. הפקודה ldd agent תציג libvault.so => not found, והרצה עם LD_LIBRARY_PATH=./modules ./agent תפתור זאת בלי קישור מחדש.

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

Makefile

מבנה כלל, תו TAB ומי נבנה ראשון

שתי תקלות פוגשות כמעט כל מי שכותב Makefile בפעם הראשונה. האחת היא הזחה ברווחים במקום ב-TAB, והאחרת היא יעד כמו clean בראש הקובץ, שגורם ל-make ללא ארגומנטים למחוק קבצים במקום לבנות.

הכלי make קורא את הקובץ Makefile (או makefile או GNUmakefile; שם אחר מועבר עם make -f name). הקובץ בנוי מכללים:

Text
target: prerequisite1 prerequisite2
	recipe line 1
	recipe line 2
  • יעד (target): לרוב שם של קובץ שהכלל בונה, או שם של פעולה.
  • תנאים מקדימים (prerequisites): קבצים או יעדים שהיעד תלוי בהם.
  • מתכון (recipe): הפקודות, וכל שורה בו חייבת להתחיל בתו TAB. שורה שמתחילה ברווחים מניבה שגיאת missing separator.
  • מתכון ריק: כותבים אותו עם נקודה-פסיק, כך: first second: ;. אין בו פקודות, וכשיעדים כאלה נבנים כתנאים של יעד אחר make לא מדפיס דבר עבורם.

הסדר של make מובן יותר מהרצה אחת מאשר מכללים. בקובץ הבא חמישה יעדים, ואף אחד מהם אינו קובץ אמיתי. השורה הראשונה היא הגדרת משתנה ולא יעד, ורק המתכון של assets כתוב בלי @:

Text
STAGE = demo

release: notes bundle
	@echo release $(STAGE) done
bundle: compiled assets
	@echo bundle ready
assets: compiled
	echo copying assets
notes:
	@echo notes written
compiled:
	@echo compiled

נריץ אותו פעם בלי ארגומנטים ופעם עם שם של יעד. כדאי לנחש את הפלט מתוך הגרף לפני שמסתכלים בו:

Bash
make
echo ---
make assets
פלט
notes written
compiled
echo copying assets
copying assets
bundle ready
release demo done
---
compiled
echo copying assets
copying assets

כך make מגיע לפלט של ההרצה הראשונה, צעד אחר צעד:

  1. לא נמסר יעד, ולכן make בוחר את הכלל הראשון בקובץ שאינו מתחיל בנקודה. STAGE = demo אינה כלל, והבחירה נופלת על release.
  2. release רושם קודם את notes. אין לו תנאים, ואין קובץ בשם הזה, ולכן הוא נחשב כצריך בנייה והמתכון שלו רץ: notes written.
  3. אחריו bundle. לפני שהמתכון שלו יורשה לרוץ, make עובר על התנאים שלו משמאל לימין. הראשון, compiled, בלי תנאים ובלי קובץ, ולכן מודפס compiled.
  4. התנאי השני של bundle הוא assets, שגם הוא תלוי ב-compiled. הוא כבר טופל בהרצה הזו ולא נבנה פעם שנייה. המתכון של assets רץ, וכיוון שאין בו @ מודפסת קודם השורה עצמה, echo copying assets, ואז הפלט שלה, copying assets.
  5. שני התנאים של bundle מוכנים, ולכן המתכון שלו רץ (bundle ready). רק אז כל התנאים של release הושלמו, והוא מדפיס את release demo done.

בהרצה השנייה, make assets, ההתחלה היא בכלל assets. notes, bundle ו-release לא משתתפים בה כלל, כי אף אחד מהם אינו תנאי שלו. מכאן ארבע מסקנות:

  • נקודת ההתחלה: ללא ארגומנטים זה הכלל הראשון שאינו מתחיל בנקודה, ועם make name זה name.
  • מי קודם: מתכון רץ רק אחרי שכל התנאים שלו הושלמו, והם נבנים משמאל לימין, כל אחד אחרי התנאים שלו. מקום הכלל בקובץ לא משפיע, ובדוגמה notes ו-compiled כתובים בסוף ובכל זאת רצים ראשונים. רק הכלל הראשון מיוחד, כיעד ברירת המחדל.
  • יעד שאינו קובץ: כשאין קובץ בשם היעד make רואה בו יעד שצריך בנייה, ולכן המתכון שלו רץ בכל הפעלה.
  • מה מודפס: כברירת מחדל כל שורת מתכון מודפסת לפני הרצתה. @ מסתיר את השורה עצמה ולא את מה שהפקודה כותבת: זה ההבדל בין echo copying assets לבין notes written, שבו מופיע רק הפלט.

כיוון שהכלל הראשון הוא ברירת המחדל, נהוג לפתוח Makefile ביעד all או בתוכנית הראשית, ולא ב-clean.

טעויות נפוצות
  • make מריץ את מתכון היעד לפני שהוא בונה את התנאים שלו, או בונה כל יעד בקובץ התנאים המקדימים נבנים תמיד קודם, ו-make בונה רק את יעד ברירת המחדל (או היעד שביקשתם) ואת התלויות שלו.
  • הכלל שנכתב ראשון קובע את סדר הבנייה, או ש-@ משתיק גם את הפלט של הפקודה הסדר נקבע לפי רשימת התנאים (הכלל הראשון מיוחד רק כברירת מחדל), ו-@ מסתיר רק את הדפסת שורת הפקודה.
בדקו את עצמכם
בקובץ מופיעים לפי הסדר: first: b c (@echo first), a: (@echo a), b: a (@echo b) ו-c: (@echo c). מה ידפיס make?

a, b, c ו-first, בסדר הזה: b תלוי ב-a, ו-first רץ אחרי שני תנאיו.

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

חותמות זמן ותלויות בקובצי כותרת

הכוח של make הוא שהוא אינו מקמפל מה שלא צריך, אך זה גם מקור לבלבול: משנים מבנה בקובץ .h, מריצים make, ומקבלים is up to date, או ש-make מקמפל רק חלק מהקבצים.

make אינו יודע דבר על שפת C. כל מה שבידיו הוא זמני השינוי של הקבצים והרשימות שכתבתם בכללים. עבורו שורת #include היא טקסט סתמי, והוא גם לא בודק אם תוכן הקובץ השתנה, אלא רק מתי נגעו בו לאחרונה.

ההחלטה ליעד אחד פשוטה: קודם מעדכנים כל תנאי שלו, ואז בודקים. אם קובץ היעד חסר, או שלפחות תנאי אחד חדש ממנו, המתכון רץ. אחרת, ליעד שיש לו מתכון, make כותב make: 'target' is up to date. ואינו מריץ דבר.

לכן כותבים את הכותרות כתנאים, כמו router.o: router.c proto.h, או מניחים ל-gcc -MMD -MP לכתוב את רשימות התלויות לקובצי .d ומכלילים אותן עם -include $(DEPS).

תרחיש 27: ארבע הרצות של make על vault

הקבצים store.c, audit.c ו-schema.h כבר קיימים בתיקייה (בלעדיהם make נעצר עם No rule to make target). הכלל של store.o תלוי ב-schema.h, והכלל של audit.o תלוי רק ב-audit.c, גם אם audit.c כולל בפועל את schema.h:

Text
vault: store.o audit.o
	@echo link $@ from $^
	@touch $@
store.o: store.c schema.h
	@echo compile $<
	@touch $@
audit.o: audit.c
	@echo compile $<
	@touch $@
כל מתכון כאן יוצר גם את קובץ היעד שלו עם touch $@, כמו שהמהדר האמיתי היה עושה. בלי השורה הזו היעדים לא היו נוצרים אף פעם, ולכן ההודעה is up to date והבנייה החלקית לא היו מתקיימות: כל הרצה הייתה מריצה את כל המתכונים מחדש.
Bash
echo "# run 1: nothing built yet"; make
echo "# run 2: nothing changed"; make
sleep 1; touch schema.h; echo "# run 3: after touching schema.h"; make
sleep 1; touch audit.c; echo "# run 4: after touching audit.c"; make
פלט
# run 1: nothing built yet
compile store.c
compile audit.c
link vault from store.o audit.o
# run 2: nothing changed
make: 'vault' is up to date.
# run 3: after touching schema.h
compile store.c
link vault from store.o audit.o
# run 4: after touching audit.c
compile audit.c
link vault from store.o audit.o
  • הרצה 1: שום יעד אינו קיים, ולכן נבנים store.o, אחריו audit.o (לפי סדר הרשימה), ובסוף vault.
  • הרצה 2: כל קובץ חדש מהתנאים שלו, ולכן vault מעודכן.
  • הרצה 3: schema.h חדש מ-store.o, ולכן רק הוא נבנה מחדש, וה-vault מקושר מחדש כי store.o החדש חדש ממנו. audit.o לא נבנה, כי schema.h אינו ברשימת התנאים שלו.
  • הרצה 4: רק audit.o נבנה מחדש, ואחריו הקישור.

לו נרשם גם audit.o: audit.c schema.h, הרצה 3 הייתה מקמפלת גם את audit.c, אחרי store.c ולפני הקישור.

ה-sleep 1 מבטיח שזמן השינוי של הקובץ המעודכן יהיה מאוחר מזה של התוצר הקיים. בפרויקט אמיתי ההפרש הזה נוצר מעצמו.

טעויות נפוצות
  • make מזהה לבד שורות #include או משווה תוכן קבצים הוא פועל רק לפי זמני שינוי ולפי מה שנכתב בכללים (או בקובצי .d שנוצרו עם -MMD).
  • עריכת כותרת מפעילה רק קישור מחדש, או שהקישור רץ לפני ההידור כל .o שהכותרת רשומה כתנאי שלו מהודר מחדש קודם, ורק אחרי כן היעד הראשי מקושר.
בדקו את עצמכם
הכללים הם tool: ui.o db.o net.o, ui.o: ui.c cfg.h, db.o: db.c ו-net.o: net.c cfg.h util.h. אחרי בנייה מלאה מעדכנים את cfg.h. מה ייבנה ובאיזה סדר?

ui.o, אחריו net.o, ובסוף tool. הקובץ db.o אינו תלוי ב-cfg.h ולכן נשאר.

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

משתנים אוטומטיים וכללי תבנית

כלל נפרד לכל קובץ .o בפרויקט גדול הוא מסורבל ונוטה לטעויות. make פותר זאת בעזרת כללי תבנית (pattern rules) עם התו %, ובעזרת משתנים אוטומטיים שמוחלפים לפני שהפקודה נשלחת למעטפת.

משתנהמה הוא מייצגערך בכלל pack.zip: a.txt b.txt c.txt
$@שם היעדpack.zip
$<התנאי הראשון ברשימה, ולא יותרa.txt
$^כל התנאים, בלי כפילויות ובלי היעד עצמוa.txt b.txt c.txt
$?רק התנאים שחדשים מהיעדתלוי במה שהשתנה

בכלל תבנית כמו %.o: %.c התו % מתאים לכל שם בסיס. כשמבקשים את util.o, התו מקבל את הערך util: התנאי הראשון הוא util.c והיעד הוא util.o.

תרחיש 28: החלפת משתנים ותבנית בפועל
Text
CC = gcc

bundle: parse lex emit
	@echo $@ / $< / $^
parse lex emit: ;

%.o: %.c
	@echo $(CC) -c $< -o $@
Bash
make
make lexer.o
פלט
bundle / parse / parse lex emit
gcc -c lexer.c -o lexer.o

make בלי ארגומנטים בונה את bundle: $@ הוא bundle, $< הוא parse, ו-$^ הוא parse lex emit. התנאים עצמם הם יעדים עם מתכון ריק, ולכן אינם מדפיסים דבר. בהרצת make lexer.o (כש-lexer.c קיים) כלל התבנית מתאים ו-% הופך ל-lexer.

גם בלי כלל תבנית משלכם make מכיר כלל מובנה שמפיק x.o מ-x.c. הפקודה הבאה, בתיקייה שבה רק widget.c ובלי Makefile, מדפיסה מה היה רץ, והיא מראה ש-CC מקבל כברירת מחדל את cc:

Bash
make -n widget.o
פלט
cc    -c -o widget.o widget.c

הכלל המובנה משתמש ב-$(CC) $(CPPFLAGS) $(CFLAGS) -c. מנגד, $? שימושי כשרוצים לטפל רק במה שהשתנה:

Text
dist.tar: a.txt b.txt
	@echo changed: $?
	@touch $@
Bash
make
sleep 1; touch b.txt; make
פלט
changed: a.txt b.txt
changed: b.txt
טעויות נפוצות
  • $< מכיל את כל התנאים, $@ הוא התנאי הראשון, או $^ כולל את היעד $@ הוא שם היעד, $< הוא התנאי הראשון בלבד, ו-$^ הוא כל התנאים בלי היעד.
  • התו % מגיע למעטפת כמו שהוא make מחליף אותו בשם המתאים עוד לפני שהפקודה רצה.
בדקו את עצמכם
בכלל site.zip: index.html style.css app.js כתוב המתכון @echo zip $@ $^ lead=$<. מה יודפס?

zip site.zip index.html style.css app.js lead=index.html.

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

משתנים: מתי הערך מחושב ומה שורת הפקודה עושה

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

Text
BASE = src
OUT = $(BASE)/out
SNAP := $(BASE)/out
BASE = lib
show:
	@echo $(OUT) $(SNAP)
Bash
make
make BASE=app
make OUT=bin
פלט
lib/out src/out
app/out app/out
bin src/out
  • make: OUT הוגדר ב-=, ולכן נשמר הטקסט $(BASE)/out ונפתר רק בשימוש, כש-BASE כבר lib. SNAP הוגדר ב-:=, ולכן נחשב באותה שורה, כש-BASE היה עדיין src.
  • make BASE=app: ההשמה משורת הפקודה גוברת על שתי ההשמות של BASE בקובץ, ולכן גם SNAP שחושב בשורה השלישית משתמש ב-app.
  • make OUT=bin: ההשמה מחליפה את OUT לגמרי, ו-SNAP אינו מושפע.

ארבע צורות ההשמה, בקצרה:

  • X = val שומר את הטקסט הגולמי ומחשב אותו בכל שימוש, אחרי שכל הקובץ נקרא.
  • X := val מחשב מיד ומקבע את התוצאה בשורת ההגדרה.
  • X ?= val מציב רק אם X עדיין לא מוגדר, למשל מהסביבה.
  • X += val מוסיף לסוף הערך הקיים.

דוגמה שמראה את ?= ו-+= יחד עם סביבה ושורת פקודה:

Text
CFLAGS ?= -O0
CFLAGS += -Wall
show:
	@echo $(CFLAGS)
Bash
make
CFLAGS=-O3 make
make CFLAGS=-O2
פלט
-O0 -Wall
-O3 -Wall
-O2

משתנה סביבה נכנס לתמונה רק אם הקובץ לא מגדיר את אותו שם בהשמה רגילה (=), אלא אם מריצים make -e; כאן ?= מוותר לסביבה ו-+= מוסיף לה. ואילו השמה משורת הפקודה מחליפה את כל ההשמות שבקובץ, כולל ה-+=.

גישה לערך נעשית עם $(VAR) או ${VAR}. לפי המוסכמה CC הוא המהדר, CFLAGS דגלי ההידור, CPPFLAGS דגלי המעבד המקדים (-I, -D), LDFLAGS דגלי הקישור ו-LDLIBS הספריות. וכך אפשר להעביר מהדר אחר משורת הפקודה, למשל make CC=clang, בלי לגעת בקובץ.

טעויות נפוצות
  • = מחשב מיד, או ש-:= ממשיך להתעדכן אחרי שורת ההגדרה = מחושב בזמן השימוש, ו-:= ננעל בשורה שבה הוגדר.
  • make CFLAGS=-O2 מתווסף לדגלים שבקובץ ההשמה משורת הפקודה מחליפה את כל מה שהקובץ הגדיר.
בדקו את עצמכם
נתונות השורות: N = 2, A := $(N)0, N += 5, B = $(N)0, והמתכון @echo $(A) $(B). מה יודפס ב-make, ומה ב-make N=7?

ב-make: 20 2 50 (ל-A נשאר 20, וב-B ה-N כבר 2 5). ב-make N=7: 70 70, כי ההשמה משורת הפקודה מחליפה גם את ה-+=.

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

.PHONY, clean וההודעות של make

clean ו-install הם שמות של פעולות ולא של קבצים: הראשון מוחק תוצרי בנייה (rm -f prog *.o) והשני מעתיק את התוכנית למקום קבוע במערכת. make אינו יודע זאת, ולכן אם בתיקייה יש קובץ או תיקייה בעלי אותו שם והכלל בלי תנאים מקדימים, הוא רואה יעד עדכני ומדלג על המתכון.

ההצהרה .PHONY: clean all install מסמנת את היעדים האלה כשמות של פעולות, וכך המתכון שלהם רץ בכל בקשה.

תרחיש 29: תיקייה בשם docs

נניח שיש יעד docs שמפיק תיעוד, ובתיקיית העבודה כבר קיימת תיקייה בשם docs. הכלל נראה כך, והפעם בלי .PHONY:

Text
docs:
	@echo generating docs
Bash
mkdir docs
make docs
פלט
make: 'docs' is up to date.

עם השורה .PHONY: docs בראש הקובץ המתכון רץ גם כשהתיקייה קיימת, ו-@ ממשיך להסתיר את שורת הפקודה:

Text
.PHONY: docs
docs:
	@echo generating docs
Bash
make docs
פלט
generating docs
תרחיש 30: שלוש הודעות, כל אחת עם הקשר משלה

קודם קובץ שבו all תלוי ב-out.txt, שנבנה מ-in.txt (ל-all אין מתכון משלו; הקובץ in.txt כבר קיים, אחרת make נעצר עם No rule to make target), ואנחנו מריצים אותו שלוש פעמים:

Text
all: out.txt
out.txt: in.txt
	cp in.txt out.txt
Bash
make
make
make out.txt
פלט
cp in.txt out.txt
make: Nothing to be done for 'all'.
make: 'out.txt' is up to date.

ההרצה השנייה מדפיסה Nothing to be done כי ליעד all אין מתכון שאפשר להריץ ואף תנאי שלו לא דרש בנייה. ההרצה השלישית מדפיסה is up to date כי ל-out.txt יש מתכון והוא כבר עדכני.

עכשיו קובץ שבו התנאי missing.o לא קיים בדיסק, ואין כלל שבונה אותו:

Text
app: missing.o
	@echo link
Bash
make
פלט
make: *** No rule to make target 'missing.o', needed by 'app'.  Stop.

ולבסוף מתכון שהוזח בשמונה רווחים במקום ב-TAB. גרסאות חדשות של GNU make מוסיפות רמז (did you mean TAB instead of 8 spaces?), וגרסאות ישנות מדפיסות רק *** missing separator. Stop.:

Bash
make
פלט
makefile:2: *** missing separator (did you mean TAB instead of 8 spaces?).  Stop.
  • מעטפת לכל שורה: make מפעיל מעטפת חדשה לכל שורה במתכון, ולכן אחרי cd בשורה אחת השורה הבאה עדיין פועלת בתיקייה הקודמת. כדי שהשינוי יחול, כותבים את שתי הפקודות באותה שורה.
  • התעלמות משגיאה: מקף - בתחילת שורת מתכון מורה ל-make להמשיך גם אם הפקודה נכשלה.
  • דגלי הרצה: make -n מדפיס את הפקודות בלי להריץ אותן, ו-make -j N מריץ עד N משימות במקביל.
טעויות נפוצות
  • קובץ בשם clean בתיקייה אינו מפריע ל-make clean, או ש-.PHONY מחזיר את הדפסת הפקודה למרות @ בלי .PHONY הקובץ הקיים עוצר את המתכון, וב-@ הפקודה נשארת מוסתרת גם ביעד phony.
  • יעד עדכני תמיד מדפיס Nothing to be done, או ש-No rule מופיע כשהיעד כבר קיים יעד עם מתכון מדפיס is up to date, ו-No rule מופיע רק כשתנאי מקדים חסר ואין כלל שייצר אותו.
בדקו את עצמכם
בתיקייה יש קובץ בשם test. ה-Makefile כולל .PHONY: test וכלל test: עם @echo running. מה ידפיס make test, ומה היה מודפס בלי .PHONY?

יודפס running. בלי .PHONY היה מודפס make: 'test' is up to date..

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

סיכום

בכל שאלה על בנייה וקישור שאלו שתי שאלות: איזה שלב רץ עכשיו, ומה הוא רואה. רוב הטעויות נובעות מהנחה שמידע זמין לשלב שלא נחשף אליו.

  • שלבי gcc ונקודות העצירה: ארבעה שלבים ברצף (עיבוד מקדים, הידור, הרכבה, קישור), והדגל קובע היכן עוצרים. -E מוציא טקסט C מעובד, -S קובץ אסמבלי .s, -c קובץ אובייקט .o, ופקודה בלי הדגלים האלה מגיעה עד הקישור ומפיקה a.out.
  • כל קובץ לבדו: כל .c מתקמפל בנפרד, ולמהדר מספיקה הצהרה על פונקציה או משתנה. רק הלינקר רואה את כל הקבצים יחד, ולכן gcc -c אינו צריך main או הגדרות, וכל שם חסר נרשם כ-U.
  • מי מדווח על מה: No such file ו-#error מגיעות מהמעבד המקדים, redefinition ו-incomplete type מהמהדר, ו-undefined reference עם multiple definition מהלינקר.
  • מה המעבד המקדים לא עושה: הוא רק מחליף טקסט. הוא לא מחשב ביטויים, לא מוסיף סוגריים ולא נוגע בתוכן מחרוזות. ארגומנט של מאקרו מורחב לפני שהוא נכנס לגוף המאקרו, והשורות שמתחילות ב-# נעלמות מהפלט של gcc -E.
  • חיפוש כותרות: "x.h" נבדק קודם בתיקיית הקובץ הכולל ואז ב--I, ואילו <x.h> נבדק רק ב--I ובתיקיות המערכת.
  • מאקרו משורת הפקודה: -DNAME=v מגדיר את המאקרו לפני שהקובץ מתחיל, ו--DNAME לבד שקול ל-1. הערך הוא טקסט, וכותרת שמגדירה ברירת מחדל עם #ifndef מאפשרת לדרוס אותה מבחוץ. #undef מבטל מהשורה שלו והלאה.
  • תנאי הידור: #ifdef בודק אם מאקרו קיים, ו-#if בודק את ערכו. מאקרו ריק נחשב מוגדר, ושם שאינו מאקרו, גם קבוע של enum, שווה 0 בתוך #if. בשרשרת #elif נשמר רק הענף הראשון שמתקיים.
  • הוראות מיוחדות ומאקרו מובנים: #error מפסיק את ההידור רק כשהוא נמצא בענף שנשאר פעיל, #pragma message מדפיס הודעה בזמן ההידור, ו-#pragma שהמהדר אינו מכיר מדולג בשקט (ללא -Wall). גרסת התקן נקראת מ-__STDC_VERSION__: 199901L עבור C99, 201112L עבור C11, 201710L עבור C17, ובתקן C90 המאקרו כלל אינו קיים. __STDC__ שווה 1.
  • שומרי הכללה: #ifndef עם שם ייחודי לכל כותרת, או #pragma once, מונעים הגדרה כפולה בתוך יחידת תרגום אחת. הם אינם מונעים multiple definition בין קבצים, ולכן בכותרת מניחים הצהרות ו-extern ואת ההגדרה כותבים בקובץ .c אחד.
  • extern, static וחוזק סמלים: הצהרת extern רק מכריזה על שם: אין בה הקצאת זיכרון ואין איפוס, וכשאף קובץ אינו מגדיר את השם מתקבל undefined reference. static על משתנה או פונקציה ברמת הקובץ הופך את הקישוריות לפנימית: שם זהה בשני קבצים כבר לא מתנגש, וגם extern שנכתב בקובץ אחר לא יגיע אליו. כששתי הגדרות חולקות שם, strong גוברת על weak בכל סדר, ושתי strong יוצרות multiple definition.
  • nm ו-inline: T קוד, D נתונים עם ערך שונה מאפס, B נתונים לא מאותחלים או מאופסים, R קבועים, U שם חסר, אות קטנה פירושה static, ו-C שייך ל-gcc שלפני גרסה 10. ב-C99 וב-C11 inline לבדו אינו מייצר סמל, ולכן ב--O0 הקישור נכשל. התיקון הוא static inline בכותרת (עותק פרטי לכל קובץ שמשתמש בה, עם המאקרו של אותו קובץ) או extern inline בקובץ .c אחד, ואת ההטמעה בודקים לפי היעדר call ב-gcc -O2 -S.
  • ספריות: ar rcs בונה ארכיון עם אינדקס סמלים, והלינקר שולף ממנו רק חברים שמגדירים שם שחסר לו באותו רגע, יחד עם מה שהחברים האלה עצמם צריכים. את -lname כותבים בלי lib ובלי סיומת: הלינקר מחפש libname.so או libname.a בתיקיות של -L ובתיקיות המערכת, ובוחר ב-.so כשיש את שניהם, אלא אם צוין -static. ספרייה באה אחרי מי שתלוי בה (A תלויה ב-B נכתב -lA -lB), וספריית המתמטיקה דורשת -lm. ספרייה משותפת נבנית עם -fPIC -shared, ובהרצה הטוען מחפש לפי נתיב מוטמע, LD_LIBRARY_PATH ותיקיות המערכת, ואף פעם לא בתיקייה הנוכחית כברירת מחדל.
  • make: ברירת המחדל היא הכלל הראשון בקובץ, והוא נבנה אחרי שכל תנאיו הושלמו משמאל לימין. ההחלטה נעשית לפי חותמות זמן, וכותרות נחשבות רק אם נרשמו בכלל במפורש. במתכון $@ הוא היעד, $< התנאי הראשון ו-$^ כל התנאים, התו % ממלא את שם הבסיס בכלל תבנית, ו-@ מסתיר את שורת הפקודה בלבד. = מחושב בכל שימוש, := מחושב מיד, והשמה בשורת הפקודה גוברת על הקובץ.
  • .PHONY והודעות: .PHONY גורם למתכון לרוץ גם כשקיים קובץ באותו שם. ליעד שיש לו מתכון והוא כבר עדכני make כותב is up to date, ואילו ליעד בלי מתכון משלו, כמו all שרק תלוי באחרים, הוא כותב Nothing to be done.