שפת 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:
# 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- בבנייה רגילה קובצי
.iו-.sאינם נשמרים. הם מופיעים רק כשעוצרים מיד אחריהם עם-Eאו-S, או כשמוסיפים-save-temps, שמשאיר את כל תוצרי הביניים (.i,.s,.o) בלי לעצור את הבנייה. -cמייצר קובץ אובייקט ותו לא. קובץ הרצה אינו נוצר.- קובץ הרצה נוצר רק כשהקישור רץ, ושמו
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: שני קבצים נקיים שאינם מתיישבים
// a.c
int mode = 1;
// b.c
int mode = 2;
int main(void) { return mode; }$ 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: מה חסר בקובץ האובייקט
// tax.c
int rate_for(int bracket); /* declared only, no body anywhere */
int owed(int income, int bracket) { return income * rate_for(bracket) / 100; }$ 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:
#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; }$ 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:
#define TICKS 8
#define SPAN (TICKS * 5)
int total = SPAN;$ 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, ושלושה קובצי מקור שכוללים אותו:
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 מוותר על יצירת קובץ. כך אפשר להוכיח איזה עותק נבחר, והנה ארבע ריצות מתיקיית הפרויקט:
$ 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 אין כותרת, ולכן עוברים ל--Iextra | CAP הוא 22 |
-Iextra core/a.c | סוגריים זוויתיים: core מדולגת, ונשאר רק -Iextra | CAP הוא 22, אף שבתיקיית הקובץ יש עותק אחר |
core/a.c בלי -I | סוגריים זוויתיים ואין תיקיית -I | fatal 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 מדפיס את כל המאקרו שמוגדרים כשהעיבוד נגמר:
$ 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. ההקשר שבו השם מוחלף הוא שיקבע מה יחושב.
כך נראית ברירת מחדל שאפשר להחליף מבחוץ:
#ifndef WIDTH
#define WIDTH 5 /* fallback when the build line says nothing */
#endif-DWIDTH=... מקדים את ההוראה הזו: בשעה שהפרה-פרוססור מגיע ל-#ifndef השם כבר קיים, והבלוק כולו מדולג.
תרחיש 6: אותו קובץ, חמש פקודות
הקובץ bar.c:
#include <stdio.h>
#ifndef WIDTH
#define WIDTH 5
#endif
int main(void) {
printf("%d\n", 20 - WIDTH);
return 0;
}$ 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 | הביטוי אחרי ההחלפה | תוצאה |
|---|---|---|---|
| בלי דגל | לא מוגדר, ולכן מוגדר כאן כ-5 | 20 - 5 | 15 |
-DWIDTH | 1, וההגדרה של 5 מדולגת | 20 - 1 | 19 |
-DWIDTH=7 | 7 | 20 - 7 | 13 |
-DWIDTH=8-2 | הטקסט 8-2 | 20 - 8-2 | 10 |
"-DWIDTH=(8-2)" | הטקסט (8-2) | 20 - (8-2) | 14 |
בשורה הרביעית רואים שהערך הוא טקסט: 20 - 8-2 נקרא משמאל לימין כ-(20 - 8) - 2, ולכן מתקבל 10 ולא 14. הסוגריים בשורה האחרונה (שבקונסולה חובה להקיף במרכאות) מחזירים את הכוונה המקורית.
תרחיש 7: מאקרו שמוגדר מחדש אחרי #undef
הקובץ price.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; }$ 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, בסדר הזה:
- כל
defined(NAME)(אוdefined NAME) מוחלף ב-1או ב-0. - מאקרו שנשארו בביטוי מוחלפים בגופם.
- כל מזהה שנשאר ואינו מאקרו, כולל שם של משתנה או של קבוע
enum, נהפך ל-0בשקט. רק-Wundefמוסיף אזהרה. - הביטוי שהתקבל מחושב כביטוי קבוע בשלמים. מה שמצריך הכרות עם טיפוסים, כמו
sizeofאו cast, אינו נתמך ונגמר ב-missing binary operator.
מכאן המסקנה: קבוע enum ומשתנה (גם const int) הם בשביל הפרה-פרוססור סתם שמות לא מוכרים, כלומר 0. הם נוצרים רק בשלב ההידור, שמגיע אחריו.
כך זה נראה בפועל. בקובץ probe.c הבדיקה הראשונה משתמשת במשתנה, ולכן נחשבת 0 > 3 ונמחקת בלי הודעה. רק שתי האחרות נעצרות בשגיאה:
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$ 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:
#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;
}$ 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 | מאקרו | 2 | 2 |
LANES | קבוע enum | 0 | 3 |
WAYS | משתנה const int | 0 | 4 |
שורת ה-printf יושבת מחוץ לכל הוראה, ולכן היא מגיעה למהדר, והוא מכיר את שלושת השמות כמו שצריך. אותו שם קיבל ערך אחד בשלב הראשון וערך אחר בשלב השני, ו--Wundef חושף את שני המקרים שבהם הפרה-פרוססור ניחש 0.
תרחיש 9: ארבע הפקודות של בדיקה אחת
הקובץ sw.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;
}$ 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 התנאים כתובים מהרחב אל הצר, וזו טעות:
#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;
}$ 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:
#include <stdio.h>
int main(void) {
#if 0
this line is not C at all ;;
#endif
puts("built fine");
return 0;
}$ 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 ריקה:
#pragma sparkle on
int main(void) { return 0; }$ 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 מראה את שני הצדדים:
#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; }$ gcc fn.c -o fn && ./fn
not a macro
probeתרחיש 11: שער גרסה עם #error ו-#pragma message
הקובץ needs11.c דורש C11 ומדפיס הודעה בזמן ההידור:
#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; }$ 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__:
#include <stdio.h>
int main(void) {
printf("%ld %d line %d\n", (long)__STDC_VERSION__, __STDC__, __LINE__);
return 0;
}$ 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 עדיין בלי שומר:
struct entry { int day; long cents; };שתי הכותרות הבאות מוגנות כל אחת בשומר משלה. הקובץ report.h:
#ifndef REPORT_H
#define REPORT_H
#include "ledger.h"
struct report { struct entry first; int pages; };
#endifהקובץ audit.h:
#ifndef AUDIT_H
#define AUDIT_H
#include "ledger.h"
struct audit { struct entry last; int flags; };
#endifוהקובץ main.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;
}$ 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 עם שומר:
#ifndef LEDGER_H
#define LEDGER_H
struct entry { int day; long cents; };
#endif$ 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:
#ifndef MECH_H
#define MECH_H
struct gear { int teeth; };
#endifוהקובץ spring.h, שהועתק מהראשון והשם בו נשאר:
#ifndef MECH_H
#define MECH_H
struct spring { int coils; };
#endifוהקובץ main.c, שכולל את שניהם ומשתמש ב-struct spring:
#include "gear.h"
#include "spring.h"
int main(void) {
struct spring s;
s.coils = 4;
return s.coils;
}$ 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:
#ifndef SETTINGS_H
#define SETTINGS_H
int verbosity = 1; /* a definition inside a header */
void note(const char *msg);
#endifהקובץ logger.c:
#include <stdio.h>
#include "settings.h"
void note(const char *msg) { if (verbosity > 0) puts(msg); }והקובץ main.c:
#include "settings.h"
int main(void) { note("started"); return verbosity; }$ 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:
#ifndef SETTINGS_H
#define SETTINGS_H
extern int verbosity;
void note(const char *msg);
#endifוההגדרה עצמה עוברת אל logger.c:
#include <stdio.h>
#include "settings.h"
int verbosity = 1;
void note(const char *msg) { if (verbosity > 0) puts(msg); }$ 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 מדגים את זה:
int a = 7;
int b;
extern int c;
int twice(int v) { return v * 2; }
int thrice(int v);$ 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 בשני קבצים
// t1.c
int total;
// t2.c
int total;
int main(void) { return total; }$ 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: הצהרה בלי בעלים
// gauge.c
#include <stdio.h>
extern int reading;
int main(void) { printf("%d\n", reading); return 0; }
// sensor.c
int reading = 0;$ 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: אותה פונקציה פנימית בשני קבצים
// 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;
}$ 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: שלושה מובנים לאותו שם
// 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;
}$ 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: קריאה ישירה לפונקציה פנימית
// bad.c
int clamp(int v);
int main(void) { return clamp(50); }$ 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: וו עם ברירת מחדל חלשה
// 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; }$ 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 רק מצהיר עליו ומדפיס. לכל קובץ יש גם פונקציה משלו, ובהמשך נראה למה זה חשוב:
// 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; }$ 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 באותו שם הדפיס את הגרסה של הקובץ הראשון.
gcc מוסיף לקובץ האובייקט סמל עזר בצורה .weak.<שם>.<סמל אחר שבקובץ>. אם הקובץ מכיל רק את ההגדרה החלשה, שני קבצים כאלה מייצרים אותו סמל עזר, והלינקר מדווח עליו ולא על level.$ 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 גלובליים | שמור בקובץ וממופה לקריאה בלבד |
.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 או עם -fcommon | int wait_ms; בקומפילציה ישנה |
כלל הקריאה: אות גדולה מסמנת סמל גלובלי, כלומר כזה שקבצים אחרים רשאים להתחבר אליו. אות קטנה מסמנת סמל מקומי של הקובץ, בדרך כלל בגלל static. לאות U אין צורה קטנה.
תרחיש 21: שורה אחר שורה: פלט nm של מודול סקר
הקובץ probe.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;
}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:
gcc -c -fcommon probe.c -o old.o && nm old.o | grep wait_ms0000000000000004 C wait_msועם אופטימיזציה המהדר רשאי להשמיט סמלים מקומיים שאינם נחוצים. אחרי -O2 נעלמו bump, guard ו-stamp, ו-cursor נשאר:
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טעויות נפוצות
- משתנה גלובלי בלי ערך התחלתי מופיע כ-
DDשמורה לנתונים שאותחלו לערך שונה מאפס. משתנה כזה נמצא ב-.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:
// 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 כשם חסר:
gcc -std=c11 -c entry.c && nm entry.o | grep floor U floor_zeroולכן הקישור נכשל (בשורת השגיאה קוצרו ל-... נתיב של ld.exe ושם קובץ זמני):
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:
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 floor20
20
0000000000000000 T floor_zerogcc 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 כולל את הכותרת בלי לקרוא לה כלל:
// 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; }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.exeidle.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 40left.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 או רק שמות אינו עדות. נבדוק זאת על קובץ קטן:
// ticks.c
static inline int ticks(int s) { return s * 60; }
int total(int m) { return ticks(m) + 5; }הכלי הראשון הוא אסמבלי. הדגל -S עוצר אחרי ההידור וכותב את הקוד כטקסט, ואנחנו סופרים בו שורות call ומציגים את גוף total של ההידור המאופטם:
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.s1
0
total:
.seh_endprologue
imull $60, %ecx, %eax
addl $5, %eax
retבבנייה בלי אופטימיזציה נשארה קריאה אחת, ובבנייה עם -O2 אין אף call: הגוף של ticks נבלע בתוך total, והכפל ב-60 והחיבור של 5 מתבצעים במקום.
אפשר לוותר על האסמבלי ולפרק את קובץ האובייקט עם objdump -d. הממצא זהה, וההוראה כבר מוצגת בקידוד המכונה שלה:
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 תמיד מוטמעת ולכן אינה מעוררת אזהרה, ולכן בניסוי הבא נבחרה פונקציה עם לולאה והסף של המהדר הוגבל בכוונה:
// 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); }gcc -O2 -Winline --param max-inline-insns-single=1 -c big.c 2>&1 | grep warningbig.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 יורד לאפס:
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 call0000000000000000 T ticks
1
0000000000000000 T ticks
0gcc 16 של MinGW ב-Windows x64, ולכן הארגומנט הראשון עובר ב-%ecx ויש שורות .seh_. ב-Linux x86-64 הארגומנט עובר ב-%edi ואין שורות .seh_, והמסקנה לגבי call נשארת זהה.טעויות נפוצות
- מחפשים
callבפלט שלgcc -E, או מסיקים הטמעה מכך ש-nmלא מציגUgcc -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:
// 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; }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.o | count_words | נכנס תמיד, כי הוא קובץ אובייקט רגיל |
2. סריקת הארכיון, החבר tok.o | count_words | מגדיר אותו ולכן נשלף, ומוסיף חסר חדש: is_blank |
3. המשך הסריקה, החבר blank.o | is_blank | מגדיר אותו ולכן נשלף |
4. החבר fold.o | אין חסרים | אין לו מה לתרום, ולכן נשאר מחוץ לתוכנית |
הפלט 5 הוא 1 + 9 / 2 (חלוקה שלמה). עם --whole-archive אותו ארכיון נכנס כולו, ו-fold_case מופיע בקובץ ההרצה:
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. לא ימצא ספרייה שיושבת בתיקייה הנוכחית:
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 אינו פותר אף שם חסר ולכן נשאר בחוץ.
סדר הספריות בשורת הפקודה ומקרה ה-libm
בשורת הפקודה אין חזרה אחורה: הלינקר קורא ארגומנט אחרי ארגומנט משמאל לימין, ובכל ארכיון הוא בודק רק מול מה שחסר לו ברגע הזה. ארכיון שמגיע לפני שנוצר בו צורך נבדק מול רשימה ריקה, אינו נותן דבר, ואין סריקה שנייה שתתקן זאת.
הסדר בין קובצי .o אינו משנה, כי כל אחד מהם נכנס בשלמותו. לספריות הכלל הוא שכל ספרייה כתובה אחרי כל מי שקורא לה.
שרשרת שבה A קוראת ל-B נכתבת -lA -lB. שתי ספריות שקוראות זו לזו אינן מסתדרות באף סדר יחיד, ולכן עוטפים אותן ב--Wl,--start-group וב--Wl,--end-group, והלינקר סורק את הקבוצה שוב ושוב עד שאין התקדמות.
אותו דין חל על gcc -L. -ltext reader.c: הקובץ reader.c מתקמפל לקובץ אובייקט זמני שנכנס לרשימה אחרי הספרייה, ולכן הספרייה נסרקת מוקדם מדי.
תרחיש 25: אותן שתי ספריות בארבעה סדרים
נפצל את הארכיון הקודם לשניים: libtok.a עם tok.o (צריך את is_blank), ו-libblank.a עם blank.o (מגדיר אותו):
ar rcs libtok.a tok.o
ar rcs libblank.a blank.oספרייה לפני reader.o נסרקת כשעדיין אין חסרים. בשורות השגיאה כאן קוצרו ל-... הנתיב של ld.exe והתחילית של הקובץ הזמני:
gcc -L. -ltext reader.o -o p1.exe
gcc -L. -ltok -lblank reader.c -o p1c.exe.../ld.exe: reader.o:reader.c:(.text+0x13): undefined reference to `count_words'
collect2.exe: error: ld returned 1 exit status
...:reader.c:(.text+0x13): undefined reference to `count_words'
collect2.exe: error: ld returned 1 exit statusגם סדר הפוך בין שתי הספריות נכשל: כש-libblank.a נסרקת, ל-tok.o עוד לא נשלף, ולכן אין חסר ש-blank.o פותר:
gcc reader.o -L. -lblank -ltok -o p2.exe.../ld.exe: ./libtok.a(tok.o):tok.c:(.text+0x11): undefined reference to `is_blank'
collect2.exe: error: ld returned 1 exit statusהסדר הנכון (המשתמש לפני מי שמספק), או קבוצת סריקה חוזרת, מצליחים ומדפיסים 5:
gcc reader.o -L. -ltok -lblank -o p3.exe && ./p3.exe
gcc reader.o -L. -Wl,--start-group -lblank -ltok -Wl,--end-group -o p4.exe && ./p4.exe5
5אותו עיקרון חל על ספריית המתמטיקה ב-Linux: sin, cos ו-sqrt שייכות ל-libm ולא ל-libc, ו-#include <math.h> רק מצהיר עליהן. לכן מוסיפים -lm, בסוף הפקודה אחרי הקבצים שמשתמשים בה.
יש כאן מלכודת: gcc מכיר את sqrt ודומיה כפונקציות מובנות (builtin). כשהארגומנט קבוע, כמו sqrt(81.0), הוא רשאי לחשב את התוצאה בזמן ההידור ולא להפיק קריאה, ואז אין צורך ב--lm כלל.
כשהארגומנט נקרא רק בזמן ההרצה נשארת קריאה אמיתית, ובלי -lm הקישור ב-Linux נכשל גם בלי דגלים מיוחדים. הדגל -fno-builtin מבטל את החישוב המוקדם, וכך גם הדוגמה עם הקבוע מפיקה קריאה ודורשת את הספרייה.
// calc.c (on Linux): the argument is a constant
#include <stdio.h>
#include <math.h>
int main(void) { printf("%.1f\n", sqrt(81.0)); return 0; }
// gcc calc.c -o calc -> the constant may be folded, so no -lm is needed
// gcc -fno-builtin calc.c -o calc -> undefined reference to `sqrt'
// gcc -fno-builtin calc.c -o calc -lm -> links, prints 9.0
// calc2.c (on Linux): the argument is known only at run time
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
int main(int argc, char **argv) { printf("%.1f\n", sqrt(atof(argv[argc - 1]))); return 0; }
// gcc calc2.c -o calc2 -> undefined reference to `sqrt' (a real call remains)
// gcc calc2.c -o calc2 -lm -> links-fno-builtin מתקשרת גם בלי -lm.טעויות נפוצות
- המיקום של
-lבשורת הפקודה לא משנה, או שספרייה מוקדמת מדי מחזירהcannot findבספריות סטטיות הסדר קריטי. ספרייה מוקדמת נמצאת, אבל לא נשלף ממנה דבר, ולכן השגיאה היאundefined reference. ar rcsלא בונה אינדקס סמלים, או ש-#include <math.h>מספיק כדי להשתמש ב-sinהאותsבונה אינדקס, ו-<math.h>רק מצהיר, כך שב-Linux צריך-lmבסוף הפקודה.
בדקו את עצמכם
הקובץ scene.o קורא ל-a_fn מתוך libA.a, ו-a_fn קוראת ל-b_fn מתוך libB.a, ו-b_fn קוראת ל-c_fn מתוך libC.a. איזה סדר נכון בשורת הפקודה, ומה השגיאה אם כותבים -lC -lA -lB?
הסדר -lA -lB -lC. ב--lC -lA -lB הספרייה libC.a נסרקת כש-c_fn עוד לא חסר, ולכן בסוף נשארת undefined reference to 'c_fn'.
הטוען הדינמי והחיפוש של קובץ ה-.so בזמן ההרצה
תוכנית שקושרה לספרייה משותפת שומרת רק את שם הקובץ, ולא את הנתיב שבו הלינקר מצא אותו. הדגל -L. שירת את הלינקר בזמן הבנייה ונשכח אחר כך, והתיקייה הנוכחית אינה חלק מהחיפוש בזמן ההרצה.
עוד לפני שהשורה הראשונה של main מתבצעת, הטוען הדינמי של המערכת, ld-linux-x86-64.so.2, סורק את המקומות האלה בזה אחר זה:
DT_RPATHשהוטמע בקובץ בעת הקישור, אבל רק כשאין בוDT_RUNPATH.- התיקיות שבמשתנה הסביבה
LD_LIBRARY_PATH. DT_RUNPATHשהוטמע בקובץ בעת הקישור.- המטמון
/etc/ld.so.cacheש-ldconfigבונה. - תיקיות ברירת המחדל של המערכת, כמו
/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:
// gauge.c
int gauge_read(void) { return 31; }
// panel.c
int gauge_read(void);
int main(void) { return gauge_read(); }# 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). הקובץ בנוי מכללים:
target: prerequisite1 prerequisite2
recipe line 1
recipe line 2- יעד (target): לרוב שם של קובץ שהכלל בונה, או שם של פעולה.
- תנאים מקדימים (prerequisites): קבצים או יעדים שהיעד תלוי בהם.
- מתכון (recipe): הפקודות, וכל שורה בו חייבת להתחיל בתו
TAB. שורה שמתחילה ברווחים מניבה שגיאתmissing separator. - מתכון ריק: כותבים אותו עם נקודה-פסיק, כך:
first second: ;. אין בו פקודות, וכשיעדים כאלה נבנים כתנאים של יעד אחרmakeלא מדפיס דבר עבורם.
הסדר של make מובן יותר מהרצה אחת מאשר מכללים. בקובץ הבא חמישה יעדים, ואף אחד מהם אינו קובץ אמיתי. השורה הראשונה היא הגדרת משתנה ולא יעד, ורק המתכון של assets כתוב בלי @:
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נריץ אותו פעם בלי ארגומנטים ופעם עם שם של יעד. כדאי לנחש את הפלט מתוך הגרף לפני שמסתכלים בו:
make
echo ---
make assetsnotes written
compiled
echo copying assets
copying assets
bundle ready
release demo done
---
compiled
echo copying assets
copying assetsכך make מגיע לפלט של ההרצה הראשונה, צעד אחר צעד:
- לא נמסר יעד, ולכן
makeבוחר את הכלל הראשון בקובץ שאינו מתחיל בנקודה.STAGE = demoאינה כלל, והבחירה נופלת עלrelease. releaseרושם קודם אתnotes. אין לו תנאים, ואין קובץ בשם הזה, ולכן הוא נחשב כצריך בנייה והמתכון שלו רץ:notes written.- אחריו
bundle. לפני שהמתכון שלו יורשה לרוץ,makeעובר על התנאים שלו משמאל לימין. הראשון,compiled, בלי תנאים ובלי קובץ, ולכן מודפסcompiled. - התנאי השני של
bundleהואassets, שגם הוא תלוי ב-compiled. הוא כבר טופל בהרצה הזו ולא נבנה פעם שנייה. המתכון שלassetsרץ, וכיוון שאין בו@מודפסת קודם השורה עצמה,echo copying assets, ואז הפלט שלה,copying assets. - שני התנאים של
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:
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 והבנייה החלקית לא היו מתקיימות: כל הרצה הייתה מריצה את כל המתכונים מחדש.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: החלפת משתנים ותבנית בפועל
CC = gcc
bundle: parse lex emit
@echo $@ / $< / $^
parse lex emit: ;
%.o: %.c
@echo $(CC) -c $< -o $@make
make lexer.obundle / parse / parse lex emit
gcc -c lexer.c -o lexer.omake בלי ארגומנטים בונה את bundle: $@ הוא bundle, $< הוא parse, ו-$^ הוא parse lex emit. התנאים עצמם הם יעדים עם מתכון ריק, ולכן אינם מדפיסים דבר. בהרצת make lexer.o (כש-lexer.c קיים) כלל התבנית מתאים ו-% הופך ל-lexer.
גם בלי כלל תבנית משלכם make מכיר כלל מובנה שמפיק x.o מ-x.c. הפקודה הבאה, בתיקייה שבה רק widget.c ובלי Makefile, מדפיסה מה היה רץ, והיא מראה ש-CC מקבל כברירת מחדל את cc:
make -n widget.occ -c -o widget.o widget.cהכלל המובנה משתמש ב-$(CC) $(CPPFLAGS) $(CFLAGS) -c. מנגד, $? שימושי כשרוצים לטפל רק במה שהשתנה:
dist.tar: a.txt b.txt
@echo changed: $?
@touch $@make
sleep 1; touch b.txt; makechanged: 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.
משתנים: מתי הערך מחושב ומה שורת הפקודה עושה
השאלה המכרעת בהשמות היא מתי הצד הימני מחושב, ואיך שורת הפקודה מתערבת. נעקוב אחרי קובץ קטן בשלוש הרצות:
BASE = src
OUT = $(BASE)/out
SNAP := $(BASE)/out
BASE = lib
show:
@echo $(OUT) $(SNAP)make
make BASE=app
make OUT=binlib/out src/out
app/out app/out
bin src/outmake: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מוסיף לסוף הערך הקיים.
דוגמה שמראה את ?= ו-+= יחד עם סביבה ושורת פקודה:
CFLAGS ?= -O0
CFLAGS += -Wall
show:
@echo $(CFLAGS)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:
docs:
@echo generating docsmkdir docs
make docsmake: 'docs' is up to date.עם השורה .PHONY: docs בראש הקובץ המתכון רץ גם כשהתיקייה קיימת, ו-@ ממשיך להסתיר את שורת הפקודה:
.PHONY: docs
docs:
@echo generating docsmake docsgenerating docsתרחיש 30: שלוש הודעות, כל אחת עם הקשר משלה
קודם קובץ שבו all תלוי ב-out.txt, שנבנה מ-in.txt (ל-all אין מתכון משלו; הקובץ in.txt כבר קיים, אחרת make נעצר עם No rule to make target), ואנחנו מריצים אותו שלוש פעמים:
all: out.txt
out.txt: in.txt
cp in.txt out.txtmake
make
make out.txtcp 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 לא קיים בדיסק, ואין כלל שבונה אותו:
app: missing.o
@echo linkmakemake: *** 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.:
makemakefile: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 וב-C11inlineלבדו אינו מייצר סמל, ולכן ב--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.