תצורת C++ C++

סקירה כללית

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

ב-Bazel צריכות לדעת:

  • אם המהדר תומך ב-thinLTO, מודולים, קישור דינמי או PIC (מיקום קוד עצמאי).
  • נתיבים לכלים הנדרשים כמו gcc, ld, ar, objcopy וכו'.
  • המערכת המובנית כוללת ספריות. Bazel זקוקה לאימות כדי לוודא שכל הכותרות שנכללו בקובץ המקור הצהירו כראוי בקובץ BUILD.
  • Sisroot המוגדר כברירת מחדל.
  • אילו סימונים לשימוש עבור הידור, קישור, העברה לארכיון.
  • אילו סימונים להשתמש עבור מצבי האיסוף הנתמכים (opt, dbg, fastbuild).
  • ליצור משתנים הנדרשים במיוחד על ידי המהדר.

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

CcToolchainConfigInfo הוא ספק שמספק את רמת ההרשאה הנדרשת כדי להגדיר את ההתנהגות של כללי C++ של Bazel&39. כברירת מחדל, Bazel מגדירה את CcToolchainConfigInfo באופן אוטומטי לגרסת ה-build שלכם, אבל אתם יכולים להגדיר אותה ידנית. לשם כך, צריך כלל של Starstark שמספק את CcToolchainConfigInfo. בנוסף, צריך לציין את המאפיין toolchain_config של ה-cc_toolchain לכלל שלכם. אפשר ליצור את CcToolchainConfigInfo על ידי התקשרות cc_common.create_cc_toolchain_config_info(). ניתן למצוא את המבנים של Starlark בכל המבנים שתצטרכו בתהליך של @rules_cc//cc:cc_toolchain_config_lib.bzl.

כשיעד C++ נכנס לשלב הניתוח, Bazel בוחרת את היעד המתאים cc_toolchain לפי הקובץ BUILD, ומקבלת את הספק CcToolchainConfigInfo מהיעד שצוין במאפיין cc_toolchain.toolchain_config. היעד cc_toolchain מעביר את המידע הזה ליעד C++ דרך CcToolchainProvider.

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

  • המהדר או המקשר לשימוש
  • התרעות לגבי שורת פקודה עבור המהדר או המקשר
  • סימונים של תצורה עברו דרך האפשרויות של --copt/--linkopt
  • משתני סביבה
  • פריטי מידע נדרשים בארגז החול שבו הפעולה מתבצעת

כל המידע שלמעלה, מלבד פריטי המידע הדרושים בארגז החול, צוין ביעד Starlark שאליו cc_toolchain מפנה.

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

בחירת כלים

הלוגיקה של בחירת הכלים פועלת באופן הבא:

  1. המשתמש מציין יעד cc_toolchain_suite בקובץ BUILD ומצביע על היעד באמצעות האפשרות --crosstool_top.

  2. היעד cc_toolchain_suite מפנה לכלים שונים. הערכים של הסימונים --cpu ו---compiler קובעים אילו מהשרשראות האלה ייבחרו, על סמך ערך הסימון ב---cpu או על סמך ערך משותף ל---cpu | --compiler. תהליך הבחירה מתבצע באופן הבא:

    • אם האפשרות --compiler מוגדרת, Bazel בוחרת את הרשומה המתאימה מהמאפיין cc_toolchain_suite.toolchains עם --cpu | --compiler. אם Bazel לא מוצאת ערך תואם, היא יוצרת שגיאה.

    • אם האפשרות --compiler לא צוינה, Bazel בוחרת את הרשומה המתאימה מתוך המאפיין cc_toolchain_suite.toolchains ב---cpu בלבד.

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

אחרי שבוחרים ארגז כלים, האובייקטים feature ו-action_config בכללים של Starlark שולטים בהגדרה של גרסת ה-build (כלומר, פריטים שמתוארים בהמשך). ההודעות האלו מאפשרות יישום מלא של תכונות C++ ב-Bazel מבלי לשנות את הקובץ הבינארי של Bazel. כללי C++ תומכים במספר פעולות ייחודיות שמתועדות באופן מפורט בקוד המקור של Bazel.

תכונות

תכונה היא ישות שדורשת התרעות לגבי שורת פקודה, פעולות, מגבלות על סביבת הביצוע או שינויים בתלות. תכונות יכולות להיות פשוטות, כמו מתן הרשאה לקובצי BUILD לבחור תצורות של דגלים, כמו treat_warnings_as_errors, או לבצע פעולות בכללי C++ ולכלול פעולות הידור חדשות וקלט במהלך האוסף, כמו header_modules או thin_lto.

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

תכונה מצוינת לפי שם, שמאפשרת איחוד מלא של תצורת הכלל של Starlark מ-Bazel. במילים אחרות, גרסת Bazel לא משפיעה על ההתנהגות של CcToolchainConfigInfo, כל עוד ההגדרות האלה לא מחייבות שימוש בתכונות חדשות.

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

  • השדה enabled של התכונה מוגדר כ-true.
  • Bazel או הבעלים של הכלל מפעילים אותה באופן מפורש.
  • המשתמש מאפשר זאת באמצעות האפשרות --feature Bazel או באמצעות המאפיין של כלל features.

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

קשרים לתכונות

בדרך כלל, יחסי תלות מנוהלים ישירות עם Bazel, שאוכפת את הדרישות ומנהלת סכסוכים מהותיים באופי של התכונות המוגדרות ב-build. המפרט של Toolchain מאפשר הגבלות מפורטות יותר לשימוש ישירות במסגרת הכללים של Starlark שחלים על תמיכה בתכונות והרחבה. הבדלים אלו הם:

מגבלות תיאור 
requires = [
   feature_set (features = [
       'feature-name-1',
       'feature-name-2'
   ]),
]
 ברמת התכונה. התכונה תהיה נתמכת רק אם התכונות שצוינו מופעלות. לדוגמה, כאשר תכונה נתמכת רק במצבי build מסוימים (opt, dbg או fastbuild). אם 'requires' מכיל מספר 'feature_set', התכונה נתמכת אם אחת מ-'feature_set' נכונה. (כאשר כל התכונות שצוינו מופעלות). 
implies = ['feature']

ברמת התכונה. תכונה זו מרמזת על התכונות שצוינו. הפעלה של תכונה מאפשרת גם באופן לא מפורש את כל התכונות שמשתמעות ממנה (כלומר, היא פועלת באופן חוזר).

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

 
provides = ['feature']

ברמת התכונה. מציין שהתכונה הזו היא אחת מכמה תכונות חלופיות בלעדיות. לדוגמה, כל התכשירים לחיטוי יוכלו לציין provides = ["sanitizer"].

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

 
with_features = [
  with_feature_set(
    features = ['feature-1'],
    not_features = ['feature-2'],
  ),
]
 סימון ברמת הקבוצה. תכונה יכולה לציין קבוצות מרובות של דגלים עם מספר קבוצות. אם מגדירים את המאפיין with_features, קבוצת הדגל מתרחבת לפקודת Build רק אם מופעלת לפחות with_feature_set אחת שבה הופעלו כל התכונות בקבוצה features שצוינה וכל התכונות שמצוינות ב-not_features מושבתות. אם המדיניות with_features לא צוינה, המערכת תחיל את קבוצת הסימונים ללא תנאי על כל פעולה שצוינה.

פעולות

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

התכונות מציינות פעולות שיש להן השפעה על Bazel, מאחר שפעולות יכולות לשנות את תרשים הפעולות של Bazel. הספק של CcToolchainConfigInfo מכיל פעולות המשויכות לסימונים וכלים המשויכים אליהם, כגון c++-compile. סימונים מוקצים לכל פעולה על ידי שיוך שלהם לתכונה.

כל שם פעולה מייצג סוג פעולה יחיד המתבצע על ידי Bazel, כגון הידור או קישור. עם זאת, יש קשר של אחד לאחד בין הפעולות וסוגי הפעולות של Bazel, שבהם סוג הפעולה ב-Bazel מתייחס לסוג Java שמבצע פעולה (למשל CppCompileAction). באופן ספציפי, הפונקציה "Assbleer actions" ו-" סוגי מהדרים' מופיעים בטבלה שלמטה, ואילו פעולות הקישור הן CppLinkAction.

פעולות הקשורות לאיסוף

פעולה תיאור
preprocess-assemble הרכבו עם עיבוד מראש. בדרך כלל עבור קובצי .S.
assemble הרכב ללא עיבוד מראש. בדרך כלל עבור קובצי .s.

פעולות המהדר

פעולה תיאור
cc-flags-make-variable הפצת כללי CC_FLAGS בדרך כלל.
c-compile הידור כ-C.
c++-compile הידור כ-C++.
c++-header-parsing מנתח המנתח של המהדר's בקובץ כותרת כדי להבטיח שהכותרת עצמאית, אחרת היא תייצר שגיאות הידור. רלוונטי רק לשרשראות כלים שתומכות במודולים.
פעולה תיאור
c++-link-dynamic-library קישור ספרייה משותפת שמכילה את כל יחסי התלות שלה.
c++-link-nodeps-dynamic-library קישור ספרייה משותפת שכוללת רק cc_library מקורות.
c++-link-executable מקשרים ספרייה סופית מוכנה לשימוש.

פעולות ב-AR

פעולות AR יוצרות קובצי אובייקטים בספריות ארכיון (.a קבצים) דרך ar, ומקודדות חלק מהסמנטיקה לשם.

פעולה תיאור
c++-link-static-library ליצור ספרייה סטטית (ארכיון).

פעולות LTO

פעולה תיאור
lto-backend פעולה רזה של הידור קודי סיביות אל אובייקטים מקומיים.
lto-index ThinLTO פעולה שיוצרת אינדקס גלובלי.

שימוש ב-action_config

ה-action_config הוא מבנה של Starlark שמתאר פעולה של Bazel. לשם כך, מציינים את הכלי (בינארי) להפעלת הפעולה וסדרות של דגלים, לפי תכונות. סימונים אלה מחילים מגבלות על הפעולה.

ה-constructor של action_config() כולל את הפרמטרים הבאים:

מאפיין תיאור
action_name פעולת ה-Bazel שאליה הפעולה הזו תואמת. Bazel משתמשת במאפיין הזה כדי לגלות דרישות לפעולה ולפעולה.
tools קובץ ההפעלה להפעלה. הכלי שהוחל על הפעולה יהיה הכלי הראשון ברשימה הכולל קבוצת תכונות שתואמת להגדרת התכונה. יש לציין ערך ברירת מחדל.
flag_sets רשימת סימונים שחלה על קבוצה של פעולות. זהה לתכונה.
env_sets רשימה של מגבלות סביבה שחלות על קבוצת פעולות. זהה לתפקיד של תכונה.

action_config יכול לדרוש ולרמז על תכונות אחרות ועל action_configs, כפי שנקבע על ידי קשרי התכונה המתוארים למעלה. התנהגות זו דומה לזו של תכונה.

שני המאפיינים האחרונים מיותרים במאפיינים התואמים לתכונות, והם כלולים כי חלק מהפעולות ב-Bazel מחייבות סימונים מסוימים או משתני סביבה, והמטרה היא להימנע מזוגות מיותרים של action_config+feature. בדרך כלל עדיף לשתף תכונה אחת במספר action_config.

לא ניתן להגדיר יותר מ-action_config עם אותו action_name באותו כלי. כך נמנעת עמימות בנתיבי כלים, והיא אוכפת את הכוונה מאחורי action_config – המאפיינים של פעולה מתוארים בבירור במקום אחד בכלי.

שימוש בכלי ליצירת כלים

action_config יכול לציין קבוצת כלים באמצעות הפרמטר tools שלו. ה-constructor של tool() מקבל את הפרמטרים הבאים:

שדה תיאור
tool_path הנתיב לכלי הרלוונטי (ביחס למיקום הנוכחי).
with_features כדי שכלי זה יחול, צריך להגדיר רשימה של תכונות שיש להגדיר לפחות אחת מהן.

ב-action_config נתון, רק tool אחד מחיל את נתיב הכלי ואת דרישות הביצוע שלו על Bazel. כדי לבחור בכלי, חוזרים על המאפיין tools ב-action_config עד שנמצא כלי עם with_feature שתואם לתצורה של התכונה. (למידע נוסף, אפשר לעיין בקשר לתכונות בשלב מוקדם יותר בדף הזה). עליכם לסיים את רשימת הכלים בכלי ברירת מחדל שתואם להגדרה של תכונה ריקה.

שימוש לדוגמה

ניתן להשתמש בתכונות ובפעולות יחד כדי ליישם פעולות Bazel עם סמנטיקה מגוונת בפלטפורמות שונות. לדוגמה, כדי ליצור סמלים של ניפוי באגים ב-macOS, צריך ליצור סמלים בפעולת ההידור, ואז להפעיל כלי מיוחד במהלך פעולת הקישור כדי ליצור ארכיון Dsym דחוס. לאחר מכן, צריך לבטל את הדחיסה של הארכיון כדי ליצור את חבילת האפליקציות ו-.plist קבצים שאפשר להשתמש בהם ב-Xcode.

ב-Bazel ניתן ליישם את התהליך הזה באופן הבא, כאשר unbundle-debuginfo היא פעולה מסוג Bazel:

load("@rules_cc//cc:defs.bzl", "ACTION_NAMES")

action_configs = [
    action_config (
        config_name = ACTION_NAMES.cpp_link_executable,
        action_name = ACTION_NAMES.cpp_link_executable,
        tools = [
            tool(
                with_features = [
                    with_feature(features=["generate-debug-symbols"]),
                ],
                tool_path = "toolchain/mac/ld-with-dsym-packaging",
            ),
            tool (tool_path = "toolchain/mac/ld"),
        ],
    ),
]

features = [
    feature(
        name = "generate-debug-symbols",
        flag_sets = [
            flag_set (
                actions = [
                    ACTION_NAMES.c_compile,
                    ACTION_NAMES.cpp_compile
                ],
                flag_groups = [
                    flag_group(
                        flags = ["-g"],
                    ),
                ],
            )
        ],
        implies = ["unbundle-debuginfo"],
   ),
]

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

load("@rules_cc//cc:defs.bzl", "ACTION_NAMES")

action_configs = [
    action_config (
        name = ACTION_NAMES.cpp_compile,
        tools = [
            tool(
                tool_path = "toolchain/bin/gcc",
            ),
        ],
    ),
]

features = [
    feature (
        name = "generate-debug-symbols",
        requires = [with_feature_set(features = ["dbg"])],
        flag_sets = [
            flag_set(
                actions = [ACTION_NAMES.cpp_compile],
                flag_groups = [
                    flag_group(
                        flags = ["-gsplit-dwarf"],
                    ),
                ],
            ),
            flag_set(
                actions = [ACTION_NAMES.cpp_link_executable],
                flag_groups = [
                    flag_group(
                        flags = ["-Wl", "--gdb-index"],
                    ),
                ],
            ),
      ],
    ),
]

קבוצות של דגלים

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

flag_group (
    flags = ["%{output_file_path}"],
)

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

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

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

flag_group (
    iterate_over = "include_paths",
    flags = ["-I%{include_paths}"],
)

מתרחב ל--I<path> עבור כל רכיב נתיב ברשימה include_paths. כל הסימונים (או flag_group) בגוף הצהרת קבוצת הסימונים מורחבים כיחידה. למשל:

flag_group (
    iterate_over = "include_paths",
    flags = ["-I", "%{include_paths}"],
)

מתרחב ל--I <path> עבור כל רכיב נתיב ברשימה include_paths.

משתנה יכול לחזור על עצמו כמה פעמים. למשל:

flag_group (
    iterate_over = "include_paths",
    flags = ["-iprefix=%{include_paths}", "-isystem=%{include_paths}"],
)

מתרחבת ל:

-iprefix=<inc0> -isystem=<inc0> -iprefix=<inc1> -isystem=<inc1>

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

flag_group (
    flags = ["-l%{libraries_to_link.name}"],
)

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

flag_group (
    iterate_over = "libraries_to_link",
    flag_groups = [
        flag_group (
            iterate_over = "libraries_to_link.shared_libraries",
            flags = ["-l%{libraries_to_link.shared_libraries.name}"],
        ),
    ],
)

הרחבה מותנית

קבוצות דגלים תומכות בהרחבה מותנית בהתאם לנוכחות של משתנה מסוים או של השדה שלו באמצעות המאפיינים expand_if_available, expand_if_not_available, expand_if_true, expand_if_false או expand_if_equal. למשל:

flag_group (
    iterate_over = "libraries_to_link",
    flag_groups = [
        flag_group (
            iterate_over = "libraries_to_link.shared_libraries",
            flag_groups = [
                flag_group (
                    expand_if_available = "libraries_to_link.shared_libraries.is_whole_archive",
                    flags = ["--whole_archive"],
                ),
                flag_group (
                    flags = ["-l%{libraries_to_link.shared_libraries.name}"],
                ),
                flag_group (
                    expand_if_available = "libraries_to_link.shared_libraries.is_whole_archive",
                    flags = ["--no_whole_archive"],
                ),
            ],
        ),
    ],
)

הפניה ל-CcToolchainConfigInfo

הקטע הזה כולל הסבר על משתני build, תכונות ומידע נוסף הדרוש להגדרה נכונה של כללי C++.

משתני build של CcToolchainConfigInfo

הנה הפניה ל-CcToolchainConfigInfo משתני build.

משתנה פעולה תיאור
source_file הידור קובץ המקור להדר.
input_file רצועה פריט מידע שרוצים להסיר.
output_file הידור פלט של הידור.
output_assembly_file הידור קובץ הרכבה הושלם. רלוונטי רק כאשר הפעולה compile מפיקה טקסט להרכבה, בדרך כלל כשמשתמשים בסימון --save_temps. התוכן זהה לזה של output_file.
output_preprocess_file הידור פלט שעבר עיבוד. הגדרה זו חלה רק על הידור של פעולות שמעבדות מראש רק את קובצי המקור, בדרך כלל באמצעות הסימון --save_temps. התוכן זהה לזה של output_file.
includes הידור רצף קבצים שהמהדר צריך לכלול ללא תנאי במקור הידור.
include_paths הידור ספריות רצף שבהן המהדר מחפש כותרות הכלולות ב-#include<foo.h> וב-#include "foo.h".
quote_include_paths הידור רצף של -iquote כולל - ספריות שבהן המהדר מחפש כותרות הכלולות ב- #include "foo.h".
system_include_paths הידור רצף של -isystem כולל - ספריות שבהן המהדר מחפש כותרות הכלולות ב- #include <foo.h>.
dependency_file הידור קובץ התלות של .d שנוצר על ידי המהדר.
preprocessor_defines הידור רצף של defines, כמו --DDEBUG.
pic הידור מפיק את הפלט כקוד בלתי תלוי במיקום.
gcov_gcno_file הידור קובץ הכיסוי של gcov.
per_object_debug_info_file הידור קובץ המידע על תוצאות ניפוי הבאגים של האובייקט (.dwp).
stripotps רצועה רצף של stripopts.
legacy_compile_flags הידור רצף של דגלים משדות CROSSTOOL קודמים, כמו compiler_flag, optional_compiler_flag, cxx_flag וגם optional_cxx_flag.
user_compile_flags הידור רצף של סימונים ממאפיין הכלל copt או מהסימונים --copt, --cxxopt ו---conlyopt.
unfiltered_compile_flags הידור רצף של סימונים מהשדה unfiltered_cxx_flag מדור קודם CROSSTOOL או מהמאפיין unfiltered_compile_flags. הם לא מסוננים על ידי כלל הכלל nocopts.
sysroot sysroot.
runtime_library_search_directories link רשומות בנתיב החיפוש בזמן ריצה (בדרך כלל מוגדר עם הסימון -rpath).
library_search_directories link רשומות בנתיב החיפוש המקשר (בדרך כלל מוגדרות עם הסימון -L).
libraries_to_link link סימונים שמספקים קבצים לקישור כקלט בהפעלה של הקישור.
def_file_path link מיקום קובץ האבטחה שבשימוש ב-Windows עם MSVC.
linker_param_file link המיקום של קובץ הפרמטר המקשר שנוצר על ידי Bazel כדי לעקוף את מגבלת האורך של שורת הפקודה.
output_execpath link נתיב הפלט של הקישור.
generate_interface_library link "yes" או "no", בהתאם ליצירה של ספריית הממשק.
interface_library_builder_path link נתיב לכלי לבניית ספריית ממשק.
interface_library_input_path link קלט עבור הכלי לבניית ספריית ifso.
interface_library_output_path link הנתיב לבניית ספריית ממשק באמצעות הכלי לבניית ifso.
legacy_link_flags link התרעות של Linker מגיעות מהשדות הקודמים CROSSTOOL.
user_link_flags link סימונים לקישור מגיעים מהמאפיינים --linkopt או linkopts.
linkstamp_paths link משתנה build שמספק נתיבי חותמת קישור.
force_pic link נוכחות של המשתנה הזה מציינת שצריך ליצור קוד PIC/PIE (האפשרות 'בזל' ' --force_pic' הועברה).
strip_debug_symbols link אם המשתנה הזה משתנה, יש להסיר את הסמלים של ניפוי הבאגים.
is_cc_test link האמת היא שהפעולה הנוכחית היא פעולת קישור של cc_test, False אם לא.
is_using_fission הידור, קישור נוכחות של המשתנה הזה מציינת שפיסה (פרטי ניפוי באגים של אובייקט) מופעלת. פרטי ניפוי הבאגים יהיו ב-.dwo קבצים במקום ב-.o קבצים, והמהדר וכל הקישור צריכים לדעת את זה.
fdo_instrument_path הידור, קישור נתיב לספרייה שבה שמור פרופיל אינסטרומנטציה של FDO.
fdo_profile_path הידור נתיב לפרופיל FDO.
fdo_prefetch_hints_path הידור נתיב לפרופיל שליפה מראש של מטמון.
csfdo_instrument_path הידור, קישור נתיב לספרייה שבה שמור פרופיל אינסטרומנטציה של FDO בהקשר רגיש.

תכונות ידועות

הנה פירוט על התכונות ותנאי ההפעלה שלהן.

Feature מסמכי תיעוד
opt | dbg | fastbuild מופעל כברירת מחדל על סמך מצב הידור.
static_linking_mode | dynamic_linking_mode מופעל כברירת מחדל על סמך מצב קישור.
per_object_debug_info מופעל אם התכונה supports_fission מוגדרת ומופעלת, ומצב האיסוף הנוכחי מצוין בסימון --fission.
supports_start_end_lib אם האפשרות מופעלת (והאפשרות --start_end_lib מוגדרת), Bazel לא תקשר לספריות סטטיות אלא תשתמש באפשרויות לקישור --start-lib/--end-lib כדי לקשר ישירות לאובייקטים. כך האצה של build מאחר ש-Bazel לא צריכה לבנות ספריות סטטיות.
supports_interface_shared_libraries אם האפשרות מופעלת (והאפשרות --interface_shared_objects מוגדרת), ה-Bazel יקשר יעדים עם הערך linkstatic כ-False (cc_test שניות כברירת מחדל) מול ספריות משותפות בממשק. כך לזרז את הקישור מחדש המצטבר.
supports_dynamic_linker אם המדיניות מופעלת, הכללים של C++ יידעו שכלי הכלים יכול ליצור ספריות משותפות.
static_link_cpp_runtimes אם האפשרות מופעלת, ה-Bazel יקשר את זמן הריצה של C++ באופן סטטי במצב קישור סטטי ובאופן דינמי במצב קישור דינמי. פריטי מידע שנוצרו בתהליך פיתוח (Artifact) שצוינו במאפיין cc_toolchain.static_runtime_lib או cc_toolchain.dynamic_runtime_lib (בהתאם למצב הקישור) יתווספו לפעולות הקישור.
supports_pic אם אפשרות זו מופעלת, Toolchain ידע להשתמש באובייקטים מסוג PIC עבור ספריות דינמיות. המשתנה 'image' נוכח כאשר נחוץ הידור PIC. אם המדיניות לא מופעלת כברירת מחדל ותכונת `--force_pic` מועברת, Bazel תבקש את 'supports_pic' ותוודא שהתכונה מופעלת. אם התכונה חסרה או שלא ניתן להפעיל אותה, לא ניתן להשתמש ב-`-force_pic'.
static_linking_mode | dynamic_linking_mode מופעל כברירת מחדל על סמך מצב קישור.
no_legacy_features מונע מ-Bazel להוסיף תכונות מדור קודם לתצורת C++. רשימת התכונות המלאה מפורטת בהמשך.

לוגיקת תיקון של תכונות מדור קודם

Bazel מחיל את השינויים הבאים על התכונות של Toolchain לתאימות לאחור.

  • התכונה legacy_compile_flags מועברת לחלק העליון של רצועת הכלים
  • התכונה default_compile_flags מועברת לחלק העליון של רצועת הכלים
  • מוסיף את התכונה dependency_file (אם לא קיימת) לחלק העליון של ארגז הכלים
  • מוסיף את התכונה pic (אם לא קיימת) לחלק העליון של ארגז הכלים
  • מוסיף את התכונה per_object_debug_info (אם לא קיימת) לחלק העליון של ארגז הכלים
  • מוסיף את התכונה preprocessor_defines (אם לא קיימת) לחלק העליון של ארגז הכלים
  • מוסיף את התכונה includes (אם לא קיימת) לחלק העליון של ארגז הכלים
  • מוסיף את התכונה include_paths (אם לא קיימת) לחלק העליון של ארגז הכלים
  • מוסיף את התכונה fdo_instrument (אם לא קיימת) לחלק העליון של ארגז הכלים
  • מוסיף את התכונה fdo_optimize (אם לא קיימת) לחלק העליון של ארגז הכלים
  • מוסיף את התכונה cs_fdo_instrument (אם לא קיימת) לחלק העליון של ארגז הכלים
  • מוסיף את התכונה cs_fdo_optimize (אם לא קיימת) לחלק העליון של ארגז הכלים
  • מוסיף את התכונה fdo_prefetch_hints (אם לא קיימת) לחלק העליון של ארגז הכלים
  • מוסיף את התכונה autofdo (אם לא קיימת) לחלק העליון של ארגז הכלים
  • מוסיף את התכונה build_interface_libraries (אם לא קיימת) לחלק העליון של ארגז הכלים
  • מוסיף את התכונה dynamic_library_linker_tool (אם לא קיימת) לחלק העליון של ארגז הכלים
  • מוסיף את התכונה shared_flag (אם לא קיימת) לחלק העליון של ארגז הכלים
  • מוסיף את התכונה linkstamps (אם לא קיימת) לחלק העליון של ארגז הכלים
  • מוסיף את התכונה output_execpath_flags (אם לא קיימת) לחלק העליון של ארגז הכלים
  • מוסיף את התכונה runtime_library_search_directories (אם לא קיימת) לחלק העליון של ארגז הכלים
  • מוסיף את התכונה library_search_directories (אם לא קיימת) לחלק העליון של ארגז הכלים
  • מוסיף את התכונה archiver_flags (אם לא קיימת) לחלק העליון של ארגז הכלים
  • מוסיף את התכונה libraries_to_link (אם לא קיימת) לחלק העליון של ארגז הכלים
  • מוסיף את התכונה force_pic_flags (אם לא קיימת) לחלק העליון של ארגז הכלים
  • מוסיף את התכונה user_link_flags (אם לא קיימת) לחלק העליון של ארגז הכלים
  • מוסיף את התכונה legacy_link_flags (אם לא קיימת) לחלק העליון של ארגז הכלים
  • מוסיף את התכונה static_libgcc (אם לא קיימת) לחלק העליון של ארגז הכלים
  • מוסיף את התכונה fission_support (אם לא קיימת) לחלק העליון של ארגז הכלים
  • מוסיף את התכונה strip_debug_symbols (אם לא קיימת) לחלק העליון של ארגז הכלים
  • מוסיף את התכונה coverage (אם לא קיימת) לחלק העליון של ארגז הכלים
  • מוסיף את התכונה llvm_coverage_map_format (אם לא קיימת) לחלק העליון של ארגז הכלים
  • מוסיף את התכונה gcc_coverage_map_format (אם לא קיימת) לחלק העליון של ארגז הכלים
  • מוסיף את התכונה fully_static_link (אם לא קיימת) לחלק התחתון של כלי הכלים
  • מוסיף את התכונה user_compile_flags (אם לא קיימת) לחלק התחתון של כלי הכלים
  • מוסיף את התכונה sysroot (אם לא קיימת) לחלק התחתון של כלי הכלים
  • מוסיף את התכונה unfiltered_compile_flags (אם לא קיימת) לחלק התחתון של כלי הכלים
  • מוסיף את התכונה linker_param_file (אם לא קיימת) לחלק התחתון של כלי הכלים
  • מוסיף את התכונה compiler_input_flags (אם לא קיימת) לחלק התחתון של כלי הכלים
  • מוסיף את התכונה compiler_output_flags (אם לא קיימת) לחלק התחתון של כלי הכלים

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