arm-linux-gnueabihf-gcc-4.7 - מקוון בענן

תָכְנִית:

שֵׁם

gcc - מהדר GNU פרוייקט C ו-C++

תַקצִיר

gcc [-c|-S|-E] [-std=תֶקֶן]
[-g] [-עמוד] [-Oרָמָה]
[-Wלהזהיר...] [-קַפְּדָנִי]
[-Idir...] [-Ldir...]
[-Dמאקרו[=defn]...] [-Uמאקרו]
[-fאוֹפְּצִיָה...] [-mאפשרות למכונה...]
[-o אוסף] [@פילה] בקובץ...

רק האפשרויות השימושיות ביותר מפורטות כאן; ראה להלן לגבי השאר. g ++ מקבלת
לרוב אותן אפשרויות כמו gcc.

תיאור

כאשר אתה מפעיל את GCC, זה בדרך כלל עושה עיבוד מקדים, קומפילציה, הרכבה וקישור.
"האפשרויות הכוללות" מאפשרות לעצור את התהליך הזה בשלב ביניים. ל
לדוגמה, ה -c האפשרות אומרת לא להפעיל את המקשר. ואז הפלט מורכב מאובייקט
פלט קבצים על ידי האסמבלר.

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

רוב אפשרויות שורת הפקודה שבהן אתה יכול להשתמש עם GCC שימושיות עבור תוכניות C; מתי
אפשרות שימושית רק עם שפה אחרת (בדרך כלל C++), ההסבר אומר זאת
בִּמְפוּרָשׁ. אם התיאור של אפשרות מסוימת אינו מזכיר מקור
שפה, אתה יכול להשתמש באפשרות זו עם כל השפות הנתמכות.

אל האני gcc התוכנית מקבלת אפשרויות ושמות קבצים כאופרנדים. לאפשרויות רבות יש ריבוי
שמות אותיות; לכן אפשרויות מרובות של אותיות בודדות עשויות לֹא להיות מקובצים: -DV. מאוד
שונה מ -d -v.

אתה יכול לערבב אפשרויות וטיעונים אחרים. לרוב, ההזמנה שבה אתה משתמש לא עושה זאת
חוֹמֶר. הסדר משנה כאשר אתה משתמש במספר אפשרויות מאותו סוג; למשל, אם
אתה מציין -L יותר מפעם אחת, מבוצע חיפוש בספריות לפי הסדר שצוין. גַם,
המיקום של ה -l האופציה היא משמעותית.

לאפשרויות רבות יש שמות ארוכים שמתחילים ב -f או עם -W---לדוגמה,
-fmove-loop-invariants, - וכן הלאה. לרובם יש גם חיובי ושלילי
טפסים; הצורה השלילית של -ffoo. יהיה -fno-foo. מדריך זה מתעד רק אחד מהם
שתי צורות אלו, מי מהן אינו ברירת המחדל.

אפשרויות

אפשרות <br> סיכום
לפניכם סיכום של כל האפשרויות, מקובצות לפי סוג. ההסברים נמצאים בהמשך
סעיפים.

באופן כללי אפשרויות
-c -S -E -o פילה -ללא-קנוניות-קידומות -צינור -מעבר-יציאה-קודים -x שפה -v
-### - עזרה[=בכיתה[, ...]] --מטרה-עזרה --גִרְסָה -עֲטִיפָה @פילה -fplugin=פילה
-fplugin-arg-שם=גדול מ -fdump-ada-spec[-רָזֶה] -fdump-go-spec=פילה

C שפה אפשרויות
-אנסי -std=תֶקֶן -fgnu89-inline -מידע נוסף שם הקובץ
-פונקציות-פרמטר-חסר-פרמטר-variadic -fno-asm -fno-builtin -fno-builtin-פונקציה
-אירוח -עומד בפני עצמו -fopenmp -fms-הרחבות -fplan9-הרחבות -טריגרפים
-no-integrated-cpp -מָסוֹרתִי -מסורתי-cpp -פול-יחיד-דיוק
-fcond-חוסר התאמה -המרות-וקטור פשתן -fsigned-bitfields -fsigned-char
-שדות סיביות עם סימני כיף -מחומן-char

C + + שפה אפשרויות
-fabi-version=n -fno-בקרת גישה -fcheck-חדש -לשמור-שטח
-fconstexpr-depth=n -הזרקת חבר -fno-elide-constructors -fno-enforce-eh-specs
-ffor-scope -fno-for-scope -fno-gnu-מילות מפתח -fno-implicit-templates
-fno-implicit-inline-templates -fno-implement-inlines -fms-הרחבות
-fno-nonansi-builtins -fnothrow-opt -fno-שמות מפעילים -fno-אופציונלי-דיאגס
-מתירנית -fno-pretty-templates -פרפו -fno-rtti -fstats -ftemplate-depth=n
-fno-threadsafe-statics -פיוז-cxa-atexit -fno-חלש -nostdinc++ -fno-default-inline
-fvisibility-inlines-hidden -fvisibility-ms-compat -וואבי -Wconversion-null
-וקטור-דטור-פרטיות -Wdelete-non-virtual-dtor -מצמצם -לא חוץ מזה
-Wnon-Virtual-dtor -הסדר -Weffc++ -Wstrict-null-sentinel
-לא-לא-חבר-תבנית -קאסט בסגנון וולד -עמוס-וירטואלי -Wno-pmf-המרות
-Wsign-promo

Objective-C ו Objective-C ++ שפה אפשרויות
-fconstant-string-class=שם כיתה -fgnu-זמן ריצה -fnext-זמן ריצה -fno-nil-receivers
-fobjc-abi-version=n -fobjc-call-cxx-cdtors -fobjc-שיגור ישיר -fobjc-חריגים
-fobjc-gc -fobjc-nilcheck -fobjc-std=objc1 -freplace-objc-classes -fzero-link
-gen-decls -Wassign-יירט -אין פרוטוקול -ובורר -Wstrict-selector-match
-בורר-מוצהר

שפה עצמאי אפשרויות
-fmessage-length=n -fdiagnostics-show-location=[פעם|כל שורה]
-fno-diagnostics-show-option

אזהרה אפשרויות
-fsyntax-בלבד -fmax-errors=n -קַפְּדָנִי -פדנטיות-טעויות -w אקסטרה - קיר
-כתובת -Waggregate-return -גבולות המלחמה -אין תכונות
-מובנה-מקרו-מוגדר מחדש -Wc++-compat -Wc++11-compat -יישור Wcast -Wcast-qual
-Wchar-מנויים -קשקש -הערה -המרה -אי-התאמה של כיסוי -Wno-cpp
-לא הוצא משימוש -הצהרות-לא-מוות -Wdisabled-אופטימיזציה -Wno-div-by-XNUMX
- קידום כפול -גוף רטוב -וונום-השוו -תוויות Wno-endif -שגיאה -שגיאה=*
-שגיאות חמורות -Wfloat-שווה - -Wformat=2 -Wno-format-contains-nul
-Wno-format-extra-args -Wformat-לא מילולי -Wformat-אבטחה -Wformat-y2k
-Wframe-larger than=לן -ללא-חפץ-לא-ערמה -Wjump-misses-init
- מוקדמות מנוצלות - מרומז -הצהרה-פונקציונלית -מוכר
-וויניט-עצמי -Winline -אולי-לא אתחול -Wno-int-to-pointer-cast
-Wno-invalid-offsetof -Winvalid-pch -Wlarer- than=לן -אופטימיזציות של Wunsafe-loop
-Wlogical-op -ולונג-ארוך -מיין -אולי-לא אתחול -חסר-פלטה
-חסרי-שדה-initializers -תכונה חסרת-פורמט -חסרים-include-dirs
-לא-דש בוץ -Wno-multichar -Wnonnull -ללא הצפה -מיתרים באורך רוח -ארוז
-Wpacked-bitfield-compat -Wpadded -סוגריים -Wpedantic-ms-format
-Wno-pedantic-ms-format -Wpointer-arith -אין-מצביע ל-int-cast -חסר-מבטל
-סוג חזרה -נקודת רצף -וצל -Wsign-השוואה -המרת סימן
-מגן Wstack -Wstack-usage=לן -Wstrict-aliasing -Wstrict-aliasing=n
-Wstrict-הצפה -Wstrict-overflow=n -Wsuggest-attribute=[טהור|const|אין דרך חזרה]
-מתג -Wswitch-default -סוויצ'-אנום -Wsync-nand -כותרות Wsystem -טרמפולינות
-תרשימים -מגבלות סוג -וונדף -לא מאותחל -לא ידוע-פרגמות -לא-פרגמות
-משימות-צפות-קבועות -לא בשימוש -פונקציה Wunused -תווית Wunused
-Wunused-local-typedefs -פרמטר Wunused -אין תוצאה שאינה בשימוש -ערך Wunused
-משתנים-Wunused -פרמטר Wunused-but-set- -בשימוש-אבל-סט-משתנה
-Wvariadic-macros -וקטור-פעולה-ביצועים -Wvla -Wvolatile-register-var
-כתוב-מחרוזות -Wzero-as-null-pointer-constant

C ו Objective-C בלבד אזהרה אפשרויות
-Wbad-function-cast -הצהרות חסרות -סוג חסר-פרמטר
-חסרי-אבטיפוס -Wnested-externs -הצהרה בסגנון וולד -הגדרה בסגנון וולד
-Wstrict-אב טיפוס -מסורתי -המרה מסורתית
-הצהרה-אחרי-הצהרה -סימן Wpointer

Debugging אפשרויות
-dאותיות -מפרט dump -מכונת dump -גרסת dump -fdbg-cnt-list -fdbg-cnt=דֶלְפֵּק-
רשימת ערכים -fdisable-ipa-pass_name -fdisable-rtl-pass_name -fdisable-rtl-לַעֲבוֹר-
שם=רשימת טווחים -fdisable-tree-pass_name -fdisable-tree-שם מעבר=רשימת טווחים
-fdump-noaddr -fdump-לא ממוספר -fdump-לא ממוספרים-קישורים -fdump-translation-unit[-n]
-fdump-class-hierarchy[-n] -fdump-ipa-all -fdump-ipa-cgraph -fdump-ipa-inline
-fdump-passes -fdump-סטטיסטיקה -fdump-tree-all -fdump-עץ-מקורי[-n]
-fdump-tree מותאם[-n] -fdump-tree-cfg -fdump-tree-vcg -fdump-tree-כינוי
-fdump-tree-ch -fdump-tree-ssa[-n] -fdump-tree-pre[-n] -fdump-tree-ccp[-n]
-fdump-tree-dce[-n] -fdump-tree-gimple[-גלם] -fdump-עץ-דש בוץ[-n]
-fdump-tree-dom[-n] -fdump-tree-dse[-n] -fdump-tree-phiprop[-n] -fdump-tree-phiopt[-n]
-fdump-tree-forwprop[-n] -fdump-tree-copyrename[-n] -fdump-tree-nrv -fdump-tree-vect
-fdump-עץ-כיור -fdump-tree-sra[-n] -fdump-tree-forwprop[-n] -fdump-tree-fre[-n]
-fdump-tree-vrp[-n] -ftree-vectorizer-verbose=n -fdump-tree-storeccp[-n]
-fdump-final-insns=פילה -fcompare-debug[=בוחר] -fcompare-debug-second
-פלימינאט-גמד2-דופים טיפוסי-feliminate-unused-debug
סמלים-feliminate-unused-debug-symbols -femit-class-debug-always -ניתן להפגין-סוג-לעבור
-ניתן להפגין-סוג-לעבור=רשימת טווחים -fdebug-types-section -fmem-דוח -fpre-ipa-mem-report
-fpost-ipa-mem-report -fprofile-arcs -פרנדום-seed=מחרוזת -fsched-verbose=n
-fsel-sched-verbose -fsel-sched-dump-cfg -fsel-sched-pipelining-verbose -שימוש בערימה
-הכיסוי הגבוה ביותר -ftime-דוח -fvar-מעקב -fvar-tracking-assignments
-מאבר-מעקב-מנתקים-טבגול -g -gרָמָה -gtoggle -גקוף -גמד-גרסה -ggdb
-grecord-gcc-מתגים -gno-record-gcc-switches -gstabs -gstabs+ -gstrict-גמד
-נו-קפדנית-גמד -gvms -gxcoff -gxcoff+ -fno-merge-debug-strings
-fno-dwarf2-cfi-asm -fdebug-prefix-map=זקן=חדש -femit-struct-debug-baseonly
-מיט-סטרוק-דבוק מופחת -femit-struct-debug-detailed[=מפרט-רשימת] -p -עמוד
-print-file-name=ספריה -print-libgcc-file-name -הדפס-מספר ספריות
-print-multi-lib -print-multi-os-directory -print-prog-name=התוכנית
-print-search-dirs -Q -print-sysroot -print-sysroot-headers-suffix -חיסכון-טמפ'
-save-temps=cwd -save-temps=obj -time[=פילה]

אופטימיזציה אפשרויות
-falign-functions[=n] -falign-jumps[=n] -falign-labels[=n] -falign-לולאות[=n]
-אסוציאטיבית-מתמטיקה -fauto-inc-dec -fענף-הסתברויות -fbranch-target-load-optimize
-fbranch-target-load-optimize2 -fbtr-bb-בלעדי -fcaller-שומר -fcheck-data-deps
-fcombine-stack-adjustments -fconserve-מחסנית -fcompare-elim -fcprop-registers
-קפיצה צולבת -fcse-follow-jumps -fcse-דלג-בלוקים -fcx-fortran-rules
-fcx-טווח מוגבל -fdata-sections -fdce -ענף מושהה -fdelete-null-pointer-checks
-fdevirtualize -fdse -פחד-הטבעה -פיפא-סרה -זול-אופטימיזציות
-ffat-lto-objects -מהיר-מתמטיקה -סופית-מתמטיקה-בלבד -ffloat-store
-fexcess-precision=סגנון -לפנים-להפיץ -ffp-contract=סגנון -פפונקציה-סעיפים
-fgcse -fgcse-after-reload -fgcse-las -fgcse-lm -זהות-fgraphite -fgcse-sm
-fif-המרה -fif-conversion2 -findirect-inlining -finline-פונקציות
-finline-functions-שנקרא פעם אחת -finline-limit=n -finline-קטנות-פונקציות -fipa-cp
-fipa-cp-clone -fipa-matrix-reorg -פיפא-pta -fipa-profile -פיפא-טהור-קונסט
-פיפא-התייחסות -fira-algorithm=אַלגוֹרִיתְם -fira-region=באזור -פירה-לולאה-לחץ
-fno-ira-share-save-slots -fno-ira-share-spill-slots -fira-verbose=n -fivopts
-fkeep-inline-functions -fkeep-static-consts -פלופ-בלוק -פלופ-לשטוח
-פלופ-מחלף -פלופ-רצועה-שלי -פלופ-מקביל-הכל -flto
-flto-compression-level -flto-partition=ALG -flto-דוח -fmerge-all-constants
-fmerge-constants -fmodulo-sched -fmodulo-sched-allow-regmoves -fmove-loop-invariants
fmudflap -fmudflapir -fmudflapth -fno-branch-count-reg -fno-default-inline
-fno-defer-pop -fno-function-cse -fno-ניחוש-ענף-הסתברות -fno-inline
-fno-math-errno -fno-חור הצצה -fno-חור הצצה2 -fno-sched-interblock -fno-sched-המפרט
-fno-סימן-אפסים -fno-toplevel-סדר מחדש -fno-מלכודת-מתמטיקה
-fno-zero-initialized-in-bss -fomit-frame-pointer -foptimize-register-move
-foptimize-אחיות-שיחות -fpartial-inlining -fpeel-לולאות -fpredictive-commoning
-fprefetch-loop-arrays -fprofile-תיקון -fprofile-dir=נתיב -fprofile-generate
-fprofile-generate=נתיב -fprofile-שימוש -fprofile-use=נתיב -fprofile-values
-תדמיתי-מתמטיקה -חופשי -פרגmove -frename-registers -Freord-בלוקים
-לאחר סדר-בלוקים-ו-מחיצה -פקודת-פונקציות -frerun-cse-after-loop
-freschedule-modulo-scheduled-loops -חישוב-מתמטיקה -fsched2-use-superblocks
-fsched-לחץ -fsched-spec-load -fsched-spec-עומס-מסוכן
-fsched-stalled-insns-dep[=n] -fsched-stalled-insns[=n] -fsched-group-heuristic
-fsched-critical-path-hyuristic -fsched-spec-insn-heuristic -fsched-rank-heuristic
-fsched-last-insn-heuristic -fsched-dep-count-heuristic -fschedule-insns
-fschedule-insns2 -fsection-עוגנים -סלקטיבי-תזמון -fsellective-scheduling2
-fsel-sched-pipelining -fsel-sched-pipelining-outer-loops -להכווץ-לעטוף
-fsignaling-nans -דיוק-קבוע-יחיד -fsplit-ivs-in-unroller
-fsplit-wide-types -מגן מחסנית -fstack-protector-all -fstrict-aliasing
-פרקט-הצפה -חוט-קפיצות -ftracer -ftree-bit-ccp -ftree-builtin-call-dce
-ftree-ccp -ftree-ch -ftree-coalesce-inline-vars -ftree-coalesce-vars -ftree-copy-prop
-ftree-copyrename -ftree-dce -ftree-dominator-opts -ftree-dse -ftree-forwprop
-ftree-fre -ftree-loop-if-convert -ftree-loop-if-convert-stores -ftree-loop-im
-ftree-phiprop -ftree-loop-distribution -ftree-loop-distribute-passtrens
-ftree-loop-ivcanon -ftree-לולאה-לינארית -ftree-loop-optimize -ftree-parallize-לולאות=n
-ftree-pre -ftree-partial-pre -ftree-pta -ftree-reassoc -כיור-ftree -ftree-sra
-ftree-switch-conversion -ftree-זנב-מיזוג -ftree-ter -ftree-vect-loop-version
-ftree-vectorize -ftree-vrp -כיף-בכל פעם -funroll-all-loops -funroll-לולאות
-אופטימיזציות של לולאת funsafe -אופטימיזציות-funsafe-math -לולאות funswitch
-fvariable-expansion-in-unroller -fvect-cost-model -fvpt -FWeb. -התוכנית שלמה -fwpa
-fuse-ld=קישורים -תוסף-מקשר-fuse --param שם=ערך -O -O0 -O1 -O2 -O3 -אוס
-אופסט

Preprocessor אפשרויות
-Aשאלה=לענות -א-שאלה[=לענות] -C -dD -די -dM -dN -Dמאקרו[=defn] -E -H
-ידirafter dir -לִכלוֹל פילה -אימאקרו פילה -iprefix פילה -iwithprefix dir
-iwithprefixbefore dir -מערכת dir -אימולטיבי dir -isysroot dir -M -ממ -MF -MG
-MP -MQ -MT -נוסטדינק -P -fdebug-cpp -ftrack-macro-expansion -fworking-מדריך
-מפה מחדש -טריגרפים -undef -Uמאקרו -Wp,אוֹפְּצִיָה -Xpreprocessor אוֹפְּצִיָה

אסמבלר אפשרות
-ווא,אוֹפְּצִיָה -Xassembler אוֹפְּצִיָה

לינקר אפשרויות
שם אובייקט-קובץ -lספריה -nostartfiles -nodefaultlibs -נוסטדליב -פַּאִי -רדינמי -s
-סטָטִי -static-libgcc -static-libstdc++ -מְשׁוּתָף -shared-libgcc -סִמלִי -T תסריט
-וול,אוֹפְּצִיָה -Xlinker אוֹפְּצִיָה -u סמל

מַדרִיך אפשרויות
-Bקידומת -Idir -plugindir=dir -אני מצטטdir -Ldir -מפרט =פילה -אני- --sysroot=dir

מכונה תלוי אפשרויות
AAArch64 אפשרויות -mbig-endian -מעט-אנדיאן -mgeneral-regs-only -mcmodel=קטנטן
-mcmodel=small -mcmodel=גדול -mstrict-align -momit-leaf-frame-pointer
-mno-omit-leaf-frame-pointer -mtls-dialect=desc -mtls-dialect=מסורתי -מרץ=שם
-mcpu=שם -mtune=שם

אדפטיבה הִתגַלוּת אפשרויות -mhalf-reg-file -mrefer-short-insn-regs -brranch-cost=NUM
-mcmove -mnops=NUM -msoft-cmpsf -msplit-lohi -mpost-inc -mpost-modify
-mstack-offset=NUM -mround-הקרוב ביותר -מלונג-שיחות -שיחות קצרות -msmall16 -mfp-mode=מצב
-mvect-double -max-vect-align=NUM -msplit-vecmove-early -m1reg-רג

זרוע אפשרויות -mapcs-frame -mno-apcs-frame -מאבי=שם -mapcs-stack-check
-mno-apcs-stack-check -mapcs-float -mno-apcs-float -mapcs-reenrant
-mno-apcs-reenrant -msched-prolog -mno-sched-פרולוג -מעט-אנדיאן -mbig-endian
-mwords-little-endian -mfloat-abi=שם -mfpe -mfp16-format=שם -מ-אגודל-עבודה
-mno-thumb-interwork -mcpu=שם -מרץ=שם -mfpu=שם -mstructure-size-boundary=n
-אם-על-חזרה -מלונג-שיחות -שיחות ארוכות -בסיס תמונה אחת
-mno-single-pic-base -mpic-register=רג -mnop-fun-dllimport -mcirrus-fix-invalid-insns
-mno-cirrus-fix-invalid-insns -שם פונקציה-mpoke -אגודל -מרם -mtpcs-frame
-mtpcs-leaf-frame -mcaller-סופר-אינטרוורקינג -mcallee-סופר-אינטרוורקינג -mtp=שם
-mtls-dialect=נִיב -mword-relocations -mfix-cortex-m3-ldrd -גישה מנוהלת
-מנאון-עבור-64 סיביות

AVR אפשרויות -mmcu=מקו -צבור-ארגס -brranch-cost=עלות -mcall-פרולוגים -מנטה8
-מנו-מפריע -להירגע -שיחות קצרות -mstrict-X -mtiny-stack

שחור אפשרויות -mcpu=מעבד[-סירטוויזיון] -מסים -momit-leaf-frame-pointer
-mno-omit-leaf-frame-pointer -mspekld-anomaly -mno-specld-anomaly -mcsync-anomaly
-mno-csync-anomaly -חלב-64k -mno-low64k -mstack-check-l1 -אמצע הספרייה המשותפת
-mno-id-shared-library -mshared-library-id=n -mleaf-id-shared-library
-mno-leaf-id-shared-library -msep-נתונים -mno-sep-data -מלונג-שיחות -שיחות ארוכות
-mfast-fp -minline-plt -רב ליבות -mcorea -מקורב -msdram -micplb

C6X אפשרויות -mbig-endian -מעט-אנדיאן -מרץ=מעבד -מסים -msdata=סוג sdata

Cris אפשרויות -mcpu=מעבד -מרץ=מעבד -mtune=מעבד -mmax-stack-frame=n
-melinux-stacksize=n -מטרקס4 -מטרקס100 -mpdebug -mcc-init -mno-תופעות לוואי
-mstack-align -mdata-align -mconst-align -m32-bit -m16-bit -m8-bit
-מנו-פרולוג-אפילוג -mno-gotplt -מלף -מאוט -מלינוקס -mlinux -סים -sim2
-mmul-bug-around -mno-mul-bug-around

CR16 אפשרויות -ממק -mcr16cplus -mcr16c -מסים -מנטה32 -mbit-ops -mdata-model=מודל

דרווין אפשרויות -כל_עומס -מותר_לקוח -קֶשֶׁת -arch_errors_fatal -רק_בלבד
-bind_at_load -חבילה -bundle_loader -שם הלקוח -גרסה_תאימות
-גרסה נוכחית -רצועה_מתה -תלות-קובץ -dylib_file -שם_התקנה_dylinker
-דִינָמִי -דינאמיליב -רשימת_סמלים_מיוצאים -רשימת קבצים -שטח שם_flat
-force_cpusubtype_ALL -force_flat_namespace -headerpad_max_install_names -iframework
-תמונה_בסיס -ניט -שם_התקנה -שמור_פרטי_externs -מולטי_מודול
-מוגדר_הכפיל -כפיל_ מוגדר_לא בשימוש -noall_load
-אין_מתים_חפצים_ותנאים -nofixprebinding -נומולטידף -noprebind
-noseglinkedit -pagezero_size -קשירה מראש -prebind_all_twolevel_modules -חבילה_פרטית
-קריאה בלבד_relocs -סקטליין -סמלי אובייקטים של כת -למה לטעון -seg1addr -ליצור
-סמלי אובייקטים של כת -מגזר -סגדדר -segs_read_only_addr -segs_read_write_addr
-seg_addr_table -seg_addr_table_filename -seglinkedit -סגפרוט -segs_read_only_addr
-segs_read_write_addr -יחיד_מודול -סטָטִי -ספריית_תת -משנה_מטריה
-רווח_שם_שניים -מִטְרִיָה -לא מוגדר -רשימת_סמלים_לא מיוצאים
-אי-התאמות_התייחסות_חלשה -מה שנטען -F נחש -מלא -mmacosx-version-min=גרסה
-מקרנל -mone-byte-bool

דצמבר אלפא אפשרויות -mno-fp-regs -msoft-float -malpha-as -מגז -מיי
-מיי-עם-לא מדויק -מיי-תואם -mfp-trap-mode=מצב -mfp-rounding-mode=מצב
-mtrap-precision=מצב -mbuild-קבועים -mcpu=סוג מעבד -mtune=סוג מעבד -mbwx -ממקס
-mfix -mcix -mfloat-vax -mfloat-ieee -מפורש-רילוקים -msmall-data -הגדלה-נתונים
-msmall-text -טקסט גדול -זיכרון-השהייה=זמן

דצמבר אלפא/VMS אפשרויות -mvms-return-codes -mdebug-main=קידומת -mmalloc64

FR30 אפשרויות -msmall-model -מנו-לסים

FRV אפשרויות -mgpr-32 -mgpr-64 -mfpr-32 -mfpr-64 -mhard-float -msoft-float
-malloc-cc -mfixed-cc -mdword -mno-dword -mdouble -mno-כפול -ממדיה -mno-media
-מולאד -mno-muladd -mfdpic -minline-plt -mgprel-ro -רב-ספרייה-תמונה
-mlinked-fp -מלונג-שיחות -ממאיר-תוויות -mlibrary-תמונה -mac-4 -mac-8 -mpack
-מנו-חבילה -mno-flags -mcond-move -mno-cond-move -moptimize-membar
-mno-optimize-membar -mscc -mno-scc -mcond-exec -mno-cond-exec -mvliw-ענף
-מנו-פליוו-ענף -multi-cond-exec -mno-multi-cond-exec -mnested-cond-exec
-mno-nested-cond-exec -mtomcat-stats -mTLS -mtls -mcpu=מעבד

גנו / לינוקס אפשרויות -mglibc -muclibc -מביוני -מאנדרואיד -tno-android-cc -tno-android-ld

H8 / 300 אפשרויות -להירגע -מ"ה -גברת -מנ -מנטה32 -ממאיר-300

HPPA אפשרויות -מרץ=סוג אדריכלות -מביג-מתג -mdisable-fpregs
-mdisable-indexing -שיחות בלתי ישירות -מגז -מגנו-לד -mhp-ld
-mfixed-range=רישום-טווח -mjump-in-delay -mlinker-opt -מלונג-שיחות
-מלונג-load-store -Mno-Big-Switch -mno-disable-fpregs -mno-disable-indexing
-מנו-מהיר-שיחות עקיפות -מנו-גז -mno-jump-in-delay -mno-long-load-store
-mno-portable-time -מנו-רך-צף -mno-space-regs -msoft-float -mpa-risc-1-0
-mpa-risc-1-1 -mpa-risc-2-0 -זמן ריצה נייד -mschedule=סוג מעבד -mspace-regs
-msio -mwsio -munix=unix-std -nolibdld -סטָטִי -חוטים

i386 ו x86-64 אפשרויות -mtune=סוג מעבד -מרץ=סוג מעבד -mfpmath=יחידה -masm=נִיב
-mno-fancy-math-387 -mno-fp-ret-in-387 -msoft-float -mno-wide-כפיל -mrtd
-ממאיר-כפול -mreferred-stack-boundary=NUM -mincoming-stack-boundary=NUM -mcld
-mcx16 -משף -ממוב -mcrc32 -mrecip -mrecip=לִבחוֹר -mvzeroupper -mrefer-avx128 -מממקס
-msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -msse4 -mavx -mavx2 -מייס -mpclmul
-mfsgsbase -mrdrnd -mf16c -mfma -msse4a -m3dnow -mpopcnt -מאבם -מבמי -mtbm -mfma4
-mxop -mlzcnt -mbmi2 -mlwp -חוטים -mno-align-stringops -מינליין-כל-stringops
-מינליין-stringops-דינמית -mstringop-strategy=ALG -מפוש-ארגס
-צבור-יוצא-ארגים -m128bit-long-double -m96bit-long-double -mregparm=NUM
-msseregparm -mveclibabi=סוג -mvect8-ret-in-mem -mpc32 -mpc64 -mpc80 -mstackrealign
-momit-leaf-frame-pointer -mno-red-zone -mno-tls-direct-seg-refs -mcmodel=מודל קוד
-מאבי=שם -maddress-mode=מצב -מ 32 -מ 64 -mx32 -mlarge-data-threshold=NUM -msse2avx
-מפנטרי -m8bit-idiv -mavx256-split-unaligned-load -mavx256-split-unaligned-store

i386 ו x86-64 Windows אפשרויות -mconsole -מקיגווין -mno-cygwin -mdll
-mnop-fun-dllimport -חוט -מוניקוד -mwin32 -mwindows -fno-set-stack-ניתן להפעלה

IA-64 אפשרויות -mbig-endian -מעט-אנדיאן -mgnu-as -מגנו-לד -מנו-תמונה
-mvolatile-asm-stop -mregister-names -msdata -mno-sdata -mconstant-gp -תמונה אוטומטית
-מfused-madd -מרין-פליטה-חלקה-מגוון-חוזה -מיניליין-float-divide-max-throughput
-mno-inline-float-divide -minline-int-divide-min-latency
-minline-int-divide-max-throughput -mno-inline-int-divide -minline-sqrt-min-latency
-minline-sqrt-max-throughput -mno-inline-sqrt -mdwarf2-asm -מעט-עצור-ביטים
-mfixed-range=רישום-טווח -mtls-size=tls-גודל -mtune=סוג מעבד -מילפ32 -mlp64
-msched-br-data-spec -msched-ar-data-spec -msched-control-spec -msched-br-in-data-spec
-msched-ar-in-data-spec -Mched-in-control-spec -msched-spec-ldc
-msched-spec-control-ldc -msched-prefer-non-data-spec-insns
-msched-prefer-non-control-spec-insns -msched-stop-bits-after-every-cycle
-msched-count-spec-in-critical-path -msel-sched-dont-check-control-spec
-msched-fp-mem-deps-XNUMX-עלות -msched-max-memory-insns-hard-limit
-msched-max-memory-insns=max-insns

IA-64/VMS אפשרויות -mvms-return-codes -mdebug-main=קידומת -mmalloc64

LM32 אפשרויות -mbarrel-shift-enabled -mdivide מאופשר -מופעל מרובה
-msign-extend-enabled -מופעל על ידי muser

M32R/D אפשרויות -M32R2. -m32rx -m32r -mdebug -ממאיר-לולאות -mno-align-לולאות
-שיעור חסר=מספר -brranch-cost=מספר -mmodel=גודל-קוד-דגם-סוג -msdata=sdata-
סוג -mno-flush-func -mflush-func=שם -מנו-פלוש-מלכודת -mflush-trap=מספר -G NUM

M32C אפשרויות -mcpu=מעבד -מסים -memregs=מספר

M680x0 אפשרויות -מרץ=קשת -mcpu=מעבד -mtune=מנגינה -מ 68000 -מ 68020 -m68020-40
-m68020-60 -מ 68030 -מ 68040 -מ 68060 -mcpu32 -מ 5200 -m5206e -מ528x -מ 5307 -מ 5407
-mcfv4e -מביטפילד -mno-bitfield -mc68000 -mc68020 -מנוביטפילד -mrtd -mno-rtd
-מדיב -mno-div -מקצר -מנו-קצר -mhard-float -מ 68881 -msoft-float -mpcrel
-מalign-int -mstrict-align -msep-נתונים -mno-sep-data -mshared-library-id=n
-אמצע הספרייה המשותפת -mno-id-shared-library -mxgot -mno-xgot

MCore אפשרויות -מהרדליט -מנו-מואר -מדיב -mno-div -mrelax-מיידי
-מנו-להירגע-מיידי -mwide-bitfields -mno-wide-bitfields -m4byte-פונקציות
-mno-4byte-functions -mcallgraph-data -mno-callgraph-data -mslow-bytes
-mno-slow-bytes -מנו-לסים -מעט-אנדיאן -mbig-endian -מ 210 -מ 340
-mstack-increment

MeP אפשרויות -mabsdiff -קניונים-אופטים -ממוצע -mbased=n -מביטופים -mc=n -mclip
-mconfig=שם -מקופ -MCOP32. -MCOP64. -mivc2 -mdc -מדיב -מב -מל -מיו נדיף -מל
-מלאדז -מ -ממינמקס -מולט -mno-opts -חוזר על עצמו -גברת -מסטור -msdram -מסים -msimnovec
-mtf -mtiny=n

MicroBlaze אפשרויות -msoft-float -mhard-float -מסמול-מחלק -mcpu=מעבד -מממפי
-mxl-soft-mul -mxl-soft-div -mxl-barrel-shift -mxl-pattern-compare -mxl-stack-check
-mxl-gp-opt -mno-clearbss -mxl-כפיל-גבוה -mxl-float-convert -mxl-float-sqrt
-mxl-mode-דגם אפליקציה

MIPS אפשרויות -ה -EB -מרץ=קשת -mtune=קשת -מיפס1 -מיפס2 -מיפס3 -מיפס4
-מיפס32 -mips32r2 -מיפס64 -mips64r2 -מיפס16 -mno-mips16 -mflip-mips16
-minterlink-mips16 -mno-interlink-mips16 -מאבי=אבי -מאביקלים -מנו-אביקל
-mshared -mno-משותף -mplt -mno-plt -mxgot -mno-xgot -mgp32 -mgp64 -mfp32
-mfp64 -mhard-float -msoft-float ציפה אחת -mdouble-float -mdsp -mno-dsp
-mdspr2 -mno-dspr2 -mfpu=מסוג fpu -msmartmips -mno-smartmips -לקוי-רווק
-mno-זוגי-סינגל -mdmx -mno-mdmx -mips3d -mno-mips3d -ממץ -מנו-מט -mllsc
-mno-llsc -מלונג64 -מלונג32 -msym32 -mno-sym32 -GNUM -mlocal-sdata
-mno-local-sdata -mextern-sdata -mno-extern-sdata -mgpopt -מנו-גופט -נתונים משובצים
-mno-embedded-data -muninit-const-in-rodata -mno-uninit-const-in-rodata
-mcode-readable=הצבה -mssplit-כתובות -mno-split-כתובות -מפורש-רילוקים
-mno-explicit-relocs -מצ'ק-אפס-חלוקה -מנו-צ'ק-אפס-חלוקה -מחלק-מלכודות
-מחלק-הפסקות -מממפי -mno-memcpy -מלונג-שיחות -שיחות ארוכות -מאד -מנון-משוגע
-מfused-madd -mno-fused-madd -nocpp -mfix-24k -mno-fix-24k -mfix-r4000
-mno-fix-r4000 -mfix-r4400 -mno-fix-r4400 -mfix-r10000 -mno-fix-r10000 -mfix-vr4120
-mno-fix-vr4120 -mfix-vr4130 -mno-fix-vr4130 -mfix-sb1 -mno-fix-sb1
-mflush-func=func -mno-flush-func -brranch-cost=NUM -סביר ענף
-מונו-ענף-סביר -mfp-חריגים -mno-fp-חריגים -mvr4130-align -mno-vr4130-align
-msynci -mno-synci -mrelax-pic-calls -mno-relax-pic-calls -mmcount-ra-address

MMIX אפשרויות -mlibfuncs -mno-libfuncs -מפסילון -מנו-אפסילון -מאבי=גנו
-mabi=mmixware -mzero-extend -mknuthdiv -mtoplevel-סמלים -מלף -ענף-ניבוי
-מנו-ענף-ניבוי -כתובות-base -כתובות-mno-base -יציאה-יחידה
-mno-יציאה-יחידה

MN10300 אפשרויות -מולט-באג -mno-mult-bug -mno-am33 -אמא33 -מאמ33-2 -אמא34 -mtune=מעבד-
סוג -mreturn-pointer-on-d0 -mno-crt0 -להירגע -mliw -מסתלב

PDP-11 אפשרויות -mfpu -msoft-float -mac0 -mno-ac0 -מ 40 -מ 45 -מ 10 -mbcopy
-mbcopy-builtin -מנטה32 -mno-int16 -מנטה16 -mno-int32 -mfloat32 -mno-float64
-mfloat64 -mno-float32 -מבשי -מנו-אבשי -ענף-יקר -ענף-זול
-munix-asm -mdec-asm

picoChip אפשרויות -מיי=ae_type -mvliw-lookahead=N -msymbol-as-address
-אזהרות-לא-יעילות

PowerPC אפשרויות ראה אפשרויות RS/6000 ו-PowerPC.

RL78 אפשרויות -מסים -ממול=אין -mmul=g13 -mmul=rl78

RS/6000 ו PowerPC אפשרויות -mcpu=סוג מעבד -mtune=סוג מעבד -mcmodel=מודל קוד -מכוח
-מנו-כוח -mpower2 -mno-power2 -mpowerpc -mpowerpc64 -mno-powerpc -maltivec
-mno-altivec -mpowerpc-gpopt -mno-powerpc-gpopt -mpowerpc-gfxopt -mno-powerpc-gfxopt
-mmfcrf -mno-mfcrf -mpopcntb -mno-popcntb -mpopcntd -mno-popcntd -mfprnd
-mno-fprnd -mcmpb -mno-cmpb -mmfpgpr -mno-mfpgpr -mhard-dfp -mno-hard-dfp
-mnew-mnemonics -עובש-מנמוניות -mfull-toc -מינימלי-טוק -mno-fp-in-toc
-mno-sum-in-toc -מ 64 -מ 32 -mxl-compat -mno-xl-compat -מפה -ממאיר-כוח
-ממאיר-טבעי -msoft-float -mhard-float -מרובה -mno-כפול ציפה אחת
-mdouble-float -msimple-fpu -mstring -mno-מחרוזת -עדכון -mno-עדכון
-mavoid-אינדקס-כתובות -mno-avoid-אינדקס-כתובות -מfused-madd -mno-fused-madd
-mbit-align -mno-bit-align -mstrict-align -mno-strict-align -ניתן להזזה
-mno-relocationable -mrelocatable-lib -mno-relocatable-lib -מטוק -mno-toc -מעט
-מעט-אנדיאן -מביג -mbig-endian -מדינמית-ללא-תמונה -maltivec -mswdiv
-בסיס תמונה אחת -mprioritize-restricted-insns=עדיפות
-msched-costly-dep=סוג_תלות -minsert-sched-nops=תכנית -mcall-sysv
-mcall-netbsd -maix-struct-return -msvr4-struct-return -מאבי=טיפוס אבי -msecure-plt
-mbss-plt -mblock-move-inline-limit=NUM -מיזל -mno-isel -מיזל=כן -מיזל=לא -mspe
-מנו-ספ -mspe=כן -mspe=לא -פגוע -mgen-cell-microcode -mwarn-cell-microcode
-mvrsave -mno-vrsave -ממולהוו -מנו-מולהוו -mdlmzb -mno-dlmzb -mfloat-gprs=כן
-mfloat-gprs=לא -mfloat-gprs=סינגל -mfloat-gprs=כפול -אפרוטוטייפ -mno-אב טיפוס
-מסים -ממממה -משוגעים -myellowknife -חבר -msdata -msdata=לִבחוֹר -mvxworks -G NUM
-phthread -mrecip -mrecip=לִבחוֹר -mno-recip -mrecip-דיוק -מנו-מתכונים-דיוק
-mveclibabi=סוג -מפריז -מנו-פריז -mpointers-to-nested-functions
-mno-pointers-to-nested-functions -msave-toc-עקיף -mno-save-toc-עקיף

RX אפשרויות -m64bit-כפילים -m32bit-כפילים -fpu -nofpu -mcpu= -mbig-endian-data
-mlittle-endian-data -msmall-data -מסים -מנו-סים -mas100-תחביר -mno-as100-תחביר
-להירגע -mmax-constant-size= -mint-register= -mpid -msave-acc-in-interrupts

S / 390 ו zSeries אפשרויות -mtune=סוג מעבד -מרץ=סוג מעבד -mhard-float -msoft-float
-mhard-dfp -mno-hard-dfp -מלונג-כפול-64 -מלונג-כפול-128 -mbackchain
-mno-backchain -מחסנית-מחסנית -מנו-ארוז-מחסנית -msmall-exec -mno-small-exec
-mmvcle -mno-mvcle -מ 64 -מ 31 -mdebug -mno-debug -מסה -מזרך -mtpf-trace
-mno-tpf-trace -מfused-madd -mno-fused-madd -mwarn-framesize -mwarn-dynamicstack
-mstack-size -mstack-guard

ציון אפשרויות -מב -מל -מןהולופ -מולס -ממק -mscore5 -mscore5u -mscore7 -mscore7d

SH אפשרויות -מ 1 -מ 2 -m2e -m2a-nofpu -m2a-יחיד בלבד -m2a-סינגל -m2a -מ 3 -m3e
-m4-nofpu -m4-יחיד בלבד -m4-סינגל -מ 4 -m4a-nofpu -m4a-יחיד בלבד -m4a-סינגל
-m4a -m4al -m5-64media -m5-64media-nofpu -m5-32media -m5-32media-nofpu -m5-קומפקטי
-m5-compact-nofpu -מב -מל -מדליין -להירגע - mbigtable -mfmovd -מהיטאצ'י -mrenesas
-mno-renesas -mnomacsave -מיי -מנו-איי -מביטופים -הגדלה -minline-ic_invalidate
-mpadstruct -mspace -נכון -מצב מוסר -multcost=מספר -mdiv=אסטרטגיה
-mdivsi3_libfunc=שם -mfixed-range=רישום-טווח -מתכונת-להתגלגל
-כתובת-mindexed -mgettrcost=מספר -mpt-תוקן -צבור-יוצא-ארגים
-מינvalid-סמלים -msoft-atomic -brranch-cost=NUM -mcbranchdi -מקמפקדי -מfused-madd
-mpretend-cmove

Solaris 2 אפשרויות -טקסט-מימפור -mno-טמא-טקסט -phthreads -phthread

SPARC אפשרויות -mcpu=סוג מעבד -mtune=סוג מעבד -mcmodel=מודל קוד -זיכרון-מודל=מ-
מודל -מ 32 -מ 64 -mapp-regs -mno-app-regs -mfaster-structs -mno-faster-structs
-mflat -מנו-שטוח -mfpu -mno-fpu -mhard-float -msoft-float -mhard-quad-float
-msoft-quad-float -mstack-bias -mno-stack-bias -מונaligned-כפילים
-mno-unaligned-doubles -mv8plus -mno-v8plus -mvis -mno-vis -mvis2 -mno-vis2
-mvis3 -mno-vis3 -mfmaf -mno-fmaf -mpopc -mno-popc -mfix-at697f

SPU אפשרויות -mwarn-reloc -מרור-reloc -msafe-dma -munsafe-dma -ענף-רמזים
-msmall-mem -mlarge-mem -mstdmain -mfixed-range=רישום-טווח -mea32 -mea64
-טירוף-חלל-המרה -mno-address-space-conversion -mcache-size=גודל המטמון
-מטומי-עדכונים -עדכונים-מנו-אטומיים

מערכת V אפשרויות -Qy -Qn -YP,שבילים -ימ,dir

TILE-Gx אפשרויות -mcpu=מעבד -מ 32 -מ 64

TILEPro אפשרויות -mcpu=מעבד -מ 32

V850 אפשרויות -מלונג-שיחות -שיחות ארוכות -ממפי -mno-ep -מפרופלוג-פונקציה
-mno-prolog-function -mspace -mtda=n -msda=n -mzda=n -mapp-regs -mno-app-regs
-mdisable-call -mno-disable-call -mv850e2v3 -mv850e2 -mv850e1 -mv850es -mv850e
-mv850 -מביג-מתג

VAX אפשרויות -מג -מגנו -מוניקס

VxWorks אפשרויות -mrtp -לא סטטי -בסטטיק -בדינמי -Xbind-עצלן -Xbind-עכשיו

x86-64 אפשרויות ראה אפשרויות i386 ו-x86-64.

Xstormy16 אפשרויות -מסים

Xtensa אפשרויות -mconst16 -mno-const16 -מfused-madd -mno-fused-madd -mforce-no-pic
-מסריאליזה-נדיף -mno-serialize-נדיף -mtext-section-literals
-mno-text-section-literals -mtarget-align -mno-target-align -מלונג שיחות
-מנו-לונג שיחות

zSeries אפשרויות ראה אפשרויות S/390 ו-zSeries.

קופונים דור אפשרויות
-fcall-sved-רג -fcall-used-רג -תוקן-רג חריגות - חריגים ללא שיחות
-שולחנות רוח כיף -פא-סינכרוני-פריק-שולחנות -finhibit-size-directive
-finstrument-פונקציות -finstrument-functions-exclude-function-list=SYM,SYM, ...
-finstrument-functions-exclude-file-list=פילה,פילה, ... -fno-נפוץ -fno-ident
-fpcc-struct-return -fpic -fPIC -fpie -fPIE -fno-jump-tables -frecord-gcc-מתגים
-freg-struct-return -fshort-enums -קצר-כפול -fshort-wchar -fverbose-asm
-fpack-struct[=n] -fstack-check -fstack-limit-register=רג -fstack-limit-symbol=SYM
-fno-stack-limit -fsplit-מחסנית -בורח-קו תחתון -ftls-model=מודל -ftrapv
-fwrapv -fbounds-check -נראות -פניקט-נדיפות-שדות

אפשרויות שליטה מה היא סוג of תְפוּקָה
קומפילציה יכולה לכלול עד ארבעה שלבים: עיבוד מקדים, קומפילציה נכונה, הרכבה ו
קישור, תמיד בסדר הזה. GCC מסוגל לעבד ולהרכיב כמה
קבצים למספר קבצי קלט של אסמבלר, או לקובץ קלט אסמבלר אחד; לאחר מכן
כל קובץ קלט assembler מייצר קובץ אובייקט, והקישור משלב את כל האובייקט
קבצים (אלה שהידור החדש, ואלו שצוינו כקלט) לקובץ הפעלה.

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

פילה.c
קוד מקור C שיש לעבד מראש.

פילה.i
קוד מקור C שאסור לעבד אותו מראש.

פילה.ii
קוד מקור C++ שאסור לעבד אותו מראש.

פילה.m
קוד מקור Objective-C. שים לב שאתה חייב לקשר עם libobjc ספריה לעשות
עבודת תוכנית Objective-C.

פילה.מִי
קוד מקור Objective-C שאסור לעבד אותו מראש.

פילה.mm
פילה.M
קוד מקור Objective-C++. שים לב שאתה חייב לקשר עם libobjc ספרייה לעשות
עבודה בתוכנית Objective-C++. ציין זאת .M מתייחס ל-M בבירה מילולית.

פילה.mii
קוד מקור Objective-C++ שאסור לעבד אותו מראש.

פילה.h
קובץ כותרת C, C++, Objective-C או Objective-C++ שיהפוך לקומפילציה מראש
header (ברירת מחדל), או קובץ כותרת C, C++ שיהפוך למפרט של Ada (דרך
-fdump-ada-spec החלף).

פילה. DC
פילה.cp
פילה.cxx
פילה.cpp
פילה.CPP
פילה‎.c++
פילה.C
קוד מקור C++ שיש לעבד אותו מראש. שימו לב שב .cxx, שתי האותיות האחרונות
שניהם חייבים להיות תרתי משמע x. כך גם .C הכוונה ל-C בירה מילולית.

פילה.mm
פילה.M
קוד מקור Objective-C++ שיש לעבד אותו מראש.

פילה.mii
קוד מקור Objective-C++ שאסור לעבד אותו מראש.

פילה.הה
פילה.H
פילה.hp
פילה.hxx
פילה.hpp
פילה.HPP
פילה.h++
פילה.tcc
קובץ כותרת C++ שיהפוך לכותרת הידור מראש או מפרט Ada.

פילה.f
פילה.ל
פילה.ftn
קוד מקור Fortran בצורה קבועה שאין לעבד אותו מראש.

פילה.F
פילה.ל
פילה.fpp
פילה.FPP
פילה.FTN
קוד מקור Fortran בצורה קבועה שיש לעבד מראש (עם המסורתי
מעבד קדם).

פילה.f90
פילה.f95
פילה.f03
פילה.f08
קוד מקור Fortran בצורה חופשית שאין לעבד אותו מראש.

פילה.XXXXX
פילה.XXXXX
פילה.XXXXX
פילה.XXXXX
קוד מקור Fortran בצורה חופשית שיש לעבד מראש (עם המסורתי
מעבד קדם).

פילה.ללכת
לך לקוד מקור.

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

פילה.adb
קובץ קוד מקור Ada המכיל גוף יחידת ספרייה (תת-תוכנית או גוף חבילה).
קבצים כאלה נקראים גם גופים.

פילה.s
קוד אסמבלר.

פילה.S
פילה.sx
קוד אסמבלר שיש לעבד מראש.

אַחֵר
קובץ אובייקטים להזנה ישר לקישור. כל שם קובץ ללא זיהוי
סיומת מטופלת כך.

אתה יכול לציין את שפת הקלט במפורש באמצעות ה -x אפשרות:

-x שפה
ציין במפורש את שפה עבור קבצי הקלט הבאים (במקום לאפשר את
מהדר בחר ברירת מחדל המבוססת על סיומת שם הקובץ). אפשרות זו חלה על כולם
קבצי הקלט הבאים עד הבא -x אוֹפְּצִיָה. ערכים אפשריים עבור שפה הם:

c c-header cpp-output
c++ c++-header c++-cpp-output
Objective-c Objective-C-header Objective-c-cpp-output
objective-c++ objective-c++-header objective-c++-cpp-output
assembler assembler-with-cpp
עדה
f77 f77-cpp-input f95 f95-cpp-input
go
תאווה

-x אף לא אחד
כבה כל מפרט של שפה, כך שהקבצים הבאים יטופלו
לפי סיומות שם הקובץ שלהם (כמו שהם אם -x לא היה בשימוש כלל).

-מעבר-יציאה-קודים
בדרך כלל gcc התוכנית תצא עם הקוד של 1 אם שלב כלשהו של המהדר
מחזירה קוד החזרה שלא הצליח. אם תפרט -מעבר-יציאה-קודים, ה gcc התוכנית
במקום זאת יחזור עם השגיאה הגבוהה ביותר מבחינה מספרית שנוצרה על ידי כל שלב שחזר
חיווי שגיאה. החזיתות C, C++ ו-Fortran מחזירות 4, אם הן פנימיות
נתקלת בשגיאת מהדר.

אם אתה רוצה רק חלק משלבי ההידור, אתה יכול להשתמש -x (או סיומות של שם קובץ)
לספר gcc איפה להתחיל, ואחת האפשרויות -c, -S, או -E להגיד איפה gcc הוא
תפסיק. שים לב שכמה שילובים (לדוגמה, -x פלט cpp -E) להורות gcc לעשות
שום דבר.

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

כברירת מחדל, שם קובץ האובייקט עבור קובץ מקור נעשה על ידי החלפת הסיומת .c,
.i, .sוכו', עם .o.

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

-S עצור לאחר שלב ההידור עצמו; לא להרכיב. הפלט נמצא ב-
צורה של קובץ קוד אסמבלר עבור כל קובץ קלט שאינו אסמבלר שצוין.

כברירת מחדל, שם קובץ האסמבלר עבור קובץ מקור נעשה על ידי החלפת הסיומת
.c, .iוכו', עם .s.

מתעלמים מקבצי קלט שאינם דורשים קומפילציה.

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

מתעלמים מקבצי קלט שאינם דורשים עיבוד מקדים.

-o פילה
שים פלט בקובץ פילה. זה חל ללא קשר לכל סוג פלט שהוא
מופק, בין אם זה קובץ הפעלה, קובץ אובייקט, קובץ assembler או
קוד C מעובד מראש.

If -o לא צוין, ברירת המחדל היא הכנסת קובץ הפעלה א.אאוט, האובייקט
עבור source.suffix in source.o, קובץ האסמבלר שלו ב מקור.ש, קומפילציה מראש
קובץ כותרת ב source.suffix.gch, וכל מקור C המעובד מראש בפלט סטנדרטי.

-v הדפס (על פלט שגיאה סטנדרטי) את הפקודות שבוצעו כדי להפעיל את השלבים של
הַהדָרָה. הדפס גם את מספר הגרסה של תוכנית מנהל ההתקן של המהדר ושל ה
מעבד קדם והקומפיילר נכון.

-###
כמו -v אלא שהפקודות אינן מבוצעות והארגומנטים מצוטט אלא אם כן
מכיל רק תווים אלפאנומריים או "./-_". זה שימושי עבור סקריפטים של מעטפת
ללכוד את שורות הפקודה שנוצרו על ידי מנהל ההתקן.

-צינור
השתמש בצינורות ולא בקבצים זמניים לתקשורת בין השלבים השונים של
הַהדָרָה. זה לא מצליח לעבוד במערכות מסוימות שבהן ה-assembler אינו מסוגל לקרוא
מצינור; אבל ל-GNU assembler אין בעיה.

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

--מטרה-עזרה
הדפס (על הפלט הסטנדרטי) תיאור של אפשרויות שורת פקודה ספציפיות ליעד
עבור כל כלי. עבור יעדים מסוימים עשוי להיות גם מידע ספציפי ליעד
מודפס.

--עזרה={בכיתה|[^]להעפיל}[, ...]
הדפס (על הפלט הסטנדרטי) תיאור של אפשרויות שורת הפקודה המובנות על ידי
המהדר שמתאים לכל המחלקות והמוקדמות שצוינו. אלו הם ה
שיעורים נתמכים:

אופטימיזציה
זה יציג את כל אפשרויות האופטימיזציה הנתמכות על ידי המהדר.

אזהרות
זה יציג את כל האפשרויות השולטות בהודעות האזהרה שהופקו על ידי
מהדר.

יעד
זה יציג אפשרויות ספציפיות ליעד. לא כמו ה --מטרה-עזרה אוֹפְּצִיָה
עם זאת, אפשרויות ספציפיות למטרה של המקשר וההרכבה לא יהיו
מוצגת. הסיבה לכך היא שכלים אלה אינם תומכים כעת במורחב
--עזרה= תחביר.

params
זה יציג את הערכים המוכרים על ידי --param אוֹפְּצִיָה.

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

משותף
זה יציג את האפשרויות המשותפות לכל השפות.

אלו הם המוקדמות הנתמכות:

לא מתועד
הצג רק את האפשרויות שאינן מתועדות.

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

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

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

--help=מטרה,לא מתועד

ניתן להפוך את התחושה של מוקדמות על ידי הקדמתו ל- ^ אופי, אז בשביל
דוגמה כדי להציג את כל אפשרויות האזהרה הבינארית (כלומר, אלו המופעלות או כבויות
ושלא לוקחים טיעון) שיש להם תיאור, השתמשו ב:

--help=אזהרות,^הצטרף,^לא מתועד

הוויכוח ל --עזרה= לא צריך להיות מורכב אך ורק ממוקדמות הפוכות.

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

--help=מטרה,מיטוביזרים

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

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

הנה דוגמה קטומה מיציאת ARM של gcc:

% gcc -Q -mabi=2 --help=target -c
האפשרויות הבאות הן ספציפיות ליעד:
-מאבי= 2
-mabort-on-noreturn [מושבת]
-mapcs [מושבת]

הפלט רגיש להשפעות של אפשרויות קו פקודה קודמות, כך עבור
לדוגמה אפשר לברר באילו אופטימיזציות מופעלות -O2 על ידי שימוש ב:

-Q -O2 --help=אופטימיזרים

לחלופין, תוכל לגלות על ידי אילו אופטימיזציות בינאריות מופעלות -O3 על ידי שימוש ב:

gcc -c -Q -O3 --help=מיטביזרים > /tmp/O3-opts
gcc -c -Q -O2 --help=מיטביזרים > /tmp/O2-opts
diff /tmp/O2-opts /tmp/O3-opts | grep מופעל

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

--גִרְסָה
הצג את מספר הגרסה וזכויות היוצרים של ה-GCC שהופעל.

-עֲטִיפָה
הפעל את כל פקודות המשנה תחת תוכנית עטיפה. שם תוכנית העטיפה ו
הפרמטרים שלו מועברים כרשימה מופרדת בפסיקים.

gcc -c tc -עטיפה gdb,--args

זה יפעיל את כל תוכניות המשנה של gcc תחת gdb --ארגס, ובכך הקריאה של cc1
יהיה gdb --ארגס cc1 ....

-fplugin=שם.לכן
טען את קוד הפלאגין בקובץ שם.לכן, ההנחה היא שזהו אובייקט משותף שיש לבצע עליו
המהדר. שם הבסיס של קובץ האובייקט המשותף משמש לזיהוי התוסף
למטרות ניתוח ארגומנטים (ראה -fplugin-arg-שם-מפתח=ערך לְהַלָן). כל אחד
הפלאגין אמור להגדיר את פונקציות ה-callback המצוינות ב-Plugins API.

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

-fdump-ada-spec[-רָזֶה]
עבור מקור C ו-C++ וקבצים כוללים, צור מפרט Ada תואם.

-fdump-go-spec=פילה
עבור קבצי קלט בכל שפה, צור הצהרות Go מתאימות ב פילה. זֶה
מייצר הצהרות Go "const", "type", "var" ו-"func", שעשויות להיות דרך שימושית
להתחיל לכתוב ממשק Go לקוד שנכתב בשפה אחרת.

@פילה
קרא את אפשרויות שורת הפקודה מ פילה. האפשרויות שנקראו מוכנסות במקום
מקורי @פילה אוֹפְּצִיָה. אם פילה לא קיים, או לא ניתן לקרוא, אז האפשרות
יטופל פשוטו כמשמעו, ולא יוסר.

אפשרויות ב פילה מופרדים על ידי רווח לבן. תו רווח עשוי להיכלל
באופציה על ידי הקיפת כל האופציה במרכאות בודדות או כפולות. כל
תו (כולל קו נטוי אחורי) עשוי להיכלל על ידי הקדמת התו להיות
כלול עם קו נטוי אחורי. ה פילה עשוי בעצמו להכיל @ נוסףפילה אפשרויות; כל
אפשרויות כאלה יעובדו באופן רקורסיבי.

קומפילציה C + + תוכניות
קובצי מקור C++ משתמשים בדרך כלל באחת מהסיומות .C, . DC, .cpp, .CPP, ‎.c++, .cp, או
.cxx; קבצי כותרות C++ משתמשים לעתים קרובות .הה, .hpp, .H, או (עבור קוד תבנית משותף) .tcc, ו
קבצי C++ מעובדים מראש משתמשים בסיומת .ii. GCC מזהה קבצים עם שמות אלה ו
מרכיב אותם כתוכניות C++ גם אם אתה קורא למהדר באותו אופן כמו לקומפילציה
תוכניות C (בדרך כלל עם השם gcc).

עם זאת, השימוש ב gcc אינו מוסיף את ספריית C++. g ++ היא תוכנית שקוראת ל-GCC ו
מטפלת .c, .h ו .i קבצים כקבצי מקור C++ במקום קבצי מקור C אלא אם כן -x is
בשימוש, ומציין אוטומטית קישור מול ספריית C++. גם תוכנית זו
שימושי בעת קומפילציה מראש של קובץ כותרת C עם a .h הרחבה לשימוש בקופילציות C++.
במערכות רבות, g ++ מותקן גם עם השם c ++.

כאשר אתה קומפילציה של תוכניות C++, אתה יכול לציין הרבה מאותן אפשרויות שורת פקודה
אתה משתמש להידור תוכניות בכל שפה; או אפשרויות שורת פקודה בעלות משמעות עבור C
ושפות קשורות; או אפשרויות בעלות משמעות רק עבור תוכניות C++.

אפשרויות שליטה C ניב
האפשרויות הבאות שולטות בניב של C (או שפות הנגזרות מ-C, כגון C++,
Objective-C ו-Objective-C++) שהמהדר מקבל:

-אנסי
במצב C, זה שווה ערך ל -std=c90. במצב C++, זה שווה ערך ל
98. std = c ++.

זה מכבה תכונות מסוימות של GCC שאינן תואמות ל-ISO C90 (מתי
קומפילציה של קוד C), או של C++ סטנדרטי (בעת קומפילציה של קוד C++), כגון "asm" ו
"typeof" מילות מפתח, ופקודות מאקרו מוגדרות מראש כגון "unix" ו-"vax" המזהות את
סוג המערכת שבה אתה משתמש. זה גם מאפשר את ה-ISO הלא רצוי ולעתים רחוקות בשימוש
תכונת טריגרף. עבור מהדר C, הוא משבית את הזיהוי של סגנון C++ //
הערות וכן מילת המפתח "מוטבעת".

מילות המפתח החלופיות "__asm__", "__extension__", "__inline__" ו-"__typeof__"
להמשיך לעבוד למרות -אנסי. לא תרצה להשתמש בהם בתוכנית ISO C,
כמובן, אבל כדאי לשים אותם בקובצי כותרת שעשויים להיכלל בהם
קומפילציות שנעשו עם -אנסי. פקודות מאקרו מוגדרות מראש לחלופיות כגון "__unix__" ו
"__vax__" זמינים גם, עם או בלי -אנסי.

אל האני -אנסי האפשרות אינה גורמת לדחייה של תוכניות שאינן ISO ללא תשלום. ל
כי, -קַפְּדָנִי נדרש בנוסף ל -אנסי.

המאקרו "__STRICT_ANSI__" מוגדר מראש כאשר -אנסי נעשה שימוש באופציה. איזה כותרת
קבצים עשויים להבחין במאקרו זה ולהימנע מלהצהיר על פונקציות מסוימות או להגדיר
פקודות מאקרו מסוימות שתקן ISO אינו דורש; זאת כדי למנוע התערבות
עם כל תוכנה שעשויה להשתמש בשמות האלה לדברים אחרים.

פונקציות שבדרך כלל יהיו מובנות אך אין להן סמנטיקה המוגדרת על ידי ISO C
(כגון "alloca" ו-"ffs") אינן פונקציות מובנות כאשר -אנסי משמש.

-std=
קבע את תקן השפה. אפשרות זו נתמכת כרגע רק כאשר
קומפילציה של C או C++.

המהדר יכול לקבל מספר תקני בסיס, כגון c90 or 98 +, ודיאלקטים של גנו
של אותם סטנדרטים, כגון gnu90 or gnu++98. על ידי ציון תקן בסיס, ה
המהדר יקבל את כל התוכניות העוקבות אחר תקן זה ואלו המשתמשות ב-GNU
הרחבות שאינן סותרות זאת. לדוגמה, -std=c90 מכבה ודאי
תכונות של GCC שאינן תואמות ל-ISO C90, כגון "asm" ו-"typeof"
מילות מפתח, אך לא הרחבות אחרות של GNU שאין להן משמעות ב-ISO C90, כגון
השמטת המונח האמצעי של ביטוי "?:". מצד שני, על ידי ציון GNU
ניב סטנדרטי, כל התכונות בהן תומכות המהדר מופעלות, גם כאשר אלו
תכונות משנות את המשמעות של תקן הבסיס וכמה תוכניות התואמות קפדנית
עשוי להידחות. התקן המסוים משמש על ידי -קַפְּדָנִי לזהות איזה
תכונות הן הרחבות של GNU בהתחשב בגרסה זו של התקן. לדוגמה -std=gnu90
-קַפְּדָנִי מזהיר לגבי סגנון C++ // הערות, תוך כדי -std=gnu99 -קַפְּדָנִי היה
לֹא.

יש לספק ערך עבור אפשרות זו; ערכים אפשריים הם

c90
c89
iso9899:1990
תמכו בכל תוכניות ISO C90 (הרחבות מסוימות של GNU שמתנגשות עם ISO C90
מושבתים). כמו -אנסי עבור קוד C.

iso9899:199409
ISO C90 כפי ששונה בתיקון 1.

c99
c9x
iso9899:1999
iso9899:199x
ISO C99. שימו לב שתקן זה עדיין אינו נתמך במלואו; לִרְאוֹת
<http://gcc.gnu.org/gcc-4.7/c99status.html> למידע נוסף. השמות c9x
ו iso9899:199x מיושנים.

c11
c1x
iso9899:2011
ISO C11, עדכון 2011 של תקן ISO C. התמיכה אינה שלמה ו
נִסיוֹנִי. השם c1x הוצא משימוש.

gnu90
gnu89
ניב GNU של ISO C90 (כולל כמה תכונות של C99). זוהי ברירת המחדל עבור C
קוד.

gnu99
gnu9x
ניב GNU של ISO C99. כאשר ISO C99 מיושם במלואו ב-GCC, זה יקרה
להפוך לברירת המחדל. השם gnu9x הוצא משימוש.

gnu11
gnu1x
ניב GNU של ISO C11. התמיכה אינה שלמה וניסיונית. השם gnu1x
הוצא משימוש.

98 +
תקן ISO C++ משנת 1998 בתוספת תיקונים. כמו -אנסי עבור קוד C++.

gnu++98
ניב גנו של 98. std = c ++. זוהי ברירת המחדל עבור קוד C++.

11 +
תקן ISO C++ לשנת 2011 בתוספת תיקונים. התמיכה ב-C++11 עדיין
ניסיוני, ועשויים להשתנות בדרכים לא תואמות במהדורות עתידיות.

gnu++11
ניב גנו של 11. std = c ++. התמיכה ב-C++11 עדיין ניסיונית ועשויה להשתנות
בדרכים לא תואמות במהדורות עתידיות.

-fgnu89-inline
האפשרות -fgnu89-inline אומר ל-GCC להשתמש בסמנטיקה המסורתית של GNU עבור "inline"
מתפקד במצב C99.
אפשרות זו מקובלת ומתעלמת מגירסאות GCC 4.1.3 עד אך לא כולל
4.3. בגרסאות GCC 4.3 ואילך זה משנה את ההתנהגות של GCC במצב C99. באמצעות
אפשרות זו שווה בערך להוספת תכונת הפונקציה "gnu_inline" לכל
פונקציות מוטבעות.

האפשרות -fno-gnu89-inline אומר במפורש ל-GCC להשתמש בסמנטיקה של C99 עבור
"inline" במצב C99 או gnu99 (כלומר, הוא מציין את התנהגות ברירת המחדל). זֶה
האפשרות נתמכה לראשונה ב-GCC 4.3. אפשרות זו אינה נתמכת ב -std=c90 or
-std=gnu90 מצב.

ניתן להשתמש בפקודות המאקרו הקדם-מעבד "__GNUC_GNU_INLINE__" ו-"__GNUC_STDC_INLINE__"
כדי לבדוק איזו סמנטיקה פועלת עבור פונקציות "מוטבעות".

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

מלבד הצהרות, הקובץ מציין בהערות את מקורה של כל הצהרה
(קובץ מקור ושורה), אם ההצהרה הייתה מרומזת, אב טיפוס או
ללא אב טיפוס (I, N לחדש או O לישן, בהתאמה, בדמות הראשונה שאחרי
מספר השורה והנקודתיים), והאם זה בא מהצהרה או הגדרה
(C or F, בהתאמה, בדמות הבאה). במקרה של פונקציה
הגדרות, רשימה בסגנון K&R של טיעונים ואחריה ההצהרות שלהם
מסופקים, הערות פנימיות, לאחר ההצהרה.

-פונקציות-פרמטר-חסר-פרמטר-variadic
קבל פונקציות וריאדיות ללא פרמטרים בעלי שם.

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

-fno-asm
אל תזהה את "asm", "inline" או "typeof" כמילת מפתח, כך שהקוד יוכל להשתמש באלה
מילים כמזהים. אתה יכול להשתמש במילות המפתח "__asm__", "__inline__" ו
"__typeof__" במקום זאת. -אנסי מרמז -fno-asm.

ב-C++, מתג זה משפיע רק על מילת המפתח "סוג של", שכן "asm" ו-"inline" הם
מילות מפתח סטנדרטיות. אולי תרצה להשתמש ב- -fno-gnu-מילות מפתח דגל במקום, אשר יש
אותו אפקט. במצב C99 (-std=c99 or -std=gnu99), מתג זה משפיע רק על
מילות מפתח "asm" ו-"typeof", שכן "inline" היא מילת מפתח סטנדרטית ב-ISO C99.

-fno-builtin
-fno-builtin-פונקציה
אל תזהה פונקציות מובנות שאינן מתחילות בהן __בנוי_ בתור תחילית.

GCC בדרך כלל יוצר קוד מיוחד כדי לטפל בפונקציות מובנות מסוימות יותר
ביעילות; למשל, קריאות ל"alloca" עשויות להפוך להוראות בודדות אשר
התאם את המחסנית ישירות, וקריאות ל"memcpy" עלולות להפוך ללולאות העתקה מוטבעות. ה
הקוד המתקבל הוא לרוב גם קטן יותר ומהיר יותר, אך מכיוון שהפונקציה קוראת לא
זמן רב יותר להופיע ככזה, אינך יכול להגדיר נקודת עצירה בשיחות אלה, וגם לא תוכל לשנות
התנהגות הפונקציות על ידי קישור לספרייה אחרת. בנוסף, מתי
פונקציה מזוהה כפונקציה מובנית, GCC עשויה להשתמש במידע על כך
פונקציה כדי להתריע על בעיות בקריאות לפונקציה זו, או ליצור עוד
קוד יעיל, גם אם הקוד המתקבל עדיין מכיל קריאות לפונקציה הזו. ל
לדוגמה, אזהרות ניתנות עם - עבור קריאות גרועות ל-"printf", כאשר "printf" הוא
מובנה, ו"strlen" כידוע אינו משנה זיכרון גלובלי.

עם -fno-builtin-פונקציה אפשרות רק את הפונקציה המובנית פונקציה מושבת.
פונקציה אסור להתחיל עם __בנוי_. אם יש שם פונקציה שאינה מובנית
בגרסה זו של GCC, אפשרות זו מתעלמת. אין מקביל
-בנוי-פונקציה אוֹפְּצִיָה; אם ברצונך להפעיל פונקציות מובנות באופן סלקטיבי מתי
באמצעות -fno-builtin or -עומד בפני עצמו, תוכל להגדיר פקודות מאקרו כגון:

#define abs(n) __builtin_abs ((n))
#הגדר strcpy (d, s) __ builtin_strcpy ((d), (s))

-אירוח
טען שהקומפילציה מתרחשת בסביבה מתארחת. זה מרמז -בנוי.
סביבה מתארחת היא כזו שבה כל הספרייה הסטנדרטית זמינה, ובתוכה
אשר ל"ראשי" יש סוג החזרה של "int". דוגמאות הן כמעט הכל מלבד א
גַרעִין. זה שווה ערך ל -fno עצמאי.

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

-fopenmp
אפשר טיפול בהנחיות OpenMP "#pragma omp" ב-C/C++ ו-"!$omp" ב-Fortran.
מתי -fopenmp מצויין, המהדר מייצר קוד מקביל בהתאם ל-
ממשק תוכניות יישום OpenMP v3.0http://www.openmp.org/>. אפשרות זו
מרמז -phthread, ולכן הוא נתמך רק על יעדים שיש להם תמיכה עבור
-phthread.

-fgnu-tm
כאשר האפשרות -fgnu-tm צוין, המהדר יפיק קוד עבור לינוקס
גרסה של מסמך מפרט ה-ABI הנוכחי של זיכרון עסקה של אינטל (עדכון
1.1, 6 במאי 2009). זוהי תכונה ניסיונית שהממשק שלה עשוי להשתנות
גרסאות עתידיות של GCC, כאשר המפרט הרשמי משתנה. שימו לב שלא
כל הארכיטקטורות נתמכות עבור תכונה זו.

למידע נוסף על התמיכה של GCC בזיכרון עסקה,

שים לב שתכונת זיכרון העסקאות אינה נתמכת עם חריגים ללא שיחות
(- חריגים ללא שיחות).

-fms-הרחבות
קבל כמה מבנים לא סטנדרטיים המשמשים בקבצי כותרות של Microsoft.

בקוד C++, זה מאפשר לשמות חברים במבנים להיות דומים לסוגים קודמים
הצהרות.

typedef int UOW;
struct ABC {
UOW UOW;
};

חלק מהמקרים של שדות ללא שם במבנים ואיגודים מתקבלים רק עם זה
אוֹפְּצִיָה.

-fplan9-הרחבות
קבל כמה מבנים לא סטנדרטיים המשמשים בקוד תוכנית 9.

זה מאפשר -fms-הרחבות, מאפשר העברת מצביעים למבנים עם אנונימי
שדות לפונקציות שמצפות מצביעים לאלמנטים מסוג השדה, ו
מתיר התייחסות לשדות אנונימיים שהוכרזו באמצעות typedef. זה רק
נתמך עבור C, לא C++.

-טריגרפים
תמיכה בטריגרפים ISO C. ה -אנסי אפשרות (וגם -סטד אפשרויות עבור ISO C קפדני
התאמה) מרמזת -טריגרפים.

-no-integrated-cpp
מבצע קומפילציה בשני מעברים: עיבוד מקדים והידור. אפשרות זו מאפשרת
משתמש סיפק "cc1", "cc1plus" או "cc1obj" דרך ה -B אוֹפְּצִיָה. המשתמש סיפק
לאחר מכן, שלב הקומפילציה יכול להוסיף שלב עיבוד מקדים נוסף לאחר הרגיל
עיבוד מקדים אך לפני הקומפילציה. ברירת המחדל היא להשתמש ב-cpp המשולב
(cpp פנימי)

הסמנטיקה של אפשרות זו תשתנה אם "cc1", "cc1plus" ו-"cc1obj" ימוזגו.

-מָסוֹרתִי
-מסורתי-cpp
בעבר, אפשרויות אלו גרמו ל-GCC לנסות לחקות מהדר C מראש סטנדרטי.
כעת הם נתמכים רק עם -E החלף. המעבד המקדים ממשיך לתמוך
מצב טרום סטנדרטי. עיין במדריך של GNU CPP לפרטים.

-fcond-חוסר התאמה
אפשר ביטויים מותנים עם טיפוסים לא תואמים בארגומנט השני והשלישי.
ערכו של ביטוי כזה בטל. אפשרות זו אינה נתמכת עבור C++.

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

-מחומן-char
תן לסוג "char" להיות לא חתום, כמו "char unsigned".

לכל סוג של מכונה יש ברירת מחדל למה "char" צריך להיות. זה או כמו
"char unsigned" כברירת מחדל או כמו "char unsigned" כברירת מחדל.

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

הסוג "char" הוא תמיד סוג נבדל מכל "char חתום" או "לא חתום".
char", למרות שהתנהגותו תמיד דומה לאחד מהשניים הללו.

-fsigned-char
תן לסוג "char" להיות חתום, כמו "חתום char".

שים לב שזה שווה ל -fno-unsigned-char, שהיא הצורה השלילית של
-מחומן-char. כמו כן, האופציה -fno-חתום-char שווה
-מחומן-char.

-fsigned-bitfields
-שדות סיביות עם סימני כיף
-fno-signed-bitfields
-fno-unsigned-bitfields
אפשרויות אלה קובעות אם שדה סיביות חתום או לא חתום, כאשר ההצהרה
אינו משתמש ב"חתום" או ב"לא חתום". כברירת מחדל, שדה סיביות כזה חתום,
כי זה עקבי: סוגי המספרים השלמים הבסיסיים כגון "int" הם טיפוסים עם סימנים.

אפשרויות שליטה C + + ניב
סעיף זה מתאר את אפשרויות שורת הפקודה בעלות משמעות רק עבור תוכניות C++;
אבל אתה יכול גם להשתמש ברוב אפשרויות המהדר של GNU ללא קשר לשפה שלך
התוכנית נמצאת. לדוגמה, אתה יכול להרכיב קובץ "firstClass.C" כך:

g++ -g -frepo -O -c firstClass.C

בדוגמה זו, בלבד -פרפו היא אפשרות המיועדת רק לתוכניות C++; אתה יכול להשתמש ב
אפשרויות אחרות בכל שפה הנתמכת על ידי GCC.

הנה רשימה של אפשרויות שכן רק להידור תוכניות C++:

-fabi-version=n
השתמש בגרסה n של C++ ABI. גרסה 2 היא הגרסה של ה-C++ ABI הראשונה
הופיע ב-G++ 3.4. גרסה 1 היא הגרסה של C++ ABI שהופיעה לראשונה ב
G++ 3.2. גרסה 0 תמיד תהיה הגרסה המתאימה ביותר ל-C++
מפרט ABI. לכן, ה-ABI שהושג באמצעות גרסה 0 ישתנה כ-ABI
באגים מתוקנים.

ברירת המחדל היא גרסה 2.

גרסה 3 מתקנת שגיאה בשינוי כתובת קבועה כארגומנט תבנית.

גרסה 4, שהופיעה לראשונה ב-G++ 4.5, מיישמת מננגל סטנדרטי עבור וקטור
סוגים.

גרסה 5, שהופיעה לראשונה ב-G++ 4.6, מתקנת את הפגיעה בתכונה
const/volatile על סוגי מצביע פונקציה, decltype של decl רגיל ושימוש ב-a
פרמטר פונקציה בהצהרה על פרמטר אחר.

גרסה 6, שהופיעה לראשונה ב-G++ 4.7, מתקנת את התנהגות הקידום של C++11
תקצירים בטווחים והשחתה של ערכות ארגומנטים של תבנית, const/static_cast, prefix ++
ו--, ופונקציית היקף מחלקה המשמשת כארגומנט תבנית.

ראה גם -וואבי.

-fno-בקרת גישה
כבה את כל בדיקת הגישה. מתג זה שימושי בעיקר לעקוף באגים ב
קוד בקרת הגישה.

-fcheck-חדש
בדוק שהמצביע שהוחזר על ידי "מפעיל חדש" אינו ריק לפני שתנסה לעשות זאת
לשנות את האחסון שהוקצה. בדיקה זו מיותרת בדרך כלל מכיוון שה-C++
התקן מציין ש"מפעיל חדש" יחזיר 0 רק אם הוא יוכרז לזרוק(),
במקרה זה המהדר תמיד יבדוק את ערך ההחזרה גם בלי זה
אוֹפְּצִיָה. בכל שאר המקרים, כאשר ל"מפעיל חדש" יש חריג לא ריק
מפרט, מיצוי הזיכרון מסומן על ידי זריקת "std::bad_alloc". ראה גם
חדש (נוטרור).

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

אפשרות זו אינה שימושית יותר ברוב היעדים, כעת לאחר שנוספה תמיכה עבור
הכנסת משתנים ל-BSS מבלי להפוך אותם למשותפים.

-fconstexpr-depth=n
הגדר את עומק ההערכה המקונן המרבי עבור פונקציות C++11 constexpr ל n. גבול
נחוץ כדי לזהות רקורסיה אינסופית במהלך הערכת ביטוי מתמדת. ה
המינימום שצוין בתקן הוא 512.

-fdeduce-init-list
אפשר ניכוי של פרמטר מסוג תבנית כ-std::initializer_list מ-
רשימת האתחול המצורפת, כלומר

תבנית אוטומטי קדימה (T t) -> decltype (realfn (t))
{
return realfn (t);
}

void f()
{
קדימה({1,2}); // העבר שיחה >
}

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

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

אפשרות זו מיועדת לתאימות, וייתכן שהיא תוסר במהדורה עתידית של G++.

-fno-elide-constructors
תקן C++ מאפשר למימוש להשמיט יצירת זמני שהוא בלבד
משמש לאתחול אובייקט אחר מאותו סוג. ציון אפשרות זו משבית
אופטימיזציה זו, ומאלץ את G++ לקרוא לבנאי ההעתקה בכל המקרים.

-fno-enforce-eh-specs
אל תיצור קוד כדי לבדוק אם יש הפרה של מפרטי חריגים בזמן הריצה.
אפשרות זו מפרה את תקן C++, אך עשויה להיות שימושית להקטנת גודל הקוד ב
ייצור בונה, ממש כמו הגדרה NDEBUG. זה לא נותן הרשאת קוד משתמש
לזרוק חריגים בניגוד למפרט החריג; המהדר יעשה זאת
עדיין לבצע אופטימיזציה בהתבסס על המפרטים, כך לזרוק חריג בלתי צפוי יעשה זאת
לגרום להתנהגות לא מוגדרת.

-ffor-scope
-fno-for-scope
If -ffor-scope מצוין, היקף המשתנים המוצהרים ב-a עבור-init-statement
מוגבל ל ל לולאה עצמה, כפי שצוין בתקן C++. אם
-fno-for-scope מצוין, היקף המשתנים המוצהרים ב-a עבור-init-statement
משתרע עד לקצה הטווח המקיף, כפי שהיה במקרה בגרסאות ישנות של G++, ו
יישומים אחרים (מסורתיים) של C++.

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

-fno-gnu-מילות מפתח
אל תזהה את "typeof" כמילת מפתח, כך שהקוד יוכל להשתמש במילה זו כמילת מפתח
מזהה. אתה יכול להשתמש במילת המפתח "__typeof__" במקום זאת. -אנסי מרמז
-fno-gnu-מילות מפתח.

-fno-implicit-templates
לעולם אל תפלוט קוד עבור תבניות שאינן מוטבעות המופעלות באופן מרומז (כלומר על ידי
להשתמש); פולט קוד רק עבור מופעים מפורשים.

-fno-implicit-inline-templates
אל תפלוט קוד גם עבור מופעים מרומזים של תבניות מוטבעות. ברירת המחדל
הוא לטפל ב-inlines בצורה שונה כך שקומפילציה עם ובלי אופטימיזציה תהיה
צריך את אותה קבוצה של מופעים מפורשים.

-fno-implement-inlines
כדי לחסוך מקום, אל תפלוט עותקים מחוץ לקו של פונקציות מוטבעות הנשלטות על ידי
#פרגמה הפעלה. זה יגרום לשגיאות מקשר אם הפונקציות האלה לא
מוטבע בכל מקום שהם נקראים.

-fms-הרחבות
השבת אזהרות פדנטיות לגבי מבנים המשמשים ב-MFC, כגון int and
קבלת מצביע לפונקציית חבר באמצעות תחביר לא סטנדרטי.

-fno-nonansi-builtins
השבת הצהרות מובנות של פונקציות שאינן מחייבות ANSI/ISO C. אלה
כלול "ffs", "alloca", "_exit", "index", "bzero", "conjf" ועוד קשורים אחרים
פונקציות.

-fnothrow-opt
התייחס למפרט חריג "throw()" כאילו היה מפרט "noexcept".
כדי להקטין או לבטל את התקורה של גודל הטקסט ביחס לפונקציה ללא יוצא מן הכלל
מִפרָט. אם לפונקציה יש משתנים מקומיים מסוגים עם לא טריוויאלי
משמידים, מפרט החריג למעשה יקטין את הפונקציה
מכיוון שניתן לבצע אופטימיזציה של ניקוי ה-EH עבור משתנים אלה. הסמנטי
ההשפעה היא שחריג נזרק מפונקציה עם חריג כזה
המפרט יביא לקריאה "להפסיק" ולא ל"בלתי צפוי".

-fno-שמות מפעילים
אל תתייחס למילות המפתח של שם המפעיל "and", "bitand", "bitor", "compl", "לא", "או"
ו-"xor" כמילים נרדפות כמילות מפתח.

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

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

-fno-pretty-templates
כאשר הודעת שגיאה מתייחסת להתמחות של תבנית פונקציה, המהדר
בדרך כלל ידפיס את החתימה של התבנית ואחריה ארגומנטים של התבנית
וכל ה-typedefs או שמות הטיפוס בחתימה (למשל "void f(T) [עם T = int]" במקום זאת
מאשר "void f(int)") כדי שיהיה ברור באיזו תבנית מדובר. כאשר טעות
ההודעה מתייחסת להתמחות של תבנית מחלקה, המהדר ישמיט כל אחת
ארגומנטים של תבנית התואמים לארגומנטים של תבנית ברירת המחדל עבור אותה תבנית. אם
כל אחת מההתנהגויות הללו מקשה על הבנת הודעת השגיאה במקום
קל יותר, משתמש -fno-pretty-templates ישבית אותם.

-פרפו
אפשר מופע אוטומטי של תבנית בזמן הקישור. גם אפשרות זו מרמזת
-fno-implicit-templates.

-fno-rtti
השבת יצירת מידע על כל מחלקה עם פונקציות וירטואליות לשימוש על ידי
תכונות זיהוי סוג זמן הריצה C++ (- ו טיפוסי). אם לא
השתמש בחלקים אלה של השפה, אתה יכול לחסוך קצת מקום על ידי שימוש בדגל זה. הערה
הטיפול בחריגים משתמש באותו מידע, אך הוא יפיק אותו לפי הצורך.
אל האני - עדיין ניתן להשתמש באופרטור לקאסטים שאינם דורשים זמן ריצה
סוג מידע, כלומר השלכה ל-"void *" או למחלקות בסיס חד-משמעיות.

-fstats
פלט סטטיסטיקות לגבי עיבוד חזיתי בסוף הקומפילציה. זֶה
מידע שימושי בדרך כלל רק לצוות הפיתוח של G++.

-fstrict-enums
אפשר למהדר לבצע אופטימיזציה תוך שימוש בהנחה שערך מסוג מונה
יכול להיות רק אחד מהערכים של הספירה (כמוגדר בתקן C++;
בעצם, ערך שיכול להיות מיוצג במספר המינימום של ביטים שצריך
מייצגים את כל המונים). ייתכן שהנחה זו אינה תקפה אם התוכנית משתמשת
cast להמרת ערך שרירותי של מספר שלם לסוג המצוין.

-ftemplate-depth=n
הגדר את עומק המופע המרבי עבור שיעורי תבנית ל n. מגבלה על
יש צורך בעומק מופע התבנית כדי לזהות רקורסיות אינסופיות במהלך התבנית
מופע בכיתה. לתוכניות התואמות ANSI/ISO C++ אסור להסתמך על מקסימום
עומק גדול מ-17 (שונה ל-1024 ב-C++11). ערך ברירת המחדל הוא 900, כמו
מהדר יכול להיגמר שטח המחסנית לפני שהוא פוגע ב-1024 במצבים מסוימים.

-fno-threadsafe-statics
אל תפלוט את הקוד הנוסף כדי להשתמש בשגרה המצוינת ב-C++ ABI עבור thread-
אתחול בטוח של סטטיקה מקומית. אתה יכול להשתמש באפשרות זו כדי להקטין את גודל הקוד
מעט בקוד שלא צריך להיות בטוח בשרשור.

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

-fno-use-cxa-get-exception-ptr
אל תשתמש בשגרת זמן הריצה "__cxa_get_exception_ptr". זה יגרום
"std::uncaught_exception" אינו נכון, אך הוא הכרחי אם שגרת זמן הריצה היא
לא זמין.

-fvisibility-inlines-hidden
מתג זה מצהיר שהמשתמש אינו מנסה להשוות מצביעים ל-inline
פונקציות או שיטות שבהן הכתובות של שתי הפונקציות נקלטו בצורה שונה
חפצים משותפים.

ההשפעה של זה היא ש-GCC עשוי, למעשה, לסמן שיטות מוטבעות עם
"__attribute__ ((visibility ("hidden")))" כך שהם לא יופיעו בייצוא
טבלה של DSO ואינם דורשים עקיף PLT כאשר משתמשים בו בתוך DSO.
להפעלת אפשרות זו יכולה להיות השפעה דרמטית על זמני הטעינה והקישור של DSO כפי שהוא
מקטין באופן מסיבי את גודל טבלת הייצוא הדינמי כאשר הספרייה עושה כבד
שימוש בתבניות.

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

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

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

-fvisibility-ms-compat
דגל זה מנסה להשתמש בהגדרות נראות כדי ליצור את מודל הקישור C++ של GCC
תואם לזה של Microsoft Visual Studio.

הדגל מבצע את השינויים הבאים במודל ההצמדה של GCC:

1. זה מגדיר את ברירת המחדל של הנראות ל"מוסתר", כמו -נראות = מוסתרת.

2. סוגים, אך לא החברים שלהם, אינם מוסתרים כברירת מחדל.

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

בקוד חדש עדיף להשתמש -נראות = מוסתרת ולייצא את המחלקות האלו
נועד להיות גלוי כלפי חוץ. למרבה הצער זה אפשרי לקוד להסתמך,
אולי בטעות, על התנהגות Visual Studio.

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

-fno-חלש
אל תשתמש בתמיכה בסמל חלש, גם אם הוא מסופק על ידי המקשר. כברירת מחדל, G++
ישתמש בסמלים חלשים אם הם זמינים. אפשרות זו קיימת רק לבדיקה, ו
אסור להשתמש על ידי משתמשי קצה; זה יביא לקוד נחות ואין לו יתרונות.
אפשרות זו עשויה להיות מוסרת במהדורה עתידית של G++.

-nostdinc++
אל תחפש קבצי כותרות בספריות הסטנדרטיות הספציפיות ל-C++, אבל תעשה זאת
עדיין חפש בספריות הסטנדרטיות האחרות. (אפשרות זו משמשת בעת בניית ה
ספריית C++.)

בנוסף, לאפשרויות האופטימיזציה, האזהרה ויצירת הקוד הללו יש משמעויות בלבד
עבור תוכניות C++:

-fno-default-inline
אל תניח מוטבע עבור פונקציות המוגדרות בתוך היקף מחלקה.
שימו לב שלפונקציות אלו תהיה קישור כמו פונקציות מוטבעות; הם פשוט לא
להיות מוטבע כברירת מחדל.

-וואבי (C, Objective-C, C++ ו-Objective-C++ בלבד)
אזהרה כאשר G++ יוצר קוד שכנראה אינו תואם לספק ניטרלי
C++ ABI. למרות שנעשה מאמץ להתריע על כל מקרים כאלה, יש
כנראה כמה מקרים שלא מוזהרים עליהם, למרות ש-G++ מייצר
קוד לא תואם. ייתכנו גם מקרים שבהם נפלטות אזהרות למרות שה
הקוד שנוצר יהיה תואם.

עליך לשכתב את הקוד שלך כדי להימנע מהאזהרות אלה אם אתה מודאג לגבי
העובדה שקוד שנוצר על ידי G++ עשוי שלא להיות תואם בינארי לקוד שנוצר על ידי
מהדרים אחרים.

חוסר ההתאמה הידוע ב -fabi-version=2 (ברירת המחדל) כוללים:

· תבנית עם פרמטר שאינו מסוג תבנית מסוג הפניה מעוותת
באופן שגוי:

חיצוני int n;
תבנית struct S {};
void n (S ) {2}

זה קבוע ב -fabi-version=3.

· סוגי וקטור SIMD המוצהרים באמצעות "__attribute ((vector_size))" מעוותים ב-
דרך לא סטנדרטית שאינה מאפשרת עומס יתר של פונקציות שלוקחות וקטורים
בגדלים שונים.

המנגל משתנה -fabi-version=4.

חוסר ההתאמה הידוע ב -fabi-version=1 כוללות:

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

struct A { ריק וירטואלי f(); int f1 : 1; };
struct B : public A { int f2 : 1; };

במקרה זה, G++ יציב את "B::f2" באותו בית כמו "A::f1"; מהדרים אחרים
לא יהיה. אתה יכול להימנע מבעיה זו על ידי ריפוד מפורש "A" כך שגודלו
הוא כפולה של גודל הבתים בפלטפורמה שלך; שיגרום ל-G++ ואחרים
מהדרים לפריסת "B" באופן זהה.

· טיפול לא נכון בריפוד זנב לבסיסים וירטואליים. G++ אינו משתמש בזנב
ריפוד בעת פריסת בסיסים וירטואליים. לדוגמה:

struct A { ריק וירטואלי f(); char c1; };
struct B { B(); char c2; };
struct C: public A, public virtual B {};

במקרה זה, G++ לא ימקם את "B" לתוך ריפוד הזנב עבור "A"; אַחֵר
מהדרים יעשו זאת. אתה יכול להימנע מבעיה זו על ידי ריפוד מפורש של "A" כך שזה
הגודל הוא כפול של היישור שלו (התעלמות ממעמדות בסיס וירטואליים); הרצון הזה
לגרום ל-G++ ולמהדרים אחרים לפריס את "C" באופן זהה.

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

union U { int i: 4096; };

בהנחה של"int" אין 4096 סיביות, G++ יהפוך את האיחוד קטן מדי
לפי מספר הביטים ב-"int".

· ניתן להציב שיעורים ריקים בקיזוזים שגויים. לדוגמה:

מבנה A {};

struct B {
א א;
ריק וירטואלי f ();
};

struct C: public B, public A {};

G++ יציב את מחלקת הבסיס "A" של "C" בהיסט שאינו אפס; זה צריך להיות ממוקם
בהיסט אפס. G++ מאמין בטעות שאיבר הנתונים "A" של "B" הוא
כבר בהיסט אפס.

· שמות של פונקציות תבנית שהסוגים שלהן כוללים "שם סוג" או תבנית תבנית
פרמטרים יכולים להיות מעוותים בצורה שגויה.

תבנית
void f(typename Q::X) {}

תבנית מחלקה Q>
void f(typename Q ::איקס) {}

מופעים של תבניות אלה עלולים להיות מעוותים בצורה שגויה.

זה גם מזהיר שינויים הקשורים ל-psABI. השינויים המוכרים ב-psABI בשלב זה כוללים:

· עבור SYSV/x86-64, כאשר עוברים איחוד עם כפול ארוך, הוא משתנה למעבר ב
זיכרון כפי שצוין ב-psABI. לדוגמה:

איחוד U {
ld כפול ארוך;
int i;
};

"איחוד U" תמיד יעבור בזיכרון.

-וקטור-דטור-פרטיות (C++ ו-Objective-C++ בלבד)
הזהר כאשר מחלקה נראית בלתי שמישה מכיוון שכל הבנאים או ההורסים בה
הכיתה היא פרטית, ואין לה חברים או פונקציות סטטיות ציבוריות.

-Wdelete-non-virtual-dtor (C++ ו-Objective-C++ בלבד)
תזהיר מתי להסיר משמש להרוס מופע של מחלקה שיש לה פונקציות וירטואליות
והורס לא וירטואלי. זה לא בטוח למחוק מופע של מחלקה נגזרת
דרך מצביע למחלקה בסיס אם למחלקת הבסיס אין וירטואלי
משמיד. אזהרה זו מופעלת על ידי - קיר.

-מצמצם (C++ ו-Objective-C++ בלבד)
אזהרה כאשר מתרחשת בפנים המרה מצמצמת האסורה על ידי C++11 { }למשל

int i = { 2.2 }; // שגיאה: צמצום מכפול ל-int

דגל זה כלול ב - קיר ו -Wc++11-compat.

עם -std=c++11, -לא צמצום מדכא את האבחון הנדרש על פי התקן.
שימו לב שזה לא משפיע על המשמעות של קוד מעוצב היטב; צמצום ההמרות
עדיין נחשבים לבלתי מעוצבים בהקשר של SFINAE.

-לא חוץ מזה (C++ ו-Objective-C++ בלבד)
אזהרה כאשר ביטוי noexcept מוערך ל-false בגלל קריאה לפונקציה
שאין לו מפרט חריג ללא זריקה (כלומר לזרוק() or משהו מלבד)
אבל ידוע על ידי המהדר שהוא לעולם לא זורק חריג.

-Wnon-Virtual-dtor (C++ ו-Objective-C++ בלבד)
אזהרה כאשר למחלקה יש פונקציות וירטואליות והרס לא וירטואלי נגיש, ב
במקרה זה יהיה אפשרי אך לא בטוח למחוק מופע של מחלקה נגזרת
דרך מצביע למחלקה הבסיסית. אזהרה זו מופעלת גם אם -Weffc++ is
נָקוּב.

-הסדר (C++ ו-Objective-C++ בלבד)
אזהרה כאשר סדר האתחולים של החברים המופיע בקוד אינו תואם את הסדר
בהם יש להוציאם להורג. לדוגמה:

מבנה A {
int i;
int j;
A(): j (0), i (1) { }
};

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

הבא -W... אפשרויות אינן מושפעות מ - קיר.

-Weffc++ (C++ ו-Objective-C++ בלבד)
הזהר לגבי הפרות של הנחיות הסגנון הבאות של סקוט מאיירס אפקטיבי
C ++, שְׁנִיָה מַהֲדוּרָה ספר:

· פריט 11: הגדר בנאי העתקה ואופרטור מטלות עבור מחלקות עם
זיכרון המוקצה באופן דינמי.

· פריט 12: העדיפו אתחול להקצאה בקונסטרוקטורים.

· פריט 14: הפוך את ההורסים לווירטואליים בכיתות בסיס.

· פריט 15: תנו ל-"operator=" להחזיר הפניה ל*זה.

· פריט 23: אל תנסה להחזיר הפניה כאשר אתה חייב להחזיר אובייקט.

הזהיר גם לגבי הפרות של הנחיות הסגנון הבאות של סקוט מאיירס עוד
אפקטיבי C + + ספר:

· פריט 6: הבחנה בין צורות תחילית ופוסט-תיקונים של תוספת והפחתה
אופרטורים.

· פריט 7: לעולם אל תעמיס יתר על המידה "&&", "||", או ",".

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

-Wstrict-null-sentinel (C++ ו-Objective-C++ בלבד)
הזהיר גם לגבי השימוש ב-"NULL" לא יצוק כזקיף. כאשר קומפילציה רק ​​עם
GCC זהו זקיף חוקי, שכן "NULL" מוגדר ל"__null". למרות שזה ריק
קבוע מצביע לא מצביע אפס, מובטח שהוא יהיה באותו גודל כמו a
מַצבִּיעַ. אבל השימוש הזה אינו נייד על פני מהדרים שונים.

-לא-לא-חבר-תבנית (C++ ו-Objective-C++ בלבד)
השבת אזהרות כאשר פונקציות חבר ללא תבנית מוצהרות בתוך תבנית.
מאז הופעתה של תמיכה במפרט תבניות מפורש ב-G++, אם השם של
חבר הוא מזהה לא מוסמך (כלומר, חבר foo(int)), מפרט שפת C++
דורש מהחבר להכריז או להגדיר פונקציה רגילה, לא תבניתית. (סָעִיף
14.5.3). לפני ש-G++ יישם מפרט מפורש, יתכן ש-Inqualified-IDs היו
מתפרש כהתמחות מסוימת של פונקציה בעלת תבנית. בגלל זה
התנהגות שאינה תואמת היא כבר לא התנהגות ברירת המחדל עבור G++,
-לא-חבר-תבנית מאפשר למהדר לבדוק את הקוד הקיים לבעיות אפשריות
נקודות ומופעל כברירת מחדל. ניתן לכבות את התנהגות המהדר החדשה הזו באמצעות
-לא-לא-חבר-תבנית, אשר שומר את קוד המהדר התואם אך משבית את ה
אזהרה מועילה.

-קאסט בסגנון וולד (C++ ו-Objective-C++ בלבד)
אזהרה אם נעשה שימוש בקאסט בסגנון ישן (בסגנון C) לסוג שאינו ריק בתוך תוכנית C++.
הקאסט בסגנון החדש (-, שידור סטטי, לפרש מחדש_cast, ו const_cast) הם
פחות פגיע להשפעות לא מכוונות והרבה יותר קל לחפש.

-עמוס-וירטואלי (C++ ו-Objective-C++ בלבד)
אזהרה כאשר הצהרת פונקציה מסתירה פונקציות וירטואליות ממחלקת בסיס. ל
לדוגמה, ב:

מבנה A {
ריק וירטואלי f();
};

struct B: public A {
void f(int);
};

גרסת המחלקה "A" של "f" מוסתרת ב-"B", וקוד כמו:

ב* ב;
b->f();

לא יצליח להרכיב.

-Wno-pmf-המרות (C++ ו-Objective-C++ בלבד)
השבת את האבחון להמרת מצביע מאוגד לפונקציית איבר לפונקציה רגילה
מַצבִּיעַ.

-Wsign-promo (C++ ו-Objective-C++ בלבד)
אזהרה כאשר רזולוציית עומס יתר בוחרת בקידום מסוג לא חתום או ממוספר ל
סוג חתום, על פני המרה לסוג לא חתום באותו גודל. קודם
גרסאות של G++ ינסו לשמור על חוסר חתימה, אבל התקן מחייב את
התנהגות נוכחית.

מבנה A {
אופרטור int ();
אופרטור A& = (int);
};

עיקרי ()
{
א א,ב;
a = b;
}

בדוגמה זו, G++ יסנתז ברירת מחדל A& מפעיל = (קונסט א&);, בזמן מול
ישתמש בהגדרת המשתמש מפעיל =.

אפשרויות שליטה Objective-C ו Objective-C ++ דיאלקטים
(הערה: מדריך זה אינו מתאר את שפות Objective-C ו-Objective-C++
עצמם.

סעיף זה מתאר את אפשרויות שורת הפקודה בעלות משמעות רק עבור Objective-C
ותוכניות Objective-C++, אבל אתה יכול גם להשתמש ברוב ה-GNU בלתי תלוי בשפה
אפשרויות מהדר. לדוגמה, תוכל להרכיב קובץ "some_class.m" כך:

gcc -g -fgnu-ריצה -O -c some_class.m

בדוגמה זו, -fgnu-זמן ריצה היא אפשרות המיועדת רק ל-Objective-C ו-Objective-C++
תוכניות; אתה יכול להשתמש באפשרויות האחרות עם כל שפה הנתמכת על ידי GCC.

שימו לב שמכיוון ש-Objective-C היא הרחבה של שפת C, הידורים של Objective-C
עשוי גם להשתמש באפשרויות ספציפיות לחזית ה-C (למשל, -מסורתי). באופן דומה,
הידורים של Objective-C++ עשויים להשתמש באפשרויות ספציפיות ל-C++ (למשל, -וואבי).

הנה רשימה של אפשרויות שכן רק עבור קומפילציה של Objective-C ו-Objective-C++
תוכניות:

-fconstant-string-class=שם כיתה
השתמש שם כיתה כשם המחלקה למופע עבור כל מחרוזת מילולית
שצוין עם התחביר "@"...". שם המחלקה המוגדר כברירת מחדל הוא "NXConstantString" if
זמן הריצה של GNU נמצא בשימוש, ו-"NSConstantString" אם זמן הריצה NeXT נמצא
בשימוש (ראה להלן). ה -fconstant-cfstrings האפשרות, אם גם קיימת, תעקוף את
-פונסטנט-מיתרים הגדרה וגורמים ל-"@..."" מילוליות להיות מונחות כקבועות
מחרוזות CoreFoundation.

-fgnu-זמן ריצה
צור קוד אובייקט תואם לזמן הריצה הסטנדרטי של GNU Objective-C. זה
ברירת המחדל עבור רוב סוגי המערכות.

-fnext-זמן ריצה
צור פלט תואם לזמן הריצה של NeXT. זוהי ברירת המחדל עבור מבוססי NeXT
מערכות, כולל Darwin ו-Mac OS X. המאקרו "__NEXT_RUNTIME__" מוגדר מראש אם
(ורק אם) נעשה שימוש באפשרות זו.

-fno-nil-receivers
נניח שכל הודעת Objective-C נשלחת ("[הודעה מקבלת:arg]") בזה
יחידת התרגום לוודא שהמקלט אינו "אפס". זה מאפשר יותר
נקודות כניסה יעילות בזמן הריצה לשימוש. אפשרות זו זמינה רק ב
בשילוב עם זמן הריצה של NeXT וגרסת ABI 0 או 1.

-fobjc-abi-version=n
השתמש בגרסה n של ה-ABI של Objective-C עבור זמן הריצה שנבחר. אפשרות זו היא
כרגע נתמך רק עבור זמן הריצה של NeXT. במקרה זה, גרסה 0 היא
ABI מסורתי (32 סיביות) ללא תמיכה במאפיינים ושאר Objective-C 2.0
תוספות. גרסה 1 היא ה-ABI המסורתי (32 סיביות) עם תמיכה במאפיינים ו
תוספות אחרות של Objective-C 2.0. גרסה 2 היא ה-ABI המודרנית (64 סיביות). אם שום דבר לא
שצוין, ברירת המחדל היא גרסה 0 במכונות יעד של 32 סיביות, וגרסה 2 ב-64 סיביות
מכונות מטרה.

-fobjc-call-cxx-cdtors
עבור כל מחלקה Objective-C, בדוק אם אחד ממשתני המופע שלה הוא אובייקט C++
עם בנאי ברירת מחדל לא טריוויאלי. אם כן, סנתז "- (מזהה) מיוחד
שיטת מופע .cxx_construct" שתפעיל בוני ברירת מחדל לא טריוויאליים על כל אחד
משתני מופע כאלה, לפי הסדר, ואז מחזירים "עצמי". באופן דומה, בדוק אם יש
משתנה מופע הוא אובייקט C++ עם הרס לא טריוויאלי, ואם כן, סנתז
שיטת "- (void) .cxx_destruct" מיוחדת שתפעיל את כל משחי ברירת המחדל הללו,
בסדר הפוך.

השיטות "- (id) .cxx_construct" ו-"- (void) .cxx_destruct" שנוצרו כך
פועלים רק על משתני מופע שהוכרזו במחלקה הנוכחית של Objective-C, ולא
אלה שקיבלו בירושה ממעמדות-על. זה באחריות המטרה-C
זמן ריצה להפעיל את כל השיטות הללו בהיררכיית הירושה של אובייקט. תעודת הזהות)
שיטות .cxx_construct" יופעלו על ידי זמן הריצה מיד לאחר אובייקט חדש
מופע מוקצה; השיטות "- (void) .cxx_destruct" יופעלו
מיד לפני זמן הריצה מקצה מופע אובייקט.

נכון לכתיבת שורות אלה, רק לזמן הריצה של NeXT ב-Mac OS X 10.4 ואילך יש תמיכה עבור
מפעיל את השיטות "- (id) .cxx_construct" ו-"- (void) .cxx_destruct".

-fobjc-שיגור ישיר
אפשר קפיצות מהירות אל שולח ההודעות. בדרווין זה מושג באמצעות ה
עמוד comm.

-fobjc-חריגים
אפשר תמיכה תחבירית לטיפול בחריגים מובנים ב-Objective-C, בדומה ל
מה שמציעים C++ ו-Java. אפשרות זו נדרשת כדי להשתמש ב-Objective-C
מילות מפתח @try, @throw, @catch, @finally ו-@synchronized. אפשרות זו זמינה
עם זמן הריצה של GNU וגם עם זמן הריצה של NeXT (אך לא זמין בשילוב עם
זמן הריצה של NeXT ב-Mac OS X 10.2 ואילך).

-fobjc-gc
אפשר איסוף אשפה (GC) בתוכניות Objective-C ו-Objective-C++. אפשרות זו
זמין רק עם זמן הריצה של NeXT; לזמן הריצה של GNU יש זבל שונה
יישום אוסף שאינו דורש דגלי מהדר מיוחדים.

-fobjc-nilcheck
עבור זמן הריצה של NeXT עם גרסה 2 של ה-ABI, בדוק אם יש שיטת מקלט אפסית
הפעלות לפני ביצוע קריאת השיטה בפועל. זוהי ברירת המחדל ויכולה להיות
מושבת באמצעות -fno-objc-nilcheck. שיטות כיתה ושיחות סופר לעולם לא נבדקות
עבור אפס בצורה זו, לא משנה למה הדגל הזה מוגדר. נכון לעכשיו הדגל הזה עושה זאת
כלום כאשר נעשה שימוש בזמן הריצה של GNU, או גרסה ישנה יותר של NeXT זמן הריצה ABI.

-fobjc-std=objc1
תואם את תחביר השפה של Objective-C 1.0, השפה המוכרת על ידי GCC 4.0.
זה משפיע רק על תוספות Objective-C לשפת C/C++; זה לא משפיע
התאמה לתקני C/C++, אשר נשלטת על ידי הניב C/C++ הנפרד
דגלי אפשרות. כאשר אפשרות זו משמשת עם Objective-C או Objective-C++
מהדר, כל תחביר Objective-C שאינו מוכר על ידי GCC 4.0 נדחה. זֶה
שימושי אם אתה צריך לוודא שניתן להרכיב את קוד Objective-C שלך
גרסאות ישנות יותר של GCC.

-freplace-objc-classes
פלט סמן מיוחד המורה ld(1) לא לקשר סטטית באובייקט המתקבל
קובץ, ואפשר dyld(1) כדי לטעון אותו בזמן ריצה במקום זאת. זה משמש ב
בשילוב עם מצב איתור באגים Fix-and-Continue, שבו נכנס קובץ האובייקט
ניתן להרכיב מחדש את השאלה ולהיטען מחדש באופן דינמי במהלך התוכנית
ביצוע, ללא צורך להפעיל מחדש את התוכנית עצמה. נכון לעכשיו, תקן-ו-
פונקציונליות המשך זמינה רק בשילוב עם זמן הריצה של NeXT ב-Mac
OS X 10.3 ואילך.

-fzero-link
בעת הידור עבור זמן הריצה של NeXT, המהדר מחליף בדרך כלל קריאות אל
"objc_getClass("...")" (כאשר שם המחלקה ידוע בזמן ההידור) עם
הפניות מחלקות סטטיות שמאוחלות בזמן טעינה, מה שמשפר את זמן הריצה
ביצועים. ציון ה -fzero-link דגל מדכא התנהגות זו וגורם
קריאות ל-"objc_getClass("...")" שישמרו. זה שימושי ב- Zero-Link
מצב איתור באגים, מכיוון שהוא מאפשר לשנות יישומי מחלקה בודדים
במהלך ביצוע התוכנית. זמן הריצה של GNU כרגע שומר תמיד קריאות אל
"objc_get_class("...")" ללא קשר לאפשרויות שורת הפקודה.

-gen-decls
dump הצהרות ממשק עבור כל המחלקות הנראות בקובץ המקור לקובץ בשם
sourcename.decl.

-Wassign-יירט (Objective-C ו-Objective-C++ בלבד)
התריע בכל פעם שמשימת Objective-C מיירטת על ידי אספן האשפה.

-אין פרוטוקול (Objective-C ו-Objective-C++ בלבד)
אם מחלקה מוכרזת ליישם פרוטוקול, מונפקת אזהרה עבור כל שיטה
בפרוטוקול שאינו מיושם על ידי הכיתה. התנהגות ברירת המחדל היא ל
פרסם אזהרה עבור כל שיטה שלא יושמה במפורש במחלקה, גם אם א
יישום השיטה עובר בירושה ממחלקת העל. אם אתה משתמש ב -אין פרוטוקול
אופציה, אז שיטות שעברו בירושה ממחלקת העל נחשבות למיושמות,
ולא יוצאת להם אזהרה.

-ובורר (Objective-C ו-Objective-C++ בלבד)
אזהרה אם נמצאו מספר שיטות מסוגים שונים עבור אותו בורר במהלך
הַהדָרָה. הבדיקה מתבצעת על רשימת השיטות בשלב הסופי של
הַהדָרָה. בנוסף, מתבצעת בדיקה עבור כל בורר המופיע ב-a
ביטוי "@selector(...)", ושיטה מתאימה עבור אותו בורר הייתה
נמצא במהלך הידור. מכיוון שבדיקות אלו סורקות את טבלת המתודות רק בסוף
של הקומפילציה, אזהרות אלו אינן מופקות אם השלב האחרון של הקומפילציה הוא
לא הושג, למשל בגלל שנמצאה שגיאה במהלך ההידור, או בגלל שה
-fsyntax-בלבד האופציה נמצאת בשימוש.

-Wstrict-selector-match (Objective-C ו-Objective-C++ בלבד)
אזהרה אם נמצאו מספר שיטות עם סוגי ארגומנט ו/או החזרה שונים עבור a
בורר שניתן בעת ​​ניסיון לשלוח הודעה באמצעות בורר זה למקבל של
הקלד "id" או "Class". כאשר הדגל הזה כבוי (שהיא התנהגות ברירת המחדל), ה
המהדר ישמיט אזהרות כאלה אם כל הבדלים שנמצאו מוגבלים לסוגים ש
חולקים את אותו גודל ויישור.

-בורר-מוצהר (Objective-C ו-Objective-C++ בלבד)
אזהרה אם נמצא ביטוי "@selector(...)" המתייחס לבורר לא מוכרז. א
הבורר נחשב לא מוכרז אם לא הוכרזה שיטה בשם זה בעבר
הביטוי "@selector(...)", או במפורש בממשק @ או ב-@protocol
הצהרה, או במשתמע בקטע @implementation. אפשרות זו תמיד פועלת
הוא בודק ברגע שנמצא ביטוי "@selector(...)", while -ובורר רק
מבצעת את בדיקותיה בשלב הסופי של ההידור. זה גם אוכף את הקידוד
מוסכמה בסגנון שלפיה יש להצהיר על שיטות ובוררים לפני השימוש.

-print-objc-runtime-info
צור כותרת C המתארת ​​את המבנה הגדול ביותר שמועבר לפי ערך, אם בכלל.

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

-fmessage-length=n
נסה לעצב הודעות שגיאה כך שיתאימו לשורות של בערך n דמויות. ה
ברירת המחדל היא 72 תווים עבור g ++ ו-0 עבור שאר הקצוות הקדמיים הנתמכים על ידי
GCC. אם n הוא אפס, אז לא תיעשה גלישת שורות; כל הודעת שגיאה תופיע
על קו בודד.

-fdiagnostics-show-location=פעם אחת
משמעותי רק במצב גלישת שורות. מורה לכתב הודעות האבחון
פולט פעם מידע מיקום מקור; כלומר, למקרה שההודעה ארוכה מכדי להתאים
על קו פיזי יחיד ויש לעטוף אותו, מיקום המקור לא ייפלט
(כתחילית) שוב, שוב ושוב, בשורות ההמשך הבאות. זה
התנהגות ברירת מחדל.

-fdiagnostics-show-location=every-line
משמעותי רק במצב גלישת שורות. מורה לכתב הודעות האבחון
פולט את אותו מידע מיקום מקור (כתחילית) עבור קווים פיזיים הנובעים מכך
מתהליך שבירת הודעה ארוכה מכדי להתאים לשורה אחת.

-fno-diagnostics-show-option
כברירת מחדל, כל אבחון שנפלט כולל טקסט המציין את אפשרות שורת הפקודה
השולט ישירות באבחון (אם אפשרות כזו ידועה לאבחון
מְכוֹנוֹת). ציון ה -fno-diagnostics-show-option הדגל מדכא את זה
התנהגות.

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

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

-fsyntax-בלבד
בדוק את הקוד עבור שגיאות תחביר, אבל אל תעשה שום דבר מעבר לזה.

-fmax-errors=n
מגביל את המספר המרבי של הודעות שגיאה ל n, בשלב זה GCC מחלץ
מאשר לנסות להמשיך ולעבד את קוד המקור. אם n הוא 0 (ברירת המחדל),
אין הגבלה על מספר הודעות השגיאה המופקות. אם -שגיאות חמורות גם
אם כן -שגיאות חמורות עדיפות על אפשרות זו.

-w חסום את כל הודעות האזהרה.

-שגיאה
הפוך את כל האזהרות לשגיאות.

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

הודעת האזהרה עבור כל אזהרה הניתנת לשליטה כוללת את האפשרות השולטת
האזהרה. לאחר מכן ניתן להשתמש באפשרות זו עם -שגיאה= ו -Wno-error= כפי שתואר
מֵעַל. (ניתן לבטל את הדפסת האפשרות בהודעת האזהרה באמצעות ה
-fno-diagnostics-show-option דֶגֶל.)

שימו לב שמפרטים -שגיאה=Foo מרמז באופן אוטומטי -WFoo. עם זאת, -Wno-error=Foo
לא מרמז על שום דבר.

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

אתה יכול לבקש אזהרות ספציפיות רבות עם אפשרויות שמתחילות -W, למשל - מרומז
לבקש אזהרות על הצהרות מרומזות. גם כל אחת מאפשרויות האזהרה הספציפיות הללו
יש צורה שלילית מתחילה -לא- לבטל אזהרות; לדוגמה, -לא מרומז.
מדריך זה מפרט רק אחד משני הטפסים, מה שאינו ברירת המחדל. להמשך,
אפשרויות ספציפיות לשפה מתייחסות גם C + + ניב אפשרויות ו Objective-C ו
Objective-C ++ ניב אפשרויות.

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

-קַפְּדָנִי
פרסם את כל האזהרות הנדרשות על ידי ISO C ו-ISO C++ המחמירים; לדחות את כל התוכניות
השתמש בהרחבות אסורות, ובכמה תוכניות אחרות שאינן עוקבות אחר ISO C ו-ISO
C++. עבור ISO C, בהתאם לגרסה של תקן ISO C שצוין על ידי כל אחד -סטד
אופציה בשימוש.

תוכניות ISO C ו-ISO C++ חוקיות צריכות להדר כראוי עם או בלי אפשרות זו
(אם כי מעטים נדירים ידרשו -אנסי או -סטד אפשרות לציון הגרסה הנדרשת
של ISO C). עם זאת, ללא אפשרות זו, הרחבות מסוימות של GNU ו-C ו-מסורתיות
תכונות C++ נתמכות גם כן. עם אפשרות זו, הם נדחים.

-קַפְּדָנִי אינו גורם להודעות אזהרה לשימוש במילות המפתח החלופיות שלהן
שמות מתחילים ומסתיימים ב __. גם אזהרות פדנטיות מושבתות בביטוי
שאחרי "__extension__". עם זאת, רק קובצי כותרות מערכת צריכים להשתמש באלה
דרכי מילוט; תוכניות יישומים צריכות להימנע מהן.

חלק מהמשתמשים מנסים להשתמש -קַפְּדָנִי כדי לבדוק תוכניות להתאמה קפדנית של ISO C. הֵם
עד מהרה מגלים שהוא לא עושה בדיוק מה שהם רוצים: הוא מוצא כמה שיטות עבודה שאינן ISO,
אבל לא כולם --- רק אלה שעבורם ISO C דורש אבחון, וכמה אחרים עבור
אילו אבחונים נוספו.

תכונה לדיווח על כל כשל בהתאמה ל-ISO C עשויה להיות שימושית במקרים מסוימים,
אבל ידרוש עבודה נוספת לא מבוטלת ויהיה שונה לגמרי מזה
-קַפְּדָנִי. אין לנו תוכניות לתמוך בתכונה כזו בעתיד הקרוב.

כאשר התקן צוין עם -סטד מייצג דיאלקט מורחב של GNU של C, כגון
gnu90 or gnu99, יש מקביל בסיס תֶקֶן, הגרסה של ISO C שבה
הדיאלקט המורחב של GNU מבוסס. אזהרות מ -קַפְּדָנִי ניתנים היכן שהם נמצאים
נדרש על פי תקן הבסיס. (לא יהיה הגיוני לתת אזהרות כאלה
רק עבור תכונות שאינן בניב GNU C שצוין, שכן בהגדרה ה-GNU
דיאלקטים של C כוללים את כל התכונות בהן המהדר תומך עם האפשרות הנתונה, ו
לא יהיה מה להזהיר.)

-פדנטיות-טעויות
כמו -קַפְּדָנִי, אלא שמופקות שגיאות ולא אזהרות.

- קיר
זה מאפשר את כל האזהרות לגבי מבנים שחלק מהמשתמשים מחשיבים
מפוקפקים, ושקל להימנע מהם (או לשנות כדי למנוע את האזהרה), אפילו ב
בשילוב עם פקודות מאקרו. זה גם מאפשר כמה אזהרות ספציפיות לשפה המתוארות
in C + + ניב אפשרויות ו Objective-C ו Objective-C ++ ניב אפשרויות.

- קיר מפעיל את דגלי האזהרה הבאים:

-כתובת -גבולות המלחמה (רק עם -O2) -Wc++11-compat -Wchar-מנויים
-וונום-השוו (ב-C/Objc; זה מופעל כברירת מחדל ב-C++) -מוכר (C ו
Objective-C בלבד) -הצהרה-פונקציונלית (C ו-Objective-C בלבד) -הערה
- -מיין (רק עבור C/ObjC אלא אם כן -עומד בפני עצמו) -אולי-לא אתחול
-חסר-פלטה -Wnonnull -סוגריים -סימן Wpointer -הסדר -סוג חזרה
-נקודת רצף -Wsign-השוואה (רק ב-C++) -Wstrict-aliasing -Wstrict-overflow=1
-מתג -תרשימים -לא מאותחל -לא ידוע-פרגמות -פונקציה Wunused
-תווית Wunused -ערך Wunused -משתנים-Wunused -Wvolatile-register-var

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

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

-קשקש -גוף רטוב - מוקדמות מנוצלות -חסרי-שדה-initializers
-סוג חסר-פרמטר (C בלבד) -הצהרה בסגנון וולד (C בלבד) -Woverride-init
-Wsign-השוואה -מגבלות סוג -לא מאותחל -פרמטר Wunused (רק עם -לא בשימוש or
- קיר) -פרמטר Wunused-but-set- (רק עם -לא בשימוש or - קיר)

האפשרות אקסטרה מדפיס גם הודעות אזהרה למקרים הבאים:

· מצביע מושווה מול מספר שלם אפס עם <, <=, >, או >=.

· (C++ בלבד) מונה ולא מונה מופיעים שניהם בתנאי
ביטוי.

· (C++ בלבד) בסיסים וירטואליים מעורפלים.

· (C++ בלבד) מנוי למערך שהוכרז הירשם.

· (C++ בלבד) לקיחת כתובת של משתנה שהוכרז הירשם.

· (C++ בלבד) מחלקת בסיס אינה מאותחלת בבנאי העתקה של מחלקה נגזרת.

-Wchar-מנויים
אזהרה אם למערך יש את הסוג "char". זוהי סיבה נפוצה לשגיאה, כמו
מתכנתים שוכחים לעתים קרובות שסוג זה חתום במכונות מסוימות. אזהרה זו היא
מופעל על ידי - קיר.

-הערה
אזהרה בכל פעם שרצף התחלה של הערות /* מופיע ב /* הערה, או בכל פעם א
קו נטוי אחורי מופיע ב-a // תגובה. אזהרה זו מופעלת על ידי - קיר.

-אין-כיסוי-אי-התאמה
אזהרה אם פרופילי המשוב אינם תואמים בעת השימוש ב -fprofile-שימוש אוֹפְּצִיָה. אם
קובץ המקור שונה בין -fprofile-gen ו -fprofile-שימוש, הקבצים עם ה
משוב על הפרופיל לא יכול להתאים לקובץ המקור ו-GCC לא יכול להשתמש בפרופיל
מידע משוב. כברירת מחדל, אזהרה זו מופעלת והיא מטופלת כשגיאה.
-אין-כיסוי-אי-התאמה ניתן להשתמש כדי להשבית את האזהרה או
-Wno-error=כיסוי-חוסר התאמה ניתן להשתמש כדי להשבית את השגיאה. השבתת השגיאה
שכן אזהרה זו יכולה לגרום לקוד שעבר אופטימיזציה גרועה והיא שימושית רק במקרה של
שינויים קלים מאוד כמו תיקוני באגים לבסיס קוד קיים. משבית לחלוטין
האזהרה אינה מומלצת.

-Wno-cpp
(C, Objective-C, C++, Objective-C++ ו-Fortran בלבד)

דחק הודעות אזהרה הנפלטות על ידי הנחיות "#אזהרה".

- קידום כפול (C, C++, Objective-C ו-Objective-C++ בלבד)
תן אזהרה כאשר ערך מסוג "צף" מקודם באופן מרומז ל"כפול". מעבדים
עם יחידת נקודה צפה של 32 סיביות "דיוק יחיד" ליישם "צף" בחומרה,
אבל מחקה "כפול" בתוכנה. במכונה כזו, עושה חישובים באמצעות
ערכים "כפולים" יקרים הרבה יותר בגלל התקורה הנדרשת לתוכנה
חיקוי.

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

שטח ציפה (רדיוס ציפה)
{
החזר 3.14159 * רדיוס * רדיוס;
}

המהדר יבצע את כל החישוב עם "כפול" מכיוון שה-floating-
נקודה מילולית היא "כפול".

-
בדוק קריאות ל-"printf" ו-"scanf" וכו', כדי לוודא שהארגומנטים מסופקים
יש סוגים המתאימים למחרוזת הפורמט שצוינה, וכי ההמרות
שצוין במחרוזת הפורמט הגיוני. זה כולל פונקציות סטנדרטיות, ו
אחרים המצוינים לפי תכונות פורמט, ב-"printf", "scanf", "strftime" ו
"strfmon" (הרחבה X/Open, לא בתקן C) משפחות (או יעד אחר-
משפחות ספציפיות). אילו פונקציות נבדקות מבלי שהיו תכונות פורמט
שצוין תלוי בגרסה הסטנדרטית שנבחרה, ובבדיקות כאלה של פונקציות
ללא התכונה שצוינה מושבתים על ידי -עומד בפני עצמו or -fno-builtin.

הפורמטים נבדקים מול תכונות הפורמט הנתמכות על ידי GNU libc גרסה 2.2.
אלה כוללים את כל תכונות ISO C90 ו-C99, כמו גם תכונות מה-Single Unix
מפרט וכמה הרחבות BSD ו-GNU. ייתכן שלא יישומי ספרייה אחרים
תמיכה בכל התכונות הללו; GCC אינו תומך באזהרה לגבי תכונות החורגות
מגבלות של ספרייה מסוימת. לעומת זאת, אם -קַפְּדָנִי משמש עם -,
יינתנו אזהרות לגבי תכונות פורמט שאינן בגרסה הסטנדרטית שנבחרה (אבל
לא לפורמטים של "strfmon", מכיוון שאלו אינם בשום גרסה של תקן C).

השאלה היא איך? - גם בודק ארגומנטים של תבנית null עבור מספר פונקציות, -
גם מרמז -Wnonnull.

- כלול ב- - קיר. לשליטה רבה יותר על כמה היבטים של בדיקת פורמטים,
האפשרויות -Wformat-y2k, -Wno-format-extra-args, -אין-פורמט-אפס-אורך,
-Wformat-לא מילולי, -Wformat-אבטחה, ו -Wformat=2 זמינים, אך אינם
כלול ב - קיר.

הערה: ב-Ubuntu 8.10 ובגירסאות מאוחרות יותר אפשרות זו מופעלת כברירת מחדל עבור C, C++,
ObjC, ObjC++. כדי להשבית, השתמש -Wformat=0.

-Wformat-y2k
If - מצוין, גם מזהיר מפני פורמטים של "strftime" שעשויים להניב רק א
שנה דו ספרתית.

-Wno-format-contains-nul
If - צוין, אל תזהיר לגבי מחרוזות פורמט המכילות בתים NUL.

-Wno-format-extra-args
If - צוין, אל תזהיר על עודף ארגומנטים ל-"printf" או "scanf"
פונקציית פורמט. תקן C מציין שמתעלמים מטיעונים כאלה.

כאשר הארגומנטים שאינם בשימוש נמצאים בין ארגומנטים משומשים שצוינו עם $
מפרטי מספרי אופרנד, בדרך כלל עדיין ניתנות אזהרות, שכן
היישום לא יכול היה לדעת איזה סוג להעביר ל-"va_arg" כדי לדלג על הלא בשימוש
טיעונים. עם זאת, במקרה של פורמטים "scanf", אפשרות זו תדכא את
אזהרה אם הארגומנטים שאינם בשימוש הם כולם מצביעים, שכן מפרט ה-Single Unix
אומר שמותר טיעונים שאינם בשימוש כאלה.

-אין-פורמט-אפס-אורך
If - צוין, אין להזהיר מפני פורמטים באורך אפס. תקן C
מציין שמתירים פורמטים באורך אפס.

-Wformat-לא מילולי
If - מצוין, גם הזהיר אם מחרוזת הפורמט אינה מחרוזת מילולית ו
אז לא ניתן לסמן, אלא אם פונקציית הפורמט לוקחת את ארגומנטי הפורמט שלה כ-a
"va_list".

-Wformat-אבטחה
If - מצוין, גם מזהיר לגבי שימושים בפונקציות פורמט המייצגות
בעיות אבטחה אפשריות. נכון לעכשיו, זה מזהיר מפני קריאות ל"printf" ו
פונקציות "scanf" כאשר מחרוזת הפורמט אינה מחרוזת מילולית ואין
פורמט ארגומנטים, כמו ב-"printf (foo);". זה עשוי להיות חור אבטחה אם הפורמט
מחרוזת הגיעה מקלט לא מהימן ומכילה %n. (זה כרגע תת-קבוצה של מה
-Wformat-לא מילולי מזהיר לגבי, אך בעתיד עשויות להתווסף אזהרות
-Wformat-אבטחה שאינם כלולים ב -Wformat-לא מילולי.)

הערה: ב-Ubuntu 8.10 ובגירסאות מאוחרות יותר אפשרות זו מופעלת כברירת מחדל עבור C, C++,
ObjC, ObjC++. כדי להשבית, השתמש -אין-פורמט-אבטחה, או השבת את כל אזהרות הפורמט
עם -Wformat=0. כדי להפוך אזהרות אבטחה לפורמט קטלניות, ציין
-שגיאה=פורמט-אבטחה.

-Wformat=2
אפשר - צ'קים בפורמט פלוס אינם כלולים ב -. כרגע שווה ערך ל
- -Wformat-לא מילולי -Wformat-אבטחה -Wformat-y2k.

-Wnonnull
אזהרה לגבי העברת מצביע ריק עבור ארגומנטים המסומנים כדורשים ערך שאינו ריק
על ידי תכונת הפונקציה "nonnull".

-Wnonnull כלול ב- - קיר ו -. זה יכול להיות מושבת עם -Wno-nonnull
אוֹפְּצִיָה.

-וויניט-עצמי (C, C++, Objective-C ו-Objective-C++ בלבד)
התריע על משתנים לא מאותחלים שמאוחלים עם עצמם. שימו לב לזה
ניתן להשתמש באפשרות רק עם -לא מאותחל אוֹפְּצִיָה.

לדוגמה, GCC יתריע על ביטול האתחול של "i" בקטע הבא בלבד
מתי -וויניט-עצמי צוין:

int f()
{
int i = i;
חזור i;
}

-מוכר (C ו-Objective-C בלבד)
אזהרה כאשר הצהרה אינה מציינת סוג. אזהרה זו מופעלת על ידי - קיר.

-הצהרה-פונקציונלית (C ו-Objective-C בלבד)
תן אזהרה בכל פעם שנעשה שימוש בפונקציה לפני ההכרזה. במצב C99
(-std=c99 or -std=gnu99), אזהרה זו מופעלת כברירת מחדל והיא הופכת ל-
שגיאה על ידי -פדנטיות-טעויות. אזהרה זו מופעלת גם על ידי - קיר.

- מרומז (C ו-Objective-C בלבד)
כמו -מוכר ו -הצהרה-פונקציונלית. אזהרה זו מופעלת
by - קיר.

- מוקדמות מנוצלות (C ו-C++ בלבד)
אזהרה אם לסוג ההחזרה של פונקציה יש מסמיך סוג כגון "const". עבור ISO C
למתג סוג כזה אין השפעה, מכיוון שהערך המוחזר על ידי פונקציה אינו an
lvalue. עבור C++, האזהרה נפלטת רק עבור סוגים סקלרים או "ריק". ISO C
אוסר על סוגי החזרות "בטלים" מוסמכים בהגדרות פונקציות, ולכן סוגי החזרות כאלה
תמיד לקבל אזהרה גם בלי אפשרות זו.

אזהרה זו מופעלת גם על ידי אקסטרה.

-מיין
הזהיר אם סוג של ראשי הוא חשוד. ראשי צריכה להיות פונקציה עם חיצוני
קישור, החזרת int, לוקח אפס ארגומנטים, שניים או שלושה ארגומנטים של
סוגים מתאימים. אזהרה זו מופעלת כברירת מחדל ב-C++ והיא מופעלת על ידי אחד מהם
- קיר or -קַפְּדָנִי.

-חסר-פלטה
אזהרה אם מאתחל אגרגט או איחוד אינו מלא בסוגריים. בהמשך
לדוגמה, המאתחל עבור a אינו בסוגריים מלאים, אבל זה עבור b הוא במלואו
בסוגריים.

int a[2][2] = { 0, 1, 2, 3 };
int b[2][2] = { { 0, 1 }, { 2, 3 } };

אזהרה זו מופעלת על ידי - קיר.

-חסרים-include-dirs (C, C++, Objective-C ו-Objective-C++ בלבד)
אזהרה אם לא קיימת ספריית include שסופק על ידי המשתמש.

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

גם להזהיר אם השוואה כמו x<=y<=z מופיע; זה שווה ערך ל (x<=y ? 1 : 0)
<= z, שהיא פרשנות שונה מזו של סימון מתמטי רגיל.

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

{
אם)
אם (ב)
foo ();
אחר
בר ();
}

ב-C/C++, כל ענף "אחר" שייך להצהרת ה"אם" הפנימית ביותר האפשרית, אשר
בדוגמה זו הוא "אם (ב)". לרוב זה לא מה שהמתכנת ציפה, כמו
מודגם בדוגמה לעיל על ידי הזחה שהמתכנת בחר. כשיש
הפוטנציאל לבלבול זה, GCC תוציא אזהרה כאשר הדגל הזה יהיה
נָקוּב. כדי לבטל את האזהרה, הוסף פלטה מפורשת סביב ה"אם" הפנימי ביותר
הצהרה כך שאין סיכוי שה"אחר" יכול להיות שייך ל"אם" ​​המקיף. ה
הקוד שיתקבל ייראה כך:

{
אם)
{
אם (ב)
foo ();
אחר
בר ();
}
}

הזהיר גם מפני שימושים מסוכנים ב-?: עם הושמטה של ​​סיומת אופרנד GNU באמצע. מתי
התנאי באופרטור ?: הוא ביטוי בוליאני שהערך המושמט יהיה
תמיד 1. לעתים קרובות המשתמש מצפה שזה יהיה ערך המחושב בתוך התנאי
ביטוי במקום.

אזהרה זו מופעלת על ידי - קיר.

-נקודת רצף
הזהר לגבי קוד שעלול להיות לו סמנטיקה לא מוגדרת בגלל הפרות של רצף
כללי נקודה בתקנים C ו-C++.

הסטנדרטים C ו-C++ מגדירים את הסדר שבו נמצאים הביטויים בתוכנית C/C++
מוערך במונחים של רצף נקודות, המייצגים סדר חלקי בין ה
ביצוע של חלקים מהתוכנית: אלה שבוצעו לפני נקודת הרצף, ואלו
הוצא להורג לאחריו. אלה מתרחשים לאחר הערכה של ביטוי מלא (אחד אשר
אינו חלק מביטוי גדול יותר), לאחר הערכה של האופרנד הראשון של א
"&&", "||", "? :" או "," (פסיק), אופרטור, לפני שנקראת פונקציה (אבל אחרי
הערכה של הטיעונים שלו ושל הביטוי המציין את הפונקציה שנקראה), וכן ב
מקומות מסוימים אחרים. מלבד כפי שמתבטא בחוקי נקודת הרצף, הסדר
של הערכה של ביטויי משנה של ביטוי לא מצוין. כל הכללים האלה
תאר רק סדר חלקי ולא סדר כולל, שכן, למשל, אם שניים
פונקציות נקראות בתוך ביטוי אחד ללא נקודת רצף ביניהן, ה
לא מצוין סדר הקריאה לפונקציות. עם זאת, הסטנדרטים
הוועדה קבעה כי קריאות התפקוד אינן חופפות.

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

דוגמאות לקוד עם התנהגות לא מוגדרת הן "a = a++;", "a[n] = b[n++]" ו-"a[i++] =
i;". כמה מקרים מסובכים יותר אינם מאובחנים על ידי אפשרות זו, והיא עשויה לתת
תוצאה חיובית כוזבת מדי פעם, אך באופן כללי היא נמצאה יעילה למדי ב
זיהוי סוג זה של בעיה בתוכניות.

התקן מנוסח באופן מבלבל, ולכן יש ויכוח על המדויק
המשמעות של נקודת הרצף הכללית במקרים עדינים. קישורים לדיונים של
ניתן למצוא בעיה, כולל הגדרות פורמליות מוצעות, בדף הקריאות של GCC,
בְּ-http://gcc.gnu.org/readings.html>.

אזהרה זו מופעלת על ידי - קיר עבור C ו-C++.

-סוג חזרה
התריע בכל פעם שפונקציה מוגדרת עם סוג החזרה שברירת המחדל הוא "int". גַם
התריע על כל הצהרת "החזרה" ללא ערך החזרה בפונקציה שסוג ההחזר שלה
אינו "בטל" (נפילה מקצה גוף הפונקציה נחשבת להחזרה
ללא ערך), ועל אמירת "החזרה" עם ביטוי בפונקציה
שסוג ההחזר שלו הוא "בטל".

עבור C++, פונקציה ללא סוג החזרה תמיד מייצרת הודעת אבחון, אפילו
מתי -סוג Wno-return מצוין. החריגים היחידים הם ראשי ופונקציות
מוגדר בכותרות המערכת.

אזהרה זו מופעלת על ידי - קיר.

-מתג
התריע בכל פעם שהצהרת "החלפה" כוללת אינדקס מסוג מסופר וחסרה "מקרה"
עבור אחד או יותר מהקודים בעלי השם של אותה ספירה. (הנוכחות של "ברירת מחדל"
תווית מונעת אזהרה זו.) תוויות "מקרה" גם מחוץ לטווח הספירה
לעורר אזהרות כאשר משתמשים באפשרות זו (גם אם יש תווית "ברירת מחדל"). זֶה
אזהרה מופעלת על ידי - קיר.

-Wswitch-default
התריע בכל פעם שבהצהרת "החלפה" אין מקרה של "ברירת מחדל".

-סוויצ'-אנום
התריע בכל פעם שהצהרת "החלפה" כוללת אינדקס מסוג מסופר וחסרה "מקרה"
עבור אחד או יותר מהקודים בעלי השם של אותה ספירה. תוויות "מארז" מחוץ ל
טווח ספירה גם מעורר אזהרות כאשר משתמשים באפשרות זו. ההבדל היחיד
בֵּין -מתג ואפשרות זו היא שאופציה זו נותנת אזהרה על הושמט
קוד ספירה גם אם יש תווית "ברירת מחדל".

-Wsync-nand (C ו-C++ בלבד)
אזהרה כאשר הפונקציות המובנות "__sync_fetch_and_nand" ו-"__sync_nand_and_fetch" הן
בשימוש. פונקציות אלו שינו את הסמנטיקה ב-GCC 4.4.

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

-פרמטר Wunused-but-set-
התריע בכל פעם שמוקצה פרמטר של פונקציה, אך אינו בשימוש אחר (מלבד
ההצהרה שלה).

כדי לדכא אזהרה זו השתמש ב- לא בשימוש תכונה.

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

-בשימוש-אבל-סט-משתנה
התריע בכל פעם שמשתנה מקומי מוקצה למשתנה, אך לא נעשה בו שימוש (מלבד שלו
הַצהָרָה). אזהרה זו מופעלת על ידי - קיר.

כדי לדכא אזהרה זו השתמש ב- לא בשימוש תכונה.

אזהרה זו מופעלת גם על ידי -לא בשימוש, אשר מופעל על ידי - קיר.

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

-תווית Wunused
התריע בכל פעם שתווית מוצהרת אך אינה בשימוש. אזהרה זו מופעלת על ידי - קיר.

כדי לדכא אזהרה זו השתמש ב- לא בשימוש תכונה.

-Wunused-local-typedefs (C, Objective-C, C++ ו-Objective-C++ בלבד)
אזהרה כאשר לא נעשה שימוש ב-typedef המוגדר באופן מקומי בפונקציה.

-פרמטר Wunused
התריע בכל פעם שלא נעשה שימוש בפרמטר פונקציה מלבד ההצהרה שלו.

כדי לדכא אזהרה זו השתמש ב- לא בשימוש תכונה.

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

-משתנים-Wunused
התריע בכל פעם שלא נעשה שימוש במשתנה מקומי או במשתנה סטטי לא קבוע
ההכרזה שלה. אזהרה זו מופעלת על ידי - קיר.

כדי לדכא אזהרה זו השתמש ב- לא בשימוש תכונה.

-ערך Wunused
התריע בכל פעם שמשפט מחשב תוצאה שלא נעשה בה שימוש מפורש. לדכא
האזהרה הזו הטילה את הביטוי הלא בשימוש לבטל את. זה כולל ביטוי-אמירה
או הצד השמאלי של ביטוי פסיק שאינו מכיל תופעות לוואי. ל
לדוגמה, ביטוי כגון x[i,j] יגרום אזהרה, בעוד x[(void)i,j] יצטרך
לֹא.

אזהרה זו מופעלת על ידי - קיר.

-לא בשימוש
כל האמור לעיל -לא בשימוש אפשרויות משולבות.

על מנת לקבל אזהרה על פרמטר פונקציה שאינו בשימוש, עליך לציין
אקסטרה -לא בשימוש (ציין זאת - קיר מרמז -לא בשימוש), או ציין בנפרד
-פרמטר Wunused.

-לא מאותחל
התריע אם נעשה שימוש במשתנה אוטומטי מבלי להיות אתחול תחילה או אם משתנה
עשוי להיות נגוע בקריאה "setjmp". ב-C++, אזהרה אם הפניה לא סטטית או לא-
סטטי const חבר מופיע במחלקה ללא בנאים.

אם ברצונך להזהיר לגבי קוד שמשתמש בערך הלא מאותחל של המשתנה ב
אתחול משלו, השתמש ב- -וויניט-עצמי אוֹפְּצִיָה.

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

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

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

{
int x;
מתג (y)
{
מקרה 1: x = 1;
לשבור;
מקרה 2: x = 4;
לשבור;
מקרה 3: x = 5;
}
foo (x);
}

אם הערך של "y" הוא תמיד 1, 2 או 3, אז "x" תמיד מאותחל, אבל GCC
לא יודע את זה. כדי לדכא את האזהרה, המשתמש צריך לספק מקרה ברירת מחדל
עם לִטעוֹן(0) או קוד דומה.

אפשרות זו גם מזהירה כאשר משתנה אוטומטי לא נדיף עשוי להשתנות על ידי א
קריאה ל-"longjmp". גם אזהרות אלו אפשריות רק באופטימיזציה
הַהדָרָה.

המהדר רואה רק את הקריאות ל"setjmp". זה לא יכול לדעת איפה "longjmp" יהיה
שקוראים לו; למעשה, מטפל באותות יכול לקרוא לזה בכל נקודה בקוד. כ
כתוצאה מכך, אתה עלול לקבל אזהרה גם כאשר למעשה אין בעיה כי "longjmp"
למעשה לא ניתן להתקשר למקום שיגרום לבעיה.

ניתן להימנע מכמה אזהרות מזויפות אם תצהיר על כל הפונקציות שבהן אתה משתמש
לעולם אל תחזור בתור "norreturn".

אזהרה זו מופעלת על ידי - קיר or אקסטרה.

-לא ידוע-פרגמות
אזהרה כאשר נתקלים בהנחיית "#pragma" שאינה מובנת על ידי GCC. אם זה
נעשה שימוש באפשרות שורת הפקודה, אזהרות אפילו יונפקו עבור פרגמות לא ידועות ב
קבצי כותרות מערכת. זה לא המקרה אם האזהרות היו מופעלות רק על ידי
- קיר אפשרות שורת פקודה.

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

-Wstrict-aliasing
אפשרות זו פעילה רק כאשר -fstrict-aliasing הוא פעיל. זה מזהיר לגבי קוד זה
עלול לשבור את כללי הכינוי הנוקשים שבהם משתמש המהדר לצורך אופטימיזציה.
האזהרה לא תופסת את כל המקרים, אבל כן מנסה לתפוס את הנפוצים יותר
מלכודות. זה כלול ב - קיר. זה שווה ערך ל -Wstrict-aliasing=3

-Wstrict-aliasing=n
אפשרות זו פעילה רק כאשר -fstrict-aliasing הוא פעיל. זה מזהיר לגבי קוד זה
עלול לשבור את כללי הכינוי הנוקשים שבהם משתמש המהדר לצורך אופטימיזציה.
רמות גבוהות יותר מתאימות לדיוק גבוה יותר (פחות תוצאות חיוביות שגויות). שלבים גבוהים
מתאים גם ליותר מאמץ, בדומה לאופן שבו -O עובד. -Wstrict-aliasing is
שווה ערך ל -Wstrict-aliasing=n, עם n=3.

רמה 1: הכי אגרסיבי, מהיר, הכי פחות מדויק. אולי שימושי כשרמות גבוהות יותר
אל תזהיר אבל -fstrict-aliasing עדיין שובר את הקוד, מכיוון שיש בו מעט מאוד false
שליליים. עם זאת, יש לזה הרבה חיוביות שגויות. מזהיר עבור כל המרות מצביעים
בין טיפוסים שאולי לא תואמים, גם אם מעולם לא ניתנו להתייחסותם. פועל מלפנים
סוף בלבד.

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

רמה 3 (ברירת מחדל עבור -Wstrict-aliasing): אמורות להיות מעט מאוד חיוביות שגויות ומעטות
שלילי שווא. מעט איטי יותר מרמות 1 או 2 כאשר האופטימיזציה מופעלת.
דואג לדפוס המשותף של משחקי מילים+התייחסות בחלק הקדמי:
"*(int*)&some_float". אם אופטימיזציה מופעלת, היא פועלת גם בחלק האחורי, שם
הוא עוסק במספר מקרי הצהרות תוך שימוש בנקודות למידע רגיש לזרימה.
מתריע רק כאשר המצביע שהומר מופנה. לא מתריע על חוסר שלם
סוגים.

-Wstrict-הצפה
-Wstrict-overflow=n
אפשרות זו פעילה רק כאשר -פרקט-הצפה הוא פעיל. זה מזהיר על מקרים
שבו המהדר מבצע אופטימיזציה בהתבסס על ההנחה שהגלישה חתומה לא עושה זאת
מתרחש. שימו לב שהוא לא מזהיר על כל המקרים שבהם הקוד עלול לעלות על גדותיו: זה
מזהיר רק על מקרים שבהם המהדר מיישם אופטימיזציה מסוימת. כך זה
אזהרה תלויה ברמת האופטימיזציה.

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

-Wstrict-overflow=1
הזהיר מפני מקרים שהם גם מפוקפקים וגם שקל להימנע מהם. לדוגמה: "x +
1 > x"; עם -פרקט-הצפה, המהדר יפשט את זה ל-1. רמה זו
of -Wstrict-הצפה מופעל על ידי - קיר; רמות גבוהות יותר אינן וחייבות להיות
מתבקש במפורש.

-Wstrict-overflow=2
התריע גם על מקרים אחרים שבהם ההשוואה מפושטת לקבוע. ל
דוגמה: "abs (x) >= 0". ניתן לפשט זאת רק כאשר -פרקט-הצפה הוא ב
אפקט, כי "abs (INT_MIN)" עולה על גדותיו ל-"INT_MIN", שהוא פחות מאפס.
-Wstrict-הצפה (ללא רמה) זהה ל -Wstrict-overflow=2.

-Wstrict-overflow=3
התריע גם על מקרים אחרים שבהם ההשוואה מפושטת. לדוגמה: "x + 1
> 1" יהיה מפושט ל-"x > 0".

-Wstrict-overflow=4
התריע גם על הקלות אחרות שאינן מכוסות על ידי המקרים לעיל. ל
דוגמה: "(x * 10) / 5" יפושט ל-"x * 2".

-Wstrict-overflow=5
התריע גם על מקרים שבהם המהדר מקטין את גודל הקבוע
מעורב בהשוואה. לדוגמה: "x + 2 > y" יפושט ל-"x + 1
>= y". זה מדווח רק ברמת האזהרה הגבוהה ביותר בגלל זה
הפשטות חלה על השוואות רבות, כך שרמת האזהרה הזו תיתן מאוד
מספר רב של תוצאות חיוביות שגויות.

-Wsuggest-attribute=[טהור|const|אין דרך חזרה]
הזהר למקרים שבהם הוספת תכונה עשויה להיות מועילה. התכונות כרגע
הנתמכים מפורטים להלן.

-Wsuggest-attribute=pure
-Wsuggest-attribute=const
-Wsuggest-attribute=norreturn
הזהר לגבי פונקציות שעשויות להיות מועמדות לתכונות "טהור", "קונסט" או
"אין דרך חזרה". המהדר מתריע רק על פונקציות הנראות בקומפילציה אחרת
יחידות או (במקרה של "טהור" ו"קונסט") אם זה לא יכול להוכיח כי הפונקציה
חוזר כרגיל. פונקציה מחזירה כרגיל אם היא לא מכילה אינסוף
לולאה או מחזיר בצורה חריגה על ידי זריקה, קריאה ל-"abort()" או לכידה. זֶה
ניתוח דורש אפשרות -פיפא-טהור-קונסט, המופעל כברירת מחדל ב- -O ו
גבוה יותר. רמות אופטימיזציה גבוהות יותר משפרות את דיוק הניתוח.

-גבולות המלחמה
אפשרות זו פעילה רק כאשר -ftree-vrp פעיל (ברירת מחדל עבור -O2 ומעל). זה
מזהיר על כתוביות משנה למערכים שהם תמיד מחוץ לתחום. אזהרה זו היא
מופעל על ידי - קיר.

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

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

-טרמפולינות
הזהר מפני טרמפולינות שנוצרו עבור מצביעים לפונקציות מקוננות.

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

-Wfloat-שווה
אזהרה אם נעשה שימוש בערכי נקודה צפה בהשוואות שוויון.

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

-מסורתי (C ו-Objective-C בלבד)
הזהיר לגבי מבנים מסוימים שמתנהגים אחרת במסורתי וב-ISO C. כמו כן
להזהיר מפני מבני ISO C שאין להם מקבילה C מסורתית ו/או בעייתית
מבנים שכדאי להימנע מהם.

· פרמטרי מאקרו המופיעים בתוך מילולי מחרוזת בגוף המאקרו. ב
החלפת מאקרו C המסורתית מתרחשת בתוך מילולי מחרוזת, אך לא
ב-ISO C.

· ב-C המסורתי, כמה הנחיות קדם-מעבד לא היו קיימות. מָסוֹרתִי
מעבדי קדם יחשבו קו כהנחיה רק ​​אם # הופיע ב
עמודה 1 על הקו. לָכֵן -מסורתי מזהיר על הנחיות ש
המסורתית C מבינה אבל תתעלם בגלל ה # לא מופיע בתור ה
הדמות הראשונה על הקו. זה גם מציע לך להסתיר הנחיות כמו #פרגמה
לא מובן על ידי C המסורתי על ידי הזחה שלהם. כמה מסורתיים
יישומים לא יזהו #elif, אז זה מציע להימנע מזה לחלוטין.

· מאקרו דמוי פונקציה המופיע ללא ארגומנטים.

· האופרטור האנרי פלוס.

· U סיומת קבועה של מספר שלם, או את F or L סיומות קבועות של נקודה צפה.
(ה-C המסורתית אכן תומכת ב L סיומת על קבועים שלמים.) שימו לב, אלה
סיומות מופיעות בפקודות מאקרו המוגדרות בכותרות המערכת של רוב המערכות המודרניות,
למשל ה _MIN/_MAX פקודות מאקרו ב" ". שימוש בפקודות מאקרו אלה בקוד משתמש עשוי
בדרך כלל מובילים לאזהרות מזויפות, אולם המעבד המשולב של GCC עשה זאת
מספיק הקשר כדי למנוע אזהרה במקרים אלה.

· פונקציה שהוכרזה חיצונית בבלוק אחד ולאחר מכן בשימוש לאחר סיום ה-
לַחסוֹם.

· להצהרת "בורר" יש אופרנד מסוג "ארוך".

· הצהרת פונקציה לא "סטטית" באה בעקבות "סטטי". המבנה הזה לא
מקובל על ידי כמה מהדרים מסורתיים של C.

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

· מזוהה שימוש בשרשור מחרוזת ISO.

· אתחול אגרגטים אוטומטיים.

· מזהה מתנגש עם תוויות. ל-C המסורתי חסר מרחב שמות נפרד עבור
תוויות.

· אתחול האיגודים. אם האתחול הוא אפס, האזהרה נשמטת.
זה נעשה בהנחה שהמאתחל האפס בקוד המשתמש מופיע
מותנה למשל "__STDC__" כדי למנוע אזהרות מאתחול חסרות ומסתמכת על
אתחול ברירת המחדל לאפס במקרה המסורתי של C.

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

· שימוש בהגדרות פונקציות בסגנון ISO C. אזהרה זו היא בכוונה לֹא הנפיק
עבור הצהרות אב טיפוס או פונקציות וריאדיות מכיוון שתכונות ISO C אלו יעשו זאת
מופיעים בקוד שלך בעת שימוש בפקודות המאקרו המסורתיות של תאימות C של liberty,
"PARAMS" ו-"VPARAMS". אזהרה זו עוקפת גם עבור פונקציות מקוננות
כי התכונה הזו היא כבר הרחבה של GCC ולכן לא רלוונטית אליה
תאימות C מסורתית.

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

-הצהרה-אחרי-הצהרה (C ו-Objective-C בלבד)
התריע כשנמצאת הצהרה לאחר הצהרה בבלוק. המבנה הזה, ידוע
מ-C++, הוצג עם ISO C99 והוא מותר כברירת מחדל ב-GCC. זה לא
נתמך על ידי ISO C90 ולא נתמך על ידי גרסאות GCC לפני GCC 3.0.

-וונדף
אזהרה אם מזהה לא מוגדר מוערך ב- #אם הוראה.

-תוויות Wno-endif
אין להזהיר בכל פעם #else או #endif ואחריהם טקסט.

-וצל
אזהרה בכל פעם שמשתנה מקומי או הצהרת סוג מאפיל על משתנה אחר,
פרמטר, סוג או חבר בכיתה (ב-C++), או בכל פעם שיש פונקציה מובנית
מוצל. שימו לב שב-C++, המהדר לא יזהיר אם משתנה מקומי מצל את a
struct/class/enum, אך יזהיר אם הוא מצל על typedef מפורש.

-Wlarer- than=לן
התריע בכל פעם שאובייקט גדול מ לן בתים מוגדר.

-Wframe-larger than=לן
אזהרה אם הגודל של מסגרת פונקציה גדול מ לן בתים. החישוב נעשה
כדי לקבוע את גודל מסגרת הערימה הוא משוער ולא שמרני. בפועל
הדרישות עשויות להיות מעט יותר גדולות מ לן גם אם לא תקבל אזהרה. ב
בנוסף, כל שטח שהוקצה באמצעות "alloca", מערכים באורך משתנה או קשור
constructs אינו נכלל על ידי המהדר בעת קביעה אם להנפיק או לא
אזהרה.

-ללא-חפץ-לא-ערמה
אין להזהיר בעת ניסיון לשחרר חפץ שלא הוקצה בערימה.

-Wstack-usage=לן
אזהרה אם השימוש בערימה של פונקציה עשוי להיות גדול מ לן בתים. החישוב
נעשה כדי לקבוע שהשימוש בערימה הוא שמרני. כל מקום שהוקצה באמצעות "alloca",
מערכים באורך משתנה, או מבנים קשורים נכללים על ידי המהדר כאשר
לקבוע אם יש לתת אזהרה או לא.

ההודעה תואמת את הפלט של -שימוש בערימה.

· אם השימוש בערימה סטטי לחלוטין אך חורג מהכמות שצוינה, זה:

אזהרה: השימוש בערימה הוא 1120 בתים

· אם השימוש בערימה הוא (חלקית) דינמי אך מוגבל, זה:

אזהרה: השימוש בערימה עשוי להיות 1648 בתים

· אם השימוש בערימה הוא (חלקית) דינמי ואינו מוגבל, זה:

אזהרה: השימוש בערימה עשוי להיות בלתי מוגבל

-אופטימיזציות של Wunsafe-loop
אזהרה אם לא ניתן לבצע אופטימיזציה של הלולאה מכיוון שהמהדר לא יכול היה להניח שום דבר
גבולות מדדי הלולאה. עם -אופטימיזציות של לולאת funsafe להזהיר אם המהדר
הניחו הנחות כאלה.

-Wno-pedantic-ms-format (יעדי MinGW בלבד)
משבית את האזהרות לגבי מפרטי רוחב בפורמט "printf" / "scanf" שאינם ISO "I32",
"I64" ו-"I" בשימוש ביעדי Windows בהתאם לזמן הריצה של MS, כאשר אתה משתמש
האפשרויות - ו -קַפְּדָנִי ללא הרחבות גנו.

-Wpointer-arith
התריע על כל דבר שתלוי ב"גודל" של סוג פונקציה או של "ריק". גנו סי
מקצה לסוגים אלה גודל של 1, מטעמי נוחות בחישובים עם "בטל *"
מצביעים ומצביעים לפונקציות. ב-C++, התריע גם כאשר פעולת אריתמטית
כולל "NULL". אזהרה זו מופעלת גם על ידי -קַפְּדָנִי.

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

-Wbad-function-cast (C ו-Objective-C בלבד)
התריע בכל פעם שקריאת פונקציה מועברת לסוג שאינו תואם. לדוגמה, הזהיר אם
"int malloc()" מועבר ל"כל דבר *".

-Wc++-compat (C ו-Objective-C בלבד)
הזהר לגבי מבני ISO C שנמצאים מחוץ לקבוצת המשנה הנפוצה של ISO C ו-ISO
C++, למשל בקשה להמרה מרומזת מ-"void *" למצביע לא-"void"
הקלד.

-Wc++11-compat (C++ ו-Objective-C++ בלבד)
אזהרה לגבי מבני C++ שמשמעותם שונה בין ISO C++ 1998 ו-ISO C++ 2011,
למשל, מזהים ב-ISO C++ 1998 שהם מילות מפתח ב-ISO C++ 2011. אזהרה זו
מדליק -מצמצם והוא מופעל על ידי - קיר.

-Wcast-qual
התריע בכל פעם שמצביע מצביע כדי להסיר סממן סוג מטיפוס היעד.
לדוגמה, הזהר אם "const char *" יצוק ל-char * רגיל.

התריעו גם בעת ביצוע קאסט שמציג מוקדמות סוג בצורה לא בטוחה. ל
דוגמה, ההעברה של "char **" ל-"const char **" אינה בטוחה, כמו בדוגמה זו:

/* p הוא ערך char **. */
const char **q = (const char **) p;
/* הקצאת מחרוזת לקריאה בלבד ל-const char * היא בסדר. */
*q = "מחרוזת";
/* כעת char** מצביע על זיכרון לקריאה בלבד. */
**p = 'b';

-יישור Wcast
התריע בכל פעם שמטיל מצביע כך שהיישור הנדרש של המטרה הוא
מוּגדָל. לדוגמה, הזהר אם "char *" יצוק ל-"int *" במכונות שבהן
ניתן לגשת למספרים שלמים רק בגבולות של שניים או ארבעה בתים.

-כתוב-מחרוזות
בעת הידור C, תן לקבועי מחרוזת את הסוג "const char[אורך]" אז ההעתקה
הכתובת של אחד לתוך מצביע שאינו "const" "char *" יקבל אזהרה. אלה
אזהרות יעזרו לך למצוא בזמן הקומפילציה קוד שיכול לנסות לכתוב לתוך מחרוזת
קבוע, אבל רק אם הקפדת מאוד על השימוש ב-"const" בהצהרות
ואבות טיפוס. אחרת, זה רק יהיה מטרד. זו הסיבה שלא עשינו
- קיר לבקש אזהרות אלו.

בעת קומפילציה של C++, התריע על ההמרה שהוצאה ממחרוזת מילולית ל-"char
*". אזהרה זו מופעלת כברירת מחדל עבור תוכניות C++.

-קשקש
אזהרה על משתנים שעלולים להשתנות על ידי longjmp or vfork. גם אזהרה זו
מופעל על ידי אקסטרה.

-המרה
הזהר מפני המרות מרומזות שעלולות לשנות ערך. זה כולל המרות
בין ממשי למספר שלם, כמו "abs (x)" כאשר "x" הוא "כפול"; המרות בין
חתום ולא חתום, כמו "Unsigned ui = -1"; והמרות לסוגים קטנים יותר, כמו
"sqrtf (M_PI)". אין להזהיר עבור שחקנים מפורשים כמו "abs ((int) x)" ו-"ui =
(ללא סימן) -1", או אם הערך לא משתנה על ידי ההמרה כמו ב"abs (2.0)".
ניתן להשבית אזהרות על המרות בין מספרים שלמים עם חתימה ללא חתימה על ידי
באמצעות -המרת Wno-sign.

עבור C++, התריע גם על רזולוציית עומס מבלבלת עבור המרות המוגדרות על ידי משתמש; ו
המרות שלעולם לא ישתמשו באופרטור המרה מסוג: המרות ל-"void", ה
אותו סוג, מחלקה בסיס או הפניה אליהם. אזהרות לגבי המרות בין
מספרים שלמים חתומים ובלתי חתומים מושבתים כברירת מחדל ב-C++ אלא אם כן -המרת סימן
מופעל במפורש.

-Wno-conversion-null (C++ ו-Objective-C++ בלבד)
אין להזהיר על המרות בין "NULL" לסוגים שאינם מצביעים. -Wconversion-null is
מופעלת כברירת מחדל.

-Wzero-as-null-pointer-constant (C++ ו-Objective-C++ בלבד)
אזהרה כאשר '0' מילולי משמש כקבוע מצביע אפס. זה יכול להיות שימושי עבור
להקל על ההמרה ל-"nullptr" ב-C++11.

-גוף רטוב
התריע אם מתרחש גוף ריק ב- if, אחר or do בזמן הַצהָרָה. אזהרה זו היא
מופעל גם על ידי אקסטרה.

-וונום-השוו
הזהיר מפני השוואה בין ערכים מסוגים שונים שנמנו. ב-C++ ספירה
חוסר התאמה בביטויים מותנים מאובחנים גם והאזהרה מופעלת על ידי
בְּרִירַת מֶחדָל. ב-C אזהרה זו מופעלת על ידי - קיר.

-Wjump-misses-init (C, Objective-C בלבד)
אזהרה אם הצהרת "גוטו" או הצהרת "בורר" קופצת קדימה על פני ה-
אתחול של משתנה, או קפיצה אחורה לתווית לאחר שהמשתנה היה
אתחול. זה רק מתריע על משתנים שמאוחלים כאשר הם נמצאים
מוּצהָר. אזהרה זו נתמכת רק עבור C ו-Objective-C; ב-C++ מהסוג הזה
סניף הוא שגיאה בכל מקרה.

-Wjump-misses-init כלול ב- -Wc++-compat. זה יכול להיות מושבת עם
-לא-קפוץ-מפספס-init אוֹפְּצִיָה.

-Wsign-השוואה
אזהרה כאשר השוואה בין ערכים חתומים וחסרי סימן עלולה לייצר שגוי
תוצאה כאשר הערך החתום מומר ללא חתום. גם אזהרה זו מופעלת
by אקסטרה; כדי לקבל את שאר האזהרות אקסטרה ללא אזהרה זו, השתמש אקסטרה
-לא-סימן-השוואה.

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

-כתובת
הזהר לגבי שימושים חשודים בכתובות זיכרון. אלה כוללים שימוש בכתובת של א
פונקציה בביטוי מותנה, כגון "void func(void); if (func)", ו
השוואות מול כתובת הזיכרון של מחרוזת מילולית, כגון "if (x == "abc").
שימושים כאלה מעידים בדרך כלל על שגיאת מתכנת: הכתובת של פונקציה תמיד
מעריך נכון, אז השימוש שלהם בתנאי בדרך כלל מצביע על כך שהמתכנת
שכחו את הסוגריים בקריאת פונקציה; והשוואות מול מילולי מחרוזת
מביאים להתנהגות לא מוגדרת ואינם ניידים ב-C, כך שהם בדרך כלל מציינים
שהמתכנת התכוון להשתמש ב-"strcmp". אזהרה זו מופעלת על ידי - קיר.

-Wlogical-op
הזהר מפני שימושים חשודים באופרטורים לוגיים בביטויים. זה כולל שימוש
אופרטורים לוגיים בהקשרים שבהם סביר להניח שצפוי לאופרטור חכם.

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

-אין תכונות
אין להזהיר אם נעשה שימוש ב"__תכונה__" בלתי צפויה, כגון תכונות לא מזוהות,
תכונות פונקציה שהוחלו על משתנים וכו'. זה לא יעצור שגיאות עבור
שימוש שגוי בתכונות נתמכות.

-מובנה-מקרו-מוגדר מחדש
אל תזהיר אם פקודות מאקרו מובנות מסוימות מוגדרות מחדש. זה מדכא אזהרות עבור
הגדרה מחדש של "__TIMESTAMP__", "__TIME__", "__DATE__", "__FILE__", וכן
"__BASE_FILE__".

-Wstrict-אב טיפוס (C ו-Objective-C בלבד)
אזהרה אם פונקציה מוצהרת או מוגדרת מבלי לציין את סוגי הארגומנטים. (אנ
הגדרת פונקציה בסגנון ישן מותרת ללא אזהרה אם לפניה א
הצהרה המציינת את סוגי הארגומנטים.)

-הצהרה בסגנון וולד (C ו-Objective-C בלבד)
התריע על שימושים מיושנים, על פי תקן C, בהצהרה. ל
לדוגמה, הזהר אם מפרטי מחלקת אחסון כמו "סטטי" אינם הדברים הראשונים ב-a
הַצהָרָה. אזהרה זו מופעלת גם על ידי אקסטרה.

-הגדרה בסגנון וולד (C ו-Objective-C בלבד)
אזהרה אם נעשה שימוש בהגדרת פונקציה בסגנון ישן. ניתנת אזהרה גם אם יש
אב טיפוס קודם.

-סוג חסר-פרמטר (C ו-Objective-C בלבד)
פרמטר פונקציה מוכרז ללא מפרט סוג בפונקציות בסגנון K&R:

void foo(bar) { }

אזהרה זו מופעלת גם על ידי אקסטרה.

-חסרי-אבטיפוס (C ו-Objective-C בלבד)
אזהרה אם מוגדרת פונקציה גלובלית ללא הצהרת אב טיפוס קודמת. זֶה
אזהרה ניתנת גם אם ההגדרה עצמה מספקת אב טיפוס. המטרה היא
לזהות פונקציות גלובליות שאינן מוצהרות בקובצי כותרות.

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

-חסרי-שדה-initializers
אזהרה אם באתחול של מבנה חסרים כמה שדות. לדוגמה, הדברים הבאים
קוד יגרום לאזהרה כזו, כי "xh" הוא אפס באופן מרומז:

struct s { int f, g, h; };
struct sx = { 3, 4 };

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

struct s { int f, g, h; };
struct sx = { .f = 3, .g = 4 };

אזהרה זו כלולה ב אקסטרה. כדי לקבל אחר אקסטרה אזהרות בלי זה,
להשתמש אקסטרה -לא-חסרים-שדה-initializers.

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

GCC גם יזהיר לגבי הגדרות פונקציות שעשויות להיות מועמדות ל"פורמט"
תכונות. שוב, אלו רק מועמדים אפשריים. GCC ינחש את ה"פורמט" הזה
תכונות עשויות להתאים לכל פונקציה שקוראת לפונקציה כמו "vprintf"
או "vscanf", אבל אולי זה לא תמיד המקרה, וחלק מהפונקציות עבורן
ייתכן שתכונות "פורמט" מתאימות לא יזוהו.

-Wno-multichar
אין להזהיר אם קבוע מרובה תווים ('פוף') משמש. בדרך כלל הם מציינים א
שגיאת הקלדה בקוד המשתמש, שכן יש להם ערכים מוגדרים ביישום, ואסור שיהיו
משמש בקוד נייד.

-Wnormalized=
ב-ISO C ו-ISO C++, שני מזהים שונים אם הם רצפים שונים של
דמויות. עם זאת, לפעמים כאשר תווים מחוץ לקבוצת התווים הבסיסית של ASCII
בשימוש, יכולים להיות שני רצפי תווים שונים שנראים זהים. להתחמק
בלבול, תקן ISO 10646 קובע כמה נוֹרמָלִיזָצִיָה כללי אשר כאשר מיושם
ודא ששני רצפים שנראים זהים יהפכו לאותו רצף. GCC
יכול להזהיר אותך אם אתה משתמש במזהים שלא נורמלו; אפשרות זו
שולט באזהרה זו.

ישנן ארבע רמות אזהרה הנתמכות על ידי GCC. ברירת המחדל היא -Wnormalized=nfc,
שמזהיר על כל מזהה שאינו בצורת ISO 10646 "C" מנורמל,
NFC. NFC הוא הטופס המומלץ לרוב השימושים.

למרבה הצער, ישנם כמה תווים המותרים במזהים לפי ISO C ו-ISO C++
שכאשר הופכים אותם ל-NFC, אינם מותרים במזהים. כלומר, אין סיכוי
להשתמש בסמלים אלה ב-ISO C או C++ ניידים ולהחזיק את כל המזהים שלך ב-NFC.
-Wnormalized=id מדכא את האזהרה עבור דמויות אלה. יש לקוות כי העתיד
גרסאות של הסטנדרטים המעורבים יתקנו זאת, וזו הסיבה שהאפשרות הזו לא
ברירת המחדל.

אתה יכול לכבות את האזהרה עבור כל התווים על ידי כתיבה -Wnormalized=אין. אתה
היית רוצה לעשות זאת רק אם אתה משתמש בסכימת נורמליזציה אחרת (כמו
"D"), כי אחרת אתה יכול בקלות ליצור באגים שממש בלתי אפשרי לעשות
לראות.

לחלק מהתווים ב-ISO 10646 יש משמעויות שונות אך נראים זהים בחלק מהגופנים
או מתודולוגיות תצוגה, במיוחד לאחר החלת עיצוב. לדוגמה
"\u207F", "SUPERSCRIPT LATIN SMALL LETTER N", יוצג בדיוק כמו "n" רגיל
שהוצב בכתב עילי. ISO 10646 מגדיר את NFKC נוֹרמָלִיזָצִיָה
תוכנית להמיר את כל אלה גם לטופס סטנדרטי, ו-GCC יזהיר אם שלך
הקוד אינו ב-NFKC אם אתה משתמש -Wnormalized=nfkc. אזהרה זו דומה ל
אזהרה לגבי כל מזהה שמכיל את האות O מכיוון שהוא עלול להתבלבל
עם הספרה 0, ולכן אינה ברירת המחדל, אך עשויה להיות שימושית כקידוד מקומי
מוסכמה אם לא ניתן לתקן את סביבת התכנות להצגת אלה
דמויות באופן מובהק.

-לא הוצא משימוש
אל תזהיר על שימוש בתכונות שהוצאו משימוש.

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

-ללא הצפה
אל תזהיר על הצפת זמן קומפילציה בביטויים קבועים.

-Woverride-init (C ו-Objective-C בלבד)
התריע אם שדה מאותחל ללא תופעות לוואי מוחלף בעת השימוש המיועד
אתחולים.

אזהרה זו כלולה ב אקסטרה. כדי לקבל אחר אקסטרה אזהרות בלי זה,
להשתמש אקסטרה -לא-עקיפה-init.

-ארוז
אזהרה אם למבנה ניתנת התכונה packed, אבל לתכונה packed אין
השפעה על הפריסה או הגודל של המבנה. מבנים כאלה עשויים להיות לא מיושרים עבור
תועלת קטנה. לדוגמה, בקוד זה, המשתנה "fx" ב-"struct bar".
להיות לא מיושר למרות של-"struct bar" אין בעצמו את התכונה packed:

struct foo {
int x;
שר א, ב, ג, ד;
} __attribute __ ((ארוז));
סרגל struct {
char z;
struct foo f;
};

-Wpacked-bitfield-compat
סדרות 4.1, 4.2 ו-4.3 של GCC מתעלמות מהתכונה "ארוז" בשדות סיביות של סוג
"לְהַשְׁחִיר". זה תוקן ב-GCC 4.4 אבל השינוי יכול להוביל להבדלים ב-
פריסת מבנה. GCC מודיע לך כשהקיזוז של שדה כזה השתנה ב-GCC
4.4. לדוגמה, אין עוד ריפוד של 4 סיביות בין שדה "a" ו-"b" בזה
מבנה you

struct foo
{
char a:4;
char b:8;
} __תכונה__ ((ארוז));

אזהרה זו מופעלת כברירת מחדל. להשתמש -Wno-packed-bitfield-compat כדי להשבית את זה
אזהרה.

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

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

-Wnested-externs (C ו-Objective-C בלבד)
אזהרה אם נתקלת בהצהרה "חיצונית" בתוך פונקציה.

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

המהדר משתמש במגוון של היוריסטיות כדי לקבוע אם להטמיע או לא
פוּנקצִיָה. לדוגמה, המהדר לוקח בחשבון את גודל ה-function being
מוטבע וכמות ההטבעה שכבר בוצעה בפונקציה הנוכחית.
לכן, שינויים חסרי משמעות לכאורה בתוכנית המקור יכולים לגרום ל
אזהרות שהופקו על ידי -Winline להופיע או להיעלם.

-Wno-invalid-offsetof (C++ ו-Objective-C++ בלבד)
דחק אזהרות מיישום ה קיזוז מאקרו לסוג שאינו POD. לפי
תקן ISO C++ משנת 1998, החל קיזוז לסוג שאינו POD אינו מוגדר. ב
עם זאת, יישומי C++ קיימים, קיזוז בדרך כלל נותן תוצאות משמעותיות
אפילו כאשר מיושמים על סוגים מסוימים של סוגי לא-POD. (כגון פשוט מבנה זֶה
לא מצליח להיות סוג POD רק בגלל שיש בנאי.) הדגל הזה מיועד
משתמשים שמודעים לכך שהם כותבים קוד לא נייד ושעשו זאת בכוונה
נבחר להתעלם מהאזהרה על כך.

ההגבלות על קיזוז עשוי להיות רגוע בגרסה עתידית של תקן C++.

-Wno-int-to-pointer-cast
הדחיק אזהרות מהטלה לסוג מצביע של מספר שלם בגודל שונה. ב
C++, השלכה לסוג מצביע בגודל קטן יותר היא שגיאה. ניצוח-למצביע-cast is
מופעלת כברירת מחדל.

-אין-מצביע ל-int-cast (C ו-Objective-C בלבד)
דחק אזהרות מהטלות ממצביע לסוג של מספר שלם בגודל שונה.

-Winvalid-pch
אזהרה אם נמצאה כותרת מהודרת מראש בנתיב החיפוש אך לא ניתן להשתמש בה.

-ולונג-ארוך
הזהיר אם ארוך ארוך נעשה שימוש בסוג. זה מופעל על ידי אחד מהם -קַפְּדָנִי or -מסורתי
במצבי ISO C90 ו-C++98. כדי לבלום את הודעות האזהרה, השתמש -לא ארוך-ארוך.

-Wvariadic-macros
אזהרה אם נעשה שימוש בפקודות מאקרו וריאדיות במצב ISO C90 פדנטי, או בתחביר החלופי של GNU
במצב פדנטי ISO C99. זוהי ברירת מחדל. כדי לבלום את הודעות האזהרה, השתמש
-Wno-variadic-macros.

-וקטור-פעולה-ביצועים
התריע אם פעולה וקטורית אינה מיושמת באמצעות יכולות SIMD של הארכיטקטורה.
שימושי בעיקר עבור כוונון הביצועים. ניתן ליישם פעולת וקטור
"piecewise", כלומר הפעולה הסקלרית מתבצעת על כל וקטור
אֵלֵמֶנט; "במקביל", כלומר פעולת הווקטור מיושמת באמצעות
סקלרים מסוג רחב יותר, שבדרך כלל יעיל יותר בביצועים; ו" בתור רווק
scalar", כלומר הוקטור מתאים לסוג סקלרי.

-Wvla
אזהרה אם נעשה שימוש במערך אורך משתנה בקוד. -Wno-vla ימנע את
-קַפְּדָנִי אזהרה על מערך האורך המשתנה.

-Wvolatile-register-var
אזהרה אם משתנה אוגר מוכרז נדיף. המשנה הנדיף לא
לעכב את כל האופטימיזציות שעלולות לבטל קריאה ו/או כתיבה לרישום
משתנים. אזהרה זו מופעלת על ידי - קיר.

-Wdisabled-אופטימיזציה
אזהרה אם כרטיס אופטימיזציה מבוקש מושבת. אזהרה זו לא בדרך כלל
לציין שמשהו לא בסדר בקוד שלך; זה רק מציין ש-GCC's
כלי האופטימיזציה לא הצליחו לטפל בקוד ביעילות. לעתים קרובות, הבעיה היא בכך
הקוד שלך גדול מדי או מורכב מדי; GCC תסרב לבצע אופטימיזציה של תוכניות כאשר
סביר להניח שהאופטימיזציה עצמה תיקח כמויות מוגזמות של זמן.

-סימן Wpointer (C ו-Objective-C בלבד)
אזהרה על העברת טיעון מצביע או הקצאה עם חתימות שונה. זֶה
האפשרות נתמכת רק עבור C ו-Objective-C. זה משתמע מ - קיר ועל ידי
-קַפְּדָנִי, שניתן להשבית באמצעותו -לא-מצביע-סימן.

-מגן Wstack
אפשרות זו פעילה רק כאשר -מגן מחסנית הוא פעיל. זה מזהיר לגבי פונקציות
שלא יהיה מוגן מפני ריסוק מחסנית.

-לא-דש בוץ
הדחיק אזהרות לגבי מבנים שלא ניתן להתקין באמצעותם -fmudflap.

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

המגבלה חלה לאחר שרשור קבוע של מחרוזת, ואינו סופר את הנגרר
NUL. ב-C90, המגבלה הייתה 509 תווים; ב-C99, הוא הועלה ל-4095. C++98 כן
לא מציינים מקסימום מינימלי נורמטיבי, אז אנחנו לא מאבחנים מחרוזות באורך יתר
C ++.

אפשרות זו משתמעת מ -קַפְּדָנִי, וניתן לנטרל באמצעות -לא-אורך יתר-מיתרים.

-משימות-צפות-קבועות (C ו-Objective-C בלבד)
GCC תוציא אזהרה עבור כל קבוע צף שאין לו סיומת. מתי
בשימוש יחד עם -כותרות Wsystem זה יתריע על קבועים כאלה בכותרת המערכת
קבצים. זה יכול להיות שימושי בעת הכנת קוד לשימוש עם "FLOAT_CONST_DECIMAL64"
פרגמה מהרחבת נקודה צפה עשרונית ל-C99.

אפשרויות ל Debugging תָכְנִית or GCC
ל-GCC יש אפשרויות מיוחדות שונות המשמשות לאיתור באגים בתוכנית שלך או ב-GCC:

-g הפקת מידע איתור באגים בפורמט המקורי של מערכת ההפעלה (דקירות, COFF,
XCOFF, או גמד 2). GDB יכול לעבוד עם מידע ניפוי באגים זה.

ברוב המערכות המשתמשות בפורמט דקירות, -g מאפשר שימוש במידע נוסף על ניפוי באגים
שרק GDB יכול להשתמש בו; המידע הנוסף הזה גורם לניפוי באגים לעבוד טוב יותר ב-GDB אבל
סביר להניח שיגרום לניפוי באגים אחרים לקרוס או לסרב לקרוא את התוכנית. אם אתה רוצה
כדי לשלוט בוודאות אם ליצור את המידע הנוסף, השתמש -gstabs+,
-gstabs, -gxcoff+, -gxcoff, או -gvms (ראה למטה).

GCC מאפשר לך להשתמש -g עם -O. קיצורי הדרך שנלקחו על ידי קוד מותאם עשויים
מייצרים מדי פעם תוצאות מפתיעות: ייתכן שחלק מהמשתנים שהצהרת אינם קיימים בהם
את כל; זרימת השליטה עשויה לנוע לזמן קצר למקום שלא ציפית לה; כמה הצהרות עשויות
לא יבוצעו מכיוון שהם מחשבים תוצאות קבועות או שהערכים שלהם כבר היו
יד; הצהרות מסוימות עשויות להתבצע במקומות שונים מכיוון שהן הועברו החוצה
לולאות.

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

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

-ggdb
הפקת מידע על ניפוי באגים לשימוש על ידי GDB. זה אומר להשתמש הכי אקספרסיבי
פורמט זמין (DWARF 2, stabs, או הפורמט המקורי אם אף אחד מהם לא
נתמך), כולל הרחבות GDB אם זה אפשרי.

-gstabs
הפקת מידע איתור באגים בפורמט stabs (אם זה נתמך), ללא GDB
הרחבות. זהו הפורמט המשמש את DBX ברוב מערכות ה-BSD. ב-MIPS, אלפא ו
System V Release 4 מערכות אפשרות זו מייצרת פלט ניפוי באגים דקירות שלא
מובן על ידי DBX או SDB. במערכות System V Release 4 אפשרות זו דורשת את ה-GNU
אספן.

סמלים-feliminate-unused-debug-symbols
הפק מידע איתור באגים בפורמט stabs (אם זה נתמך), עבור סמלים בלבד
שמשתמשים בהם בפועל.

-femit-class-debug-always
במקום לפלוט מידע איתור באגים עבור מחלקה C++ בקובץ אובייקט אחד בלבד,
פולט אותו בכל קבצי האובייקטים באמצעות המחלקה. יש להשתמש באפשרות זו רק עם
מאפי באגים שאינם מסוגלים להתמודד עם הדרך שבה GCC פולט בדרך כלל מידע על ניפוי באגים
עבור מחלקות מכיוון ששימוש באפשרות זו יגדיל את גודל המידע באגים
לפי עד כדי פקטור של שניים.

-fno-debug-types-section
כברירת מחדל בעת שימוש ב-DWARF v4 ומעלה מסוג DIEs יוכנסו לעצמם
קטע .debug_types במקום להפוך אותם לחלק מקטע .debug_info. זה
יעיל יותר להכניס אותם לקטעי comdat נפרדים מכיוון שהמקשר יהיה אז
מסוגל להסיר כפילויות. אבל לא כל צרכני DWARF תומכים בקטעי .debug_types
עדיין.

-gstabs+
הפק מידע איתור באגים בפורמט stabs (אם זה נתמך), באמצעות GNU
הרחבות מובנות רק על ידי מאתר הבאגים של GNU (GDB). השימוש בהרחבות אלו הוא
סביר שיגרום לניפוי באגים אחרים לקרוס או לסרב לקרוא את התוכנית.

-גקוף
הפק מידע איתור באגים בפורמט COFF (אם זה נתמך). זה
פורמט בשימוש SDB ברוב מערכות System V לפני גרסה 4 של System V.

-gxcoff
הפק מידע איתור באגים בפורמט XCOFF (אם זה נתמך). זה
פורמט המשמש את מאפר הבאגים של DBX במערכות IBM RS/6000.

-gxcoff+
הפק מידע איתור באגים בפורמט XCOFF (אם זה נתמך), באמצעות GNU
הרחבות מובנות רק על ידי מאתר הבאגים של GNU (GDB). השימוש בהרחבות אלו הוא
עלול לגרום לאותי באגים אחרים לקרוס או לסרב לקרוא את התוכנית, ועלול לגרום
אסמבלים אחרים מלבד ה-GNU assembler (GAS) ייכשלו עם שגיאה.

-גמד-גרסה
הפק מידע איתור באגים בפורמט DWARF (אם זה נתמך). זה
פורמט בשימוש DBX ב-IRIX 6. הערך של גרסה יכול להיות 2, 3 או 4; ה
גרסת ברירת המחדל היא 2.

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

גרסה 4 עשויה לדרוש GDB 7.0 ו -fvar-tracking-assignments לתועלת מירבית.

-grecord-gcc-מתגים
מתג זה גורם לאפשרויות שורת הפקודה המשמשות להפעלת המהדר שעלול
להשפיע על יצירת הקוד שיש לצרף לתכונה DW_AT_producer ב-DWARF
מידע באגים. האפשרויות משורשרות עם רווחים המפרידים ביניהן
אחד את השני ומגרסת המהדר. ראה גם -frecord-gcc-מתגים בשביל מישהו אחר
דרך לאחסן אפשרויות מהדר בקובץ האובייקט.

-gno-record-gcc-switches
אסור להוסיף אפשרויות שורת פקודה לתכונה DW_AT_producer ב-DWARF
מידע באגים. זוהי ברירת המחדל.

-gstrict-גמד
אסור להשתמש בהרחבות של גרסת DWARF סטנדרטית מאוחרת יותר מזו שנבחרה עם
-גמד-גרסה. ברוב המטרות באמצעות הרחבות DWARF שאינן מתנגשות ממאוחר יותר
גרסאות סטנדרטיות מותרות.

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

-gvms
הפק מידע איתור באגים בפורמט ניפוי באגים VMS (אם זה נתמך). זה
פורמט המשמש את DEBUG במערכות VMS.

-gרָמָה
-ggdbרָמָה
-gstabsרָמָה
-גקוףרָמָה
-gxcoffרָמָה
-gvmsרָמָה
בקש מידע על ניפוי באגים וגם השתמש רָמָה כדי לציין כמה מידע. ה
רמת ברירת המחדל היא 2.

רמה 0 אינה מייצרת כלל מידע על ניפוי באגים. לכן, -ג0 שולל -g.

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

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

-gdwarf-2 אינו מקבל רמת ניפוי באגים משורשרת, מכיוון ש-GCC נהג לתמוך ב-
אוֹפְּצִיָה -גמד שנועד ליצור מידע באגים בגרסה 1 של ה-DWARF
פורמט (ששונה מאוד מגרסה 2), וזה היה מבלבל מדי.
פורמט ניפוי באגים מיושן מזמן, אך לא ניתן לשנות את האפשרות כעת. במקום להשתמש
נוסף -gרָמָה אפשרות לשנות את רמת ניפוי הבאגים עבור DWARF.

-gtoggle
כבה את יצירת מידע ניפוי באגים, אם השארת אפשרות זו הייתה מייצרת אותו,
או להפעיל אותו ברמה 2 אחרת. המיקום של טיעון זה בשורת הפקודה
לא משנה, זה נכנס לתוקף לאחר עיבוד כל האפשרויות האחרות, וזה עושה זאת
רק פעם אחת, לא משנה כמה פעמים היא ניתנת. זה נועד בעיקר לשימוש
עם -fcompare-debug.

-fdump-final-inss[=פילה]
זרוק את הייצוג הפנימי הסופי (RTL) ל פילה. אם הארגומנט האופציונלי הוא
הושמט (או אם פילה הוא "."), השם של קובץ ה-dump ייקבע על ידי הוספה
".gkd" לשם קובץ הפלט הקומפילציה.

-fcompare-debug[=בוחר]
אם לא מתרחשת שגיאה במהלך ההידור, הפעל את המהדר פעם שנייה, והוסף בוחר ו
-fcompare-debug-second לטיעונים שהועברו לאוסף השני. לזרוק את
ייצוג פנימי סופי בשני הקופילציות, והדפיס שגיאה אם ​​הם שונים.

אם סימן השוויון מושמט, ברירת המחדל -gtoggle משמש.

משתנה הסביבה GCC_COMPARE_DEBUG, אם מוגדר, לא ריק ולא אפס,
מאפשר באופן מרומז -fcompare-debug. אם GCC_COMPARE_DEBUG מוגדר למחרוזת
מתחיל עם מקף, ואז הוא משמש עבור בוחר, אחרת ברירת המחדל -gtoggle is
מְשׁוּמָשׁ.

-fcompare-debug=, עם סימן השוויון אבל בלי בוחר, שווה ל
-fno-compare-debug, אשר משבית את השלכת הייצוג הסופי ואת
אוסף שני, מונע אפילו GCC_COMPARE_DEBUG מכניסה לתוקף.

כדי לוודא כיסוי מלא במהלך -fcompare-debug בדיקה, סט GCC_COMPARE_DEBUG לומר
-פרפר-דבוג-לא מרותק, ש-GCC ידחה כאפשרות לא חוקית בכל
קומפילציה בפועל (ולא עיבוד מקדים, הרכבה או קישור). כדי לקבל רק א
אזהרה, הגדרה GCC_COMPARE_DEBUG ל -w%n-fcompare-debug לֹא נעקר זה מה שאעשה.

-fcompare-debug-second
אפשרות זו מועברת באופן מרומז למהדר עבור ההידור השני המבוקש
by -fcompare-debug, יחד עם אפשרויות להשתיק אזהרות, והשמטת אפשרויות אחרות
שיגרום לפלטים של מהדר תופעת לוואי לקבצים או לפלט הסטנדרטי.
שמם של קבצי dump וקבצים זמניים שמורים משתנים כך שיכילו את ה-".gk"
הרחבה נוספת במהלך הקומפילציה השנייה, כדי למנוע החלפת אלה
שנוצר על ידי הראשון.

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

-פלימינאט-גמד2-דופים
דחוס מידע ניפוי באגים DWARF2 על ידי ביטול מידע משוכפל על כל אחד מהם
סֵמֶל. אפשרות זו הגיונית רק בעת יצירת מידע ניפוי באגים DWARF2
עם -gdwarf-2.

-femit-struct-debug-baseonly
שלח מידע ניפוי באגים עבור טיפוסים דמויי struct רק כאשר שם הבסיס של ה-
קובץ מקור הקומפילציה מתאים לשם הבסיס של הקובץ שבו הוגדר ה-struct.

אפשרות זו מקטינה באופן משמעותי את גודל מידע ניפוי באגים, אך ב-
אובדן פוטנציאלי משמעותי במידע הסוג למאתר הבאגים. לִרְאוֹת
-מיט-סטרוק-דבוק מופחת לאופציה פחות אגרסיבית. לִרְאוֹת
-femit-struct-debug-detailed לשליטה מפורטת יותר.

אפשרות זו פועלת רק עם DWARF 2.

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

אפשרות זו מפחיתה באופן משמעותי את גודל המידע באגים, עם חלק
אובדן פוטנציאלי במידע על סוג למאתר הבאגים. לִרְאוֹת -femit-struct-debug-baseonly
לאופציה אגרסיבית יותר. לִרְאוֹת -femit-struct-debug-detailed לפרטים נוספים
שליטה.

אפשרות זו פועלת רק עם DWARF 2.

-femit-struct-debug-detailed[=מפרט-רשימת]
ציין את סוגי המבנה שעבורם המהדר יפיק מידע באגים.
הכוונה היא לצמצם מידע כפול של ניפוי מבנה בין אובייקטים שונים
קבצים בתוך אותה תוכנית.

אפשרות זו היא גרסה מפורטת של -מיט-סטרוק-דבוק מופחת ו
-femit-struct-debug-baseonly, אשר ישרת עבור רוב הצרכים.

למפרט יש את התחביר[דיר:|ind:][ord:|ז'אנר:](כל|sys|בסיס|אף לא אחד)

המילה הראשונה האופציונלית מגבילה את המפרט למבנים המשמשים ישירות
(דיר:) או בשימוש עקיף (ind:). סוג struct משמש ישירות כאשר הוא הטיפוס
של משתנה, איבר. שימושים עקיפים נוצרים באמצעות מצביעים למבנים. זה,
כאשר השימוש במבנה לא שלם יהיה חוקי, השימוש הוא עקיף. דוגמה היא
מבנה אחד ישיר; מבנה שתיים * עקיף;.

המילה השנייה האופציונלית מגבילה את המפרט למבנים רגילים (ord:) או
מבנים גנריים (ז'אנר:). מבנים גנריים מעט מסובכים להסבר. עבור C++,
אלו הן התמחויות לא מפורשות של מחלקות תבנית, או מחלקות שאינן תבניתיות
בתוך האמור לעיל. לשפות תכנות אחרות יש גנריות, אבל
-femit-struct-debug-detailed עדיין לא מיישם אותם.

המילה השלישית מציינת את קבצי המקור עבור אותם מבנים שעבורם המהדר
יפלוט מידע ניפוי באגים. הערכים אף לא אחד ו כל יש משמעות נורמלית. ה
ערך בסיס פירושו שבסיס השם של הקובץ שבו הצהרת הסוג
appears חייב להתאים לבסיס השם של קובץ ההידור הראשי. בפועל,
זה אומר שסוגים שהוכרזו ב foo.c ו foo.h יהיה מידע על ניפוי באגים, אבל
סוגים שהוכרזו בכותרת אחרת לא יעשו זאת. הערך sys פירושו שסוגים אלה מספקים
בסיס או מוצהר בכותרות המערכת או המהדר.

ייתכן שיהיה עליך להתנסות כדי לקבוע את ההגדרות הטובות ביותר עבור היישום שלך.

ברירת המחדל היא -femit-struct-debug-detailed=הכל.

אפשרות זו פועלת רק עם DWARF 2.

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

-fdebug-prefix-map=זקן=חדש
בעת קומפילציה של קבצים בספרייה זקן, הקלט מידע על ניפוי באגים המתאר אותם כ
in חדש במקום.

-fno-dwarf2-cfi-asm
שלח מידע על שחרור DWARF 2 כקטע ".eh_frame" שנוצר מהמהדר במקום להשתמש
הנחיות GAS ".cfi_*".

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

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

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

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

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

-fpre-ipa-mem-report
-fpost-ipa-mem-report
גורם למהדר להדפיס כמה סטטיסטיקות לגבי הקצאת זיכרון קבועה לפני או
לאחר אופטימיזציה בין-הליכים.

-שימוש בערימה
הופך את ערימת הפלט של המהדר למידע על השימוש עבור התוכנית, בפונקציה לכל פונקציה
בָּסִיס. שם הקובץ עבור ה-dump נעשה על ידי הוספה .su אל ה שם עזר. שם עזר is
נוצר מהשם של קובץ הפלט, אם צוין במפורש והוא אינו an
קובץ הפעלה, אחרת זה שם הבסיס של קובץ המקור. ערך מורכב מ
שלושה שדות:

· שם הפונקציה.

· מספר בתים.

· מוקדמות אחד או יותר: "סטטי", "דינמי", "מוגבל".

המוקדמות "סטטי" פירושו שהפונקציה מבצעת מניפולציות על הערימה באופן סטטי: א
מספר קבוע של בתים מוקצים למסגרת בהזנת פונקציה ומשוחררים ב-
יציאה מהפונקציה; אחרת לא בוצעו התאמות ערימה בפונקציה. השני
השדה הוא המספר הקבוע הזה של בתים.

המוקדמות "דינמי" פירושו שהפונקציה מבצעת מניפולציות על המחסנית באופן דינמי: in
בנוסף להקצאה הסטטית שתוארה לעיל, התאמות מחסניות מתבצעות ב-
גוף הפונקציה, למשל לדחיפה/פופ ארגומנטים סביב קריאות לפונקציה. אם ה
גם ה-qualifier "bounded" קיים, כמות ההתאמות הללו מוגבלת
זמן קומפילציה והשדה השני הוא גבול עליון של כמות הערימה הכוללת בשימוש
לפי הפונקציה. אם הוא אינו קיים, כמות ההתאמות הללו אינה מוגבלת
בזמן הקומפילציה והשדה השני מייצג רק את החלק התחום.

-fprofile-arcs
הוסף קוד כדי שהתוכנית תזרום קשתות מצוידים במכשיר. במהלך ביצוע התוכנית
מתעד כמה פעמים כל סניף וקריאה מבוצעים וכמה פעמים הוא נלקח
או מחזירים. כאשר תוכנית ההידור יוצאת היא שומרת את הנתונים הללו לקובץ שנקרא
auxname.gcda עבור כל קובץ מקור. הנתונים עשויים לשמש עבור פרופיל מכוון
אופטימיזציות (-fענף-הסתברויות), או לניתוח כיסוי בדיקה
(-הכיסוי הגבוה ביותר). כל קובץ אובייקט שם עזר נוצר מהשם של
קובץ הפלט, אם צוין במפורש והוא אינו קובץ ההפעלה הסופי, אחרת הוא
הוא שם הבסיס של קובץ המקור. בשני המקרים כל סיומת מוסרת (למשל
foo.gcda עבור קובץ קלט dir/foo.c, או dir/foo.gcda עבור קובץ הפלט שצוין כ -o
dir/foo.o).

-- כיסוי
אפשרות זו משמשת להידור ולקישור של קוד המיועד לניתוח כיסוי. ה
אפשרות היא מילה נרדפת ל -fprofile-arcs -הכיסוי הגבוה ביותר (בעת הידור) ו- -lgcov
(בעת קישור). עיין בתיעוד עבור אפשרויות אלה לפרטים נוספים.

· קומפיל את קבצי המקור עם -fprofile-arcs בנוסף אופטימיזציה ויצירת קוד
אפשרויות. לניתוח כיסוי בדיקה, השתמש בתוספת -הכיסוי הגבוה ביותר אוֹפְּצִיָה.
אינך צריך ליצור פרופיל של כל קובץ מקור בתוכנית.

· קשר את קבצי האובייקט שלך עם -lgcov or -fprofile-arcs (האחרון מרמז על
לְשֶׁעָבַר).

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

· עבור אופטימיזציות מכוונות פרופיל, הידור שוב את קבצי המקור עם אותו הדבר
אפשרויות אופטימיזציה ויצירת קוד פלוס -fענף-הסתברויות.

· לניתוח כיסוי בדיקה, השתמש gcov להפיק ממנו מידע קריא אנושי
מה היא .gcno ו .gcda קבצים. עיין ב gcov תיעוד להמשך
מידע.

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

-הכיסוי הגבוה ביותר
צור קובץ הערות ש- gcov כלי כיסוי קוד יכול להשתמש כדי להציג תוכנית
כיסוי. קובץ ההערה של כל קובץ מקור נקרא auxname.gcno. עיין ב
-fprofile-arcs אפשרות למעלה לתיאור של שם עזר והוראות כיצד לעשות זאת
ליצור נתוני כיסוי בדיקה. נתוני הכיסוי יתאימו יותר לקובצי המקור,
אם לא תבצע אופטימיזציה.

-fdbg-cnt-list
הדפס את השם ואת הגבול העליון של המונה עבור כל מונים לניפוי באגים.

-fdbg-cnt=רשימת ערכים נגדית
הגדר את הגבול העליון של מונה ניפוי הבאגים הפנימי. רשימת ערכים נגדית הוא מופרד בפסיקים
רשימה של שם:ערך צמדים שקובעים את הגבול העליון של כל מונה באגים שם ל
ערך. לכל מונים לניפוי באגים יש את הגבול העליון הראשוני של UINT_MAX, ובכך dbg_cnt()
מחזירה true תמיד אלא אם הגבול העליון מוגדר על ידי אפשרות זו. למשל עם
-fdbg-cnt=dce:10,tail_call:0 dbg_cnt(dce) יחזיר true רק עבור 10 הראשונים
קריאות

-ניתן להפגין-סוג-לעבור
-fdisable-סוג-לעבור=רשימת טווחים
זוהי קבוצה של אפשרויות ניפוי באגים המשמשות לביטול/לאפשר במפורש
האופטימיזציה עוברת. עבור משתמשי מהדר, אפשרויות רגילות להפעלה/השבתה של מעברים
צריך להשתמש במקום.

*<-fdisable-ipa-לעבור>
השבת את ה-IPA Pass לעבור. לעבור הוא שם המעבר. אם אותו מעבר הוא סטטי
מופעל במהדר מספר פעמים, לשם המעבר יש לצרף א
מספר רציף החל מ-1.

*<-fdisable-rtl-לעבור>
*<-fdisable-rtl-לעבור=רשימת טווחים>
השבת את rtl pass לעבור. לעבור הוא שם המעבר. אם אותו מעבר הוא סטטי
מופעל במהדר מספר פעמים, לשם המעבר יש לצרף א
מספר רציף החל מ-1. רשימת טווחים היא רשימה מופרדת בפסיקים של
טווחי פונקציות או שמות אסמבלר. כל טווח הוא זוג מספרים מופרד ב-a
המעי הגס. הטווח כולל בשני הקצוות. אם הטווח טריוויאלי, המספר
ניתן לפשט זוג כמספר בודד. אם צומת cgraph של הפונקציה uid is
הנופלים באחד מהטווחים שצוינו, ה- לעבור מושבת בגלל זה
פונקציה. ה uid מוצג בכותרת הפונקציה של קובץ dump, וה-pass
ניתן לזרוק שמות באמצעות אפשרות -fdump-passes.

*<-fdisable-tree-לעבור>
*<-fdisable-tree-לעבור=רשימת טווחים>
השבת מעבר עצים לעבור. לראות -fdisable-rtl לתיאור האופציה
ארגומנטים.

*<-fenable-ipa-לעבור>
אפשר ipa pass לעבור. לעבור הוא שם המעבר. אם אותו מעבר הוא סטטי
מופעל במהדר מספר פעמים, לשם המעבר יש לצרף א
מספר רציף החל מ-1.

*<-fenable-rtl-לעבור>
*<-fenable-rtl-לעבור=רשימת טווחים>
אפשר rtl pass לעבור. לראות -fdisable-rtl לתיאור ארגומנט אפשרות ו
דוגמאות.

*<-עץ-ניתן-לעבור>
*<-עץ-ניתן-לעבור=רשימת טווחים>
אפשר מעבר עצים לעבור. לראות -fdisable-rtl לתיאור טיעוני האופציה.

# השבת את ccp1 עבור כל הפונקציות
-fdisable-tree-ccp1
# השבת ביטול מלא עבור פונקציה ש-cgraph node uid שלה הוא 1
-fenable-tree-cunroll=1
# disable gcse2 עבור פונקציות בטווחים הבאים [1,1],
# [300,400] ו-[400,1000]
# השבת את gcse2 עבור הפונקציות foo ו-foo2
-fdisable-rtl-gcse2=foo,foo2
# השבת את ההטמעה המוקדמת
-פני-עץ-עץ-אלין
# השבת את ה-ipa inlining
-fdisable-ipa-inline
# אפשר פתיחה מלאה של עץ
-ניתן-עץ-להתגלגל

-dאותיות
-fdump-rtl-לעבור
אומר לבצע dumps לניפוי באגים במהלך הקומפילציה בזמנים שצוינו על ידי אותיות. זֶה
משמש לאיתור באגים במעברים מבוססי RTL של המהדר. שמות הקבצים לרוב
מההשלכות מתבצעות על ידי הוספת מספר מעבר ומילה ל- שם dump, וה
קבצים נוצרים בספרייה של קובץ הפלט. שימו לב שמספר המעבר הוא
מחושבים באופן סטטי כאשר עוברים נרשמים במנהל המעבר. כך ה
המספור אינו קשור לסדר הדינמי של ביצוע מעברים. באופן מיוחד,
כרטיס שהותקן על ידי תוסף יכול להיות בעל מספר מעל 200 גם אם הוא בוצע די
מוקדם. שם dump נוצר מהשם של קובץ הפלט, אם במפורש
שצוין וזה לא קובץ הפעלה, אחרת זה שם הבסיס של המקור
קוֹבֶץ. למתגים אלה עשויים להיות השפעות שונות כאשר -E משמש לעיבוד מקדים.

ניתן להפעיל dumps לניפוי באגים באמצעות a -fdump-rtl להחליף או משהו -d אוֹפְּצִיָה אותיות. כאן
הן האותיות האפשריות לשימוש ב לעבור ו אותיות, והמשמעויות שלהם:

-fdump-rtl-alignments
dump לאחר שחושבו יישורי ענף.

-fdump-rtl-asmcons
dump לאחר תיקון הצהרות rtl שיש להם אילוצי כניסה/יציאה לא מסופקים.

-fdump-rtl-auto_inc_dec
dump לאחר גילוי אוטומטי-inc-dec. הכרטיס הזה מופעל רק על ארכיטקטורות ש
יש הוראות תוספת אוטומטית או ביטול אוטומטי.

-fdump-rtl-מחסומים
לזרוק לאחר ניקוי הוראות המחסום.

-fdump-rtl-bbpart
השלכה לאחר חלוקה של בלוקים בסיסיים חמים וקרים.

-fdump-rtl-bbro
זרימה לאחר סידור מחדש של בלוק.

-fdump-rtl-btl1
-fdump-rtl-btl2
-fdump-rtl-btl1 ו -fdump-rtl-btl2 לאפשר השלכה אחרי יעד שני הענפים
אופטימיזציית העומס עוברת.

-fdump-rtl-bypass
עקיפת זריקה לאחר קפיצה ובקרה על אופטימיזציות של זרימה.

-fdump-rtl-combine
זרוק לאחר מעבר שילוב הוראות RTL.

-fdump-rtl-compgotos
dump לאחר שכפול ה-gotos המחושבים.

-fdump-rtl-ce1
-fdump-rtl-ce2
-fdump-rtl-ce3
-fdump-rtl-ce1, -fdump-rtl-ce2, ו -fdump-rtl-ce3 לאפשר השלכה לאחר השלושה
אם ההמרה תעבור.

-fdump-rtl-cprop_hardreg
השלכה לאחר הפצת עותק רישום קשיח.

-fdump-rtl-csa
השלכה לאחר שילוב התאמות מחסנית.

-fdump-rtl-cse1
-fdump-rtl-cse2
-fdump-rtl-cse1 ו -fdump-rtl-cse2 אפשר השלכה לאחר שני המשנה הנפוצים
חיסול הביטוי עובר.

-fdump-rtl-dce
זרוק לאחר שביטול הקוד המת העצמאי עובר.

-fdump-rtl-dbr
השלכה לאחר דחיית תזמון סניפים.

-fdump-rtl-dce1
-fdump-rtl-dce2
-fdump-rtl-dce1 ו -fdump-rtl-dce2 לאפשר השלכה לאחר שני החנות המתים
חיסול עובר.

-fdump-rtl-eh
dump לאחר סיום קוד הטיפול ב-EH.

-fdump-rtl-eh_ranges
השלכה לאחר המרה של אזורי טווח טיפול ב-EH.

-fdump-rtl-expand
dump אחרי דור RTL.

-fdump-rtl-fwprop1
-fdump-rtl-fwprop2
-fdump-rtl-fwprop1 ו -fdump-rtl-fwprop2 לאפשר השלכה לאחר שני קדימה
הריבוי עובר.

-fdump-rtl-gcse1
-fdump-rtl-gcse2
-fdump-rtl-gcse1 ו -fdump-rtl-gcse2 לאפשר השלכה לאחר משותף עולמי
חיסול תת-ביטויים.

-fdump-rtl-init-regs
dump לאחר אתחול הרשמים.

-fdump-rtl-initvals
dump לאחר חישוב ערכי הערכים ההתחלתיים.

-fdump-rtl-into_cfglayout
dump לאחר המרה למצב cfglayout.

-Fdump-rtl-ira
dump לאחר הקצאת רישום חוזרת.

-fdump-rtl-jump
השלכה לאחר אופטימיזציית הקפיצה השנייה.

-fdump-rtl-loop2
-fdump-rtl-loop2 מאפשר dumping לאחר שהאופטימיזציה של לולאת rtl עוברת.

-fdump-rtl-mach
זרוק לאחר ביצוע אישור הארגון מחדש תלוי במכונה, אם זה עובר
קיים.

-fdump-rtl-mode_sw
dump לאחר הסרת מתגי מצב מיותר.

-fdump-rtl-rnreg
זרוק לאחר מספור מחדש של הרישום.

-fdump-rtl-outof_cfglayout
dump לאחר המרה ממצב cfglayout.

-fdump-rtl-peephole2
לזרוק לאחר מעבר חור הצצה.

-fdump-rtl-postreload
dump לאחר אופטימיזציות שלאחר טעינה מחדש.

-fdump-rtl-pro_and_epilogue
dump לאחר יצירת פרולוגים ואפילוגים של הפונקציה.

-fdump-rtl-regmove
dump לאחר מעבר המהלך של הרישום.

-fdump-rtl-sched1
-fdump-rtl-sched2
-fdump-rtl-sched1 ו -fdump-rtl-sched2 אפשר השלכה לאחר החסימה הבסיסית
תזמון עוברים.

-fdump-rtl-see
ביטול הרחבת השלט לאחר השלט.

-fdump-rtl-seqabstr
dump לאחר גילוי רצף נפוץ.

-fdump-rtl-קצר
לזרוק לאחר קיצור ענפים.

-fdump-rtl-אחי
זרוק לאחר אופטימיזציות של שיחות אחים.

-fdump-rtl-split1
-fdump-rtl-split2
-fdump-rtl-split3
-fdump-rtl-split4
-fdump-rtl-split5
-fdump-rtl-split1, -fdump-rtl-split2, -fdump-rtl-split3, -fdump-rtl-split4 ו
-fdump-rtl-split5 לאפשר השלכה לאחר חמישה סבבים של פיצול הוראות.

-fdump-rtl-sms
השלכה לאחר תזמון מודולו. הכרטיס הזה מופעל רק בחלק מהארכיטקטורות.

-fdump-rtl-stack
dump לאחר המרה מ"קובץ הרישום השטוח" של GCC ל-x87
אוגרים דמויי מחסנית. כרטיס זה פועל רק על גרסאות x86.

-fdump-rtl-subreg1
-fdump-rtl-subreg2
-fdump-rtl-subreg1 ו -fdump-rtl-subreg2 אפשר השלכה לאחר שתי תת reg
הרחבה עוברת.

-fdump-rtl-unshare
dump אחרי שכל ה-rtl בוטל.

-fdump-rtl-vartrack
השלכה לאחר מעקב משתנה.

-fdump-rtl-vregs
dump לאחר המרת אוגרים וירטואליים לרגיסטרים קשיחים.

-fdump-rtl-web
השלכה לאחר פיצול טווח חי.

-fdump-rtl-regclass
-fdump-rtl-subregs_of_mode_init
-fdump-rtl-subregs_of_mode_finish
-fdump-rtl-dfinit
-fdump-rtl-dfinish
dumps אלה מוגדרים אך תמיד מייצרים קבצים ריקים.

-in
-fdump-rtl-all
צור את כל המזבלות המפורטות לעיל.

-דA ציין את הפלט של ה-assembler עם מידע אחר על ניפוי באגים.

-dD זרוק את כל הגדרות המאקרו, בתום העיבוד המקדים, בנוסף לרגיל
פלט.

-dH הפק dump core בכל פעם שמתרחשת שגיאה.

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

-dP זרוק את ה-RTL בפלט האסמבלר כהערה לפני כל הוראה. גַם
מדליק -dp ביאור.

-DV. עבור כל אחד מקבצי ה-dump האחרים שצוינו (-fdump-rtl-לעבור), לזרוק א
ייצוג של גרף זרימת הבקרה המתאים לצפייה עם VCG ל
file.pass.vcg.

-dx פשוט צור RTL עבור פונקציה במקום להרכיב אותה. משמש בדרך כלל עם
-fdump-rtl-expand.

-fdump-noaddr
בעת ביצוע איתור באגים, דכא פלט כתובת. זה הופך את זה לאפשרי יותר
השתמש ב-diff על איתור באגים ב-dumps עבור קריאות מהדר עם קבצים בינאריים שונים של מהדר
ו/או מיקומי התחלה שונים של טקסט / bss / data / heap / stack / dso.

-fdump-לא ממוספר
בעת ביצוע איתור באגים, דחק מספרי הוראות ופלט כתובת. זֶה
עושה את זה ריאלי יותר להשתמש ב-diff על איתור באגים עבור קריאות מהדר עם
אפשרויות שונות, במיוחד עם ובלי -g.

-fdump-לא ממוספרים-קישורים
בעת ביצוע איתור באגים (ראה -d אפשרות למעלה), דחק מספרי הוראות עבור ה
קישורים להוראות הקודמות והבאות ברצף.

-fdump-translation-unit (C++ בלבד)
-fdump-translation-unit-אפשרויות (C++ בלבד)
זרוק ייצוג של מבנה העץ עבור כל יחידת התרגום לקובץ.
שם הקובץ נעשה על ידי הוספה .tu לשם קובץ המקור, והקובץ הוא
נוצר באותה ספרייה כמו קובץ הפלט. אם ה -אפשרויות נעשה שימוש בטופס,
אפשרויות שולט בפרטי המזבלה כמתואר עבור -fdump-עץ אפשרויות.

-fdump-class-hierarchy (C++ בלבד)
-fdump-class-hierarchy-אפשרויות (C++ בלבד)
זרוק ייצוג של ההיררכיה של כל מחלקה ושל פריסת טבלת פונקציות וירטואלית ל-a
קוֹבֶץ. שם הקובץ נעשה על ידי הוספה .מעמד לשם קובץ המקור ולקובץ
נוצר באותה ספרייה כמו קובץ הפלט. אם ה -אפשרויות נעשה שימוש בטופס,
אפשרויות שולט בפרטי המזבלה כמתואר עבור -fdump-עץ אפשרויות.

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

את כל מאפשר את כל השלכות הניתוח הבין-פרוצדורליות.

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

מוטבע
הטבלה לאחר פונקציה.

-fdump-passes
זרוק את רשימת מעברי האופטימיזציה המופעלים ומכבים על ידי הזרם
אפשרויות שורת הפקודה.

-fdump-סטטיסטיקה-אוֹפְּצִיָה
אפשר ולשלוט בהשלכת סטטיסטיקת מעברים בקובץ נפרד. שם הקובץ הוא
נוצר על ידי הוספת סיומת המסתיימת ב .סטָטִיסטִיקָה לשם קובץ המקור, וה-
הקובץ נוצר באותה ספרייה כמו קובץ הפלט. אם ה -אוֹפְּצִיָה הצורה היא
בשימוש, -סטטיסטיקות יגרום לסיכום של מונים על כל יחידת ההידור תוך כדי
-פרטים יזרוק כל אירוע כשהכרטיסים מייצרים אותם. ברירת המחדל עם לא
האפשרות היא לסכם מונים עבור כל פונקציה שהודרה.

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

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

asmname
אם "DECL_ASSEMBLER_NAME" הוגדר עבור דקל נתון, השתמש בזה ב-dump
במקום "DECL_NAME". השימוש העיקרי שלו הוא קלות השימוש בעבודה אחורה
שמות מעוותים בקובץ ה-assembly.

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

חי הדפס ייצוג גולמי של העץ. כברירת מחדל, עצים מודפסים יפה
ייצוג דמוי C.

פרטים
אפשר dump מפורט יותר (לא מכובד בכל אפשרות dump).

סטטיסטיקות
אפשר השלכת נתונים סטטיסטיים שונים על הכרטיס (לא מכובד בכל מזבלה
אוֹפְּצִיָה).

אבני
אפשר הצגת גבולות בלוקים בסיסיים (מושבת ב-raw dumps).

וופ
אפשר הצגת אופרנדים וירטואליים עבור כל הצהרה.

לינו
אפשר הצגת מספרי שורות עבור הצהרות.

uid אפשר הצגת המזהה הייחודי ("DECL_UID") עבור כל משתנה.

מִלוּלִי
אפשר הצגת dump העץ עבור כל הצהרה.

eh אפשר הצגת מספר אזור ה-EH המחזיק כל הצהרה.

scev
אפשר הצגת פרטי ניתוח אבולוציה סקלרית.

את כל הפעל את כל האפשרויות, מלבד חי, רָזֶה, מִלוּלִי ו לינו.

השלכות העצים הבאות אפשריות:

מְקוֹרִי
לזרוק לפני כל אופטימיזציה מבוססת עץ, כדי file.original.

אופטימיזציה
לזרוק אחרי הכל עץ מבוסס אופטימיזציה, כדי file.optimized.

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

cfg זרוק את גרף זרימת הבקרה של כל פונקציה לקובץ. שם הקובץ נוצר על ידי
מצרף .cfg לשם קובץ המקור.

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

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

SSA זרוק מידע הקשור ל-SSA לקובץ. שם הקובץ נעשה על ידי הוספה .ssa
לשם קובץ המקור.

כינוי
זרוק מידע כינוי עבור כל פונקציה. שם הקובץ נעשה על ידי הוספה
.alias לשם קובץ המקור.

המק"ס זרוק כל פונקציה אחרי CCP. שם הקובץ נעשה על ידי הוספה .CCP אל ה
שם קובץ המקור.

storeccp
זרוק כל פונקציה אחרי STORE-CCP. שם הקובץ נעשה על ידי הוספה .storeccp
לשם קובץ המקור.

מראש השלכת עצים לאחר ביטול יתירות חלקית. שם הקובץ נוצר על ידי
מצרף .מִרֹאשׁ לשם קובץ המקור.

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

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

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

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

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

SRA זרוק כל פונקציה לאחר ביצוע החלפה סקלרית של אגרגטים. הקובץ
השם נעשה על ידי הוספה .sra לשם קובץ המקור.

כִּיוֹר
זרוק כל פונקציה לאחר ביצוע שקיעת קוד. שם הקובץ נוצר על ידי
מצרף .כִּיוֹר לשם קובץ המקור.

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

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

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

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

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

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

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

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

vp זרוק כל פונקציה לאחר התפשטות טווח ערכים (VRP). שם הקובץ נוצר על ידי
מצרף .vrp לשם קובץ המקור.

את כל אפשר את כל השלכות העצים הזמינות עם הדגלים הניתנים באפשרות זו.

-ftree-vectorizer-verbose=n
אפשרות זו שולטת בכמות פלט ניפוי הבאגים שהווקטורייזר מדפיס. זֶה
המידע נכתב לפי שגיאת תקן, אלא אם כן -fdump-tree-all or -fdump-tree-vect
מצוין, ובמקרה זה הוא יוצא לקובץ רישום ה-dump הרגיל, .vect. פורום
n=0 לא מדווח מידע אבחון. אם n=1 הווקטורייזר מדווח על כל לולאה
שעבר וקטור, והמספר הכולל של לולאות שעברו וקטור. אם n=2 ה
Vectorizer מדווח גם על לולאות שאינן מוקטוריות שעברו את שלב הניתוח הראשון
(vect_analyze_loop_form) - כלומר ניתן לספירה, הפנימי ביותר, יחיד-bb, כניסה/יציאה בודדת
לולאות. זו אותה רמת מילוליות זו -fdump-tree-vect-stats שימושים. גבוה יותר
רמות מילוליות אומרות או יותר מידע שנשפך עבור כל לולאה מדווחת, או זהה
כמות המידע שדווח עבור לולאות נוספות: אם n=3, מודל עלות וקטורייזר
מידע מדווח. אם n=4, מידע הקשור ליישור נוסף ל-
דיווחים. אם n=5, מידע הקשור להפניות נתונים (למשל תלות בזיכרון, זיכרון
access-patterns) מתווסף לדוחות. אם n=6, הווקטורייזר מדווח גם לא-
לולאות פנימיות וקטוריות שלא עברו את שלב הניתוח הראשון (כלומר, אולי לא
ניתן לספירה, או עשוי להקשות על זרימת הבקרה). אם n=7, מדווח הווקטורייזר
גם לולאות מקוננות ללא וקטור. אם n=8, מידע הקשור ל-SLP נוסף ל-
דיווחים. ל n=9, כל המידע שהווקטורייזר מייצר במהלך הניתוח שלו
ומדווח על טרנספורמציה. זו אותה רמת מילוליות זו
-fdump-tree-vect-details שימו

-פרנדום-seed=מחרוזת
אפשרות זו מספקת סיד ש-GCC משתמש בו כאשר אחרת הוא היה משתמש במספרים אקראיים.
הוא משמש ליצירת שמות סמלים מסוימים שצריכים להיות שונים בכל אחד מהם
קובץ הידור. הוא משמש גם להצבת חותמות ייחודיות בקבצי נתוני כיסוי וב-
קבצי אובייקט שמייצרים אותם. אתה יכול להשתמש ב -פרנדום-זרע אפשרות לייצר
קבצי אובייקטים זהים לשחזור.

אל האני מחרוזת צריך להיות שונה עבור כל קובץ שאתה מקמפל.

-fsched-verbose=n
ביעדים המשתמשים בתזמון הוראות, אפשרות זו שולטת בכמות
איתור באגים פלט המתזמן מדפיס. מידע זה נכתב בשגיאת תקן,
אלא אם כן -fdump-rtl-sched1 or -fdump-rtl-sched2 מצוין, ובמקרה זה הוא פלט
לקובץ רישום המזבלה הרגיל, .sched1 or .sched2 בהתאמה. אולם עבור n
גדול מתשע, הפלט מודפס תמיד לפי שגיאת תקן.

בעד n גדול מאפס, -אשר-ורבוז מוציא את אותו מידע כמו
-fdump-rtl-sched1 ו -fdump-rtl-sched2. פורום n גדול מאחד, הוא גם פלט בסיסי
הסתברויות חסימה, מידע מפורט על רשימה מוכנה ומידע על יחידה/מתקן. ל n
יותר משניים, הוא כולל RTL בנקודת ביטול, זרימת בקרה ומידע על אזורים. ו
ל n מעל ארבע, -אשר-ורבוז כולל גם מידע על תלות.

-חיסכון-טמפ'
-save-temps=cwd
אחסן את קבצי הביניים ה"זמניים" הרגילים לצמיתות; למקם אותם בזרם
ספרייה ושם אותם על סמך קובץ המקור. לפיכך, קומפילציה foo.c עם -c
-חיסכון-טמפ' ייצור קבצים foo.i ו foo.s, בנוסף ל foo.o. זה יוצר א
מעובד מראש foo.i קובץ הפלט למרות שהמהדר משתמש כעת בדרך כלל ב-an
מעבד קדם משולב.

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

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

gcc -save-temps -o outdir1/foo.o indir1/foo.c&
gcc -save-temps -o outdir2/foo.o indir2/foo.c&

עלול לגרום ל foo.i ו foo.o נכתב בו זמנית על ידי שני המהדרים.

-save-temps=obj
אחסן את קבצי הביניים ה"זמניים" הרגילים לצמיתות. אם ה -o נעשה שימוש באפשרות,
הקבצים הזמניים מבוססים על קובץ האובייקט. אם ה -o האפשרות אינה בשימוש, ה
-save-temps=obj מתג מתנהג כמו -חיסכון-טמפ'.

לדוגמה:

gcc -save-temps=obj -c foo.c
gcc -save-temps=obj -c bar.c -o dir/xbar.o
gcc -save-temps=obj foobar.c -o dir2/yfoobar

היה יוצר foo.i, foo.s, dir/xbar.i, dir/xbar.s, dir2/yfoobar.i, dir2/yfoobar.s, ו
dir2/yfoobar.o.

-time[=פילה]
דווח על זמן ה-CPU שלוקח כל תת-תהליך ברצף ההידור. עבור ג
קבצי מקור, זהו המהדר הנכון והאסמבלר (בתוספת המקשר אם הקישור הוא
בוצע).

ללא מפרט של קובץ פלט, הפלט נראה כך:

# cc1 0.12 0.01
# כ-0.00 0.01

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

עם המפרט של קובץ פלט, הפלט מצורף לקובץ בעל השם,
וזה נראה כך:

0.12 0.01 cc1
0.00 0.01 as

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

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

זה מופעל כברירת מחדל בעת קומפילציה עם אופטימיזציה (-אוס, -O, -O2,...),
מידע באגים (-g) ופורמט מידע ניפוי באגים תומך בו.

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

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

-מאבר-מעקב-מנתקים-טבגול
למתג -fvar-tracking-assignments, באותו אופן ש -gtoggle toggles -g.

-print-file-name=ספריה
הדפס את השם המוחלט המלא של קובץ הספרייה ספריה זה ישמש מתי
קישור --- ואל תעשה שום דבר אחר. עם אפשרות זו, GCC אינו מבצע קומפילציה או קישור
כל דבר; זה רק מדפיס את שם הקובץ.

-הדפס-מספר ספריות
הדפס את שם הספרייה המתאים ל-multilib שנבחר על ידי מתגים אחרים
קיים בשורת הפקודה. ספרייה זו אמורה להתקיים ב GCC_EXEC_PREFIX.

-print-multi-lib
הדפס את המיפוי משמות ספריות multilib למתגי מהדר המאפשרים אותם.
שם הספרייה מופרד מהמתגים על ידי ;, וכל מתג מתחיל ב-an
@ במקום ה -, ללא רווחים בין מתגים מרובים. זה אמור
קל עיבוד מעטפת.

-print-multi-os-directory
הדפס את הנתיב לספריות מערכת ההפעלה עבור ה-multilib שנבחר, יחסית לחלק lib
ספריית משנה. אם קיימות ספריות מערכת ההפעלה ב- lib ספריית משנה וללא multilibs
משמשים, זה בדרך כלל פשוט ., אם קיימות ספריות מערכת הפעלה ב סיומת libs אח
ספריות זה מדפיס למשל ../lib64, ../ lib or ../lib32, או אם ספריות מערכת ההפעלה כן
נוכח ב lib/subdir ספריות משנה שהוא מדפיס למשל amd64, sparcv9 or Ev6.

-print-multiarch
הדפס את הנתיב לספריות מערכת ההפעלה עבור ה-multiarch שנבחר, יחסית לכמה lib
ספריית משנה.

-print-prog-name=התוכנית
כמו -שם קובץ הדפסה, אך מחפש תוכנית כגון cpp.

-print-libgcc-file-name
כמו -print-file-name=libgcc.a.

זה שימושי כאשר אתה משתמש -נוסטדליב or -nodefaultlibs אבל אתה כן רוצה לקשר עם
libgcc.a. אתה יכול לעשות

gcc -nostdlib ... `gcc -print-libgcc-file-name`

-print-search-dirs
הדפס את השם של ספריית ההתקנה המוגדרת ורשימת תוכניות ו
ספריות ספריות gcc יחפש --- ואל תעשה שום דבר אחר.

זה שימושי כאשר gcc מדפיס את הודעת השגיאה התקנה בְּעָיָה, לא יכול Exec
cpp0: לא כזה פילה or בספרייה. כדי לפתור את זה אתה צריך לשים cpp0 ו
רכיבי מהדר אחרים איפה gcc מצפה למצוא אותם, או שאתה יכול להגדיר את
משתנה הסביבה GCC_EXEC_PREFIX לספרייה שבה התקנת אותם. אל תעשה
לשכוח את הנגרר /.

-print-sysroot
הדפס את ספריית היעד הבסיסית שתשמש במהלך ההידור. זה
בסיס בסיס יעד שצוין בזמן ההגדרה או באמצעות ה- --sysroot אוֹפְּצִיָה,
אולי עם סיומת נוספת שתלויה באפשרויות הידור. אם אין מטרה
Sysroot מצוין, האפשרות לא מדפיסה דבר.

-print-sysroot-headers-suffix
הדפס את הסיומת שנוספה לבסיס המטרה בעת חיפוש כותרות, או תן
שגיאה אם ​​המהדר לא מוגדר עם סיומת כזו --- ואל תעשה כלום
Other.

-מכונת dump
הדפס את מכונת היעד של המהדר (לדוגמה, i686-pc-linux-gnu)---ואל תעשה
עוד משהו.

-גרסת dump
הדפס את גרסת המהדר (לדוגמה, 3.0) --- ואל תעשה שום דבר אחר.

-מפרט dump
הדפס את המפרט המובנה של המהדר --- ואל תעשה שום דבר אחר. (זה משמש כאשר
GCC עצמו נבנה.)

טיפוסי-feliminate-unused-debug
בדרך כלל, בעת הפקת פלט DWARF2, GCC יפלוט מידע איתור באגים עבור כולם
סוגים שהוכרזו ביחידת הידור, ללא קשר לשאלה אם הם באמת או לא
בשימוש באותה יחידת הידור. לפעמים זה שימושי, למשל אם, במאתר הבאגים,
אתה רוצה להטיל ערך לטיפוס שאינו בשימוש בפועל בתוכנית שלך (אבל הוא
מוּצהָר). עם זאת, לעתים קרובות יותר, הדבר גורם לכמות משמעותית של שטח מבוזבז.
עם אפשרות זו, GCC ימנע מיצירת פלט של סמל ניפוי באגים עבור סוגים שכן
בשום מקום לא נעשה בו שימוש בקובץ המקור הנערך.

אפשרויות כי שליטה אופטימיזציה
אפשרויות אלה שולטות בסוגים שונים של אופטימיזציות.

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

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

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

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

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

בהתאם ליעד ולאופן ההגדרה של GCC, קבוצה שונה במקצת של
אופטימיזציות עשויות להיות מופעלות בכל אחת מהן -O רמה מאלו המפורטות כאן. אתה יכול להפעיל את GCC
עם -Q --help=אופטימיזרים כדי לברר את הסט המדויק של אופטימיזציות המופעלות ב
כל רמה.

-O
-O1 בצע אופטימיזציה. אופטימיזציה של קומפילציה לוקחת קצת יותר זמן, והרבה יותר זיכרון עבור
פונקציה גדולה.

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

-O מפעיל את דגלי האופטימיזציה הבאים:

-fauto-inc-dec -fcompare-elim -fcprop-registers -fdce -fdefer-pop -ענף מושהה
-fdse -ניחוש-ענף-הסתברות -fif-conversion2 -fif-המרה -פיפא-טהור-קונסט
-fipa-profile -פיפא-התייחסות -fmerge-constants -fsplit-wide-types -ftree-bit-ccp
-ftree-builtin-call-dce -ftree-ccp -ftree-ch -ftree-copyrename -ftree-dce
-ftree-dominator-opts -ftree-dse -ftree-forwprop -ftree-fre -ftree-phiprop -ftree-sra
-ftree-pta -ftree-ter -כיף-בכל פעם

-O גם נדלק -fomit-frame-pointer במכונות שבהן פעולה זו אינה מפריעה
עם איתור באגים.

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

-O2 מפעיל את כל דגלי האופטימיזציה שצוינו על ידי -O. זה גם מפעיל את הדברים הבאים
דגלי אופטימיזציה: -חוט-קפיצות -falign-פונקציות -falign-קפיצות -falign-לולאות
-falign-תוויות -fcaller-שומר -קפיצה צולבת -fcse-follow-jumps -fcse-דלג-בלוקים
-fdelete-null-pointer-checks -fdevirtualize -זול-אופטימיזציות -fgcse
-fgcse-lm -finline-קטנות-פונקציות -findirect-inlining -פיפא-סרה
-foptimize-אחיות-שיחות -fpartial-inlining -fpeephole2 -פרגmove -Freord-בלוקים
-פקודת-פונקציות -frerun-cse-after-loop -fsched-interblock -fsched-spec
-fschedule-insns -fschedule-insns2 -fstrict-aliasing -פרקט-הצפה
-ftree-switch-conversion -ftree-זנב-מיזוג -ftree-pre -ftree-vrp

נא לשים לב לאזהרה למטה -fgcse על פנייה -O2 על תוכניות המשתמשות ב-computed
גוטוס.

הערה: באובונטו 8.10 ובגירסאות מאוחרות יותר, -D_FORTIFY_SOURCE=2 מוגדר כברירת מחדל, והוא
מופעל מתי -O מוגדר ל-2 ומעלה. זה מאפשר זמן קומפילציה נוסף ו
בדיקת זמן ריצה עבור מספר פונקציות libc. כדי להשבית, ציין או
-U_FORTIFY_SOURCE or -D_FORTIFY_SOURCE=0.

-O3 בצע אופטימיזציה עוד יותר. -O3 מפעיל את כל האופטימיזציות שצוינו על ידי -O2 וגם נדלק
מה היא -finline-פונקציות, -לולאות funswitch, -fpredictive-commoning, -fgcse-after-reload,
-ftree-vectorize, -ftree-partial-pre ו -fipa-cp-clone אפשרויות.

-O0 צמצם את זמן ההידור וגרמו לניפוי באגים להניב את התוצאות הצפויות. זה
ברירת המחדל.

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

-אוס משבית את דגלי האופטימיזציה הבאים: -falign-פונקציות -falign-קפיצות
-falign-לולאות -falign-תוויות -Freord-בלוקים -לאחר סדר-בלוקים-ו-מחיצה
-fprefetch-loop-arrays -ftree-vect-loop-version

-אופסט
התעלם מעמידה בתקנים מחמירים. -אופסט מאפשר לכולם -O3 אופטימיזציות. זה גם
מאפשר אופטימיזציות שאינן תקפות עבור כל התוכניות התואמות הסטנדרטיות. זה
מדליק -מהיר-מתמטיקה והספציפי ל-Fortran -fno-protect-parens ו -fstack-מערכי.

אם אתה משתמש במספר -O אפשרויות, עם או בלי מספרי רמה, האפשרות האחרונה כזו היא
זה יעיל.

אפשרויות הטופס -fדגל ציין דגלים בלתי תלויים במכונה. ברוב הדגלים יש את שניהם
צורות חיוביות ושליליות; הצורה השלילית של -ffoo. יהיה -fno-foo. בשולחן
להלן, רק אחד מהטפסים מופיע --- זה שבדרך כלל תשתמש בו. אתה יכול להבין
להוציא את הטופס השני על ידי הסרה לא- או הוספתו.

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

-fno-default-inline
אל תהפוך פונקציות איברים לשורה כברירת מחדל רק בגלל שהן מוגדרות בפנים
היקף המחלקה (C++ בלבד). אחרת, כאשר אתה מציין -O, פונקציות איברים מוגדרות
בתוך היקף המחלקה מורכבים בשורה כברירת מחדל; כלומר, אין צורך להוסיף מוטבע
לפני שם הפונקציה איבר.

-fno-defer-pop
תמיד הצב את הארגומנטים לכל קריאת פונקציה ברגע שהפונקציה הזו חוזרת. ל
מכונות שחייבות להופיע ארגומנטים לאחר קריאת פונקציה, המהדר מאפשר בדרך כלל
ארגומנטים מצטברים בערימה עבור מספר קריאות לפונקציות ומציגות את כולם
פַּעַם.

נכים ברמות -O, -O2, -O3, -אוס.

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

אפשרות זו מופעלת כברירת מחדל ברמות אופטימיזציה -O, -O2, -O3, -אוס.

-ffp-contract=סגנון
-ffp-contract=off משבית התכווצות ביטוי של נקודה צפה. -ffp-contract=מהיר
מאפשר התכווצות ביטוי של נקודה צפה כמו יצירת כפול-הוספה מאוחד
פעולות אם למטרה יש תמיכה מקורית עבורן. -ffp-contract=on מאפשר
התכווצות ביטוי של נקודה צפה אם מותר על פי תקן השפה. זה
כרגע לא מיושם ומטופל שווה ל -ffp-contract=off.

ברירת המחדל היא -ffp-contract=מהיר.

-fomit-frame-pointer
אל תשמור את מצביע המסגרת בפנקס עבור פונקציות שאינן זקוקות לכזו. זֶה
נמנע מההוראות לשמירה, הגדרה ושחזור של מצביעי מסגרת; זה גם עושה an
רישום נוסף זמין בפונקציות רבות. It גם עושה ניפוי בלתי אפשרי on
כמה מכונה.

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

החל מגרסה 4.6 של GCC, הגדרת ברירת המחדל (כאשר לא מתבצע אופטימיזציה לגודל) עבור
יעדי 32 סיביות Linux x86 ו-32 סיביות Darwin x86 שונו ל
-fomit-frame-pointer. ניתן לחזור לברירת המחדל -fno-omit-frame-pointer by
הגדרת GCC עם ה --enable-frame-pointer אפשרות להגדיר.

מופעל ברמות -O, -O2, -O3, -אוס.

-foptimize-אחיות-שיחות
בצע אופטימיזציה של שיחות אחים וזנב רקורסיביות.

מופעל ברמות -O2, -O3, -אוס.

-fno-inline
אין להרחיב שום פונקציה בשורה מלבד אלו המסומנות ב-"always_inline"
תְכוּנָה. זוהי ברירת המחדל כאשר לא מתבצע אופטימיזציה.

ניתן לפטור פונקציות בודדות מהטבעה על ידי סימוןן ב-"noinline"
תכונה.

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

מופעל ברמה -O2.

-findirect-inlining
Inline גם שיחות עקיפות שמתגלה כידוע בזמן הקומפילציה בזכות
הטבעה הקודמת. לאפשרות זו יש השפעה כלשהי רק כאשר ה-inlining עצמו מופעל
על ידי -finline-פונקציות or -finline-קטנות-פונקציות אפשרויות.

מופעל ברמה -O2.

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

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

מופעל ברמה -O3.

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

מופעל ברמות -O1, -O2, -O3 ו -אוס.

-פחד-הטבעה
פונקציות מוטבעות המסומנות ב-"always_inline" ופונקציות שהגוף שלהן נראה קטן יותר מ
קריאת הפונקציה תקורה מוקדם לפני ביצוע -fprofile-generate מכשור ו
מעבר מוטבע אמיתי. פעולה זו הופכת את הפרופיל לזול משמעותית ובדרך כלל
שילוב מהיר יותר בתוכניות עם שרשראות גדולות של פונקציות עטיפה מקוננות.

מופעלת כברירת מחדל.

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

מופעל ברמות -O2, -O3 ו -אוס.

-finline-limit=n
כברירת מחדל, GCC מגביל את גודל הפונקציות שניתן להטמין. הדגל הזה מאפשר
שליטה גסה בגבול זה. n הוא גודל הפונקציות שניתן לשלב בהן
מספר הוראות פסבדו.

Inlining נשלט למעשה על ידי מספר פרמטרים, אשר ניתן לפרט
בנפרד על ידי שימוש --param שם=ערך. ה -finline-limit=n אופציות קובע חלק מ
פרמטרים אלה כדלקמן:

max-inline-insns-סינגל
מוגדר n/ 2.

max-inline-insns-auto
מוגדר n/ 2.

ראה להלן לתיעוד של הפרמטרים הבודדים השולטים ב-inlining ו
עבור ברירות המחדל של פרמטרים אלה.

הערה: אולי אין ערך לזה -finline-limit מה שגורם להתנהגות ברירת מחדל.

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

-fno-keep-inline-dllexport
זוהי גרסה עדינה יותר של -fkeep-inline-functions, אשר חל רק על
פונקציות המוצהרות באמצעות התכונה "dllexport" או declspec

-fkeep-inline-functions
ב-C, פולט פונקציות "סטטיות" המוכרזות "מוטבעות" בקובץ האובייקט, גם אם
הפונקציה הוטבעה בכל המתקשרים שלה. מתג זה אינו משפיע
פונקציות באמצעות סיומת "Extern inline" ב-GNU C90. ב-C++, פולט כל דבר
פונקציות מוטבעות בקובץ האובייקט.

-fkeep-static-consts
פליט משתנים שהוכרזו "קונסט סטטי" כאשר האופטימיזציה לא מופעלת, גם אם
אין התייחסות למשתנים.

GCC מאפשר אפשרות זו כברירת מחדל. אם אתה רוצה לאלץ את המהדר לבדוק אם ה
הוענק למשתנה, ללא קשר אם האופטימיזציה מופעלת או לא, השתמש
מה היא -fno-keep-static-consts אוֹפְּצִיָה.

-fmerge-constants
ניסיון למזג קבועים זהים (קבועי מחרוזת וקבועי נקודה צפה)
על פני יחידות הידור.

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

מופעל ברמות -O, -O2, -O3, -אוס.

-fmerge-all-constants
נסה למזג קבועים זהים ומשתנים זהים.

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

-fmodulo-sched
בצע תזמון סווינג מודולו מיד לפני מעבר התזמון הראשון. זֶה
מעביר מסתכל על הלולאות הפנימיות ביותר ומסדר מחדש את ההוראות שלהם על ידי חפיפה שונות
איטרציות.

-fmodulo-sched-allow-regmoves
בצע תזמון מודולו מבוסס SMS אגרסיבי יותר עם מהלכי רישום מותרים. על ידי
הגדרת הדגל הזה יימחקו קצוות מסוימים נגד תלות שיפעילו
הדור של מהלכי רג המבוססים על ניתוח טווח החיים. אפשרות זו היא
יעיל רק עם -fmodulo-sched מאופשר.

-fno-branch-count-reg
אל תשתמש בהוראות "הפחתה והענף" בפנקס ספירה, אלא במקום זאת
ליצור רצף של הוראות שמפחיתות רגיסטר, להשוות אותו מולו
אפס, ואז הסתעף על סמך התוצאה. אפשרות זו היא בעלת משמעות רק ב
ארכיטקטורות התומכות בהוראות כאלה, הכוללות x86, PowerPC, IA-64 ו
S / 390.

ברירת המחדל היא -fbranch-count-reg.

-fno-function-cse
אין לשים כתובות של פונקציות ברגיסטרים; בצע כל הוראה שקוראת א
פונקציה קבועה מכילה את כתובת הפונקציה במפורש.

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

ברירת המחדל היא -ffunction-cse

-fno-zero-initialized-in-bss
אם היעד תומך בקטע BSS, GCC כברירת מחדל מציבה משתנים שכן
אתחול לאפס לתוך BSS. זה יכול לחסוך מקום בקוד המתקבל.

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

ברירת המחדל היא -fzero-initialized-in-bss.

-fmudflap -fmudflapth -fmudflapir
עבור חזיתות התומכות בו (C ו-C++), מכשיר כל מצביע/מערך מסוכן
פעולות ייחוס, חלק מפונקציות מחרוזת/ערימה של ספרייה סטנדרטית ועוד כמה פעולות אחרות
מבנים הקשורים למבחני טווח/תוקף. מודולים כל כך מכשור צריכים להיות
חסין מפני הצפת חיץ, שימוש בערימה לא חוקית וכמה מחלקות אחרות של C/C++
שגיאות תכנות. המכשור מסתמך על ספריית זמן ריצה נפרדת
(libmudflap), שתקושר לתוכנית אם -fmudflap ניתן בזמן הקישור.
התנהגות זמן הריצה של התוכנית המכשור נשלטת על ידי MUDFLAP_OPTIONS
משתנה הסביבה. ראה "env MUDFLAP_OPTIONS=-help a.out" לאפשרויות שלו.

השתמש -fmudflapth במקום -fmudflap לקמפל ולקשר אם התוכנית שלך מרובת
מוּשׁחָל. להשתמש -fmudflapir, בנוסף -fmudflap or -fmudflapth, אם
מכשור צריך להתעלם מקריאת מצביע. זה מייצר פחות מכשור (ו
לכן ביצוע מהיר יותר) ועדיין מספק הגנה מסוימת מפני זיכרון מוחלט
משחית כתיבה, אך מאפשרת קריאת נתונים בטעות להתפשט בתוך תוכנית.

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

מופעל ברמות -O2, -O3, -אוס.

-fsplit-wide-types
בעת שימוש בסוג שתופס מספר אוגרים, כגון "ארוך ארוך" ב-32 סיביות
מערכת, לפצל את הרשמים ולהקצות אותם באופן עצמאי. זה בדרך כלל
מייצר קוד טוב יותר עבור סוגים אלה, אך עשוי להקשות על ניפוי באגים.

מופעל ברמות -O, -O2, -O3, -אוס.

-fcse-follow-jumps
בחיסול תת-ביטויים נפוצים (CSE), סרוק דרך הוראות קפיצה כאשר
מטרת הקפיצה אינה מושגת בשום נתיב אחר. לדוגמה, כאשר נתקל ב-CSE
הצהרת "אם" עם סעיף "אחר", CSE יעקוב אחר הקפיצה כאשר התנאי
שנבדק הוא שקר.

מופעל ברמות -O2, -O3, -אוס.

-fcse-דלג-בלוקים
זה דומה ל -fcse-follow-jumps, אבל גורם ל-CSE לעקוב אחרי קפיצות זה
לדלג על בלוקים באופן מותנה. כאשר CSE נתקל בהצהרת "אם" פשוטה עם לא
סעיף אחר, -fcse-דלג-בלוקים גורם ל-CSE לעקוב אחר הקפיצה מסביב לגוף של
"אם".

מופעל ברמות -O2, -O3, -אוס.

-frerun-cse-after-loop
הפעל מחדש את ביטול ביטוי המשנה הנפוץ לאחר ביצוע אופטימיזציות של לולאה.

מופעל ברמות -O2, -O3, -אוס.

-fgcse
בצע מעבר גלובלי לחיסול תת-ביטויים נפוצים. גם המעבר הזה מבצע
התפשטות קבועה עולמית והעתקה.

הערה: בעת קומפילציה של תוכנית באמצעות gotos מחושבים, הרחבה של GCC, אתה עשוי לקבל
ביצועי זמן ריצה טובים יותר אם תשבית את ביטול ביטוי המשנה הנפוץ הגלובלי
לעבור על ידי הוספה -fno-gcse לשורת הפקודה.

מופעל ברמות -O2, -O3, -אוס.

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

מופעל כברירת מחדל כאשר gcse מופעל.

-fgcse-sm
מתי -fgcse-sm מופעל, העברת תנועה לחנות מופעלת לאחר common common
חיסול תת-ביטויים. כרטיס זה ינסה להעביר חנויות מחוץ ללולאות. מתי
בשימוש בשילוב עם -fgcse-lm, לולאות המכילות רצף טעינה/חנות יכולות להיות
שונה לעומס לפני הלולאה וחנות אחרי הלולאה.

לא מופעל בשום רמת אופטימיזציה.

-fgcse-las
מתי -fgcse-las מופעל, מעבר ביטול תת-הביטוי הנפוץ הגלובלי
מבטל עומסים מיותרים שמגיעים אחרי חנויות לאותו מיקום זיכרון (שניהם
פיטורים חלקיים ומלאים).

לא מופעל בשום רמת אופטימיזציה.

-fgcse-after-reload
מתי -fgcse-after-reload מופעל, מבוצע מעבר ביטול עומס מיותר
לאחר טעינה מחדש. מטרת המעבר הזה היא לנקות שפיכה מיותרת.

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

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

מופעל ברמות -O2, -O3, -אוס.

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

-fdce
בצע ביטול קוד מת (DCE) ב-RTL. מופעל כברירת מחדל ב -O וגבוה יותר.

-fdse
בצע ביטול חנויות מתות (DSE) ב-RTL. מופעל כברירת מחדל ב -O וגבוה יותר.

-fif-המרה
נסה להפוך קפיצות מותנות למקבילות נטולות סניפים. זה כולל שימוש
של מהלכים מותנים, מינימום, מקסימום, קביעת דגלים והוראות שרירי הבטן, וכמה טריקים שניתן לבצע
לפי אריתמטיקה סטנדרטית. השימוש בביצוע מותנה בשבבים היכן שהוא
זמין נשלט על ידי "if-conversion2".

מופעל ברמות -O, -O2, -O3, -אוס.

-fif-conversion2
השתמש בביצוע מותנה (כאשר זמין) כדי להפוך קפיצות מותנות לתוך
מקבילות ללא סניפים.

מופעל ברמות -O, -O2, -O3, -אוס.

-fdelete-null-pointer-checks
נניח שתוכניות אינן יכולות להפנות בבטחה למצביעי null, ושאין קוד או נתונים
האלמנט שוכן שם. זה מאפשר אופטימיזציות פשוטות של קיפול קבוע בכלל
רמות אופטימיזציה. בנוסף, מעברי אופטימיזציה אחרים ב-GCC משתמשים בדגל זה כדי
שליטה בניתוחי זרימת נתונים גלובליים המבטלים בדיקות חסרות תועלת עבור מצביעי אפס;
אלה מניחים שאם מצביע נבדק לאחר שכבר בוצע ביטול ההפניה, הוא
לא יכול להיות ריק.

עם זאת, שימו לב שבסביבות מסוימות הנחה זו אינה נכונה. להשתמש
-fno-delete-null-pointer-checks כדי להשבית אופטימיזציה זו עבור תוכניות התלויות
על ההתנהגות הזו.

יעדים מסוימים, במיוחד אלה משובצים, משביתים אפשרות זו בכל הרמות. אחרת
זה מופעל בכל הרמות: -O0, -O1, -O2, -O3, -אוס. מעברים המשתמשים במידע
מופעלים באופן עצמאי ברמות אופטימיזציה שונות.

-fdevirtualize
ניסיון להמיר שיחות לפונקציות וירטואליות לשיחות ישירות. זה נעשה גם וגם
במסגרת הליך ובין פרוצדורלי כחלק מהטבעה עקיפה
("-findirect-inlining") והתפשטות מתמדת בין-פרוצדורלית (-fipa-cp). מופעל
ברמות -O2, -O3, -אוס.

-זול-אופטימיזציות
בצע מספר אופטימיזציות קטנות שהן יקרות יחסית.

מופעל ברמות -O2, -O3, -אוס.

-חופשי
נסה להסיר הוראות הרחבה מיותרות. זה מועיל במיוחד עבור
ארכיטקטורת x86-64 אשר משתרעת באופן מרומז באפס ברגיסטרים של 64 סיביות לאחר
כותבים לחצי ה-32-bit התחתון שלהם.

מופעל עבור x86 ברמות -O2, -O3.

-foptimize-register-move
-פרגmove
נסה להקצות מחדש מספרי רישום בהוראות תנועה וכאופרנדים של אחרים
הוראות פשוטות על מנת למקסם את כמות קשירת הרשמים. זה
מועיל במיוחד במכונות עם הוראות שני אופרנדים.

הערות -פרגmove ו -foptimize-register-move הם אותה אופטימיזציה.

מופעל ברמות -O2, -O3, -אוס.

-fira-algorithm=אַלגוֹרִיתְם
השתמש באלגוריתם הצביעה שצוין עבור מקצה האוגר המשולב. ה
אַלגוֹרִיתְם טיעון יכול להיות עדיפות, המציין את צביעה העדיפות של Chow, או CB,
אשר מפרט צביעה Chaitin-Briggs. צביעה Chaitin-Briggs אינה מיושמת
עבור כל הארכיטקטורות, אבל עבור אותם יעדים שתומכים בכך, זוהי ברירת המחדל
כי זה מייצר קוד טוב יותר.

-fira-region=באזור
השתמש באזורים שצוינו עבור מקצה האוגר המשולב. ה באזור טענה
צריך להיות אחד מהבאים:

את כל השתמש בכל הלולאות כאזורי הקצאת רישום. זה יכול לתת את התוצאות הטובות ביותר עבור
מכונות עם סט רישום קטן ו/או לא סדיר.

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

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

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

אפשרות זו מופעלת ברמה -O3 עבור כמה יעדים.

-fno-ira-share-save-slots
השבת שיתוף של חריצי מחסנית המשמשים לשמירת אוגרים קשיחים המשמשים בשיחות
שיחה. כל אוגר קשיח מקבל משבצת מחסנית נפרדת, וכתוצאה מכך מחסנית פונקציות
המסגרות גדולות יותר.

-fno-ira-share-spill-slots
השבת את השיתוף של חריצי מחסנית שהוקצו עבור פסאודו-ריסטרים. כל פסאודו-רישום
שאינו מקבל אוגר קשיח מקבל משבצת מחסנית נפרדת, וכתוצאה מכך פונקציה
מסגרות ערימה גדולות יותר.

-fira-verbose=n
שליטה במילוליות של קובץ ה-dump עבור מקצה האוגר המשולב. ה
ערך ברירת המחדל הוא 5. אם הערך n גדול או שווה ל-10, פלט ה-dump נשלח
כדי stderr באמצעות אותו פורמט כמו n מינוס 10.

-ענף מושהה
אם נתמך עבור מחשב היעד, נסה לסדר מחדש את ההוראות לניצול
משבצות הוראות זמינות לאחר דחיית הוראות סניף.

מופעל ברמות -O, -O2, -O3, -אוס.

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

מופעל ברמות -O2, -O3.

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

מופעל ברמות -O2, -O3, -אוס.

-fno-sched-interblock
אל תזמן הוראות על פני בלוקים בסיסיים. זה מופעל בדרך כלל כברירת מחדל
בעת תזמון לפני הקצאת רישום, כלומר עם -fschedule-insns או -O2 or
גבוה.

-fno-sched-המפרט
אל תאפשר תנועה ספקולטיבית של הוראות ללא עומס. זה מופעל בדרך כלל על ידי
ברירת מחדל בעת תזמון לפני הקצאת רישום, כלומר עם -fschedule-insns או
-O2 או גבוה יותר.

-fsched-לחץ
אפשר תזמון insn רגיש ללחץ של האוגר לפני הקצאת האוגר.
זה הגיוני רק כאשר תזמון לפני הקצאת רישום מופעלת, כלומר עם
-fschedule-insns או -O2 או גבוה יותר. שימוש באפשרות זו יכול לשפר את ההפקה
קוד ולהקטין את גודלו על ידי מניעת עליית לחץ האוגר מעל המספר
של רישומים קשיחים זמינים וכתוצאה מכך נשפך רישום בפנקס
הַקצָאָה.

-fsched-spec-load
אפשר תנועה ספקולטיבית של כמה הוראות עומס. זה הגיוני רק מתי
תזמון לפני הקצאת רישום, כלומר עם -fschedule-insns או -O2 או גבוה יותר.

-fsched-spec-עומס-מסוכן
אפשר תנועה ספקולטיבית של הוראות עומס נוספות. זה הגיוני רק מתי
תזמון לפני הקצאת רישום, כלומר עם -fschedule-insns או -O2 או גבוה יותר.

-fsched-stalled-insns
-fsched-stalled-insns=n
הגדר כמה אינסנס (אם בכלל) ניתן להעביר בטרם עת מהתור של תקועים
נכנס לרשימת המוכנים, במהלך מעבר התזמון השני.
-fno-sched-stalled-insns פירושו שאף חבילות לא יועברו בטרם עת,
-fsched-stalled-insns=0 פירוש הדבר שאין הגבלה על כמה כניסות בתור ניתן להעביר
בטרם עת. -fsched-stalled-insns ללא ערך שווה ערך ל
-fsched-stalled-insns=1.

-fsched-stalled-insns-dep
-fsched-stalled-insns-dep=n
הגדירו כמה קבוצות insn (מחזורים) ייבדקו עבור תלות בנתקע
insn שהוא מועמד להסרה מוקדמת מהתור של insns שנתקעו. זֶה
משפיע רק במהלך מעבר התזמון השני, ורק אם
-fsched-stalled-insns משמש. -fno-sched-stalled-insns-dep שווה
-fsched-stalled-insns-dep=0. -fsched-stalled-insns-dep ללא ערך שווה ערך
ל -fsched-stalled-insns-dep=1.

-fsched2-use-superblocks
בעת תזמון לאחר הקצאת רישום, השתמש באלגוריתם תזמון סופרבלוק.
תזמון Superblock מאפשר תנועה על פני גבולות בלוק בסיסיים וכתוצאה מכך מהר יותר
לוחות זמנים. אפשרות זו היא ניסיונית, מכיוון שלא כל תיאורי המכונה בשימוש על ידי GCC
לדגמן את ה-CPU מקרוב מספיק כדי למנוע תוצאות לא אמינות מהאלגוריתם.

זה הגיוני רק כאשר מתזמנים לאחר הקצאת רישום, כלומר עם
-fschedule-insns2 או -O2 או גבוה יותר.

-fsched-group-heuristic
אפשר את ההיוריסטיקה הקבוצתית בלוח הזמנים. היוריסטיקה זו מעדיפה את ההוראה
ששייך לקבוצת לוח זמנים. זה מופעל כברירת מחדל כאשר תזמון הוא
מופעל, כלומר עם -fschedule-insns or -fschedule-insns2 או -O2 או גבוה יותר.

-fsched-critical-path-hyuristic
אפשר את היוריסטית הנתיב הקריטי במתזמן. ההיוריסטיקה הזו מעדיף
הוראות על הנתיב הקריטי. זה מופעל כברירת מחדל כאשר תזמון הוא
מופעל, כלומר עם -fschedule-insns or -fschedule-insns2 או -O2 או גבוה יותר.

-fsched-spec-insn-heuristic
אפשר את היוריסטית ההוראה הספקולטיבית במתזמן. ההיוריסטיקה הזו מעדיף
הוראות ספקולטיביות עם חולשת תלות גדולה יותר. זה מופעל כברירת מחדל
כאשר תזמון מופעל, כלומר עם -fschedule-insns or -fschedule-insns2 או -O2
או גבוה יותר.

-fsched-rank-heuristic
אפשר את היוריסטית הדירוג במתזמן. היוריסטיקה זו מעדיפה את ההוראה
שייך לבלוק בסיסי עם גודל או תדירות גדולים יותר. זה מופעל כברירת מחדל
כאשר תזמון מופעל, כלומר עם -fschedule-insns or -fschedule-insns2 או -O2
או גבוה יותר.

-fsched-last-insn-heuristic
אפשר את היוריסטית ההוראה האחרונה במתזמן. היוריסטיקה זו מעדיפה את
הוראה שפחות תלויה בהוראה האחרונה שתוזמנה. זה מופעל
כברירת מחדל כאשר תזמון מופעל, כלומר עם -fschedule-insns or -fschedule-insns2
או -O2 או גבוה יותר.

-fsched-dep-count-heuristic
אפשר את היוריסטית ספירת התלות במתזמן. היוריסטיקה זו מעדיפה את
הוראה שיש לה יותר הוראות בהתאם לה. זה מופעל כברירת מחדל
כאשר תזמון מופעל, כלומר עם -fschedule-insns or -fschedule-insns2 או -O2
או גבוה יותר.

-freschedule-modulo-scheduled-loops
תזמון המודולו בא לפני התזמון המסורתי, אם לולאה הייתה מודולו
מתוזמן, ייתכן שנרצה למנוע מעברי התזמון המאוחרים לשנות את שלו
לוח זמנים, אנו משתמשים באפשרות זו כדי לשלוט בזה.

-סלקטיבי-תזמון
תזמן הוראות באמצעות אלגוריתם תזמון סלקטיבי. ריצות תזמון סלקטיבי
במקום מעבר המתזמן הראשון.

-fsellective-scheduling2
תזמן הוראות באמצעות אלגוריתם תזמון סלקטיבי. ריצות תזמון סלקטיבי
במקום מעבר המתזמן השני.

-fsel-sched-pipelining
אפשר צנרת תוכנה של לולאות פנימיות ביותר במהלך תזמון סלקטיבי. זֶה
לאופציה אין השפעה עד לאחד מ -סלקטיבי-תזמון or -fsellective-scheduling2 is
נדלק.

-fsel-sched-pipelining-outer-loops
כאשר צינורות לולאות במהלך תזמון סלקטיבי, גם צינור לולאות חיצוניות. זֶה
לאופציה אין השפעה עד -fsel-sched-pipelining מופעל.

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

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

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

מופעל ברמות -O2, -O3, -אוס.

-fcombine-stack-adjustments
עוקב אחר התאמות מחסנית (דחיפות וקפיצות) ומערימה הפניות לזיכרון ולאחר מכן מנסה
למצוא דרכים לשלב ביניהם.

מופעל כברירת מחדל ב -O1 וגבוה יותר.

-fconserve-מחסנית
נסה למזער את השימוש בערימה. המהדר ינסה להשתמש בפחות שטח מחסנית,
גם אם זה הופך את התוכנית לאיטי יותר. אפשרות זו מרמזת על הגדרת ה ערימה גדולה-
מסגרת פרמטר ל-100 וה- גדול-מחסנית-פריים-צמיחה פרמטר ל-400.

-ftree-reassoc
בצע שיוך מחדש על עצים. דגל זה מופעל כברירת מחדל ב -O וגבוה יותר.

-ftree-pre
בצע ביטול יתירות חלקית (PRE) על עצים. דגל זה מופעל על ידי
ברירת מחדל ב -O2 ו -O3.

-ftree-partial-pre
הפוך את ביטול יתירות חלקית (PRE) לאגרסיבי יותר. דגל זה מופעל על ידי
ברירת מחדל ב -O3.

-ftree-forwprop
בצע ריבוי קדימה על עצים. דגל זה מופעל כברירת מחדל ב -O ו
גבוה.

-ftree-fre
בצע ביטול יתירות מלאה (FRE) על עצים. ההבדל בין FRE ל
PRE הוא ש-FRE מתייחס רק לביטויים שמחושבים בכל הנתיבים המובילים אליהם
החישוב המיותר. ניתוח זה מהיר יותר מ-PRE, אם כי הוא חושף פחות
פיטורים. דגל זה מופעל כברירת מחדל ב -O וגבוה יותר.

-ftree-phiprop
בצע הנפת משאות ממצביעים מותנים על עצים. מעבר זה מופעל על ידי
ברירת מחדל ב -O וגבוה יותר.

-ftree-copy-prop
בצע ריבוי העתקות על עצים. מעבר זה מבטל פעולות העתקה מיותרות.
דגל זה מופעל כברירת מחדל ב -O וגבוה יותר.

-פיפא-טהור-קונסט
גלה אילו פונקציות הן טהורות או קבועות. מופעל כברירת מחדל ב -O וגבוה יותר.

-פיפא-התייחסות
גלה אילו משתנים סטטיים אינם בורחים אינם יכולים להימלט מיחידת ההידור.
מופעל כברירת מחדל ב -O וגבוה יותר.

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

-fipa-profile
בצע הפצת פרופיל בין-הליכים. הפונקציות נקראות רק מקור
פונקציות מסומנות כקר. גם פונקציות שבוצעו פעם אחת (כגון "קר",
"norreturn", בנאים סטטיים או הרסנים) מזוהים. פונקציות קרות ו
לולאה פחות חלקים של פונקציות שבוצעו פעם אחת לאחר מכן מותאמים לגודל. מופעל על ידי
ברירת מחדל ב -O וגבוה יותר.

-fipa-cp
בצע התפשטות מתמדת בין פרוצדורלית. אופטימיזציה זו מנתחת את התוכנית
כדי לקבוע מתי הערכים המועברים לפונקציות הם קבועים ולאחר מכן מבצע אופטימיזציה
בהתאם לכך. אופטימיזציה זו יכולה להגדיל משמעותית את הביצועים אם
לאפליקציה יש קבועים שהועברו לפונקציות. דגל זה מופעל כברירת מחדל ב
-O2, -אוס ו -O3.

-fipa-cp-clone
בצע שיבוט פונקציות כדי להפוך את ההתפשטות הקבועה בין פרוצדורלית לחזקה יותר. מתי
מופעל, התפשטות קבועה בין פרוצדורלית תבצע שיבוט פונקציות כאשר
ניתן לקרוא לפונקציה גלויה חיצונית עם ארגומנטים קבועים. בגלל זה
אופטימיזציה יכולה ליצור עותקים מרובים של פונקציות, היא עשויה להגדיל באופן משמעותי
גודל קוד (ראה --param ipcp-unit-growth=ערך). דגל זה מופעל כברירת מחדל ב
-O3.

-fipa-matrix-reorg
בצע שיטוח מטריצה ​​והעברה. שיטוח מטריצה ​​מנסה להחליף an
מטריצה ​​m-ממדית עם מטריצה ​​n-ממדית המקבילה שלה, כאשר n < m. זֶה
מפחית את רמת העקיפה הדרושה לגישה לרכיבי המטריצה. ה
אופטימיזציה שניה היא טרנספוזיציה מטריצה, המנסה לשנות את סדר ה-
מידות המטריצה ​​על מנת לשפר את מקומיות המטמון. שתי האופטימיזציות צריכות את
-התוכנית שלמה דֶגֶל. העברה מופעלת רק אם מידע על פרופיל
זמין.

-כיור-ftree
בצע תנועת אחסון קדימה על עצים. דגל זה מופעל כברירת מחדל ב -O ו
גבוה.

-ftree-bit-ccp
בצע התפשטות מעט מותנית דלילה על עצים והפצת מצביע
מידע יישור. מעבר זה פועל רק על משתנים סקלרים מקומיים והוא
מופעל כברירת מחדל ב -O וגבוה יותר. זה דורש את זה -ftree-ccp מאופשר.

-ftree-ccp
בצע ריבוי קבוע מותנה דליל (CCP) על עצים. המעבר הזה בלבד
פועל על משתנים סקלרים מקומיים ומופעל כברירת מחדל ב- -O וגבוה יותר.

-ftree-switch-conversion
בצע המרה של אתחולים פשוטים במעבר לאתחולים מ-a
מערך סקלארי. דגל זה מופעל כברירת מחדל ב -O2 וגבוה יותר.

-ftree-זנב-מיזוג
חפש רצפי קוד זהים. כאשר נמצא, החלף אחד בקפיצה לשני.
אופטימיזציה זו ידועה כמיזוג זנב או קפיצה צולבת. דגל זה מופעל על ידי
ברירת מחדל ב -O2 וגבוה יותר. ניתן להגביל את זמן הקומפילציה במעבר זה באמצעות
מקסימום-זנב-מיזוג-השוואות פרמטר ו- מקסימום-זנב-מיזוג-איטרציות פָּרָמֶטֶר.

-ftree-dce
בצע ביטול קוד מת (DCE) על עצים. דגל זה מופעל כברירת מחדל ב -O
וגבוה יותר.

-ftree-builtin-call-dce
בצע ביטול קוד מת מותנה (DCE) עבור קריאות לפונקציות מובנות
עשוי להגדיר "שגיאה" אך חוץ מתופעות לוואי. דגל זה מופעל כברירת מחדל
at -O2 ומעלה אם -אוס לא מצוין גם.

-ftree-dominator-opts
בצע מגוון של ניקויים סקלרים פשוטים (הפצה קבועה/העתקה, יתירות
חיסול, התפשטות טווח ופישוט ביטוי) מבוסס על דומינטור
מעבר עצים. זה מבצע גם השחלת קפיצות (כדי להפחית קפיצות לקפיצות). זֶה
דגל מופעל כברירת מחדל ב -O וגבוה יותר.

-ftree-dse
בצע ביטול חנות מתה (DSE) על עצים. חנות מתה היא חנות לתוך זיכרון
מיקום שמאוחר יותר מוחלף על ידי חנות אחרת ללא עומסים מתערבים. ב
במקרה זה ניתן למחוק את החנות הקודמת. דגל זה מופעל כברירת מחדל ב -O ו
גבוה.

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

-ftree-loop-optimize
בצע אופטימיזציות של לולאות על עצים. דגל זה מופעל כברירת מחדל ב -O ו
גבוה.

-ftree-לולאה-לינארית
בצע טרנספורמציות של החלפת לולאה על עץ. כמו -פלופ-מחלף. להשתמש
שינוי הקוד הזה, יש להגדיר את GCC עם --with-ppl ו --עם-קלוג ל
אפשר את תשתית הטרנספורמציה של לולאת גרפיט.

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

DO J = 1, M
DO I = 1, N
A(J, I) = A(J, I) * C
אנדו
אנדו

החלפת לולאה תמיר את הלולאה כאילו המשתמש כתב:

DO I = 1, N
DO J = 1, M
A(J, I) = A(J, I) * C
אנדו
אנדו

מה שיכול להיות מועיל כאשר "N" גדול יותר מהמטמונים, מכיוון שבפורטרן, ה
אלמנטים של מערך מאוחסנים בזיכרון ברציפות לפי עמודה, והמקור
לולאה חוזרת על פני שורות, ועלולה ליצור בכל גישה פספוס מטמון. זֶה
אופטימיזציה חלה על כל השפות הנתמכות על ידי GCC ואינה מוגבלת ל
פורטרן. כדי להשתמש בשינוי קוד זה, יש להגדיר את GCC עם --with-ppl
ו --עם-קלוג כדי לאפשר את תשתית הטרנספורמציה של לולאת גרפיט.

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

DO I = 1, N
A(I) = A(I) + C
אנדו

כריית רצועות לולאה תהפוך את הלולאה כאילו המשתמש כתב:

DO II = 1, N, 51
DO I = II, min (II + 50, N)
A(I) = A(I) + C
אנדו
אנדו

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

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

DO I = 1, N
DO J = 1, M
A (j, i) = b (i) + c (j)
אנדו
אנדו

חסימת לולאה תהפוך את הלולאה כאילו המשתמש כתב:

DO II = 1, N, 51
DO JJ = 1, M, 51
DO I = II, min (II + 50, N)
DO J = JJ, min (JJ + 50, M)
A (j, i) = b (i) + c (j)
אנדו
אנדו
אנדו
אנדו

מה שיכול להיות מועיל כאשר "M" גדול יותר מהמטמונים, בגלל הלולאה הפנימית ביותר
יחזור על כמות קטנה יותר של נתונים שניתן לשמור במטמונים. זֶה
אופטימיזציה חלה על כל השפות הנתמכות על ידי GCC ואינה מוגבלת ל
פורטרן. כדי להשתמש בשינוי קוד זה, יש להגדיר את GCC עם --with-ppl
ו --עם-קלוג כדי לאפשר את תשתית הטרנספורמציה של לולאת גרפיט.

-זהות-fgraphite
אפשר את שינוי הזהות עבור גרפיט. עבור כל SCoP שאנו יוצרים את
ייצוג רב-הדרלי ולהפוך אותו בחזרה לגימפל. באמצעות -זהות-fgraphite
אנו יכולים לבדוק את העלויות או היתרונות של הטרנספורמציה של GIMPLE -> GRAPHITE -> GIMPLE.
כמה אופטימיזציות מינימליות מבוצעות גם על ידי מחולל הקוד CLooG, כמו אינדקס
פיצול וביטול קוד מת בלולאות.

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

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

-fcheck-data-deps
השווה את התוצאות של מספר מנתחי תלות נתונים. אפשרות זו משמשת עבור
איתור באגים של מנתחי התלות בנתונים.

-ftree-loop-if-convert
נסה להפוך קפיצות מותנות בלולאות הפנימיות ביותר ללא ענפים
מקבילות. הכוונה היא להסיר זרימת בקרה מהלולאות הפנימיות ביותר לפי הסדר
כדי לשפר את היכולת של מעבר הוקטוריזציה לטפל בלולאות אלו. זה
מופעל כברירת מחדל אם וקטוריזציה מופעלת.

-ftree-loop-if-convert-stores
נסה גם אם-להמיר קפיצות מותנות המכילות כתיבה בזיכרון. זֶה
הטרנספורמציה עלולה להיות לא בטוחה עבור תוכניות מרובות פתילים מכיוון שהיא משתנה מותנית
זיכרון כותב לתוך זיכרון בלתי מותנה כותב. לדוגמה,

עבור (i = 0; i < N; i++)
אם (תנאי)
A[i] = expr;

יהפוך ל

עבור (i = 0; i < N; i++)
A[i] = תנאי ? expr : A[i];

עלולים לייצר מירוצי נתונים.

-ftree-loop-distribution
בצע הפצת לולאה. דגל זה יכול לשפר את ביצועי המטמון בגופי לולאה גדולים
ולאפשר לבצע אופטימיזציות נוספות של לולאה, כמו הקבלה או וקטוריזציה
מקום. לדוגמה, הלולאה

DO I = 1, N
A (i) = b (i) + c
D(I) = E(I) * F
אנדו

הופך ל

DO I = 1, N
A (i) = b (i) + c
אנדו
DO I = 1, N
D(I) = E(I) * F
אנדו

-ftree-loop-distribute-passtrens
בצע הפצת לולאה של דפוסים שניתן ליצור קוד עם קריאות ל-a
סִפְרִיָה. דגל זה מופעל כברירת מחדל ב -O3.

המעבר הזה מפיץ את לולאות האתחול ויוצר קריאה לממסט אפס.
לדוגמה, הלולאה

DO I = 1, N
A(I) = 0
B(I) = A(I) + I
אנדו

הופך ל

DO I = 1, N
A(I) = 0
אנדו
DO I = 1, N
B(I) = A(I) + I
אנדו

ולולאת האתחול הופכת לקריאה לממסט אפס.

-ftree-loop-im
בצע תנועה בלתי משתנה של לולאה על עצים. מעבר זה מזיז רק אינוריאנטים שיהיו
קשה לטפל ברמת RTL (שיחות פונקציה, פעולות שמתרחבות ללא טריוויאליות
רצפים של אינסנס). עם -לולאות funswitch זה גם מזיז אופרנדים של תנאים
הם בלתי משתנה מחוץ ללולאה, כך שנוכל להשתמש רק בניתוח אי וריאנטיות טריוויאלי
בביטול מיתוג לולאה. הכרטיס כולל גם תנועת חנות.

-ftree-loop-ivcanon
צור מונה קנוני למספר האיטרציות בלולאות שעבורן קובעים
מספר איטרציות דורש ניתוח מסובך. אופטימיזציות מאוחרות יותר עשויות
לקבוע את המספר בקלות. שימושי במיוחד בקשר לפרילה.

-fivopts
בצע אופטימיזציות של משתני אינדוקציה (הפחתת חוזק, משתנה אינדוקציה
מיזוג וביטול משתני אינדוקציה) על עצים.

-ftree-parallize-loops=n
מקביל לולאות, כלומר, פצל את מרחב האיטרציה שלהם כדי לרוץ ב-n חוטים. זה
אפשרי רק עבור לולאות שהאיטרציות שלהן עצמאיות ויכולות להיות שרירותיות
סדר מחדש. האופטימיזציה משתלמת רק במכונות ריבוי מעבדים, עבור לולאות
שהם עתירי מעבד, ולא מוגבלים, למשל על ידי רוחב פס של זיכרון. אפשרות זו
מרמז -phthread, ולכן הוא נתמך רק על יעדים שיש להם תמיכה עבור
-phthread.

-ftree-pta
בצע ניתוח נקודות-אל-פונקציות מקומיות על עצים. דגל זה מופעל כברירת מחדל
at -O וגבוה יותר.

-ftree-sra
בצע החלפה סקלרית של אגרגטים. מעבר זה מחליף הפניות למבנה
עם סקלרים כדי למנוע העברת מבנים לזיכרון מוקדם מדי. הדגל הזה הוא
מופעל כברירת מחדל ב -O וגבוה יותר.

-ftree-copyrename
בצע שינוי שם עותק על עצים. המעבר הזה מנסה לשנות את שם המהדר זמני ל
משתנים אחרים במיקומי העתקה, בדרך כלל מביאים לשמות משתנים אשר יותר
דומה מאוד למשתנים המקוריים. דגל זה מופעל כברירת מחדל ב -O ו
גבוה.

-ftree-coalesce-inlined-vars
ספר למעבר שם העותק (ראה -ftree-copyrename) כדי לנסות לשלב משתמש קטן-
גם משתנים מוגדרים, אבל רק אם הם היו מוטבעים מפונקציות אחרות. זה
צורה מוגבלת יותר של -ftree-coalesce-vars. זה עלול להזיק למידע על ניפוי באגים של כאלה
משתנים מוטבעים, אבל זה ישמור משתנים של הפונקציה המוטבעת בנפרד
אחד את השני, כך שיש סיכוי גבוה יותר שיכילו את הערכים הצפויים ב-a
פגישת איתור באגים. זו הייתה ברירת המחדל בגרסאות GCC ישנות מ-4.7.

-ftree-coalesce-vars
ספר למעבר שם העותק (ראה -ftree-copyrename) כדי לנסות לשלב משתמש קטן-
גם משתנים מוגדרים, במקום רק זמני מהדר. זה עלול להגביל מאוד
היכולת לנפות באגים בתוכנית מותאמת שהידור עם -fno-var-tracking-assignments.
בצורה השלילה, דגל זה מונע התלכדות SSA של משתני משתמש, כולל
משובצים. אפשרות זו מופעלת כברירת מחדל.

-ftree-ter
בצע החלפת ביטוי זמנית במהלך השלב SSA->נורמלי. יחיד
זמני שימוש/הגדרה יחיד מוחלפים במיקום השימוש שלהם עם ההגדרה שלהם
ביטוי. זה מביא לקוד שאינו GIMPLE, אבל נותן למרחיבים הרבה יותר
עצים מורכבים לעבוד עליהם וכתוצאה מכך ליצור RTL טוב יותר. זה מופעל על ידי
ברירת מחדל ב -O וגבוה יותר.

-ftree-vectorize
בצע וקטוריזציה של לולאה על עצים. דגל זה מופעל כברירת מחדל ב -O3.

-ftree-slp-וקטוריזה
בצע וקטוריזציה בסיסית של בלוקים על עצים. דגל זה מופעל כברירת מחדל ב -O3 ו
מתי -ftree-vectorize מאופשר.

-ftree-vect-loop-version
בצע גירסאות לולאה בעת ביצוע וקטוריזציה של לולאה על עצים. כאשר מופיעה לולאה
להיות ניתנים לווקטור, אלא שלא ניתן לקבוע יישור נתונים או תלות בנתונים
בזמן הקומפילציה, אז נוצרות גרסאות וקטוריות ולא ווקטוריות של הלולאה
יחד עם בדיקות זמן ריצה עבור יישור או תלות כדי לשלוט באיזו גרסה היא
יצא לפועל. אפשרות זו מופעלת כברירת מחדל למעט ברמה -אוס איפה זה מושבת.

-fvect-cost-model
אפשר מודל עלות לוקטוריזציה.

-ftree-vrp
בצע ריבוי טווח ערכים על עצים. זה דומה להתפשטות המתמדת
לעבור, אבל במקום ערכים, טווחי ערכים מופצים. זה מאפשר את
אופטימיזציה להסרת בדיקות טווח מיותרות כמו בדיקות מאוגדות מערך ומצביע null
המחאות. זה מופעל כברירת מחדל ב -O2 וגבוה יותר. חיסול בדיקת מצביע אפס
נעשה רק אם -fdelete-null-pointer-checks מאופשר.

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

-funroll-לולאות
פתח לולאות שניתן לקבוע את מספר האיטרציות שלהן בזמן ההידור או לאחר מכן
כניסה ללופ. -funroll-לולאות מרמז -frerun-cse-after-loop. אפשרות זו עושה
קוד גדול יותר, ואולי יגרום לו לרוץ מהר יותר או לא.

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

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

שילוב של -FWeb. ו-CSE לעתים קרובות מספיק כדי להשיג את אותו אפקט. למרות זאת
במקרים שגוף הלולאה מסובך יותר מבלוק בסיסי יחיד, זה לא
אָמִין. זה גם לא עובד בכלל על חלק מהארכיטקטורות עקב
הגבלות בכרטיס CSE.

אופטימיזציה זו מופעלת כברירת מחדל.

-fvariable-expansion-in-unroller
עם אפשרות זו, המהדר יצור עותקים מרובים של כמה משתנים מקומיים
בעת פתיחת לולאה שיכולה לגרום לקוד מעולה.

-fpartial-inlining
חלקים מוטבעים של פונקציות. אפשרות זו משפיעה רק כאשר הטבעת עצמה היא
מופעל על ידי -finline-פונקציות or -finline-קטנות-פונקציות אפשרויות.

מופעל ברמה -O2.

-fpredictive-commoning
בצע אופטימיזציה של שיתוף חזוי, כלומר שימוש חוזר בחישובים (במיוחד
טעינות ואחסון זיכרון) שבוצעו באיטרציות קודמות של לולאות.

אפשרות זו מופעלת ברמה -O3.

-fprefetch-loop-arrays
אם נתמך על ידי מכונת היעד, צור הוראות לשליפה מראש של זיכרון
שפר את הביצועים של לולאות הניגשות למערכים גדולים.

אפשרות זו עשויה ליצור קוד טוב יותר או גרוע יותר; התוצאות תלויות מאוד ב
מבנה לולאות בתוך קוד המקור.

נכה ברמה -אוס.

-fno-חור הצצה
-fno-חור הצצה2
השבת כל אופטימיזציה של חורי הצצה ספציפיים למכונה. ההבדל בין
-fno-חור הצצה ו -fno-חור הצצה2 הוא כיצד הם מיושמים במהדר; כמה
מטרות משתמשות באחת, חלקן משתמשות בשני, מעטות משתמשות בשניהם.

-חור הצצה מופעל כברירת מחדל. -fpeephole2 מופעל ברמות -O2, -O3, -אוס.

-fno-ניחוש-ענף-הסתברות
אל תנחש הסתברויות הסתעפות באמצעות היוריסטיות.

GCC ישתמש בהיוריסטיקה כדי לנחש הסתברויות ענפים אם הן לא מסופקות על ידי
משוב על פרופיל (-fprofile-arcs). היוריסטיות אלו מבוססות על זרימת הבקרה
גרָף. אם כמה הסתברויות ענף מצוינות על ידי __builtin_expect, אז ה
יוריסטיקה תשמש כדי לנחש הסתברויות הסתעפות עבור שאר זרימת הבקרה
גרף, לוקח את __builtin_expect מידע בחשבון. יחסי הגומלין בין ה
היוריסטיקה ו __builtin_expect יכול להיות מורכב, ובמקרים מסוימים, זה עשוי להיות שימושי
להשבית את ההיוריסטיקה כך שההשפעות של __builtin_expect קל יותר
מבינה.

ברירת המחדל היא -ניחוש-ענף-הסתברות ברמות -O, -O2, -O3, -אוס.

-Freord-בלוקים
סדר מחדש בלוקים בסיסיים בפונקציית הקומפילציה על מנת לצמצם את מספר הנלקחים
סניפים ולשפר את יישוב הקוד.

מופעל ברמות -O2, -O3.

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

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

-פקודת-פונקציות
סדר מחדש פונקציות בקובץ האובייקט על מנת לשפר את מקומיות הקוד. זה
מיושם על ידי שימוש בתתי סעיפים מיוחדים ".text.hot" עבור הביצועים התכופים ביותר
functions ו-".text.unlikely" עבור פונקציות לא סבירות שבוצעו. ההזמנה מחדש מתבצעת על ידי
ה-linker כך שפורמט קובץ האובייקט חייב לתמוך בקטעים בעלי שם וה-linker חייב למקם
אותם בצורה סבירה.

כמו כן, משוב על הפרופיל חייב להיות זמין כדי להפוך אפשרות זו לאפקטיבית. לִרְאוֹת
-fprofile-arcs לקבלת פרטים.

מופעל ברמות -O2, -O3, -אוס.

-fstrict-aliasing
אפשר למהדר להניח את כללי הכינוי המחמירים ביותר החלים על השפה
הולקט. עבור C (ו++C), זה מפעיל אופטימיזציות המבוססות על סוג של
ביטויים. בפרט, מניחים כי חפץ מסוג אחד לעולם לא יתגורר ב-
כתובת זהה לאובייקט מסוג אחר, אלא אם הסוגים כמעט זהים.
לדוגמה, "int unsigned" יכול לכינוי "int", אך לא "void*" או "double". א
סוג התווים יכול לכנות כל סוג אחר.

שימו לב במיוחד לקוד כזה:

union a_union {
int i;
כפול ד;
};

int f() {
איגוד א_איגוד ט;
td = 3.0;
החזר טי;
}

תרגול הקריאה מחבר איגוד שונה מזה האחרון
נכתב אל (הנקרא "טייפ-punning") נפוץ. אפילו עם -fstrict-aliasing, הקלד-
מותר לפענח, בתנאי שהגישה לזיכרון מתבצעת דרך סוג האיחוד. אז ה
הקוד למעלה יעבוד כצפוי. עם זאת, ייתכן שקוד זה אינו:

int f() {
איגוד א_איגוד ט;
int* ip;
td = 3.0;
ip = &t.i;
החזר *ip;
}

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

int f() {
כפול d = 3.0;
return ((union a_union *) &d)->i;
}

אל האני -fstrict-aliasing האפשרות מופעלת ברמות -O2, -O3, -אוס.

-פרקט-הצפה
אפשר למהדר להניח כללי גלישה קפדניים בחתימה, בהתאם לשפה
הולקט. עבור C (ו-C++) זה אומר שהצפת כאשר עושים חשבון עם
מספרים חתומים אינם מוגדרים, מה שאומר שהמהדר עשוי להניח שלא
לִקְרוֹת. זה מאפשר אופטימיזציות שונות. לדוגמה, המהדר יניח
שביטוי כמו "i + 10 > i" תמיד יהיה נכון עבור סימן "i". זֶה
ההנחה תקפה רק אם הצפה חתומה אינה מוגדרת, שכן הביטוי הוא שקר
אם "i + 10" עולה על גדותיו בעת שימוש בחשבון משלים שניים. כאשר אפשרות זו נמצאת
להשפיע על כל ניסיון לקבוע אם פעולה במספרים חתומים תעלה על גדותיו
חייב להיות כתוב בקפידה כדי לא לכלול למעשה הצפה.

אפשרות זו גם מאפשרת למהדר להניח סמנטיקה קפדנית של מצביע: נתון א
מצביע לאובייקט, אם הוספת היסט למצביע זה אינו מייצר מצביע
לאותו אובייקט, התוספת אינה מוגדרת. זה מאפשר למהדר להסיק
ש"p + u > p" נכון תמיד עבור מצביע "p" ומספר שלם ללא סימן "u". זֶה
ההנחה תקפה רק מכיוון שהמצביע אינו מוגדר, כפי שהוא
false אם "p + u" עולה על גדותיו באמצעות אריתמטיקה משלימה שניים.

ראה גם -fwrapv אוֹפְּצִיָה. באמצעות -fwrapv פירושו שהגלישה בסימן מספר שלם הוא
מוגדר במלואו: זה עוטף. מתי -fwrapv משמש, אין הבדל בין
-פרקט-הצפה ו -fno-strict-overflow עבור מספרים שלמים. עם -fwrapv סוגים מסוימים
הצפה מותרת. לדוגמה, אם המהדר מקבל הצפה בעת ביצוע
אריתמטיקה על קבועים, עדיין ניתן להשתמש בערך הוצף עם -fwrapv, אבל לא
אחרת.

אל האני -פרקט-הצפה האפשרות מופעלת ברמות -O2, -O3, -אוס.

-falign-פונקציות
-falign-functions=n
יישר את תחילת הפונקציות לעוצמה הבאה של שניים הגדול מ n, דילוג עד n
בתים. לדוגמה, -falign-functions=32 מיישר פונקציות ל-32 הבתים הבאים
גבול, אבל -falign-functions=24 יתיישר לגבול הבא של 32 בתים רק אם
ניתן לעשות זאת על ידי דילוג על 23 בתים או פחות.

-fno-align-functions ו -falign-functions=1 מקבילים ומתכוונים שמתפקדים
לא יהיה מיושר.

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

If n לא צוין או שהוא אפס, השתמש בברירת מחדל תלוית מכונה.

מופעל ברמות -O2, -O3.

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

-fno-align-labels ו -falign-labels=1 שוות ערך ומשמעותם שתוויות לא יהיו
מיושר.

If -falign-לולאות or -falign-קפיצות אם כן, ישימים והם גדולים מהערך הזה
הערכים שלהם משמשים במקום זאת.

If n לא צוין או שהוא אפס, השתמש בברירת מחדל תלוית מכונה שסביר מאוד
להיות 1, כלומר אין יישור.

מופעל ברמות -O2, -O3.

-falign-לולאות
-falign-loops=n
יישר לולאות לגבול של עוצמה של שניים, דילוג עד n בתים כמו -falign-פונקציות.
התקווה היא שהלולאה תבוצע פעמים רבות, מה שיפצה על כל
ביצוע פעולות הדמה.

-fno-align-לולאות ו -falign-loops=1 שוות ערך ומתכוון שלא יהיו לולאות
מיושר.

If n לא צוין או שהוא אפס, השתמש בברירת מחדל תלוית מכונה.

מופעל ברמות -O2, -O3.

-falign-קפיצות
-falign-jumps=n
יישר מטרות הסתעפות לגבול של שניים, עבור מטרות הסתעפות שבהן המטרות
ניתן להגיע רק על ידי קפיצה, דילוג עד n בתים כמו -falign-פונקציות. ב
במקרה זה, אין צורך לבצע פעולות דמה.

-fno-align-jumps ו -falign-jumps=1 שוות ערך ומתכוון שלא יהיו לולאות
מיושר.

If n לא צוין או שהוא אפס, השתמש בברירת מחדל תלוית מכונה.

מופעל ברמות -O2, -O3.

-כיף-בכל פעם
אפשרות זו נותרה מטעמי תאימות. -כיף-בכל פעם אין השפעה, בעוד
-fno-unit-בכל פעם מרמז -fno-toplevel-סדר מחדש ו -fno-חתך-עוגנים.

מופעלת כברירת מחדל.

-fno-toplevel-סדר מחדש
אל תסדר מחדש פונקציות ברמה העליונה, משתנים והצהרות "asm". פלט אותם פנימה
באותו סדר שהם מופיעים בקובץ הקלט. כאשר משתמשים באפשרות זו,
משתנים סטטיים ללא הפניה לא יוסרו. אפשרות זו נועדה לתמוך
קוד קיים המסתמך על הזמנה מסוימת. עבור קוד חדש, עדיף להשתמש
תכונות.

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

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

מופעל כברירת מחדל עם -funroll-לולאות.

-התוכנית שלמה
נניח שיחידת ההידור הנוכחית מייצגת את כל התוכנית הנערכים.
כל הפונקציות והמשתנים הציבוריים למעט "ראשי" ואלה שמוזגו על ידי
התכונה "externally_visible" הופכות לפונקציות סטטיות ולמעשה עוברות אופטימיזציה
בצורה אגרסיבית יותר על ידי מייעלים בין-הליכים. אם זהב משמש כפלאגין המקשר,
תכונות "externally_visible" מתווספות אוטומטית לפונקציות (עדיין לא משתנות
עקב זרם זהב בעיה) שניגשים אליהם מחוץ לאובייקטי LTO לפי
קובץ רזולוציה שהופק על ידי זהב. עבור קישורים אחרים שאינם יכולים ליצור רזולוציה
הקובץ, עדיין נחוצות תכונות "externally_visible" מפורשות. בעוד אפשרות זו
שווה ערך לשימוש נכון במילת המפתח "סטטית" עבור תוכניות המורכבות מ-a
קובץ בודד, בשילוב עם אפשרות -flto דגל זה יכול לשמש כדי להרכיב רבים
תוכניות בקנה מידה קטן יותר מכיוון שהפונקציות והמשתנים הופכים מקומיים עבור השלם
יחידת קומפילציה משולבת, לא עבור קובץ המקור היחיד עצמו.

מרמז על אפשרות זו -כל הקובץ עבור תוכניות Fortran.

-flto[=n]
אפשרות זו מפעילה את האופטימיזציה הסטנדרטית של זמן קישור. כאשר מופעל עם קוד המקור, זה
יוצר את GIMPLE (אחד מהייצוגים הפנימיים של GCC) וכותב אותו ל-ELF המיוחד
מקטעים בקובץ האובייקטים. כאשר קבצי האובייקט מקושרים יחד, כל ה
גופי פונקציה נקראים מקטעי ELF אלה ומוצגים כאילו היו
חלק מאותה יחידת תרגום.

כדי להשתמש בכלי האופטימיזציה של זמן קישור, -flto יש לציין בזמן ההידור ובמהלכו
הקישור האחרון. לדוגמה:

gcc -c -O2 -flto foo.c
gcc -c -O2 -flto bar.c
gcc -o myprog -flto -O2 foo.o bar.o

שתי הפניות הראשונות ל-GCC שומרות ייצוג קוד בתים של GIMPLE במיוחד
חלקי ELF בפנים foo.o ו bar.o. ההזמנה הסופית קוראת את קוד הביטים של GIMPLE
החל מ- foo.o ו bar.o, ממזג את שני הקבצים לתמונה פנימית אחת ומבצע קומפילציה
התוצאה כרגיל. מאז שניהם foo.o ו bar.o מתמזגים לתמונה אחת, זה
גורם לכל הניתוחים הבין-הליכים והאופטימיזציות ב-GCC לעבוד על פני
שני קבצים כאילו היו אחד אחד. זה אומר, למשל, שהאינלינר הוא
מסוגל להטמיע פונקציות ב bar.o לתוך פונקציות ב foo.o ולהיפך.

דרך נוספת (פשוטה יותר) לאפשר אופטימיזציה של זמן קישור היא:

gcc -o myprog -flto -O2 foo.c bar.c

האמור לעיל יוצר bytecode עבור foo.c ו בר.ג, ממזג אותם יחד ליחיד
ייצוג GIMPLE ומייעל אותם כרגיל להפקה myprog.

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

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

שימו לב שכאשר קובץ מורכב עם -flto, קובץ האובייקט שנוצר גדול מ-
קובץ אובייקט רגיל מכיוון שהוא מכיל GIMPLE bytecodes ואת הקוד הסופי הרגיל.
המשמעות היא שניתן לקשר קבצי אובייקט עם מידע LTO כאובייקט רגיל
קבצים; אם -flto לא מועבר למקשר, אין אופטימיזציות בין-הליכים
הוחל.

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

gcc -c -O0 -flto foo.c
gcc -c -O0 -flto bar.c
gcc -o myprog -flto -O3 foo.o bar.o

זה מייצר קבצי אובייקט בודדים עם קוד אסמבלר לא מותאם, אבל ה
בינארי המתקבל myprog מותאם ב -O3. אם, במקום זאת, הבינארי הסופי הוא
נוצר בלי -flto, לאחר מכן myprog אינו מותאם.

בעת הפקת הבינארי הסופי עם -flto, GCC מחיל רק אופטימיזציות של זמן קישור
לקבצים המכילים bytecode. לכן, אתה יכול לערבב ולהתאים קבצי אובייקט
וספריות עם GIMPLE bytecodes וקוד אובייקט סופי. GCC בוחר אוטומטית
אילו קבצים לבצע אופטימיזציה במצב LTO ואיזה קבצים לקשר ללא המשך
מעבד.

ישנם כמה דגלי יצירת קוד שנשמרו על ידי GCC בעת יצירת קודי בתים, כמו
יש להשתמש בהם בשלב הקישור האחרון. נכון לעכשיו, האפשרויות הבאות
נשמרים בקבצי bytecode של GIMPLE: -fPIC, -נפוץ וכל -m דגלי מטרה.

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

אם LTO נתקל באובייקטים עם הצמדה C שהוכרזה עם סוגים לא תואמים בנפרד
יחידות תרגום שיש לקשר יחד (התנהגות לא מוגדרת לפי ISO C99
6.2.7), עשויה להינתן אבחנה לא קטלנית. ההתנהגות עדיין לא מוגדרת בריצה
הזמן.

תכונה נוספת של LTO היא שניתן ליישם אופטימיזציות בין-הליכים
על קבצים שנכתבו בשפות שונות. זה דורש תמיכה בחזית השפה
סוֹף. נכון לעכשיו, הקצה הקדמי C, C++ ו-Fortran מסוגלים לפלוט GIMPLE
bytecodes, אז משהו כזה אמור לעבוד:

gcc -c -flto foo.c
g++ -c -flto bar.cc
gfortran -c -flto baz.f90
g++ -o myprog -flto -O3 foo.o bar.o baz.o -lgfortran

שימו לב שהקישור הסופי נעשה עם g ++ כדי לקבל את ספריות זמן הריצה של C++ ו
-לגפורטרן נוסף כדי לקבל את ספריות זמן הריצה של Fortran. באופן כללי, בעת ערבוב
שפות במצב LTO, עליך להשתמש באותם אפשרויות פקודת קישור כמו בעת ערבוב
שפות באוסף רגיל (שאיננו LTO); כל מה שאתה צריך להוסיף הוא -flto לכל
קומפיל וקשר פקודות.

אם קבצי אובייקט המכילים GIMPLE bytecode מאוחסנים בארכיון של ספרייה, נניח
libfoo.a, אפשר לחלץ ולהשתמש בהם בקישור LTO אם אתה משתמש ב-
מקשר עם תמיכה בפלאגין. כדי להפעיל תכונה זו, השתמש בדגל -תוסף-מקשר-fuse
בזמן הקישור:

gcc -o myprog -O2 -flto -fuse-linker-plugin ao bo -lfoo

כאשר תוסף הקישור מופעל, המקשר מחלץ מהם את קבצי ה-GIMPLE הדרושים
libfoo.a ומעביר אותם ל-GCC הפועל כדי להפוך אותם לחלק מהמצטבר
תמונת GIMPLE למיטוב.

אם אינך משתמש בקישור עם תמיכה בפלאגין ו/או לא מפעיל את המקשר
תוסף, ואז האובייקטים בפנים libfoo.a נשלפים ומקושרים כרגיל, אבל הם
אל תשתתף בתהליך האופטימיזציה של LTO.

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

היישום הנוכחי של LTO אינו עושה ניסיון ליצור bytecode כלומר
נייד בין סוגים שונים של מארחים. קובצי ה-bytecode הם עם גרסאות ויש
הוא בדיקת גרסאות קפדנית, כך שקובצי bytecode שנוצרו בגרסה אחת של GCC לא יעשו זאת
לעבוד עם גרסה ישנה/חדשה יותר של GCC.

אופטימיזציה של זמן קישור לא עובדת טוב עם יצירת מידע באגים.
שילוב -flto עם -g כרגע ניסיוני וצפוי לייצר שגוי
תוצאות.

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

אתה יכול גם לציין -flto=שרת עבודה להשתמש במצב שרת העבודה של GNU make כדי לקבוע
מספר המשרות המקבילות. זה שימושי כאשר ה-Makefile הקורא ל-GCC כבר נמצא
ביצוע במקביל. עליך להקדים את א + למתכון הפקודה בהורה
Makefile כדי שזה יעבוד. אפשרות זו כנראה עובדת רק אם MAKE הוא מתוצרת גנו.

אפשרות זו מושבתת כברירת מחדל

-flto-partition=ALG
ציין את אלגוריתם החלוקה המשמש את כלי האופטימיזציה של זמן קישור. הערך הוא
או "1to1" כדי לציין חלוקה לשיקוף קבצי המקור המקוריים או
"מאוזן" כדי לציין חלוקה לנתחים בגודל שווה (בכל פעם שאפשר).
ציון "ללא" בתור אלגוריתם משבית לחלוטין את החלוקה והזרימה. ה
ערך ברירת המחדל הוא "מאוזן".

-flto-compression-level=n
אפשרות זו מציינת את רמת הדחיסה המשמשת עבור שפת ביניים כתובה
לקבצי אובייקט LTO, והוא בעל משמעות רק בשילוב עם מצב LTO (-flto).
ערכים חוקיים הם 0 (ללא דחיסה) עד 9 (דחיסה מקסימלית). ערכים מחוץ לזה
הטווח מוצמד ל-0 או 9. אם האפשרות לא ניתנת, ברירת המחדל מאוזנת
נעשה שימוש בהגדרת הדחיסה.

-flto-דוח
מדפיס דוח עם פרטים פנימיים על פעולתו של אופטימיזציית זמן הקישור. ה
התוכן של דוח זה משתנה מגרסה לגרסה. זה אמור להיות שימושי ל-GCC
מפתחים בעת עיבוד קבצי אובייקט במצב LTO (via -flto).

מושבת כברירת מחדל.

-תוסף-מקשר-fuse
מאפשר שימוש בתוסף קישור במהלך אופטימיזציה של זמן קישור. אפשרות זו מסתמכת
על תמיכה בפלאגין ב-linker, שזמין בזהב או ב-GNU ld 2.21 או
חדש יותר.

אפשרות זו מאפשרת חילוץ של קבצי אובייקט עם קוד בתים GIMPLE מחוץ לספרייה
אַרְכִיוֹן. זה משפר את איכות האופטימיזציה על ידי חשיפת קוד נוסף לקישור-
מייעל זמן. מידע זה מפרט לאילו סמלים ניתן לגשת חיצונית
(על ידי אובייקט שאינו LTO או במהלך קישור דינמי). כתוצאה מכך שיפורים באיכות הקוד על
קבצים בינאריים (וספריות משותפות המשתמשות בחשיפה נסתרת) דומים ל
"-fhole-program". לִרְאוֹת -flto לתיאור ההשפעה של דגל זה וכיצד לעשות זאת
תשתמש בזה.

אפשרות זו מופעלת כברירת מחדל כאשר תמיכת LTO ב-GCC מופעלת ו-GCC הייתה
מוגדר לשימוש עם קישור תומך תוספים (GNU ld 2.21 או חדש יותר או זהב).

-ffat-lto-objects
אובייקטי LTO שמנים הם קובצי אובייקט המכילים גם את שפת הביניים וגם את
קוד פריט. זה הופך אותם לשימושים גם לקישור LTO וגם לקישור רגיל. זֶה
אפשרות יעילה רק בעת קומפילציה עם -flto ומתעלמים ממנו בזמן הקישור.

-fno-fat-lto-objects משפר את זמן הקומפילציה על פני LTO רגיל, אך דורש את
שרשרת כלים מלאה כדי להיות מודע ל-LTO. זה דורש מקשר עם תמיכה בפלאגין מקשר
עבור פונקציונליות בסיסית. בנוסף, nm, ar ו-ranlib צריכים לתמוך במקשר
תוספים כדי לאפשר סביבת בנייה מלאה (שיכולה לבנות סטטי
ספריות וכו').

ברירת המחדל היא -ffat-lto-objects אבל ברירת המחדל הזו נועדה להשתנות בעתיד
משתחרר כאשר סביבות התומכות בפלאגין קישור הופכות נפוצות יותר.

-fcompare-elim
לאחר הקצאת רישום ופיצול הוראות הקצאה לאחר הרישום, זהה
הוראות אריתמטיות שמחשבות דגלי מעבד בדומה לפעולת השוואה
על סמך החשבון הזה. אם אפשר, בטל את פעולת ההשוואה המפורשת.

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

מופעל ברמות -O, -O2, -O3, -אוס.

-fuse-ld=זהב
השתמש זהב מקשר במקום מקשר ברירת המחדל.

-fuse-ld=bfd
השתמש ld.bfd מקשר במקום מקשר ברירת המחדל.

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

מופעל ברמות -O, -O2, -O3, -אוס.

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

-fprofile-dir=נתיב
הגדר את הספרייה לחיפוש קבצי נתוני הפרופיל שבהם נתיב. אפשרות זו
משפיע רק על נתוני הפרופיל שנוצרו על ידי -fprofile-generate, -הכיסוי הגבוה ביותר,
-fprofile-arcs ובשימוש על ידי -fprofile-שימוש ו -fענף-הסתברויות וקשורים אליו
אפשרויות. ניתן להשתמש בנתיבים מוחלטים ויחסיים כאחד. כברירת מחדל, GCC ישתמש ב-
הספרייה הנוכחית כ נתיב, ולכן קובץ נתוני הפרופיל יופיע באותו
ספרייה כקובץ האובייקט.

-fprofile-generate
-fprofile-generate=נתיב
אפשר אפשרויות המשמשות בדרך כלל עבור יישום מכשור כדי לייצר פרופיל שימושי
להידור מחדש מאוחר יותר עם אופטימיזציה מבוססת משוב פרופיל. אתה חייב להשתמש
-fprofile-generate הן בעת ​​הידור והן בעת ​​קישור התוכנית שלך.

האפשרויות הבאות מופעלות: "-fprofile-arcs", "-fprofile-values", "-fvpt".

If נתיב מצוין, GCC יסתכל על נתיב כדי למצוא את נתוני המשוב על הפרופיל
קבצים. לִרְאוֹת -fprofile-dir.

-fprofile-שימוש
-fprofile-use=נתיב
אפשר אופטימיזציות מכוונות משוב פרופיל, ואופטימיזציות רווחיות בדרך כלל
רק עם משוב פרופיל זמין.

האפשרויות הבאות מופעלות: "-fbranch-probabilities", "-fvpt",
"-funroll-loops", "-fpeel-loops", "-ftracer"

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

If נתיב מצוין, GCC יסתכל על נתיב כדי למצוא את נתוני המשוב על הפרופיל
קבצים. לִרְאוֹת -fprofile-dir.

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

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

אפשרות זו מונעת דיוק עודף לא רצוי במכונות כגון 68000 where
הרגיסטרים הצפים (של ה-68881) שומרים על דיוק רב יותר ממה ש"כפול" אמור להיות
יש. באופן דומה עבור ארכיטקטורת x86. עבור רוב התוכניות, דיוק עודף
עושה רק טוב, אבל כמה תוכניות מסתמכות על ההגדרה המדויקת של IEEE צף
נְקוּדָה. להשתמש -ffloat-store עבור תוכניות כאלה, לאחר שינוים כדי לאחסן את כולם
חישובי ביניים רלוונטיים למשתנים.

-fexcess-precision=סגנון
אפשרות זו מאפשרת שליטה נוספת על דיוק עודף במכונות בהן צפות-
לרגיסטרים של נקודות יש דיוק רב יותר מהסוגים "צפים" ו"כפולים" של IEEE וה-
המעבד אינו תומך בפעולות עיגול לסוגים אלה. כברירת מחדל,
-fexcess-precision=מהיר בתוקף; זה אומר שהפעולות מתבצעות ב
את הדיוק של הרגיסטרים ושהוא בלתי צפוי בעת עיגול לסוגים
המצוין בקוד המקור מתרחש. בעת הידור C, if
-fexcess-precision=סטנדרטי צוין אז דיוק עודף יפעל לפי הכללים
המצוין ב-ISO C99; בפרט, גם השחקנים וגם ההקצאות גורמים לערכים להיות
מעוגלים לסוגים הסמנטיים שלהם (אילו -ffloat-store משפיע רק על מטלות).
אפשרות זו מופעלת כברירת מחדל עבור C אם אפשרות התאמה קפדנית כגון
-std=c99 משמש.

-fexcess-precision=סטנדרטי אינו מיושם עבור שפות אחרות מלבד C, ואין לו
השפעה אם -אופטימיזציות-funsafe-math or -מהיר-מתמטיקה מצוין. ב-x86, זה
גם אין השפעה אם -mfpmath = sse or -mfpmath=sse+387 צוין; בקודם
במקרה, סמנטיקה של IEEE חלה ללא דיוק יתר, ובאחרון, עיגול הוא
בלתי צפוי.

-מהיר-מתמטיקה
סטים -fno-math-errno, -אופטימיזציות-funsafe-math, -סופית-מתמטיקה-בלבד,
-fno-עגל-מתמטיקה, -fno-signaling-nans ו -fcx-טווח מוגבל.

אפשרות זו גורמת להגדרת המאקרו הקדם-מעבד "__FAST_MATH__".

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

-fno-math-errno
אל תגדיר ERRNO לאחר קריאה לפונקציות מתמטיות המבוצעות עם סינגל
הוראה, למשל, sqrt. תוכנית המסתמכת על חריגים של IEEE לשגיאות מתמטיקה
טיפול עשוי לרצות להשתמש בדגל זה למהירות תוך שמירה על אריתמטיקה של IEEE
תאימות.

אפשרות זו אינה מופעלת על ידי אף אחד -O אפשרות מכיוון שהיא עלולה לגרום לפלט שגוי
עבור תוכניות התלויות ביישום מדויק של IEEE או ISO
כללים/מפרטים לפונקציות מתמטיות. עם זאת, זה עשוי להניב קוד מהיר יותר עבור
תוכניות שאינן דורשות את הערבויות של מפרטים אלה.

ברירת המחדל היא -fmath-errno.

במערכות דארווין, ספריית המתמטיקה אף פעם לא מגדירה "שגיאה". לכן אין סיבה
שהמהדר ישקול את האפשרות שהוא עשוי, ו -fno-math-errno האם ה
ברירת המחדל.

-אופטימיזציות-funsafe-math
אפשר אופטימיזציות עבור אריתמטיקה של נקודה צפה ש(א) מניחים שארגומנטים ו
התוצאות תקפות ו(ב) עשויות להפר את תקני IEEE או ANSI. בשימוש בזמן הקישור,
הוא עשוי לכלול ספריות או קבצי הפעלה המשנים את מילת הבקרה של FPU ברירת המחדל או
אופטימיזציות דומות אחרות.

אפשרות זו אינה מופעלת על ידי אף אחד -O אפשרות מכיוון שהיא עלולה לגרום לפלט שגוי
עבור תוכניות התלויות ביישום מדויק של IEEE או ISO
כללים/מפרטים לפונקציות מתמטיות. עם זאת, זה עשוי להניב קוד מהיר יותר עבור
תוכניות שאינן דורשות את הערבויות של מפרטים אלה. מאפשר
-fno-סימן-אפסים, -fno-מלכודת-מתמטיקה, -אסוציאטיבית-מתמטיקה ו -תדמיתי-מתמטיקה.

ברירת המחדל היא -fno-unsafe-math-optimizations.

-אסוציאטיבית-מתמטיקה
אפשר שיוך מחדש של אופרנדים בסדרות של פעולות נקודה צפה. זֶה
מפר את תקן שפת ISO C ו-C++ על ידי שינוי אולי תוצאת החישוב.
הערה: הזמנה מחדש עשויה לשנות את סימן האפס וכן להתעלם מ-NaNs ולבלום או
ליצור זרימת יתר או הצפה (ולכן לא ניתן להשתמש בו על קוד שמסתמך על עיגול
התנהגות כמו "(x + 2**52) - 2**52". עשוי גם לסדר מחדש השוואות נקודות צפה ו
לכן לא ניתן להשתמש בו כאשר נדרשות השוואות מסודרות. אפשרות זו דורשת זאת
שניהם -fno-סימן-אפסים ו -fno-מלכודת-מתמטיקה להיות בתוקף. יתר על כן, זה לא עושה
הרבה הגיון עם -חישוב-מתמטיקה. עבור Fortran האפשרות מופעלת אוטומטית כאשר
שניהם -fno-סימן-אפסים ו -fno-מלכודת-מתמטיקה בתוקף.

ברירת המחדל היא -fno-אסוציאטיבי-מתמטיקה.

-תדמיתי-מתמטיקה
אפשר להשתמש בהדדיות של ערך במקום לחלק בערך אם זה
מאפשר אופטימיזציות. לדוגמה, ניתן להחליף את "x / y" ב-"x * (1/y)", כלומר
שימושי אם "(1/y)" כפוף לביטול ביטוי משנה נפוץ. שימו לב שזה
מאבד דיוק ומגדיל את מספר הפלופים הפועלים על הערך.

ברירת המחדל היא -fno-הדדיות-מתמטיקה.

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

אפשרות זו אינה מופעלת על ידי אף אחד -O אפשרות מכיוון שהיא עלולה לגרום לפלט שגוי
עבור תוכניות התלויות ביישום מדויק של IEEE או ISO
כללים/מפרטים לפונקציות מתמטיות. עם זאת, זה עשוי להניב קוד מהיר יותר עבור
תוכניות שאינן דורשות את הערבויות של מפרטים אלה.

ברירת המחדל היא -fno-finite-מתמטיקה-בלבד.

-fno-סימן-אפסים
אפשר אופטימיזציות עבור אריתמטיקה של נקודה צפה שמתעלמת מהסימן של אפס.
אריתמטיקה IEEE מציינת את ההתנהגות של ערכי +0.0 ו-0.0 ברורים, אשר לאחר מכן
אוסר על פישוט של ביטויים כגון x+0.0 או 0.0*x (אפילו עם
-סופית-מתמטיקה-בלבד). אפשרות זו מרמזת שהסימן של תוצאת אפס אינו
משמעותי.

ברירת המחדל היא -fsigned-אפסים.

-fno-מלכודת-מתמטיקה
הידור קוד בהנחה שפעולות נקודה צפה אינן יכולות ליצור גלויות למשתמש
מלכודות. מלכודות אלו כוללות חלוקה באפס, הצפה, זרימת יתר, תוצאה לא מדויקת ו
פעולה לא חוקית. אפשרות זו דורשת זאת -fno-signaling-nans להיות בתוקף.
הגדרת אפשרות זו עשויה לאפשר קוד מהיר יותר אם מסתמכים על אריתמטיקה IEEE "ללא הפסקה",
למשל.

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

ברירת המחדל היא -ftrapping-מתמטיקה.

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

ברירת המחדל היא -fno-עגל-מתמטיקה.

אפשרות זו היא ניסיונית ואינה מבטיחה כרגע להשבית את כל GCC
אופטימיזציות המושפעות ממצב עיגול. גרסאות עתידיות של GCC עשויות לספק
שליטה עדינה יותר בהגדרה זו באמצעות הפרגמה "FENV_ACCESS" של C99. שורת הפקודה הזו
האפשרות תשמש כדי לציין את מצב ברירת המחדל עבור "FENV_ACCESS".

-fsignaling-nans
הידור קוד בהנחה ש-NANs איתות IEEE עשויים ליצור מלכודות גלויות למשתמש במהלך
פעולות נקודה צפה. הגדרת אפשרות זו משביתה אופטימיזציות שעשויות להשתנות
מספר החריגים הנראים עם איתות NaNs. אפשרות זו מרמזת
-ftrapping-מתמטיקה.

אפשרות זו גורמת להגדרת המאקרו הקדם-מעבד "__SUPPORT_SNAN__".

ברירת המחדל היא -fno-signaling-nans.

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

-דיוק-קבוע-יחיד
התייחס לקבועי נקודה צפה כעל דיוק יחיד במקום המרה מרומזת
אותם לקבועים בעלי דיוק כפול.

-fcx-טווח מוגבל
כאשר מופעלת, אפשרות זו מציינת כי אין צורך בשלב הפחתת טווח כאשר
ביצוע חלוקה מורכבת. כמו כן, אין בדיקה האם התוצאה של א
כפל או חילוק מורכבים הם "NaN + I*NaN", תוך ניסיון להציל את
המצב במקרה כזה. ברירת המחדל היא -fno-cx-טווח מוגבל, אך מופעל על ידי
-מהיר-מתמטיקה.

אפשרות זו שולטת בהגדרת ברירת המחדל של פרגמת ISO C99 "CX_LIMITED_RANGE".
עם זאת, האפשרות חלה על כל השפות.

-fcx-fortran-rules
כפל וחילוק מורכבים פועלים לפי כללי Fortran. הפחתת טווח נעשית כ
חלק מחלוקה מורכבת, אבל אין בדיקה אם התוצאה של קומפלקס
הכפל או החלוקה הם "NaN + I*NaN", תוך ניסיון להציל את המצב
במקרה הזה.

ברירת המחדל היא -fno-cx-fortran-rules.

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

-fענף-הסתברויות
לאחר הפעלת תוכנית הידור עם -fprofile-arcs, אתה יכול להרכיב אותו בפעם השנייה
באמצעות -fענף-הסתברויות, כדי לשפר אופטימיזציות על סמך מספר הפעמים
כל סניף נלקח. כאשר התוכנית הידור עם -fprofile-arcs יציאות זה שומר
ביצוע arc סופר לקובץ שנקרא sourcename.gcda עבור כל קובץ מקור. ה
המידע בקובץ הנתונים הזה תלוי מאוד במבנה של הקובץ שנוצר
קוד, לכן עליך להשתמש באותו קוד מקור ובאותן אפשרויות אופטימיזציה עבור שניהם
אוספים.

עם -fענף-הסתברויות, GCC שם א REG_BR_PROB הערה על כל אחד JUMP_INSN ו
CALL_INSN. ניתן להשתמש בהם כדי לשפר אופטימיזציה. נכון לעכשיו, הם משמשים רק
במקום אחד: ב reorg.c., במקום לנחש לאיזה נתיב יש סבירות גבוהה לסניף
לקחת, את REG_BR_PROB ערכים משמשים כדי לקבוע בדיוק איזה נתיב נלקח יותר
לעתים קרובות.

-fprofile-values
אם משלבים עם -fprofile-arcs, הוא מוסיף קוד כך שיש נתונים על ערכים של
ביטויים בתוכנית נאספים.

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

מופעל עם -fprofile-generate ו -fprofile-שימוש.

-fvpt
אם משלבים עם -fprofile-arcs, הוא מורה למהדר להוסיף קוד לאיסוף
מידע על ערכי ביטויים.

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

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

מופעל כברירת מחדל עם -funroll-לולאות ו -fpeel-לולאות.

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

מופעל עם -fprofile-שימוש.

-funroll-לולאות
פתח לולאות שניתן לקבוע את מספר האיטרציות שלהן בזמן ההידור או לאחר מכן
כניסה ללופ. -funroll-לולאות מרמז -frerun-cse-after-loop, -FWeb. ו
-frename-registers. זה גם מפעיל קילוף לולאה מלא (כלומר הסרה מלאה של
לולאות עם מספר קבוע קטן של איטרציות). אפשרות זו הופכת את הקוד לגדול יותר, ו
עשוי לגרום לו לרוץ מהר יותר או לא.

מופעל עם -fprofile-שימוש.

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

-fpeel-לולאות
מקלפת לולאות שיש להן מספיק מידע שהן לא מתגלגלות הרבה (מ
משוב על הפרופיל). זה גם מפעיל קילוף לולאה מלא (כלומר הסרה מלאה של
לולאות עם מספר קבוע קטן של איטרציות).

מופעל עם -fprofile-שימוש.

-fmove-loop-invariants
מאפשר את מעבר התנועה הבלתי משתנה של הלולאה במיטוב הלולאה של RTL. מופעל ברמה
-O1

-לולאות funswitch
הזז ענפים עם תנאים בלתי משתנה של לולאה מחוץ ללולאה, עם כפילויות של ה-
לולאה בשני הענפים (שונה בהתאם לתוצאה של המצב).

-פפונקציה-סעיפים
-fdata-sections
הצב כל פונקציה או פריט נתונים בקטע משלו בקובץ הפלט אם היעד
תומך בסעיפים שרירותיים. שם הפונקציה או שם פריט הנתונים
קובע את שם המקטע בקובץ הפלט.

השתמש באפשרויות אלה במערכות שבהן המקשר יכול לבצע אופטימיזציות לשיפור
מקום התייחסות במרחב ההדרכה. רוב המערכות משתמשות באובייקט ELF
למעבדי פורמט ו-SPARC המריצים את Solaris 2 יש קישורים עם אופטימיזציות כאלה.
ייתכן של-AIX יהיו אופטימיזציות אלה בעתיד.

השתמש באפשרויות אלה רק כאשר יש יתרונות משמעותיים מכך. כאשר אתה
ציין את האפשרויות הללו, האסמבלר והמקשר ייצור אובייקט גדול יותר ו
קבצי הפעלה וגם יהיו איטיים יותר. לא תוכל להשתמש ב-"gprof" על כולם
מערכות אם תציין אפשרות זו וייתכן שתהיה לך בעיות עם ניפוי באגים
ציין גם אפשרות זו וגם -g.

-fbranch-target-load-optimize
בצע אופטימיזציה של עומס רשם יעד ענף לפני השרשור של פרולוג/אפילוג.
השימוש באוגרי מטרה בדרך כלל יכול להיחשף רק במהלך טעינה מחדש, ובכך להרים
טעינה מחוץ ללולאות וביצוע תזמון בין-בלוק מצריך אופטימיזציה נפרדת
לַעֲבוֹר.

-fbranch-target-load-optimize2
בצע אופטימיזציה של עומס רשם יעד ענף לאחר השרשור של פרולוג/אפילוג.

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

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

הערה: ב-Ubuntu 6.10 ובגירסאות מאוחרות יותר אפשרות זו מופעלת כברירת מחדל עבור C, C++,
ObjC, ObjC++, אם אף אחד מהם -fno-מחסנית-מגן, -נוסטדליב, ולא -עומד בפני עצמו יש לו
מצאתי.

-fstack-protector-all
כמו -מגן מחסנית אלא שכל הפונקציות מוגנות.

-fsection-עוגנים
נסה להפחית את מספר חישובי הכתובות הסמליות באמצעות "עוגן" משותף
סמלים כדי לטפל באובייקטים קרובים. שינוי זה יכול לעזור להפחית את המספר
של ערכי GOT וגישה של GOT בכמה יעדים.

לדוגמה, יישום הפונקציה הבאה "foo":

סטטי int a, b, c;
int foo (void) { return a + b + c; }

בדרך כלל יחשב את הכתובות של כל שלושת המשתנים, אבל אם תרכיב אותו
עם -fsection-עוגנים, הוא יגש למשתנים מנקודת עיגון משותפת
במקום זאת. האפקט דומה לפסאודוקוד הבא (שאינו C חוקי):

int foo (בטל)
{
רשום int *xr = &x;
החזר xr[&a - &x] + xr[&b - &x] + xr[&c - &x];
}

לא כל היעדים תומכים באפשרות זו.

--param שם=ערך
במקומות מסוימים, GCC משתמש בקבועים שונים כדי לשלוט בכמות האופטימיזציה
נעשה. לדוגמה, GCC לא יכלול פונקציות מוטבעות המכילות יותר מפרט מסוים
מספר הוראות. אתה יכול לשלוט בחלק מהקבועים האלה בשורת הפקודה
באמצעות --param אוֹפְּצִיָה.

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

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

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

מקסימום-קפיצה-קצוות
המספר המרבי של קצוות נכנסים שיש לקחת בחשבון עבור קפיצה צולבת. האלגוריתם
בשימוש על ידי -קפיצה צולבת הוא O(N^2) במספר הקצוות הנכנסים לכל בלוק.
הגדלת ערכים פירושה אופטימיזציה אגרסיבית יותר, מה שהופך את זמן ההידור
להגדיל עם כנראה שיפור קטן בגודל ההפעלה.

min-crossjump-ins
המספר המינימלי של הוראות שיש להתאים בסוף שני בלוקים
לפני שיבוצעו עליהם קפיצות צולבות. ערך זה מתעלם במקרה
שבו כל ההוראות בבלוק שממנו מקפצים מותאמות. ה
ערך ברירת המחדל הוא 5.

max-grow-copy-bb-insns
מקדם ההרחבה המקסימלי של גודל הקוד בעת העתקת בלוקים בסיסיים במקום
קפיצה. ההרחבה היא ביחס להוראת קפיצה. ערך ברירת המחדל הוא
8.

max-goto-duplication-insns
המספר המרבי של הוראות לשכפול לבלוק שקופץ ל-a
goto מחושב. כדי להימנע מהתנהגות O(N^2) במספר מעברים, גורמים GCC
גוטוס מחושבים בשלב מוקדם בתהליך הקומפילציה, ומבטל אותם עד מאוחר
אפשרי. רק קפיצות מחושבות בסוף בלוקים בסיסיים עם לא יותר ממקסימום-
goto-duplication-inss אינם מושפעים. ערך ברירת המחדל הוא 8.

max-delay-slot-insn-search
המספר המרבי של הוראות שיש לקחת בחשבון כשמחפשים הוראה
למלא משבצת עיכוב. אם יותר ממספר הוראות שרירותי זה
חיסכון, החיסכון בזמן מילוי משבצת ההשהיה יהיה מינימלי אז תפסיק
מחפש. הגדלת ערכים פירושה אופטימיזציה אגרסיבית יותר, מה שהופך את
עלייה בזמן הקומפילציה עם כנראה שיפור קטן בזמן הביצוע.

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

max-gcse-memory
הכמות המקסימלית המשוערת של זיכרון שתוקצה על מנת
לבצע את האופטימיזציה העולמית של חיסול תת-ביטויים נפוצים. אם יותר זיכרון
ממה שצוין נדרש, האופטימיזציה לא תתבצע.

מקסימום-gcse-הכנסה-יחס
אם היחס בין הוספת ביטוי למחיקות גדול מהערך הזה עבור
כל ביטוי, אז RTL PRE יוסיף או יסיר את הביטוי ובכך יעזוב
חישובים מיותרים חלקית בזרם ההוראות. ערך ברירת המחדל הוא
20.

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

max-modulo-backtrack-tritts
המספר המרבי של ניסיונות מסלול אחורה שהמתזמן צריך לבצע כאשר מודולו
תזמון לולאה. ערכים גדולים יותר יכולים להגדיל באופן אקספוננציאלי את זמן ההידור.

max-inline-insns-סינגל
מספר פרמטרים שולטים ב-inliner של העץ המשמש ב-gcc. מספר זה קובע את
המספר המרבי של הוראות (נספרות בייצוג הפנימי של GCC) ב-a
פונקציה יחידה שה-inliner של העץ ישקול להטבעה. רק זה
משפיע על פונקציות שהוכרזו בשורה ועל שיטות מיושמות בהצהרת מחלקה
(C++). ערך ברירת המחדל הוא 400.

max-inline-insns-auto
כאשר אתה משתמש ב -finline-פונקציות (כלול ב -O3), הרבה פונקציות שיעשו זאת
אחרת לא ייחשב להטמעה על ידי המהדר ייבדק. ל
הפונקציות הללו, מגבלה שונה (מגבילה יותר) בהשוואה לפונקציות
ניתן להחיל את המוצהר מוטבע. ערך ברירת המחדל הוא 40.

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

גדול-פונקציה-צמיחה
מציין את הצמיחה המקסימלית של פונקציה גדולה הנגרמת על ידי שילוב באחוזים. ה
ערך ברירת המחדל הוא 100 מה שמגביל את צמיחת הפונקציות הגדולות לפי 2.0 מהמקור
גודל.

יחידות גדולות
המגבלה המציינת יחידת תרגום גדולה. צמיחה הנגרמת משילוב של יחידות
גדול מהגבול הזה מוגבל על ידי --param גידול יחידה מוטבע. ליחידות קטנות
זה עשוי להיות הדוק מדי (שקול יחידה המורכבת מפונקציה A שהיא מוטבעת ו
ב' שרק קורא ל-A שלוש פעמים. אם B קטן ביחס ל-A, הצמיחה של היחידה
הוא 300\% ובכל זאת שיבוץ כזה שפוי מאוד. ליחידות גדולות מאוד המורכבות מ
פונקציות קטנות שאינן ניתנות לכיוון, אולם נדרשת מגבלת הגידול הכוללת של היחידה
הימנע מפיצוץ אקספוננציאלי של גודל קוד. לפיכך עבור יחידות קטנות יותר, הגודל הוא
עלה ל --param יחידות גדולות לפני החלת --param גידול יחידה מוטבע.
ברירת המחדל היא 10000

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

ipcp-unit-growth
מציין את הצמיחה הכוללת המקסימלית של יחידת ההידור הנגרמת על ידי תהליכים בין-פרוצדורליים
התפשטות מתמדת. ערך ברירת המחדל הוא 10 המגביל את צמיחת היחידה ל-1.1
פעמים מהגודל המקורי.

מסגרת-מחסנית גדולה
המגבלה המציינת מסגרות מחסניות גדולות. תוך כדי הטבעת האלגוריתם מנסה
כדי לא לעבור את הגבול הזה יותר מדי. ערך ברירת המחדל הוא 256 בתים.

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

max-inline-insns-רקורסיבי
מקסימום-קו-קו-אינס-רקורסבי-אוטו
מציין את המספר המרבי של הוראות עותק מחוץ לקו של עצמי רקורסיבי מוטבע
פונקציה יכולה לצמוח לתוך על ידי ביצוע inlining רקורסיבי.

עבור פונקציות המוצהרות בתוך שורה --param max-inline-insns-רקורסיבי נלקח לתוכו
חֶשְׁבּוֹן. עבור פונקציה שלא הוכרזה בשורה, הטבעה רקורסיבית מתרחשת רק כאשר
-finline-פונקציות (כלול ב -O3) מופעל ו --param max-inline-insns-
רקורסיבי-אוטומטי משמש. ערך ברירת המחדל הוא 450.

מקסימום-inline-רקורסיבי-עומק
max-inline-recursive-depth-auto
מציין את עומק הרקורסיה המרבי המשמש את ההטמעה הרקורסיבית.

עבור פונקציות המוצהרות בתוך שורה --param מקסימום-inline-רקורסיבי-עומק נלקח לתוכו
חֶשְׁבּוֹן. עבור פונקציה שלא הוכרזה בשורה, הטבעה רקורסיבית מתרחשת רק כאשר
-finline-פונקציות (כלול ב -O3) מופעל ו --param max-inline-recursive-
עומק אוטומטי משמש. ערך ברירת המחדל הוא 8.

min-inline-recursive-probability
הטבעה רקורסיבית רווחית רק לתפקוד שיש לו רקורסיה עמוקה
ממוצע ויכול לפגוע בתפקוד בעל עומק רקורסיה קטן על ידי הגדלת ה-
גודל פרולוג או מורכבות של גוף הפונקציה למייעל אחרים.

כאשר משוב פרופיל זמין (ראה -fprofile-generate) הרקורסיה בפועל
ניתן לנחש עומק לפי ההסתברות שהפונקציה תחזור על עצמה באמצעות קריאה נתונה
ביטוי. פרמטר זה מגביל את ה-inlining רק לביטוי קריאה של מי
ההסתברות חורגת מהסף הנתון (באחוזים). ערך ברירת המחדל הוא 10.

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

max-early-inliner-iterations
max-early-inliner-iterations
מגבלת איטרציות של אינליינר מוקדם. זה בעצם מגביל את מספר המקוננים
שיחות עקיפות מוקדמות inliner יכול לפתור. שרשראות עמוקות יותר עדיין מטופלות באיחור
הטבעה.

comdat-שיתוף-הסתברות
comdat-שיתוף-הסתברות
ההסתברות (באחוזים) שתהיה פונקציה מוטבעת של C++ עם נראות comdat
משותף על פני מספר יחידות אוסף. ערך ברירת המחדל הוא 20.

min-vect-loop-bound
המספר המינימלי של איטרציות שמתחתן לולאה לא תעבור וקטור מתי
-ftree-vectorize משמש. מספר האיטרציות לאחר הוקטוריזציה צריך
להיות גדול מהערך שצוין על ידי אפשרות זו כדי לאפשר וקטוריזציה. ה
ערך ברירת המחדל הוא 0.

gcse-cost-distance-ratio
גורם קנה מידה בחישוב המרחק המרבי שניתן להזיז ביטוי לפיו
אופטימיזציות של GCSE. זה נתמך כרגע רק בכרטיס ההנפה בקוד.
ככל שהיחס גדול יותר, כך הנפת קוד אגרסיבית יותר תהיה עם פשוטה
ביטויים, כלומר, הביטויים שעלו פחות מ gcse-unrestricted-
עלות. ציון 0 ישבית הרמה של ביטויים פשוטים. ברירת המחדל
הערך הוא 10.

gcse-unrestricted-cost
עלות, נמדדת באופן גס כעלות של הוראת מכונה טיפוסית יחידה, ב
אילו אופטימיזציות של GCSE לא יגבילו את המרחק שביטוי יכול לעבור.
זה נתמך כרגע רק בכרטיס ההנפה בקוד. ככל שהעלות נמוכה יותר,
הרמת קוד אגרסיבית יותר תהיה. ציון 0 יאפשר הכל
ביטויים לנסיעה למרחקים בלתי מוגבלים. ערך ברירת המחדל הוא 3.

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

מקסימום-זנב-מיזוג-השוואות
הכמות המקסימלית של bbs דומים להשוואה עם bb. זה משמש כדי להימנע
התנהגות ריבועית במיזוג זנב עצים. ערך ברירת המחדל הוא 10.

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

max-unrolled-insns
המספר המרבי של הוראות שצריכה להיות לולאה אם ​​לולאה זו
unrolled, ואם הלולאה מתגלגלת, היא קובעת כמה פעמים קוד הלולאה
מתגלגל.

max-average-unrolled-insns
המספר המרבי של הוראות מוטות על ידי הסתברויות לביצוען כי
לולאה צריכה להיות אם הלולאה הזו מתגלגלת, ואם הלולאה מתגלגלת, היא
קובע כמה פעמים קוד הלולאה ייפתח.

מקסימום זמני פתיחה
המספר המרבי של פתיחת לולאה בודדת.

max-peeled-ins
המספר המרבי של הוראות שצריכה להיות ללולאה אם ​​הלולאה מקולפת,
ואם הלולאה מקולף, היא קובעת כמה פעמים קוד הלולאה מקולף.

מקסימום-קליפה-זמני
המספר המרבי של קילופים של לולאה בודדת.

מקסימום-מקולפים-לגמרי-insns
המספר המרבי של אינסנס של לולאה מקולף לחלוטין.

מקסימום-זמני-קליפה-לגמרי
המספר המרבי של איטרציות של לולאה שיתאים לקילוף מלא.

מקסימום-לגמרי-קלוף-לולאה-עומק-קן
העומק המרבי של קן לולאה המתאים לקילוף מלא.

max-unswitch-insns
המספר המרבי של אינסנס של לולאה לא משתנה.

רמה מקסימלית של ביטול מתג
המספר המרבי של סניפים ללא מיתוג בלולאה אחת.

לא יקר
העלות המינימלית של ביטוי יקר בתנועה בלתי משתנה של הלולאה.

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

iv-max-considered-uses
האופטימיזציות של משתני האינדוקציה מוותרות על לולאות המכילות יותר אינדוקציה
שימושים משתנים.

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

scev-max-expr-size
קשור לגודל הביטויים המשמשים בנתח האבולוציות הסקלריות. גָדוֹל
ביטויים מאטים את הנתח.

SCEV-MAX-EXPR-COMPLEXITY
קשור למורכבות הביטויים במנתח האבולוציות הסקלריות.
ביטויים מורכבים מאטים את הנתח.

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

אומגה-max-geqs
המספר המרבי של אי-שוויון במערכת אילוצי אומגה. ברירת המחדל
הערך הוא 256.

אומגה-מקס-eqs
המספר המרבי של שוויון במערכת אילוצי אומגה. ערך ברירת המחדל
הוא 128.

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

אומגה-hash-table-size
גודל טבלת הגיבוב בפותר אומגה. ערך ברירת המחדל הוא 550.

מפתחות אומגה-מקס
המספר המקסימלי של מפתחות בשימוש פותר אומגה. ערך ברירת המחדל הוא 500.

אומגה-לחסל-אילוצים-מיותרים
כאשר מוגדר ל-1, השתמש בשיטות יקרות כדי לבטל את כל האילוצים המיותרים. ה
ערך ברירת המחדל הוא 0.

vect-max-version-for-alignment-checks
המספר המרבי של בדיקות זמן ריצה שניתן לבצע בעת ביצוע לולאה
גרסאות ליישור בוקטורייזר. ראה אפשרות ftree-vect-loop-version
לקבלת מידע נוסף.

vect-max-version-for-alias-checks
המספר המרבי של בדיקות זמן ריצה שניתן לבצע בעת ביצוע לולאה
גרסאות עבור כינוי ב-Vectorizer. ראה אפשרות ftree-vect-loop-version עבור
עוד מידע.

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

hot-bb-count-fraction
בחר חלק מהספירה המקסימלית של חזרות של בלוק בסיסי בתוכנית
נתון בלוק בסיסי צריך להיחשב חם.

hot-bb-frequency-fraction
בחר חלק מתדירות בלוק הכניסה של ביצוע בלוק בסיסי
פונקציה בהינתן בלוק בסיסי צריך להיחשב חם.

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

יישור-סף
בחר חלק מהתדירות המקסימלית של ביצוע בלוק בסיסי בפונקציה
בלוק בסיסי נתון יתיישר.

align-loop-iterations
לולאה צפויה לחזור על כך שמא יקבל מספר האיטרציות שנבחר
מיושר.

כיסוי-דינמי-נותב
tracer-dynamic-coverage-feedback
ערך זה משמש להגבלת יצירת סופרבלוק לאחר האחוז הנתון של
הוראות שבוצעו מכוסות. זה מגביל הרחבת גודל קוד מיותרת.

אל האני tracer-dynamic-coverage-feedback משמש רק כאשר משוב פרופיל הוא
זמין. הפרופילים האמיתיים (בניגוד לאומדנים סטטיים) הם רבים
פחות מאוזן מה שמאפשר לסף להיות ערך גדול יותר.

tracer-max-code-growth
עצור את שכפול הזנב לאחר שגידול הקוד הגיע לאחוז נתון. זה
טיעון מגניב למדי, שכן רוב הכפילויות יבוטלו מאוחר יותר בהצלבה
קופץ, כך שהוא עשוי להיות מוגדר לערכים גבוהים בהרבה מהגידול הרצוי בקוד.

tracer-min-branch ratio
עצור צמיחה הפוכה כאשר ההסתברות ההפוכה לקצה הטוב ביותר קטנה מזה
סף (באחוזים).

tracer-min-branch ratio
tracer-min-branch-ratio-feedback
עצור את הצמיחה קדימה אם לקצה הטוב ביותר יש הסתברות נמוכה מזו
סף.

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

מקסימום-cse-נתיב-אורך
המספר המרבי של בלוקים בסיסיים בנתיב ש-cse מתייחס אליו. ברירת המחדל היא 10.

max-cse-insns
ההנחיות המקסימליות תהליך CSE לפני השטיפה. ברירת המחדל היא 1000.

ggc-min-expand
GCC משתמשת באוסף אשפה כדי לנהל את הקצאת הזיכרון שלה. הפרמטר הזה
מציין את האחוז המינימלי שבו צריך להיות ערימת אספן האשפה
מותר להרחיב בין האוספים. כוונון זה עשוי לשפר את מהירות ההידור;
אין לו השפעה על יצירת קוד.

ברירת המחדל היא 30% + 70% * (RAM/1GB) עם גבול עליון של 100% כאשר RAM >= 1GB.
אם "getrlimit" זמין, המושג "RAM" הוא הקטן ביותר מבין זיכרון RAM ו
"RLIMIT_DATA" או "RLIMIT_AS". אם GCC אינו מסוגל לחשב זיכרון RAM על מסויים
פלטפורמה, נעשה שימוש בגבול התחתון של 30%. הגדרת פרמטר זה ו ggc-min-
גודל ערימה לאפס גורם לאיסוף מלא להתרחש בכל הזדמנות. זה
איטי מאוד, אבל יכול להיות שימושי לניפוי באגים.

ggc-min-heapsize
גודל מינימלי של ערימת האשפה לפני שהוא מתחיל לטרוח לאסוף
אַשׁפָּה. האיסוף הראשון מתרחש לאחר שהערימה מתרחבת ב ggc-min-expand%
מעבר ggc-min-heapsize. שוב, כוונון זה עשוי לשפר את מהירות ההידור, וכן
אין השפעה על יצירת קוד.

ברירת המחדל היא הקטן מבין RAM/8, RLIMIT_RSS, או מגבלה שמנסה להבטיח
שלא חורגים מ-RLIMIT_DATA או RLIMIT_AS, אבל עם גבול תחתון של 4096
(ארבעה מגה-בייט) וגבול עליון של 131072 (128 מגה-בייט). אם GCC אינו מסוגל
כדי לחשב זיכרון RAM בפלטפורמה מסוימת, נעשה שימוש בגבול התחתון. מגדיר את זה
פרמטר גדול מאוד משבית למעשה את איסוף האשפה. מגדיר את זה
פרמטר ו- ggc-min-expand לאפס גורם לאיסוף מלא להתרחש בכל
הזדמנות.

max-reload-search-insns
המספר המרבי של טעינת הוראות חוזרת צריך להסתכל אחורה עבור שווה ערך
הירשם. הגדלת ערכים פירושה אופטימיזציה אגרסיבית יותר, מה שהופך את
זמן הקומפילציה גדל עם כנראה ביצועים מעט טובים יותר. ברירת המחדל
הערך הוא 100.

max-cselib-memory-locations
המספר המרבי של מיקומי זיכרון צריך לקחת בחשבון cselib.
הגדלת ערכים פירושה אופטימיזציה אגרסיבית יותר, מה שהופך את זמן ההידור
להגדיל עם כנראה ביצועים מעט טובים יותר. ערך ברירת המחדל הוא 500.

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

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

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

max-sched-region-blocks
המספר המקסימלי של בלוקים באזור שיש לקחת בחשבון עבור interblock
תזמון. ערך ברירת המחדל הוא 10.

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

max-sched-region-insns
המספר המקסימלי של אינסנס באזור שיש לקחת בחשבון עבור interblock
תזמון. ערך ברירת המחדל הוא 100.

max-pipeline-region-insns
המספר המרבי של מבנים באזור שיש לקחת בחשבון עבור צנרת ב-
מתזמן סלקטיבי. ערך ברירת המחדל הוא 200.

מינימום-spec-prob
ההסתברות המינימלית (באחוזים) להגיע לבלוק מקור עבור interblock
תזמון ספקולטיבי. ערך ברירת המחדל הוא 40.

max-sched-extend-regions-iters
המספר המרבי של איטרציות דרך CFG להרחבת אזורים. 0 - השבת
הרחבת אזור, N - לעשות לכל היותר N איטרציות. ערך ברירת המחדל הוא 0.

max-sched-insn-conflict-delay
עיכוב הסכסוך המקסימלי עבור אינסנס שייחשב לתנועה ספקולטיבית.
ערך ברירת המחדל הוא 3.

sched-spec-prob-cutoff
ההסתברות המינימלית להצלחת ספקולציות (באחוזים), כך שהספקולציות
insn יתוכנן. ערך ברירת המחדל הוא 40.

sched-mem-true-dep-cost
מרחק מינימלי (במחזורי CPU) בין חנות לטעינה המיקוד לאותו זיכרון
מיקומים. ערך ברירת המחדל הוא 1.

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

selsched-max-sched-times
מספר הפעמים המקסימלי שתוזמן הוראה במהלך סלקטיבי
תזמון. זוהי המגבלה על מספר האיטרציות שבאמצעותן
ההוראה עשויה להיות צנרת. ערך ברירת המחדל הוא 2.

selsched-max-insns-to-rename
המספר המרבי של ההוראות הטובות ביותר ברשימה המוכנות שנחשבות עבורן
שינוי שם במתזמן הסלקטיבי. ערך ברירת המחדל הוא 2.

sms-min-sc
הערך המינימלי של ספירת השלבים שמתזמן ה-swing modulo יפיק. ה
ערך ברירת המחדל הוא 2.

max-last-value-rtl
הגודל המרבי נמדד כמספר RTLs שניתן להקליט בביטוי
בשילוב עבור פסאודו אוגר בתור הערך האחרון הידוע של אותו אוגר. ה
ברירת המחדל היא 10000.

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

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

וירטואלי-מיפויים-יחס
אם מספר המיפויים הווירטואליים גדול יותר מהמספר
של סמלים וירטואליים שיש לעדכן, ואז עדכון ה-SSA המצטבר עובר ל-a
עדכון מלא עבור הסמלים האלה. יחס ברירת המחדל הוא 3.

ssp-buffer-size
הגודל המינימלי של מאגרים (כלומר מערכים) שיקבלו ריסוק מחסנית
הגנה מתי -fstack-הגנה משמש.

ברירת המחדל הזו לפני אובונטו 10.10 הייתה "8". כרגע זה "4", כדי להגדיל את
מספר הפונקציות המוגנות על ידי מגן הערימה.

max-jump-thread-dplication-stmts
המספר המרבי של הצהרות המותר בבלוק שיש לשכפל כאשר
קפיצות השחלה.

max-fields-for-field-sensitive
כמות מקסימלית של שדות במבנה נטפל באופן רגיש לשטח
במהלך ניתוח מצביע. ברירת המחדל היא אפס עבור -O0, ו-O1 ו-100 עבור -Os,
-O2, ו-O3.

אחזור מראש
הערכה של מספר ההוראות הממוצע שמתבצעות לפני השליפה מראש
מסיים. המרחק שאנו משיגים מראש הוא פרופורציונלי לקבוע הזה.
הגדלת מספר זה עשויה גם להוביל לשליפה מראש של פחות זרמים (ראה
סימולטני-preetches).

סימולטני-preetches
מספר מקסימלי של שליפות מוקדמות שיכולות לפעול בו-זמנית.

l1-cache-line-size
גודל שורת המטמון במטמון L1, בבתים.

גודל מטמון l1
גודל מטמון L1, בקילו-בייט.

גודל מטמון l2
גודל מטמון L2, בקילו-בייט.

min-insn-to-pretch-ratio
היחס המינימלי בין מספר ההוראות למספר השליפות המוקדמות
כדי לאפשר שליפה מוקדמת בלולאה.

prefetch-min-insn-to-mem-ratio
היחס המינימלי בין מספר ההוראות למספר הזיכרון
הפניות כדי לאפשר שליפה מוקדמת בלולאה.

שימוש-קנוניים-טיפוסים
האם המהדר צריך להשתמש במערכת מסוג "קנוני". כברירת מחדל, זה
צריך להיות תמיד 1, שמשתמש במנגנון פנימי יעיל יותר להשוואה
סוגים ב-C++ ו-Objective-C++. עם זאת, אם באגים במערכת הסוג הקנוני הם
גורם לכשלי קומפילציה, הגדר ערך זה ל-0 כדי להשבית סוגים קנוניים.

switch-conversion-max-branch ratio
המרת אתחול מתג תסרב ליצור מערכים גדולים מ
switch-conversion-max-branch ratio כפול ממספר הסניפים במתג.

מקסימום-חלקי-אנטיק-אורך
אורך מקסימלי של הסט האנטי החלקי שחושב במהלך חלקי העץ
אופטימיזציה של חיסול יתירות (-ftree-pre) בעת אופטימיזציה ב- -O3 ומעל.
עבור סוגים מסוימים של קוד מקור, ביטול יתירות חלקית משופרת
אופטימיזציה יכולה לברוח, ולצרוך את כל הזיכרון הזמין במארח
מְכוֹנָה. פרמטר זה מגדיר מגבלה על אורך הסטים המחושבים,
מה שמונע את התנהגות הבריחה. הגדרת ערך של 0 עבור פרמטר זה תעשה זאת
לאפשר אורך סט בלתי מוגבל.

sccvn-max-scc-size
גודל מקסימלי של רכיב מחובר חזק (SCC) במהלך עיבוד SCCVN. אם
מגבלה זו נפגעת, עיבוד SCCVN עבור כל הפונקציה לא יתבצע ו
אופטימיזציות בהתאם לכך יושבתו. ברירת המחדל המקסימלית של גודל SCC היא
10000.

ira-max-loops-num
IRA משתמש בהקצאת רישום אזורי כברירת מחדל. אם פונקציה מכילה יותר
לולאות מאשר המספר שניתן על ידי פרמטר זה, רק לכל היותר המספר הנתון של
הלולאות המבוצעות בתדירות הגבוהה ביותר יוצרות אזורים להקצאת רישום אזורי.
ערך ברירת המחדל של הפרמטר הוא 100.

ira-max-conflict-table-size
למרות ש-IRA משתמש באלגוריתם מתוחכם כדי לדחוס את טבלת הקונפליקט, ה-
הטבלה עדיין יכולה לדרוש כמויות מוגזמות של זיכרון עבור פונקציות ענק. אם ה
טבלת התנגשות עבור פונקציה יכולה להיות יותר מהגודל ב-MB שניתן על ידי זה
פרמטר, מקצה האוגר משתמש במקום זאת ב- מהיר יותר, פשוט יותר ונמוך יותר
אלגוריתם איכותי שאינו דורש בניית טבלת התנגשות פסאודו-רישום.
ערך ברירת המחדל של הפרמטר הוא 2000.

ira-loop-reserved-regs
ניתן להשתמש ב-IRA כדי להעריך לחץ רישום מדויק יותר בלולאות לקבלת החלטות
כדי להזיז אינוריאנטים של לולאה (ראה -O3). מספר הרשמים הזמינים שמורים עבור
כמה מטרות אחרות ניתנות על ידי פרמטר זה. ערך ברירת המחדל של ה-
הפרמטר הוא 2, שהוא המספר המינימלי של רגיסטרים הדרושים לטיפוס
הוראות. ערך זה הוא הטוב ביותר שנמצא מניסויים רבים.

loop-invariant-max-bbs-in-loop
תנועה בלתי משתנה של לולאה יכולה להיות יקרה מאוד, הן בזמן הקומפילציה והן בזמן
כמות הזיכרון הדרוש לזמן קומפילציה, עם לולאות גדולות מאוד. לולאות עם עוד
בלוקים בסיסיים מאשר פרמטר זה לא יהיו אופטימיזציה של תנועה בלתי משתנה בלולאה
בוצע עליהם. ערך ברירת המחדל של הפרמטר הוא 1000 עבור -O1 ו-10000
עבור -O2 ומעלה.

loop-max-datarefs-for-datadeps
בניית נתונים תלויים היא יקרה עבור לולאות גדולות מאוד. הפרמטר הזה
מגביל את מספר הפניות לנתונים בלולאות שנחשבות לנתונים
ניתוח תלות. לולאות גדולות אלה לא יטופלו אז על ידי
אופטימיזציות באמצעות תלות בנתוני לולאה. ערך ברירת המחדל הוא 1000.

מקסימום-vartrack-size
מגדיר את המספר המרבי של חריצי טבלת hash לשימוש במהלך זרימת נתונים משתנה של מעקב
ניתוח של כל פונקציה. אם חריגה מהמגבלה הזו עם מעקב משתנה ב
הקצאות מופעלות, ניתוח עבור פונקציה זו נוסה שוב בלעדיה, לאחר
הסרת כל ה-debug insns מהפונקציה. אם חריגה מהמגבלה גם בלי
debug insns, ניתוח מעקב var מושבת לחלוטין עבור הפונקציה.
הגדרת הפרמטר לאפס הופכת אותו לבלתי מוגבל.

max-vartrack-expr-depth
מגדיר מספר מרבי של רמות רקורסיה בעת ניסיון למפות שמות משתנים או
ניפוי באגים זמניים לביטויי ערך. זה מחליף את זמן הקומפילציה ליותר
מידע על ניפוי באגים מלא. אם זה מוגדר נמוך מדי, ביטויי ערך שהם
זמין ויכול להיות מיוצג במידע על ניפוי באגים עלול בסופו של דבר לא להיות בשימוש;
הגדרה זו גבוהה יותר עשויה לאפשר למהדר למצוא באגים מורכבים יותר
ביטויים, אך השימוש בזמן קומפילציה וזיכרון עשוי לגדול. ברירת המחדל היא 12.

min-nondebug-insn-uid
השתמש ב-uids שמתחיל בפרמטר זה עבור insns ללא באגים. הטווח מתחת ל-
הפרמטר שמור באופן בלעדי עבור רכיבי ניפוי באגים שנוצרו על ידי
-fvar-tracking-assignments, אבל תוספי ניפוי באגים עשויים לקבל UID (לא חופפים) למעלה
זה אם הטווח השמור מוצה.

ipa-sra-ptr-growth factor
IPA-SRA יחליף מצביע למצרף בפרמטר חדש אחד או יותר
רק כאשר הגודל המצטבר שלהם קטן או שווה ל ipa-sra-ptr-growth factor
פעמים מגודל פרמטר המצביע המקורי.

tm-max-aggregate-size
בעת יצירת עותקים של משתנים מקומיים בטרנזקציה, פרמטר זה
מציין את הגודל בבתים שלאחריו משתנים יישמרו עם הרישום
מתפקד בניגוד לשמירה/שחזור של צמדי רצף קוד. אפשרות זו בלבד
חל בעת השימוש -fgnu-tm.

graphite-max-nb-scop-params
כדי להימנע מהשפעות אקספוננציאליות בטרנספורמציה של לולאת גרפיט, המספר של
פרמטרים בחלק בקרה סטטית (SCoP) מוגבלים. ערך ברירת המחדל הוא 10
פרמטרים. משתנה שערכו אינו ידוע בזמן ההידור ומוגדר
מחוץ ל-SCoP הוא פרמטר של ה-SCoP.

גרפיט-מקס- BBS-punction
כדי למנוע השפעות אקספוננציאליות בזיהוי של SCoPs, גודל הפונקציות
מנותח על ידי גרפיט מוגבל. ערך ברירת המחדל הוא 100 בלוקים בסיסיים.

לולאה-גוש-אריח-גודל
חסימת לולאות או רצועת טרנספורמציות של כרייה, מופעלת עם -פלופ-בלוק or
-פלופ-רצועה-שלי, פשט את שלי כל לולאה בקן הלולאה במספר נתון של
איטרציות. ניתן לשנות את אורך הרצועה באמצעות לולאה-גוש-אריח-גודל
פָּרָמֶטֶר. ערך ברירת המחדל הוא 51 חזרות.

ipa-cp-value-list-size
IPA-CP מנסה לעקוב אחר כל הערכים והסוגים האפשריים שהועברו לפונקציה
פרמטר על מנת להפיץ אותם ולבצע דה וירטואליזציה. ipa-cp-value-
גודל רשימה הוא המספר המרבי של ערכים וסוגים שהוא מאחסן לכל רשמי אחד
פרמטר של פונקציה.

lto-מחיצות
ציין את המספר הרצוי של מחיצות שנוצרו במהלך הידור WHOPR. ה
מספר המחיצות צריך לעלות על מספר המעבדים המשמשים להידור. ה
ערך ברירת המחדל הוא 32.

lto-minpartition
גודל מחיצה מינימלית עבור WHOPR (בהוראות משוערות). זה מונע
הוצאות של פיצול תוכניות קטנות מאוד ליותר מדי מחיצות.

cxx-max-namespaces-for-diagnostic-help
המספר המרבי של מרחבי שמות שיש להתייעץ בהם לקבלת הצעות בעת חיפוש שמות ב-C++
נכשל עבור מזהה. ברירת המחדל היא 1000.

כיור-תדר-סף
תדירות הביצוע היחסית המקסימלית (באחוזים) של בלוק היעד
ביחס לחסימה המקורית של הצהרה כדי לאפשר שקיעת הצהרה של א
הַצהָרָה. מספרים גדולים יותר מביאים לשקיעת אמירה אגרסיבית יותר. ה
ערך ברירת המחדל הוא 75. התאמה חיובית קטנה מוחלת על הצהרות עם
אופרנדים זיכרון כפי שהם אפילו יותר רווחיים אז לשקוע.

max-stores-to-sink
המספר המרבי של זוגות חנויות מותנות שניתן לשקוע. הגדר ל-0 אם
או וקטוריזציה (-ftree-vectorize) או אם-המרה (-ftree-loop-if-convert)
מושבת. ברירת המחדל היא 2.

אפשר-טעינת-מירוצים-נתונים
אפשר למיטובים להציג מירוצי נתונים חדשים על עומסים. הגדר ל-1 כדי לאפשר,
אחרת ל-0. אפשרות זו מופעלת כברירת מחדל אלא אם כן נקבעה באופן מרומז על ידי ה-
-fmemory-model= אוֹפְּצִיָה.

אפשר-מחסן-נתונים-מירוצי
אפשר למיטובים להציג מירוצי נתונים חדשים בחנויות. הגדר ל-1 כדי לאפשר,
אחרת ל-0. אפשרות זו מופעלת כברירת מחדל אלא אם כן נקבעה באופן מרומז על ידי ה-
-fmemory-model= אוֹפְּצִיָה.

אפשר-ארוז-טעינה-מירוצי נתונים
אפשר למיטובים להציג מירוצי נתונים חדשים על עומסי נתונים צפופים. הגדר ל-1 ל
לאפשר, אחרת ל-0. אפשרות זו מופעלת כברירת מחדל אלא אם כן מוגדרת באופן מרומז על ידי
מה היא -fmemory-model= אוֹפְּצִיָה.

אפשר-ארוז-מרוצים-נתונים
אפשר למיטובים להציג מירוצי נתונים חדשים בחנויות נתונים עמוסות. הגדר ל-1 ל
לאפשר, אחרת ל-0. אפשרות זו מופעלת כברירת מחדל אלא אם כן מוגדרת באופן מרומז על ידי
מה היא -fmemory-model= אוֹפְּצִיָה.

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

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

אפשרויות שליטה מה היא Preprocessor
אפשרויות אלה שולטות במעבד הקדם C, המופעל על כל קובץ מקור C לפני המציאות
הַהדָרָה.

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

-Wp,אוֹפְּצִיָה
אתה יכול להשתמש -Wp,אוֹפְּצִיָה לעקוף את מנהל ההדר ולעבור אוֹפְּצִיָה ישירות דרך
למעבד המקדים. אם אוֹפְּצִיָה מכיל פסיקים, הוא מחולק לאפשרויות מרובות ב
הפסיקים. עם זאת, אפשרויות רבות משתנות, מתורגמות או מתפרשות על ידי
מנהל התקן מהדר לפני שהועבר למעבד הפרה, ו -Wp עוקף בכוח
השלב הזה. הממשק הישיר של המעבד מראש אינו מתועד ונתון ל
לשנות, אז במידת האפשר כדאי להימנע משימוש -Wp ולתת לנהג לטפל ב
אפשרויות במקום.

-Xpreprocessor אוֹפְּצִיָה
לעבור אוֹפְּצִיָה כאופציה למעבד הקדם. אתה יכול להשתמש בזה כדי לספק מערכת-
אפשרויות קדם-מעבד ספציפיות ש-GCC לא יודע לזהות.

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

-D שם
הגדירו מראש שם כמאקרו, עם הגדרה 1.

-D שם=הגדרה
התוכן של הגדרה מסומנים ומעובדים כאילו הופיעו במהלך
תרגום שלב שלישי בא #define הוֹרָאָה. בפרט, ההגדרה תהיה
קטוע על ידי תווים משובצים בשורה חדשה.

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

אם ברצונך להגדיר מאקרו דמוי פונקציה בשורת הפקודה, כתוב את הארגומנט שלו
רשימה עם סוגריים מסביב לפני סימן השוויון (אם יש). סוגריים הם
משמעותי לרוב הפגזים, אז תצטרך לצטט את האפשרות. עם sh ו CSH,
-ד'שם(ארגונים...)=הגדרה' יצירות.

-D ו -U האפשרויות מעובדות לפי הסדר שהן ניתנות בשורת הפקודה. את כל
-אימאקרו פילה ו -לִכלוֹל פילה האפשרויות מעובדות אחרי הכל -D ו -U אפשרויות.

-U שם
בטל כל הגדרה קודמת של שם, מובנה או מסופק עם א -D אוֹפְּצִיָה.

-undef
אל תגדיר מראש פקודות מאקרו ספציפיות למערכת או GCC ספציפיות. התקן שהוגדר מראש
פקודות מאקרו נשארות מוגדרות.

-I dir
הוסף את הספרייה dir לרשימת הספריות שיש לחפש אחר קובצי כותרות.
מדריכים בשם על ידי -I מחפשים לפני שהמערכת הרגילה כוללת ספריות.
אם הספרייה dir היא מערכת סטנדרטית כולל ספרייה, התעלמות מהאפשרות
ודא שסדר החיפוש המוגדר כברירת מחדל עבור ספריות מערכת והטיפול המיוחד
של כותרות המערכת אינן מובסות. אם dir מתחיל ב-"=", ואז ה-"=" יהיה
מוחלף בקידומת ה-sysroot; לִרְאוֹת --sysroot ו -isysroot.

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

- קיר
מפעיל את כל האזהרות האופציונליות הרצויות עבור קוד רגיל. כרגע זה
is -הערה, -תרשימים, -ומולטיקאר ואזהרה על קידום מספר שלם הגורם ל-a
שינוי סימן בביטויי "#if". שימו לב שרבות מהאזהרות של המעבד
פועלים כברירת מחדל ואין להם אפשרויות לשלוט בהם.

-הערה
-הערות
אזהרה בכל פעם שרצף התחלה של הערות /* מופיע ב /* הערה, או בכל פעם א
backslash-newline מופיע ב-a // תגובה. (לשתי הצורות יש את אותה השפעה.)

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

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

-מסורתי
הזהיר לגבי מבנים מסוימים שמתנהגים אחרת במסורתי וב-ISO C. כמו כן
להזהיר מפני מבני ISO C שאין להם מקבילה C מסורתית, ובעייתיים
מבנים שיש להימנע מהם.

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

-Wunused-macros
התריע על פקודות מאקרו המוגדרות בקובץ הראשי שאינן בשימוש. מאקרו הוא מְשׁוּמָשׁ אם זה
הורחב או נבדק על קיומו לפחות פעם אחת. המעבד המקדים יתריע גם אם
המאקרו לא היה בשימוש בזמן שהוא הוגדר מחדש או לא מוגדר.

פקודות מאקרו מובנות, פקודות מאקרו המוגדרות בשורת הפקודה ופקודות מאקרו המוגדרות ב- include
לא מוזהרים לגבי קבצים.

הערה: אם נעשה שימוש בפועל במאקרו, אבל נעשה בו שימוש רק בלוקים מותנים שדילגתם עליו, אז
CPP ידווח על זה כלא בשימוש. כדי להימנע מהאזהרה במקרה כזה, ייתכן שתשתפר
את היקף ההגדרה של המאקרו על ידי, למשל, העברתו לתוך הראשון שדילג עליו
לַחסוֹם. לחלופין, אתה יכול לספק שימוש דמה עם משהו כמו:

#אם הוגדרה_מאקרו_גורם_האזהרה
#endif

-תוויות-Wendif
התריע בכל פעם ש #else או #endif ואחריהם טקסט. זה קורה בדרך כלל ב
קוד הטופס

#אם FOO
...
#אחרת FOO
...
#endif FOO

ה-"FOO" השני והשלישי צריכות להיות בתגובות, אך לרוב אינן בתוכניות ישנות יותר.
אזהרה זו מופעלת כברירת מחדל.

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

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

-w דחק את כל האזהרות, כולל אלו ש-GNU CPP מנפיק כברירת מחדל.

-קַפְּדָנִי
הנפק את כל האבחונים החובה המפורטים בתקן C. חלקם נשארו
כברירת מחדל, מכיוון שהם מופעלים לעתים קרובות בקוד לא מזיק.

-פדנטיות-טעויות
הנפק את כל האבחון החובה, והפוך את כל האבחון החובה לשגיאות.
זה כולל אבחון חובה ש-GCC מנפיק בלעדיו -קַפְּדָנִי אלא מתייחס כמו
אזהרות.

-M במקום להוציא את התוצאה של עיבוד מקדים, פלט כלל מתאים לעשות
תיאור התלות של קובץ המקור הראשי. המעבד המקדים מוציא אחד
לעשות כלל המכיל את שם קובץ האובייקט עבור אותו קובץ מקור, נקודתיים והשמות
של כל הקבצים הכלולים, כולל אלה שמגיעים -לִכלוֹל or -אימאקרו הפקודה
אפשרויות קו.

אלא אם צוין במפורש (עם -MT or -MQ), שם קובץ האובייקט מורכב מה-
שם קובץ המקור עם כל סיומת שהוחלפה בסיומת קובץ אובייקט ובסיומת כלשהי
חלקי הספרייה המובילים הוסרו. אם יש הרבה קבצים כלולים אז הכלל הוא
לפצל למספר שורות באמצעות \-שורה חדשה. לכלל אין פקודות.

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

חולף -M לנהג מרמז -E, ומדכא אזהרות עם מרומז -w.

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

זה מרמז כי הבחירה של סוגריים זווית או מרכאות כפולות ב #include
ההנחיה כשלעצמה אינה קובעת אם הכותרת הזו תופיע ב -ממ
פלט תלות. זהו שינוי קל בסמנטיקה מגרסאות GCC 3.0 ו
מוקדם יותר.

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

בשימוש עם אפשרויות הנהג -MD or -MMD, -MF עוקף את תלות ברירת המחדל
קובץ פלט.

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

תכונה זו משמשת לעדכון אוטומטי של קבצי makefile.

-MP אפשרות זו מורה ל-CPP להוסיף יעד מזויף עבור כל תלות מלבד ה-
הקובץ הראשי, מה שגורם לכל אחד להיות תלוי בכלום. חוקי הדמה האלה עוקפים שגיאות
לעשות נותן אם תסיר קבצי כותרת מבלי לעדכן את קובץ Makefile להתאים.

זהו פלט טיפוסי:

test.o: test.c test.h

test.h:

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

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

לדוגמה, -MT '$(objpfx)foo.o' עשוי לתת

$(objpfx)foo.o: foo.c

-MQ יעד
כמו -MT, אבל זה מצטט כל תווים שהם מיוחדים ליצירה.
-MQ '$(objpfx)foo.o' נותן

$$(objpfx)foo.o: foo.c

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

-MD -MD שווה -M -MF פילהחוץ מזה -E אינו משתמע. הנהג
קובע פילה בהתבסס על האם א -o ניתנת אפשרות. אם כן, הנהג משתמש בו
טיעון אבל עם סיומת של .d, אחרת זה לוקח את השם של קובץ הקלט,
מסיר כל רכיבי ספרייה וסיומת, ומחיל א .d סיומת.

If -MD משמש בשילוב עם -E, כל -o מתג מובן כדי לציין את
קובץ פלט תלות, אך אם נעשה בו שימוש ללא -E, כל אחד -o מובן לציין א
קובץ אובייקט המטרה.

השאלה היא איך? -E אינו משתמע, -MD יכול לשמש ליצירת קובץ פלט תלות בתור א
תופעת לוואי של תהליך הקומפילציה.

-MMD
כמו -MD מלבד לציין רק קבצי כותרות של משתמש, לא קובצי כותרות של מערכת.

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

-fpch-preprocess
אפשרות זו מאפשרת שימוש בכותרת מהודרת מראש יחד עם -E. זה מכניס מיוחד
"#pragma", "#pragma GCC pch_preprocess "שם קובץ"" בפלט כדי לסמן את המקום
היכן נמצאה הכותרת המורכבת מראש, ושלה שם הקובץ. כאשר -מעובד מראש הוא ב
השתמש, GCC מזהה את ה-"#pragma" הזה וטוען את ה-PCH.

אפשרות זו כבויה כברירת מחדל, מכיוון שהפלט המעובד מראש המתקבל הוא רק
מתאים באמת כקלט ל-GCC. הוא מופעל על ידי -חיסכון-טמפ'.

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

-x c
-x c ++
-x מטרה-ג
-x assembler-with-cpp
ציין את שפת המקור: C, C++, Objective-C או assembly. אין לזה שום קשר
עם התאמה לתקנים או הרחבות; זה רק בוחר לאיזה תחביר בסיס
לְצַפּוֹת. אם לא תיתן אף אחת מהאפשרויות הללו, cpp יגזור את השפה מה-
סיומת קובץ המקור: .c, . DC, .m, או .S. כמה הרחבות נפוצות אחרות עבור
גם C++ ו-assembly מוכרים. אם cpp לא מזהה את התוסף, זה
יתייחס לקובץ כ-C; זהו המצב הגנרי ביותר.

הערה: גרסאות קודמות של cpp התקבלו א -לאנג אפשרות שבחרה הן את
השפה ורמת התאימות לתקנים. אפשרות זו הוסרה, בגלל
זה מתנגש עם -l אוֹפְּצִיָה.

-std=תֶקֶן
-אנסי
ציין את התקן שאליו הקוד צריך להתאים. כרגע CPP יודע על C
ותקני C++; אחרים עשויים להתווסף בעתיד.

תֶקֶן יכול להיות אחד מ:

"c90"
"c89"
"iso9899:1990"
תקן ISO C משנת 1990. c90 הוא הקיצור המקובל לגרסה זו של
הסטנדרט.

אל האני -אנסי האופציה שווה ל -std=c90.

"iso9899:199409"
תקן 1990 C, כפי שתוקן ב-1994.

"iso9899:1999"
"c99"
"iso9899:199x"
"c9x"
תקן ISO C המתוקן, שפורסם בדצמבר 1999. לפני הפרסום, זה
היה ידוע בשם C9X.

"iso9899:2011"
"c11"
"c1x"
תקן ISO C המתוקן, שפורסם בדצמבר 2011. לפני הפרסום, זה
היה ידוע בשם C1X.

"gnu90"
"gnu89"
תקן 1990 C בתוספת הרחבות GNU. זוהי ברירת המחדל.

"gnu99"
"gnu9x"
תקן C 1999 בתוספת הרחבות של GNU.

"gnu11"
"gnu1x"
תקן C 2011 בתוספת הרחבות של GNU.

"c++98"
תקן ISO C++ משנת 1998 בתוספת תיקונים.

"gnu++98"
זהה ל 98. std = c ++ בתוספת הרחבות של GNU. זוהי ברירת המחדל עבור קוד C++.

-אני- פצל את נתיב הכלול. כל ספריות שצוינו עם -I אפשרויות לפני -אני- יש לו
חיפשו רק כותרות שהתבקשו עם "#include"קוֹבֶץ""; לא מחפשים אותם
"#לִכלוֹלקובץ>". אם צוינו ספריות נוספות עם -I אפשרויות לאחר ה
-אני-, המדריכים האלה מחפשים את כולם #include הוראות.

בנוסף, -אני- מעכב את השימוש בספרייה של ספריית הקבצים הנוכחית כ
ספריית החיפוש הראשונה עבור "#include"קוֹבֶץ"". אפשרות זו הוצאה משימוש.

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

-nostdinc++
אל תחפש קבצי כותרות בספריות הסטנדרטיות הספציפיות ל-C++, אבל עדיין תעשה
חפש בספריות הסטנדרטיות האחרות. (אפשרות זו משמשת בעת בניית ה-C++
סִפְרִיָה.)

-לִכלוֹל פילה
התַהֲלִיך פילה כאילו "#include "קובץ"" הופיע כשורה הראשונה של המקור הראשי
קוֹבֶץ. עם זאת, הספרייה הראשונה שחיפשה פילה האם הפרה-מעבד עובד
בספרייה במקום of הספרייה המכילה את קובץ המקור הראשי. אם לא נמצא
שם, מחפשים אותו בשארית שרשרת החיפוש "#include "..."" כמו
רגיל.

אם מרובה -לִכלוֹל ניתנות אפשרויות, הקבצים כלולים בסדר שהם
מופיעים בשורת הפקודה.

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

כל הקבצים שצוינו על ידי -אימאקרו מעובדים לפני כל הקבצים שצוינו על ידי -לִכלוֹל.

-ידirafter dir
חיפוש dir עבור קובצי כותרות, אבל עשה זאת לאחר כל הספריות שצוינו עם -I ו
ספריות מערכת סטנדרטיות מוצו. dir מתייחסים למערכת הכוללת
מַדרִיך. אם dir מתחיל ב-"=", ואז ה-"=" יוחלף ב-sysroot
קידומת; לִרְאוֹת --sysroot ו -isysroot.

-iprefix קידומת
לפרט קידומת בתור הקידומת עבור הבאות -iwithprefix אפשרויות. אם הקידומת
מייצג ספרייה, עליך לכלול את הסופי /.

-iwithprefix dir
-iwithprefixbefore dir
צרף dir לקידומת שצוינה קודם לכן עם -iprefix, ומוסיפים את המתקבל
ספרייה לנתיב החיפוש כולל. -iwithprefixbefore שם אותו באותו מקום -I
היה; -iwithprefix שם את זה איפה -ידirafter היה.

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

-אימולטיבי dir
השתמש dir כספריית משנה של הספרייה המכילה כותרות C++ ספציפיות ליעד.

-מערכת dir
חיפוש dir עבור קובצי כותרות, לאחר כל הספריות שצוינו על ידי -I אבל לפני
ספריות מערכת סטנדרטיות. סמן אותו כספריית מערכת, כך שהוא יקבל אותו דבר
טיפול מיוחד כפי שמיושם על ספריות המערכת הסטנדרטיות. אם dir מתחיל
עם "=", אז ה-"=" יוחלף בקידומת sysroot; לִרְאוֹת --sysroot ו
-isysroot.

-אני מצטט dir
חיפוש dir רק עבור קבצי כותרות שהתבקשו עם "#include"קוֹבֶץ""; הם לא
חיפש את "#includeקובץ>", לפני כל הספריות שצוינו על ידי -I ולפני
ספריות מערכת סטנדרטיות. אם dir מתחיל ב-"=", ואז ה-"=" יוחלף ב-
קידומת ה-sysroot; לִרְאוֹת --sysroot ו -isysroot.

-fdirectives-בלבד
בעת עיבוד מקדים, טפל בהנחיות, אך אל תרחיב פקודות מאקרו.

התנהגות האופציה תלויה ב -E ו -מעובד מראש אפשרויות.

עם -E, עיבוד מקדים מוגבל לטיפול בהנחיות כגון "#define",
"#ifdef", ו-"#error". פעולות קדם-מעבד אחרות, כגון הרחבת מאקרו ו
המרת טריגרף לא מבוצעת. בנוסף -dD האפשרות היא במרומז
מאופשר.

עם -מעובד מראש, הגדרה מראש של שורת הפקודה ורוב פקודות המאקרו המובנות היא
נָכֶה. מאקרו כגון "__LINE__", שהם תלויי הקשר, מטופלים
בדרך כלל. זה מאפשר הידור של קבצים שעובדו קודם לכן עם "-E
-fdirectives-בלבד".

עם שניהם -E ו -מעובד מראש, הכללים עבור -מעובד מראש לקבל עדיפות. זֶה
מאפשר עיבוד מקדים מלא של קבצים שעובדו קודם לכן עם "-E
-fdirectives-בלבד".

-fdollars-in-identifiers
לְקַבֵּל $ במזהים.

-מזהים-fextended
קבל שמות תווים אוניברסליים במזהים. אפשרות זו היא ניסיונית; ב
גרסה עתידית של GCC, היא תופעל כברירת מחדל עבור C99 ו-C++.

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

-מעובד מראש משתמע אם לקובץ הקלט יש אחת מהסיומות .i, .ii or .מִי.
אלו הן ההרחבות ש-GCC משתמש בהן עבור קבצים מעובדים מראש שנוצרו על ידי -חיסכון-טמפ'.

-ftabstop=רוחב
הגדר את המרחק בין עצירות הטאב. זה עוזר למעבד המקדים לדווח על העמודה הנכונה
מספרים באזהרות או בשגיאות, גם אם מופיעות כרטיסיות על הקו. אם הערך נמוך יותר
מ-1 או יותר מ-100, המערכת מתעלמת מהאפשרות. ברירת המחדל היא 8.

-fdebug-cpp
אפשרות זו שימושית רק לאיתור באגים של GCC. בשימוש עם -E, דופק ניפוי באגים
מידע על מפות מיקום. לפני כל אסימון בפלט יש dump של
המפה שייך למיקומה. המזבלה של המפה שמחזיקה את מיקומו של אסימון
יהיה:

{"P":F ;"F":F ;"L": ;"C": ;"S": ;"M": ;"E": "loc": }

בשימוש ללא -E, לאפשרות זו אין השפעה.

-ftrack-macro-expansion[=רָמָה]
עקוב אחר מיקומים של אסימונים על פני הרחבות מאקרו. זה מאפשר למהדר לפלוט
אבחון לגבי ערימת הרחבת המאקרו הנוכחית כאשר מתרחשת שגיאת קומפילציה ב
הרחבת מאקרו. שימוש באפשרות זו גורם למעבד הפרה ולקומפיילר לצרוך
יותר זיכרון. ה רָמָה ניתן להשתמש בפרמטר כדי לבחור את רמת הדיוק של האסימון
מעקב אחר מיקום ובכך מקטין את צריכת הזיכרון במידת הצורך. ערך 0 of
רָמָה מבטל את האפשרות הזו כאילו לא -ftrack-macro-expansion היה נוכח ב
שורת הפקודה. ערך 1 עוקב אחר מיקומי אסימונים במצב מושפל למען
זיכרון תקורה מינימלי. במצב זה כל האסימונים הנובעים מהרחבה של an
לארגומנט של מאקרו דמוי פונקציה יש אותו מיקום. ערך 2 עוקב אחר אסימונים
מיקומים לחלוטין. הערך הזה הוא הכי רעב לזיכרון. כאשר אפשרות זו ניתנת
אין ארגומנט, ערך ברירת המחדל של הפרמטר הוא 2.

-fexec-charset=ערכה
הגדר את ערכת תווי הביצוע, המשמשת לקבועי מחרוזת ותווים. ברירת המחדל
הוא UTF-8. ערכה יכול להיות כל קידוד שנתמך על ידי ספריית "iconv" של המערכת
שגרה.

-fwide-exec-charset=ערכה
הגדר את ערכת תווי הביצוע הרחבה, המשמשת עבור מחרוזת רחבה וקבועי תווים.
ברירת המחדל היא UTF-32 או UTF-16, מה שמתאים לרוחב של "wchar_t". כפי ש
עם -fexec-charset, ערכה יכול להיות כל קידוד שנתמך על ידי ה"אייקון" של המערכת
שגרת ספרייה; עם זאת, יהיו לך בעיות עם קידודים שאינם מתאימים
בדיוק ב-"wchar_t".

-פונט-גטס =ערכה
הגדר את ערכת תווי הקלט, המשמשת לתרגום מקבוצת התווים של הקלט
קובץ לקבוצת תווי המקור המשמשת את GCC. אם המקום אינו מציין, או GCC
לא יכול לקבל מידע זה מהמקום, ברירת המחדל היא UTF-8. זה יכול להיות
נדחק על ידי המקום או אפשרות שורת הפקודה הזו. כרגע הפקודה
אפשרות הקו מקבלת עדיפות אם יש התנגשות. ערכה יכול להיות כל קידוד
נתמך על ידי שגרת ספריית "iconv" של המערכת.

-fworking-מדריך
אפשר יצירה של סמני קווים בפלט הפרה-מעבד שיאפשרו למהדר
לדעת את ספריית העבודה הנוכחית בזמן העיבוד המקדים. כאשר אפשרות זו היא
מופעלת, המעבד המקדים יפלוט, לאחר סמן הקו הראשוני, סמן קו שני
עם ספריית העבודה הנוכחית ואחריה שני קווים. GCC ישתמש בזה
ספרייה, כאשר היא קיימת בקלט המעובד מראש, כפי שהספרייה נפלטה בשם
ספריית העבודה הנוכחית בחלק מהפורמטים של מידע איתור באגים. אפשרות זו היא
מופעל באופן מרומז אם מידע ניפוי באגים מופעל, אך ניתן למנוע זאת באמצעות
הצורה השלילה -fno-working-directory. אם -P דגל קיים בפקודה
שורה, לאפשרות זו אין השפעה, מכיוון שלא נפלטו הנחיות "#line" כלשהן.

-עמודה-fno-show
אין להדפיס מספרי עמודות באבחון. זה עשוי להיות נחוץ אם יש אבחון
נסרק על ידי תוכנה שאינה מבינה את מספרי העמודות, כגון
Dejagnu.

-A לְבַסֵס=לענות
קבע טענה עם הפרדיקט לְבַסֵס ותענה לענות. טופס זה הוא
העדיפו את הצורה הישנה יותר -A לְבַסֵס(לענות), אשר עדיין נתמך, כי זה
אינו משתמש בתווים מיוחדים של מעטפת.

-A -לְבַסֵס=לענות
בטל טענה עם הפרדיקט לְבַסֵס ותענה לענות.

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

M במקום הפלט הרגיל, צור רשימה של #define הנחיות לכל
פקודות מאקרו שהוגדרו במהלך ביצוע המעבד המקדים, כולל מוגדרות מראש
פקודות מאקרו. זה נותן לך דרך לגלות מה מוגדר מראש בגרסה שלך של
המעבד המקדים. בהנחה שאין לך קובץ foo.h, הפקודה

לגעת ב-foo.h; cpp -dM foo.h

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

אם אתה משתמש -dM בלי ה -E אוֹפְּצִיָה, -dM מתפרש כמילה נרדפת ל
-fdump-rtl-mach.

D כמו M אלא משני בחינות: כן לֹא כלול את פקודות המאקרו המוגדרות מראש, וזה
פלטים שניהם מה היא #define הנחיות והתוצאה של עיבוד מקדים. שני הסוגים
של הפלט עבור לקובץ הפלט הסטנדרטי.

N כמו D, אבל פולט רק את שמות המאקרו, לא את ההרחבות שלהם.

I תְפוּקָה #include הנחיות בנוסף לתוצאה של עיבוד מקדים.

U כמו D אלא שרק פקודות מאקרו מורחבות, או שהגדרתן נבדקת
בהנחיות קדם-מעבד, הם פלט; הפלט מתעכב עד לשימוש או
בדיקה של המאקרו; ו #undef הנחיות מופקות גם עבור פקודות מאקרו שנבדקו אבל
לא מוגדר באותו זמן.

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

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

אתה צריך להיות מוכן לתופעות לוואי בעת השימוש -C; זה גורם למעבד הקדם
להתייחס להערות כאל אסימונים בפני עצמם. לדוגמה, הערות המופיעות ב-
התחלה של מה שיהיה קו הנחיה משפיעה להפוך את הקו הזה ל-an
קו מקור רגיל, מכיוון שהאסימון הראשון בקו אינו עוד a #.

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

בנוסף לתופעות הלוואי של -C אפשרות, -CC אפשרות גורמת לכל סגנון C++
הערות בתוך מאקרו להמרה להערות בסגנון C. זאת כדי למנוע מאוחר יותר
שימוש במאקרו הזה מהערה בשוגג על שאר שורת המקור.

אל האני -CC האופציה משמשת בדרך כלל לתמיכה בהערות מוך.

-מסורתי-cpp
נסו לחקות את ההתנהגות של מעבדי קדם C של פעם, בניגוד ל-ISO C
מעבדי קדם.

-טריגרפים
עיבוד רצפי טריגרף. אלו הם רצפים של שלושה תווים, כולם מתחילים ב
??, שמוגדרים על ידי ISO C לייצג תווים בודדים. לדוגמה, ??/ עומד
ל \, כך '??/n' הוא קבוע תו עבור שורה חדשה. כברירת מחדל, GCC מתעלם
טריגרפים, אבל במצבים התואמים לתקן הוא ממיר אותם. ראה את -סטד ו -אנסי
אפשרויות.

תשעת הטריגרפים והמחליפים שלהם הם

טריגרף: ??( ??) ??< ??> ??= ??/ ??' ??! ??-
החלפה: [ ] { } # \ ^ | ~

-מפה מחדש
אפשר קוד מיוחד כדי לעקוף מערכות קבצים המאפשרות רק קבצים קצרים מאוד
שמות, כגון MS-DOS.

- עזרה
--מטרה-עזרה
הדפס טקסט המתאר את כל אפשרויות שורת הפקודה במקום לעבד כל דבר מראש.

-v מצב מילולי. הדפס את מספר הגרסה של GNU CPP בתחילת הביצוע, וכן
דווח על הטופס הסופי של נתיב הכלול.

-H הדפס את השם של כל קובץ כותרת בשימוש, בנוסף לפעילויות רגילות אחרות. כל אחד
השם מסומן כדי להראות עד כמה עמוק ב- #include מחסנית זה. כותרת מהודרת מראש
מודפסים גם קבצים, גם אם הם נמצאים כלא חוקיים; קומפילציה מראש לא חוקית
קובץ הכותרת מודפס עם ...איקס ותקף עם ...! .

-הפך
--גִרְסָה
הדפס את מספר הגרסה של GNU CPP. עם מקף אחד, המשך לעיבוד מקדים כרגיל.
עם שני מקפים, צא מיד.

חולף אפשרויות ל מה היא אסמבלר
אתה יכול להעביר אפשרויות להרכב.

-ווא,אוֹפְּצִיָה
לעבור אוֹפְּצִיָה כאופציה להרכב. אם אוֹפְּצִיָה מכיל פסיקים, הוא מפוצל
לאפשרויות מרובות בפסיקים.

-Xassembler אוֹפְּצִיָה
לעבור אוֹפְּצִיָה כאופציה להרכב. אתה יכול להשתמש בזה כדי לספק מערכת ספציפית
אפשרויות assembler ש-GCC לא יודע לזהות.

אם אתה רוצה להעביר אפשרות שדורשת ארגומנט, עליך להשתמש -Xassembler פעמיים,
פעם עבור האפשרות ופעם עבור הטיעון.

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

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

-c
-S
-E אם נעשה שימוש באחת מהאפשרויות הללו, המקשר אינו מופעל, ושמות קבצי האובייקט
לא צריך לשמש כטיעונים.

-lספריה
-l ספריה
חפש בספרייה ששמה ספריה בעת קישור. (החלופה השנייה עם ה
הספרייה כארגומנט נפרד מיועדת רק לתאימות POSIX ואינה מומלצת.)

זה משנה היכן בפקודה אתה כותב את האפשרות הזו; המקשר מחפש
ומעבד ספריות וקבצי אובייקט בסדר שהם צוינו. לכן, foo.o
-לז bar.o מחפש בספרייה z אחרי קובץ foo.o אבל לפני bar.o. אם bar.o מתייחס
פונקציות ב z, ייתכן שהפונקציות הללו לא ייטענו.

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

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

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

-lobjc
אתה צריך את המקרה המיוחד הזה של -l אפשרות לקישור Objective-C או
תוכנית Objective-C++.

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

-nodefaultlibs
אל תשתמש בספריות המערכת הסטנדרטיות בעת הקישור. רק הספריות שאתה מציין
יועבר למקשר, אפשרויות המציינות קישור של ספריות המערכת, כגון
כמו "-static-libgcc" או "-shared-libgcc", יתעלם. קבצי האתחול הסטנדרטיים
משמשים כרגיל, אלא אם כן -nostartfiles משמש. המהדר עשוי ליצור קריאות אל
"memcmp", "memset", "memcpy" ו-"memmove". ערכים אלה נפתרים בדרך כלל על ידי
ערכים ב-libc. נקודות כניסה אלו צריכות להיות מסופקות באמצעות מנגנון אחר
כאשר האפשרות הזו מצויינת.

-נוסטדליב
אל תשתמש בקבצי האתחול הסטנדרטיים של המערכת או בספריות בעת הקישור. אין הפעלה
קבצים ורק הספריות שתציין יועברו ל-linker, options
ציון קישור של ספריות המערכת, כגון "-static-libgcc" או
"-shared-libgcc", יתעלם. המהדר עשוי ליצור קריאות ל-"memcmp",
"memset", "memcpy" ו-"memmove". ערכים אלו נפתרים בדרך כלל על ידי ערכים ב
libc. נקודות כניסה אלה צריכות להיות מסופקות באמצעות מנגנון אחר כאשר זה
אפשרות זו מוגדרת.

אחת מהספריות הסטנדרטיות שעקפו -נוסטדליב ו -nodefaultlibs is libgcc.a,
ספריה של תתי-שגרות פנימיות שבהן GCC משתמש כדי להתגבר על חסרונות מסוימים
מכונות, או צרכים מיוחדים לשפות מסוימות.

ברוב המקרים, אתה צריך libgcc.a גם כאשר אתה רוצה להימנע מספריות סטנדרטיות אחרות.
במילים אחרות, כשאתה מציין -נוסטדליב or -nodefaultlibs אתה צריך בדרך כלל
לפרט -lgcc גם כן. זה מבטיח שאין לך אזכורים לא פתורים
תתי שגרות פנימיות של ספריית GCC. (לדוגמה, __רָאשִׁי, משמש כדי להבטיח C++
ייקרא בנאים.)

-פַּאִי
הפקת עמדה עצמאית לביצוע על יעדים התומכים בה. לצפוי
תוצאות, עליך לציין גם את אותה קבוצת אפשרויות ששימשו ליצירת קוד
(-fpie, -fPIE, או אפשרויות משנה של דגם) כאשר אתה מציין אפשרות זו.

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

-s הסר את כל מידע על טבלת הסמלים והעברת המיקום מקובץ ההפעלה.

-סטָטִי
במערכות התומכות בקישור דינמי, הדבר מונע קישור עם המשותף
ספריות. במערכות אחרות, לאפשרות זו אין השפעה.

-מְשׁוּתָף
צור אובייקט משותף שאותו ניתן לקשר עם אובייקטים אחרים ליצירת
בר הפעלה. לא כל המערכות תומכות באפשרות זו. לתוצאות צפויות, אתה חייב
ציין גם את אותה קבוצת אפשרויות ששימשו ליצירת קוד (-fpic, -fPIC, או
אפשרויות משנה) כאשר אתה מציין אפשרות זו.[1]

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

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

לכן, מנהלי ההתקן G++ ו-GCJ מוסיפים אוטומטית -shared-libgcc בכל פעם שאתה בונה
ספרייה משותפת או קובץ הפעלה ראשי, מכיוון שתוכניות C++ ו-Java משתמשות בדרך כלל
חריגים, אז זה הדבר הנכון לעשות.

אם, במקום זאת, אתה משתמש במנהל ההתקן של GCC כדי ליצור ספריות משותפות, אתה עשוי לגלות שהן
לא תמיד יהיה מקושר עם המשותף libgcc. אם GCC מוצא, בתצורה שלו
זמן, שיש לך קישור שאינו GNU או קישור GNU שאינו תומך באפשרות
--eh-frame-hdr, זה יקשר את הגרסה המשותפת של libgcc לתוך ספריות משותפות על ידי
בְּרִירַת מֶחדָל. אחרת, הוא ינצל את המקשר ויבצע אופטימיזציה של
קישור לגרסה המשותפת של libgcc, מקשרים עם הגרסה הסטטית של libgcc
כברירת מחדל. זה מאפשר לחריגים להתפשט באמצעות ספריות משותפות כאלה,
מבלי לגרור עלויות רילוקיישן בזמן טעינת הספרייה.

עם זאת, אם ספרייה או קובץ הפעלה ראשי אמורים לזרוק או לתפוס חריגים, אתה
חייב לקשר אותו באמצעות מנהל ההתקן G++ או GCJ, בהתאם לשפות המשמשות ב-
תוכנית, או באמצעות האפשרות -shared-libgcc, כך שהוא מקושר עם המשותף
libgcc.

-static-libstdc++
כאשר g ++ תוכנית משמשת לקישור תוכנית C++, היא בדרך כלל אוטומטית
קישור נגד libstdc ++. אם libstdc ++ זמין כספרייה משותפת, וה-
-סטָטִי האפשרות אינה בשימוש, אז זה יקשר מול הגרסה המשותפת של
libstdc ++. זה בדרך כלל בסדר. עם זאת, לפעמים כדאי להקפיא את
גרסה של libstdc ++ בשימוש על ידי התוכנית מבלי לעבור את כל הדרך לסטטי מלא
קישור. ה -static-libstdc++ אפשרות מכוונת את g ++ דרייבר לקישור libstdc ++
באופן סטטי, מבלי לקשר בהכרח ספריות אחרות באופן סטטי.

-סִמלִי
קשר הפניות לסמלים גלובליים בעת בניית אובייקט משותף. להזהיר על כל
הפניות לא פתורות (אלא אם כן נדנו על ידי אפשרות עורך הקישורים -Xlinker -z
-Xlinker defs). רק מערכות בודדות תומכות באפשרות זו.

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

-Xlinker אוֹפְּצִיָה
לעבור אוֹפְּצִיָה כאופציה למקשר. אתה יכול להשתמש בזה כדי לספק מערכת ספציפית
אפשרויות קישור ש-GCC לא מזהה.

אם ברצונך להעביר אפשרות שלוקחת ארגומנט נפרד, עליך להשתמש -Xlinker
פעמיים, פעם אחת עבור האפשרות ופעם עבור הטיעון. למשל לעבור -לִטעוֹן
הגדרותאתה חייב לכתוב -Xlinker -לִטעוֹן -Xlinker הגדרות. זה לא עובד
כדי לכתוב -Xlinker "-לִטעוֹן הגדרות", כי זה מעביר את כל המחרוזת כ-a
טיעון יחיד, שזה לא מה שהמקשר מצפה.

כאשר משתמשים במקשר של GNU, לרוב נוח יותר להעביר ארגומנטים למקשר
אפשרויות באמצעות אוֹפְּצִיָה=ערך תחביר מאשר כארגומנטים נפרדים. למשל, אתה
יכול לציין -Xlinker -Map=output.map ולא -Xlinker -מַפָּה -Xlinker output.map.
ייתכן שמקשרים אחרים לא יתמכו בתחביר זה עבור אפשרויות שורת הפקודה.

-וול,אוֹפְּצִיָה
לעבור אוֹפְּצִיָה כאופציה למקשר. אם אוֹפְּצִיָה מכיל פסיקים, הוא מפוצל ל
אפשרויות מרובות בפסיקים. אתה יכול להשתמש בתחביר זה כדי להעביר ארגומנט ל-
אוֹפְּצִיָה. לדוגמה, -Wl,-Map,output.map מעברי -מַפָּה output.map למקשר. מתי
באמצעות מקשר GNU, אתה יכול גם לקבל את אותו אפקט עם -Wl, -Map = output.map.

הערה: באובונטו 8.10 ובגירסאות מאוחרות יותר, עבור LDFLAGS, האפשרות -Wl,-z,relro משמש.
כדי להשבית, השתמש -Wl,-z,norelro.

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

אפשרויות ל מַדרִיך חיפוש
אפשרויות אלה מציינות ספריות לחיפוש קובצי כותרות, ספריות וחלקים
של המהדר:

-Idir
הוסף את הספרייה dir לראש רשימת הספריות שיש לחפש את הכותרת
קבצים. זה יכול לשמש כדי לעקוף קובץ כותרות של המערכת, ולהחליף את קובץ הכותרת שלך
גרסה, מכיוון שמחפשים ספריות אלו לפני קובץ הכותרת של המערכת
ספריות. עם זאת, אין להשתמש באפשרות זו כדי להוסיף ספריות המכילות
קובצי כותרות מערכת שסופקו על ידי הספק (השתמש -מערכת בשביל זה). אם אתה משתמש ביותר מאחד
-I אפשרות, הספריות נסרקות בסדר משמאל לימין; המערכת הסטנדרטית
ספריות באות אחרי.

אם מערכת רגילה כוללת ספרייה, או ספרייה שצוינה עם -מערכת, הוא
מצוין גם עם -I, ה -I האפשרות תתעלם. הספרייה עדיין תהיה
חיפש אבל בתור ספריית מערכת במיקום הרגיל שלה במערכת כוללים שרשרת.
זאת על מנת להבטיח שהנוהל של GCC לתיקון כותרות מערכת באגי וההזמנה
עבור ההנחיה include_next לא השתנו בטעות. אם אתה באמת צריך
שנה את סדר החיפוש עבור ספריות מערכת, השתמש ב- -נוסטדינק ו / או -מערכת
אפשרויות.

-plugindir=dir
הגדר את הספרייה לחיפוש תוספים שעוברים על פניהם -fplugin=שם במקום
-fplugin=נתיב/שם.לכן. אפשרות זו אינה מיועדת לשימוש על ידי המשתמש, אלא רק
עבר ליד הנהג.

-אני מצטטdir
הוסף את הספרייה dir לראש רשימת הספריות שיש לחפש את הכותרת
תיקים רק למקרה של #include "פילה"; לא מחפשים אותם #include <פילה>,
אחרת ממש כמו -I.

-Ldir
הוסף ספרייה dir לרשימת הספריות שיש לחפש -l.

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

תוכנית מנהל ההדרים מפעילה אחת או יותר מתת-התוכניות cpp, cc1, as ו ld.
זה מנסה קידומת בתור קידומת לכל תוכנית שהיא מנסה להפעיל, גם עם וגם בלי
מכונה/גרסה/.

עבור כל תת-תוכנית שתופעל, מנהל התקן המהדר מנסה תחילה את -B קידומת, אם בכלל.
אם השם הזה לא נמצא, או אם -B לא צוין, הנהג מנסה שני סטנדרטים
קידומות, /usr/lib/gcc/ ו /usr/local/lib/gcc/. אם אף אחד מאלה לא מביא ל-
שם הקובץ שנמצא, מחפשים את שם התוכנית ללא שינוי באמצעות ה
ספריות המצוינות ברשימה שלך נתיב משתנה הסביבה.

המהדר יבדוק אם הנתיב שסופק על ידי -B מתייחס לספרייה,
ובמידת הצורך הוא יוסיף תו מפריד ספריות בסוף הנתיב.

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

קובץ התמיכה בזמן הריצה libgcc.a ניתן גם לחפש באמצעות ה -B קידומת, אם
נָחוּץ. אם זה לא נמצא שם, שני הקידומות הסטנדרטיות לעיל מנוסים, וזה
זה הכל. הקובץ נשאר מחוץ לקישור אם הוא לא נמצא באמצעים אלה.

דרך נוספת לציין קידומת בדומה ל- -B הקידומת היא להשתמש בסביבה
משתנה GCC_EXEC_PREFIX.

כמו kludge מיוחד, אם הנתיב מסופק על ידי -B is [dir/]stageN/, שם N הוא מספר
בטווח 0 עד 9, אז הוא יוחלף ב [dir/]include. זה כדי לעזור
רצועת אתחול של המהדר.

-מפרט =פילה
התַהֲלִיך פילה לאחר שהמהדר יקרא את התקן מפרט טכני קובץ, כדי לעקוף
ברירות המחדל שבהן gcc תוכנית מנהל ההתקן משתמשת בעת קביעת הבוררים לעבור
ל cc1, cc1plus, as, ldוכו' יותר מאחד -מפרט =פילה ניתן לציין ב-
שורת הפקודה, והם מעובדים לפי הסדר, משמאל לימין.

--sysroot=dir
השתמש dir בתור ספריית השורש הלוגית לכותרות וספריות. לדוגמה, אם ה
מהדר יחפש בדרך כלל כותרות ב / usr / include וספריות ב / Usr / lib,
הוא יחפש במקום זאת dir/usr/include ו dir/usr/lib.

אם אתה משתמש גם באפשרות זו וגם ב- -isysroot אפשרות ולאחר מכן את --sysroot אפשרות תהיה
חל על ספריות, אבל ה -isysroot האפשרות תחול על קובצי כותרות.

לקשר GNU (החל מגרסה 2.16) יש את התמיכה הדרושה לכך
אוֹפְּצִיָה. אם המקשר שלך אינו תומך באפשרות זו, היבט קובץ הכותרת של
--sysroot עדיין יעבוד, אבל היבט הספרייה לא.

-אני- אפשרות זו הוצאה משימוש. בבקשה תשתמש -אני מצטט במקום זאת עבור -I ספריות לפני
מה היא -אני- ולהסיר את -אני-. כל ספריות שאתה מציין איתן -I אפשרויות לפני ה
-אני- מחפשים רק את המקרה של #include "פילה"; לא מחפשים אותם
ל #include <פילה>.

אם צוינו ספריות נוספות עם -I אפשרויות לאחר ה -אני-, אלה
מחפשים את כל הספריות #include הנחיות. (בדרך כלל את כל -I ספריות
משמשים בדרך זו.)

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

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

מפרט יעד מכונה ו מהדר גִרְסָה
הדרך הרגילה להפעיל את GCC היא להפעיל את קובץ ההפעלה שנקרא gcc, או מכונה-gcc כאשר חוצה-
קומפילציה, או מכונה-gcc-גרסה להפעיל גרסה אחרת מזו שהותקנה
אחרון.

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

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

אדפטיבה הִתגַלוּת אפשרויות

אלה -m אפשרויות מוגדרות עבור Adapteva Epiphany:

-mhalf-reg-file
אל תקצה שום רשם בטווח "r32"..."r63". זה מאפשר לרוץ על הקוד
גרסאות חומרה חסרות רגיסטרים אלה.

-mrefer-short-insn-regs
הקצאה מועדפת לרשמים המאפשרים יצירת הוראות קצרות. זה יכול
לגרום להגדלת ספירת ההוראות, אז אם זה מקטין או מגדיל את גודל הקוד
עשוי להשתנות ממקרה למקרה.

-brranch-cost=NUM
הגדר את עלות הסניפים לערך NUM הוראות "פשוטות". עלות זו היא רק א
היוריסטית ואינה מובטחת להפיק תוצאות עקביות בכל מהדורות.

-mcmove
אפשר יצירת מהלכים מותנים.

-mnops=NUM
פולט NUM לא לפני כל הוראה אחרת שנוצרה.

-mno-soft-cmpsf
עבור השוואות של נקודה צפה ברמת דיוק יחידה, שלח הוראת fsub ובדוק את
דגלים. זה מהיר יותר מהשוואת תוכנה, אבל יכול לקבל תוצאות שגויות
נוכחות של NaNs, או כאשר שני מספרים קטנים שונים מושווים כך שהם
ההפרש מחושב כאפס. ברירת המחדל היא -msoft-cmpsf, אשר משתמש לאט יותר, אבל
השוואת תוכנה תואמת IEEE.

-mstack-offset=NUM
הגדר את ההיסט בין החלק העליון של הערימה לבין מצביע הערימה. למשל, ערך של 8
פירושו שמונה בתים בטווח sp+0...sp+7 יכולים לשמש על ידי פונקציות עלים
ללא הקצאת מחסנית. ערכים מלבד 8 or 16 לא נבדקו ולא סביר שיעשו זאת
עֲבוֹדָה. שימו לב גם שאופציה זו משנה את ה-ABI, קומפילציה של תוכנית עם a
היסט מחסנית שונה מזה שהספריות הורכבו איתו בדרך כלל לא
עֲבוֹדָה. אפשרות זו יכולה להיות שימושית אם ברצונך להעריך אם היסט מחסנית שונה
ייתן לך קוד טוב יותר, אבל למעשה להשתמש בהיסט מחסנית שונה לבנייה
תוכניות עבודה, מומלץ להגדיר את שרשרת הכלים עם המתאים
--with-stack-offset=NUM אוֹפְּצִיָה.

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

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

-שיחות קצרות
אם לא צוין אחרת על ידי תכונה, נניח שכל השיחות הישירות נמצאות בטווח
של הוראות b / bl, אז השתמש בהוראות אלה עבור שיחות ישירות. ברירת המחדל
is -מלונג-שיחות.

-msmall16
נניח שניתן לטעון כתובות כערכים ללא סימנים של 16 סיביות. זה לא חל על
כתובות פונקציה עבור אשר -מלונג-שיחות הסמנטיקה בתוקף.

-mfp-mode=מצב
הגדר את המצב הרווח של יחידת הנקודה הצפה. זה קובע את הצף-
מצב נקודה שסופק וצפוי בזמן קריאת פונקציה והחזרה. הֲכָנָה
מצב זה להתאים את המצב שאתה צריך בעיקר בתחילת הפונקציה יכול להפוך את שלך
תוכניות קטנות ומהירות יותר על ידי הימנעות מתגי מצבים מיותרים.

מצב ניתן להגדיר לאחד מהערכים הבאים:

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

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

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

int זהו המצב המשמש לביצוע חישובי מספרים שלמים ב-FPU, למשל מספר שלם
כפל, או מספר שלם כפל-וצבור.

ברירת המחדל היא -mfp-mode=מתקשר

-mnosplit-lohi
-mno-postinc
-mno-postmodify
תיקוני יצירת קוד המשביתים, בהתאמה, פיצול של עומסים של 32 סיביות,
יצירת כתובות לאחר תוספת, ויצירת כתובות לאחר שינוי. ה
ברירות המחדל הן msplit-lohi, -mpost-inc, ו -mpost-modify.

-mnovect-דאבל
שנה את מצב ה- SIMD המועדף ל-SImode. ברירת המחדל היא -mvect-double, אשר שימושים
DImode כמצב SIMD מועדף.

-max-vect-align=NUM
היישור המקסימלי עבור סוגי מצב וקטור SIMD. NUM יכול להיות 4 או 8. ברירת המחדל היא
8. שימו לב שזהו שינוי ב-ABI, למרות שממשקי פונקציית ספרייה רבים יעשו זאת
לא יושפעו, אם הם לא משתמשים במצבי וקטור SIMD במקומות שבהם הם משפיעים על הגודל
ו/או יישור של סוגים רלוונטיים.

-msplit-vecmove-early
וקטור פיצול נע למהלכי מילה בודדת לפני טעינה מחדש. בתיאוריה זה יכול לתת
הקצאת רישום טובה יותר, אבל עד כה נראה שהמצב הפוך בדרך כלל.

-m1reg-רג
ציין אוגר שיחזיק את הקבוע -1, מה שהופך את הטעינה לשלילית קטנה
קבועים ומסיכות סיביות מסוימות מהר יותר. הערכים המותרים עבור reg הם r43 ו-r63,
אשר מציינים להשתמש ברישום זה כאוגר קבוע, ואין, כלומר לא
למטרה זו נעשה שימוש ברישום. ברירת המחדל היא -m1reg-none.

AAArch64 אפשרויות

אפשרויות אלה מוגדרות עבור יישומי AArch64:

-mbig-endian
צור קוד גדול. זוהי ברירת המחדל כאשר GCC מוגדר עבור an
aarch64_be-*-* יעד.

-mgeneral-regs-only
צור קוד שמשתמש רק ברישום הכללי.

-מעט-אנדיאן
צור קוד קטן-אנדיאן. זוהי ברירת המחדל כאשר GCC מוגדר עבור an
aarch64-*-* אבל לא aarch64_be-*-* יעד.

-mcmodel=קטנטן
צור קוד עבור מודל הקוד הזעיר. התוכנית והסמלים המוגדרים סטטית שלה
חייבים להיות בטווח של 1GB אחד מהשני. מצביעים הם 64 סיביות. תוכניות יכולות להיות סטטיות
או מקושרים באופן דינמי. מודל זה אינו מיושם במלואו ובעיקר מתייחס אליו כאל
"קָטָן".

-mcmodel=small
צור קוד עבור מודל הקוד הקטן. התוכנית וההגדרה שלה סטטית
הסמלים חייבים להיות בטווח של 4GB אחד מהשני. מצביעים הם 64 סיביות. תוכניות יכולות להיות
מקושר סטטי או דינמי. זהו מודל הקוד המוגדר כברירת מחדל.

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

-mstrict-align
אל תניח שהמערכת תטפל בהפניות זיכרון לא מיושרות.

-momit-leaf-frame-pointer
-mno-omit-leaf-frame-pointer
השמט או השאר את מצביע המסגרת בפונקציות עלה. ההתנהגות הקודמת היא ה
ברירת המחדל.

-mtls-dialect=desc
השתמש בתיאורי TLS כמנגנון אחסון מקומי-חוט עבור גישה דינמית של TLS
משתנים. זוהי ברירת המחדל.

-mtls-dialect=מסורתי
השתמש ב-TLS המסורתי כמנגנון אחסון מקומי-חוט עבור גישה דינמית של TLS
משתנים.

-מרץ=שם
ציין את השם של ארכיטקטורת היעד, אופציונלי עם סיומת אחת או יותר
משנה תכונות. לאפשרות זו יש את הטופס -מרץ=קשת{+[לא]תכונה}*, איפה ה
רק ערך עבור קשת is armv8-a. הערכים האפשריים עבור תכונה מתועדים ב-
סעיף משנה להלן.

כאשר צוינו תכונה מתנגשת, התכונה הכי ימנית משמשת.

GCC משתמש בשם זה כדי לקבוע איזה סוג של הוראות הוא יכול לפלוט בעת הפקה
קוד הרכבה. ניתן להשתמש באפשרות זו בשילוב עם או במקום -mcpu=
אוֹפְּצִיָה.

-mcpu=שם
ציין את שם מעבד היעד, עם סיומת אופציונלית על ידי תכונה אחת או יותר
משנה. לאפשרות זו יש את הטופס -mcpu=מעבד{+[לא]תכונה}*, היכן שאפשר
ערכים עבור מעבד יש לו גנרית, גָדוֹל. הערכים האפשריים עבור תכונה מתועדים ב
תת הסעיף להלן.

כאשר צוינו תכונה מתנגשת, התכונה הכי ימנית משמשת.

GCC משתמש בשם זה כדי לקבוע איזה סוג של הוראות הוא יכול לפלוט בעת הפקה
קוד הרכבה.

-mtune=שם
ציין את שם המעבד לכוון את הביצועים עבורו. הקוד יהיה מכוון
כאילו מעבד המטרה היה מהסוג שצוין באפשרות זו, אך עדיין משתמש
הוראות התואמות למעבד היעד שצוין על ידי א -mcpu= אוֹפְּצִיָה. זֶה
אפשרות לא יכולה להיות סיומת על ידי משנה תכונות.

-מרץ ו -mcpu משנה תכונות

משנה תכונות בשימוש עם -מרץ ו -mcpu יכול להיות אחד מהבאים:

קריפטו
אפשר הרחבת Crypto. זה מרמז שמתקדם SIMD מופעל.

fp אפשר הוראות נקודה צפה.

סימד
אפשר הוראות SIMD מתקדמות. זה מרמז על הוראות נקודה צפה
מופעל. זוהי ברירת המחדל עבור כל הערכים האפשריים הנוכחיים עבור אפשרויות -מרץ ו
-mcpu=.

זרוע אפשרויות

אלה -m האפשרויות מוגדרות עבור ארכיטקטורות מתקדמות RISC Machines (ARM):

-מאבי=שם
צור קוד עבור ה-ABI שצוין. הערכים המותרים הם: apcs-gnu, atpcs, aapcs,
aapcs-linux ו iwmmxt.

-mapcs-frame
צור מסגרת מחסנית התואמת את תקן ARM Procedure Call עבור כולם
פונקציות, גם אם זה לא הכרחי לחלוטין לביצוע נכון של הקוד.
מפרט -fomit-frame-pointer עם אפשרות זו יגרום למסגרות המחסנית לא להיות
נוצר עבור פונקציות עלים. ברירת המחדל היא -mno-apcs-frame.

-מפות
זוהי מילה נרדפת ל -mapcs-frame.

-מ-אגודל-עבודה
צור קוד התומך בהתקשרות בין ערכות ההוראות ARM ו-Thumb.
ללא אפשרות זו, בארכיטקטורות קדם-v5, שתי ערכות ההוראות לא יכולות להיות
בשימוש אמין בתוך תוכנית אחת. ברירת המחדל היא -mno-thumb-interwork, מאז מעט
קוד גדול יותר נוצר כאשר -מ-אגודל-עבודה מצוין. בתצורות AAPCS
אפשרות זו חסרת משמעות.

-mno-sched-פרולוג
מנע סידור מחדש של הוראות בפרולוג הפונקציה, או מיזוג של
הוראות אלה עם ההוראות בגוף הפונקציה. זה אומר שהכל
פונקציות יתחילו עם קבוצה מזוהה של הוראות (או למעשה אחת מתוך א
בחירה מתוך קבוצה קטנה של פרולוגים פונקציות שונות), ומידע זה יכול להיות
משמש לאיתור הפונקציות start if בתוך קטע קוד בר הפעלה. ברירת המחדל
is -msched-prolog.

-mfloat-abi=שם
מציין באיזה ABI של נקודה צפה להשתמש. הערכים המותרים הם: רך, softfp ו
קָשֶׁה.

מפרט רך גורם ל-GCC ליצור פלט המכיל קריאות לספרייה עבור צף-
פעולות נקודתיות. softfp מאפשר יצירת קוד באמצעות נקודה צפה בחומרה
הוראות, אבל עדיין משתמש במוסכמות השיחות הרכות-צף. קָשֶׁה מאפשר
יצירת הוראות נקודה צפה ומשתמשת במוסכמות שיחות ספציפיות ל-FPU.

ברירת המחדל תלויה בתצורת היעד הספציפית. שימו לב שה-hard-float
ו- ABIs soft float אינם תואמים קישורים; אתה חייב להרכיב את כל התוכנית שלך עם
אותו ABI, וקישור עם קבוצה תואמת של ספריות.

-מעט-אנדיאן
צור קוד עבור מעבד הפועל במצב little-endian. זוהי ברירת המחדל עבור
כל התצורות הסטנדרטיות.

-mbig-endian
צור קוד עבור מעבד הפועל במצב big-endian; ברירת המחדל היא קומפילציה
קוד עבור מעבד קטן אנדיאן.

-mwords-little-endian
אפשרות זו חלה רק בעת יצירת קוד עבור מעבדים גדולים. לִיצוֹר
קוד לסדר מילים קטן-אנדיאן אבל סדר בתים גדול-אנדיאן. כלומר, בייט
סדר הטופס 32107654. הערה: יש להשתמש באפשרות זו רק אם אתה צריך
תאימות עם קוד עבור מעבדי ARM גדולים שנוצרו על ידי גרסאות של
מהדר לפני 2.8. אפשרות זו הוצאה משימוש כעת.

-מרץ=שם
זה מציין את השם של ארכיטקטורת ARM היעד. GCC משתמש בשם זה כדי
לקבוע איזה סוג של הוראות הוא יכול לפלוט בעת הפקת קוד הרכבה. זֶה
ניתן להשתמש באפשרות בשילוב עם או במקום -mcpu= אוֹפְּצִיָה. מוּתָר
השמות הם: armv2, armv2a, armv3, armv3m, armv4, armv4t, armv5, armv5t, armv5e,
armv5te, armv6, ARMV6J, armv6t2, armv6z, armv6zk, armv6-m, armv7, armv7-a, armv7-r,
armv7-m, armv7e-m, iwmmxt, iwmmxt2, ep9312.

-צעדה = יליד גורם למהדר לזהות אוטומטית את הארכיטקטורה של ה-build
מַחשֵׁב. נכון לעכשיו, תכונה זו נתמכת רק בלינוקס, ולא בכולם
ארכיטקטורות מוכרות. אם הזיהוי האוטומטי לא מצליח לאפשרות אין
השפעה.

-mtune=שם
אפשרות זו מציינת את השם של מעבד ARM היעד שעבורו GCC צריך להתכוונן
הביצועים של הקוד. עבור יישומי ARM מסוימים יכולים להיות ביצועים טובים יותר
מתקבל על ידי שימוש באפשרות זו. השמות המותרים הם: arm2, arm250, arm3, arm6,
arm60, arm600, arm610, arm620, arm7, זרוע 7 מ', arm7d, arm7dm, arm7di, arm7dmi, arm70,
arm700, arm700i, arm710, arm710c, arm7100, arm720, arm7500, arm7500fe, arm7tdmi,
arm7tdmi-s, arm710t, arm720t, arm740t, זרוע חזקה, strongarm110, strongarm1100,
strongarm1110, arm8, arm810, arm9, arm9e, arm920, arm920t, arm922t, arm946e-s,
arm966e-s, arm968e-s, arm926ej-s, arm940t, arm9tdmi, arm10tdmi, arm1020t, arm1026ej-s,
arm10e, arm1020e, arm1022e, arm1136j-s, arm1136jf-s, mpcore, mpcorenovfp, arm1156t2-s,
arm1156t2f-s, arm1176jz-s, arm1176jzf-s, קליפת המוח-a5, קליפת המוח-a7, קליפת המוח-a8, קליפת המוח-a9,
קליפת המוח-a15, cortex-r4, cortex-r4f, cortex-r5, קורטקס-m4, קורטקס-m3, קורטקס-m1,
קורטקס-m0, xscale, iwmmxt, iwmmxt2, ep9312, fa526, fa626, fa606te, fa626te, fmp626,
fa726te.

-mtune=גנרי-קשת מציין ש-GCC צריך לכוון את הביצועים לשילוב של
מעבדים בתוך הארכיטקטורה קשת. המטרה היא ליצור קוד שפועל היטב ב-
המעבדים הפופולריים ביותר הנוכחיים, מאזנים בין אופטימיזציות שמועילות לחלק
מעבדים בטווח, והימנעות ממלכודות ביצועים של מעבדים אחרים. ההשפעות של
אפשרות זו עשויה להשתנות בגרסאות GCC עתידיות כאשר דגמי CPU באים והולכים.

-mtune=native גורם למהדר לזהות אוטומטית את ה-CPU של מחשב ה-build. בְּ
קיים, תכונה זו נתמכת רק בלינוקס, ולא כל הארכיטקטורות
מוּכָּר. אם הזיהוי האוטומטי לא מצליח לאפשרות אין השפעה.

-mcpu=שם
זה מציין את השם של מעבד ARM היעד. GCC משתמש בשם זה כדי לגזור את
שם ארכיטקטורת ARM היעד (כאילו צוין על ידי -מרץ) ומעבד ARM
סוג שעבורו יש לכוונן לביצועים (כאילו צוין על ידי -mtune). איפה האפשרות הזו
משמש בשילוב עם -מרץ or -mtune, אפשרויות אלו עדיפות על פני ה
חלק מתאים של אפשרות זו.

השמות המותרים עבור אפשרות זו זהים לאלו עבור -mtune.

-mcpu=גנרי-קשת מותר גם הוא, והוא שווה ערך ל -מרץ=קשת
-mtune=גנרי-קשת. לראות -mtune לקבלת מידע נוסף.

-mcpu = יליד גורם למהדר לזהות אוטומטית את ה-CPU של מחשב ה-build. בְּ
קיים, תכונה זו נתמכת רק בלינוקס, ולא כל הארכיטקטורות
מוּכָּר. אם הזיהוי האוטומטי לא מצליח לאפשרות אין השפעה.

-mfpu=שם
-mfpe=מספר
-mfp=מספר
זה מציין באיזו חומרת נקודה צפה (או אמולציית חומרה) זמינה
המטרה. השמות המותרים הם: fpa, fpe2, fpe3, עצמאי, vfp, vfpv3, vfpv3-fp16,
vfpv3-d16, VFPV3-D16-FP16, vfpv3xd, vfpv3xd-fp16, נאון, neon-fp16, vfpv4, vfpv4-d16,
fpv4-sp-d16 ו ניאון-vfpv4. -mfp ו -mfpe הן מילים נרדפות ל -mfpu=fpeמספר, עבור
תאימות עם גרסאות ישנות יותר של GCC.

If -msoft-float צוין זה מציין את הפורמט של ערכי נקודה צפה.

אם חומרת הנקודה הצפה שנבחרה כוללת את סיומת NEON (למשל -mfpu=נאון),
שים לב שפעולות נקודה צפה לא ישמשו על ידי כרטיס הווקטוריזציה האוטומטי של GCC
אלא אם כן -אופטימיזציות-funsafe-math מצוין גם. הסיבה לכך היא חומרת NEON
אינו מיישם במלואו את תקן IEEE 754 עבור אריתמטיקה של נקודה צפה (ב
ערכים דנורמליים מסוימים מתייחסים לאפס), כך שהשימוש בהוראות NEON עשוי
להוביל לאובדן דיוק.

-mfp16-format=שם
ציין את הפורמט של סוג הנקודה הצפה "__fp16" בחצי דיוק. מוּתָר
שמות הם אף לא אחד, איי, ו חלופה; ברירת המחדל היא אף לא אחד, במקרה זה ה-"__fp16"
סוג אינו מוגדר.

-mstructure-size-boundary=n
הגודל של כל המבנים והאיגודים יעוגל כלפי מעלה לכפולה של המספר
של ביטים שהוגדרו על ידי אפשרות זו. הערכים המותרים הם 8, 32 ו-64. ערך ברירת המחדל
משתנה עבור שרשרות כלים שונות. עבור שרשרת הכלים הממוקדת COFF ערך ברירת המחדל הוא
8. ערך של 64 מותר רק אם ה-ABI הבסיסי תומך בו.

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

-אם-על-חזרה
צור קריאה לפונקציה "בטל" בסוף פונקציית "norreturn". זה יהיה
להתבצע אם הפונקציה מנסה לחזור.

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

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

תכונה זו אינה מופעלת כברירת מחדל. מפרט -שיחות ארוכות ישחזר את
התנהגות ברירת מחדל, וכך גם הצבת קריאות הפונקציה בטווח של a #פרגמה
ארוך_שיחות הוֹרָאָה. שימו לב למתגים הללו אין השפעה על אופן הפעולה של המהדר
יוצר קוד לטיפול בקריאות פונקציה באמצעות מצביעי פונקציה.

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

-mpic-register=רג
ציין את האוגר שישמש עבור כתובת PIC. ברירת המחדל היא R10 אלא אם כן מחסנית-
הבדיקה מופעלת כאשר נעשה שימוש ב-R9.

-mcirrus-fix-invalid-insns
הכנס NOPs לתוך זרם ההוראות כדי לעקוף בעיות עם
שילובי הוראות Maverick לא חוקיים. אפשרות זו תקפה רק אם
-mcpu=ep9312 נעשה שימוש באפשרות כדי לאפשר יצירת הוראות עבור ה-Cirrus
מעבד משותף של Maverick בנקודה צפה. אפשרות זו אינה מופעלת כברירת מחדל, שכן
הבעיה קיימת רק ביישומים ישנים יותר של Maverick. ברירת המחדל יכולה להיות מחדש
מופעל על ידי שימוש ב- -mno-cirrus-fix-invalid-insns מתג.

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

t0
.ascii "שם_פונקציה_זרוע", 0
.align
t1
‎.word 0xff000000 + (t1 - t0)
שם_פונקציה_לזרוע
mov ip, sp
stmfd sp!, {fp, ip, lr, pc}
sub fp, ip, #4

בעת ביצוע מעקב מחסנית, קוד יכול לבדוק את הערך של "pc" המאוחסן ב-"fp +
0". אם פונקציית המעקב מסתכלת על המיקום "pc - 12" ו-8 הביטים העליונים הם
set, אז אנחנו יודעים שיש שם פונקציה מוטבע מיד לפני זה
מיקום ובעל אורך "((pc[-3]) & 0xff000000)".

-אגודל
-מרם
בחר בין הפקת קוד המופעל במצבי ARM ו-Thumb. ברירת המחדל עבור
רוב התצורות הן ליצור קוד שפועל במצב ARM, אבל ברירת המחדל
ניתן לשנות על ידי הגדרת GCC עם --with-mode=היו אפשרות להגדיר.

-mtpcs-frame
צור מסגרת מחסנית התואמת את תקן ה-Thumb Procedure Call for
כל הפונקציות שאינן עלה. (פונקציית עלה היא כזו שאינה קוראת לאף אחת אחרת
פונקציות.) ברירת המחדל היא -mno-tpcs-frame.

-mtpcs-leaf-frame
צור מסגרת מחסנית התואמת את תקן ה-Thumb Procedure Call for
כל פונקציות העלים. (פונקציית עלה היא כזו שאינה קוראת לפונקציות אחרות.)
ברירת המחדל היא -mno-apcs-leaf-frame.

-mcallee-סופר-אינטרוורקינג
נותן לכל הפונקציות הנראות כלפי חוץ בקובץ הנערך הוראת ARM
set header אשר עובר למצב Thumb לפני ביצוע שאר הפונקציה.
זה מאפשר לקרוא לפונקציות אלו מקוד שאינו פועל בין פעולות. אפשרות זו היא
לא תקף בתצורות AAPCS מכיוון ששיתוף פעולה מופעל כברירת מחדל.

-mcaller-סופר-אינטרוורקינג
מאפשר לשיחות באמצעות מצביעי פונקציות (כולל פונקציות וירטואליות) לבצע כהלכה
ללא קשר לשאלה אם קוד היעד הידור עבור עבודה הדדית או לא.
ישנה תקורה קטנה בעלות ביצוע מצביע פונקציה אם אפשרות זו
מופעל. אפשרות זו אינה חוקית בתצורות AAPCS מכיוון שהאינטראקציה היא
מופעלת כברירת מחדל.

-mtp=שם
ציין את מודל הגישה עבור מצביע האחסון המקומי של השרשור. הדגמים התקפים הם
רך, שיוצר קריאות ל-"__aeabi_read_tp", cp15, שמביא את החוט
מצביע מ-"cp15" ישירות (נתמך בארכיטקטורת arm6k), ו המכונית, אשר
משתמש בשיטה הזמינה הטובה ביותר עבור המעבד הנבחר. הגדרת ברירת המחדל היא
המכונית.

-mtls-dialect=נִיב
ציין את הניב לשימוש לגישה לאחסון מקומי של שרשור. שני דיאלקטים הם
נתמך --- גנו ו gnu2. ה גנו דיאלקט בוחר את ערכת GNU המקורית עבור
תמיכה בדגמי TLS דינמיים מקומיים וגלובליים. ה gnu2 דיאלקט בוחר את ה-GNU
סכימת תיאורים, המספקת ביצועים טובים יותר עבור ספריות משותפות. הגנו
סכימת המתאר תואמת את הסכימה המקורית, אך דורשת חדש
אסמבלר, מקשר ותמיכה בספרייה. דגמי TLS ראשוניים ומקומיים הם
לא מושפע מהאפשרות הזו ותמיד השתמש בסכימה המקורית.

-mword-relocations
צור רק העברות מוחלטות על ערכים בגודל מילה (כלומר R_ARM_ABS32). זה
מופעל כברירת מחדל ביעדים (uClinux, SymbianOS) שבהם טוען זמן הריצה כופה
הגבלה זו ומתי -fpic or -fPIC מוגדר.

-mfix-cortex-m3-ldrd
חלק מלייבות Cortex-M3 עלולות לגרום לשחיתות נתונים כאשר "ldrd" הוראות עם
נעשה שימוש באוגרי יעד ובסיס חופפים. אפשרות זו נמנעת מיצירת
הוראות אלה. אפשרות זו מופעלת כברירת מחדל כאשר -mcpu=cortex-m3 is
נָקוּב.

-גישה מנוהלת
-mno-unaligned-access
מאפשר (או משבית) קריאה וכתיבה של ערכי 16 ו-32 סיביות מכתובות
שאינם מיושרים 16 או 32 סיביות. כברירת מחדל, גישה לא מיושרת מושבתת עבור כולם
טרום-ARMv6 וכל ארכיטקטורות ARMv6-M, ומופעל עבור כל שאר הארכיטקטורות. אם
גישה לא מיושרת אינה מופעלת ואז יינתנו למילים במבני נתונים ארוזים
בייט בכל פעם.

תכונת ARM "Tag_CPU_unaligned_access" תוגדר בקובץ האובייקט שנוצר
נכון או לא נכון, בהתאם להגדרה של אפשרות זו. אם לא מיושר
הגישה מופעלת אז גם סמל המעבד "__ARM_FEATURE_UNALIGNED" יהיה
מוּגדָר.

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

AVR אפשרויות

-mmcu=מקו
ציין את ארכיטקטורות ערכת ההוראות של Atmel AVR (ISA) או סוג MCU.

ברירת המחדל עבור אפשרות זו היא @tie{}"avr2".

GCC תומך בהתקני הרסיבר וה-ISA הבאים:

"avr2"
מכשירים "קלאסיים" עם עד 8@tie{}KiB של זיכרון תוכניות. מקו@tie{}= "attiny22",
"attiny26", "at90c8534", "at90s2313", "at90s2323", "at90s2333", "at90s2343",
"at90s4414", "at90s4433", "at90s4434", "at90s8515", "at90s8535".

"avr25"
מכשירים "קלאסיים" עם עד 8@tie{}KiB של זיכרון תוכניות ועם "MOVW"
הוראה. מקו@tie{}= "ata6289", "attiny13", "attiny13a", "attiny2313",
"attiny2313a", "attiny24", "attiny24a", "attiny25", "attiny261", "attiny261a",
"attiny43u", "attiny4313", "attiny44", "attiny44a", "attiny45", "attiny461",
"attiny461a", "attiny48", "attiny84", "attiny84a", "attiny85", "attiny861",
"attiny861a", "attiny87", "attiny88", "at86rf401".

"avr3"
מכשירים "קלאסיים" עם 16@tie{}KiB עד 64@tie{}KiB של זיכרון תוכניות.
מקו@tie{}= "at43usb355", "at76c711".

"avr31"
מכשירים "קלאסיים" עם 128@tie{}KiB של זיכרון תוכניות. מקו@tie{}= "atmega103",
"at43usb320".

"avr35"
מכשירים "קלאסיים" עם 16@tie{}KiB עד 64@tie{}KiB של זיכרון תוכנית ועם
הוראת "MOVW". מקו@tie{}= "atmega16u2", "atmega32u2", "atmega8u2",
"attiny167", "at90usb162", "at90usb82".

"avr4"
מכשירים "משופרים" עם עד 8@tie{}KiB של זיכרון תוכניות. מקו@tie{}=
"atmega48", "atmega48a", "atmega48p", "atmega8", "atmega8hva", "atmega8515",
"atmega8535", "atmega88", "atmega88a", "atmega88p", "atmega88pa", "at90pwm1",
"at90pwm2", "at90pwm2b", "at90pwm3", "at90pwm3b", "at90pwm81".

"avr5"
מכשירים "משופרים" עם 16@tie{}KiB עד 64@tie{}KiB של זיכרון תוכנית.
מקו@tie{}= "atmega16", "atmega16a", "atmega16hva", "atmega16hva2", "atmega16hvb",
"atmega16m1", "atmega16u4", "atmega161", "atmega162", "atmega163", "atmega164a",
"atmega164p", "atmega165", "atmega165a", "atmega165p", "atmega168", "atmega168a",
"atmega168p", "atmega169", "atmega169a", "atmega169p", "atmega169pa", "atmega32",
"atmega32c1", "atmega32hvb", "atmega32m1", "atmega32u4", "atmega32u6",
"atmega323", "atmega324a", "atmega324p", "atmega324pa", "atmega325", "atmega325a",
"atmega325p", "atmega3250", "atmega3250a", "atmega3250p", "atmega328",
"atmega328p", "atmega329", "atmega329a", "atmega329p", "atmega329pa",
"atmega3290", "atmega3290a", "atmega3290p", "atmega406", "atmega64", "atmega64c1",
"atmega64hve", "atmega64m1", "atmega640", "atmega644", "atmega644a", "atmega644p",
"atmega644pa", "atmega645", "atmega645a", "atmega645p", "atmega6450",
"atmega6450a", "atmega6450p", "atmega649", "atmega649a", "atmega649p",
"atmega6490", "at90can32", "at90can64", "at90pwm216", "at90pwm316", "at90scr100",
"at90usb646", "at90usb647", "at94k", "m3000".

"avr51"
מכשירים "משופרים" עם 128@tie{}KiB של זיכרון תוכניות. מקו@tie{}= "atmega128",
"atmega128rfa1", "atmega1280", "atmega1281", "atmega1284p", "at90can128",
"at90usb1286", "at90usb1287".

"avr6"
מכשירים "משופרים" עם מחשב של 3 בתים, כלומר עם יותר מ-128@tie{}KiB של תוכנית
זיכרון. מקו@tie{}= "atmega2560", "atmega2561".

"avrxmega2"
מכשירי "XMEGA" עם יותר מ-8@tie{}KiB ועד 64@tie{}KiB של זיכרון תוכנית.
מקו@tie{}= "atxmega16a4", "atxmega16d4", "atxmega16x1", "atxmega32a4",
"atxmega32d4", "atxmega32x1".

"avrxmega4"
מכשירי "XMEGA" עם יותר מ-64@tie{}KiB ועד 128@tie{}KiB של תוכנית
זיכרון. מקו@tie{}= "atxmega64a3", "atxmega64d3".

"avrxmega5"
מכשירי "XMEGA" עם יותר מ-64@tie{}KiB ועד 128@tie{}KiB של תוכנית
זיכרון ויותר מ-64@tie{}KiB של זיכרון RAM. מקו@tie{}= "atxmega64a1",
"atxmega64a1u".

"avrxmega6"
התקני "XMEGA" עם יותר מ-128@tie{}KiB של זיכרון תוכניות. מקו@tie{}=
"atxmega128a3", "atxmega128d3", "atxmega192a3", "atxmega192d3", "atxmega256a3",
"atxmega256a3b", "atxmega256a3bu", "atxmega256d3".

"avrxmega7"
התקני "XMEGA" עם יותר מ-128@tie{}KiB של זיכרון תוכניות ויותר מ
64@tie{}KiB של זיכרון RAM. מקו@tie{}= "atxmega128a1", "atxmega128a1u".

"avr1"
ISA זה מיושם על ידי ליבת AVR המינימלית ונתמך עבור assembler בלבד.
מקו@tie{}= "attiny11", "attiny12", "attiny15", "attiny28", "at90s1200".

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

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

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

-brranch-cost=עלות
הגדר את עלויות הסניף עבור הוראות סניף מותנות ל עלות. ערכים סבירים
ל עלות הם מספרים שלמים קטנים ולא שליליים. עלות הסניף המוגדרת כברירת מחדל היא 0.

-mcall-פרולוגים
פונקציות פרולוגים/אפילוגים מורחבים כקריאות לתתי שגרות מתאימות. קוד
הגודל קטן יותר.

-מנטה8
נניח ש"int" הוא מספר שלם של 8 סיביות. זה משפיע על הגדלים של כל הסוגים: "char" הוא 1
בייט, "int" הוא 1 בייט, "long" הוא 2 בתים, ו-"long long" הוא 4 בתים. אנא
שים לב שאופציה זו אינה תואמת את תקני C, אך היא מביאה לקטן יותר
גודל קוד.

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

-להירגע
נסה להחליף "CALL" בהתאמה. הוראת "JMP" על ידי ה"RCALL" הקצר יותר. "RJMP"
הוראה אם ​​רלוונטית. הגדרת "-mrelax" רק מוסיפה את האפשרות "--relax" ל-
שורת הפקודה מקשר כאשר קוראים למקשר.

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

יש להפעיל את ההרגעה אם יש צורך בסתמי קישור, ראה סעיף על "EIND" ו
בדלי קישור למטה.

-שיחות קצרות
אפשרות זו הוצאה משימוש והיא תוסר ב-GCC 4.8. ראה "-mrelax" עבור א
תחליף.

השתמש בהוראות "RCALL"/"RJMP" אפילו במכשירים עם תוכנית 16@tie{}KiB או יותר
זיכרון, כלומר במכשירים בעלי הוראות "CALL" ו-"JMP".

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

אפשרות זו משמשת באופן פנימי על ידי המהדר כדי לבחור ולבנות עבורם multilibs
ארכיטקטורות "avr2" ו-"avr25". ארכיטקטורות אלו מערבבות מכשירים עם ובלי
"SPH". עבור כל הגדרה שאינה "-mmcu=avr2" או "-mmcu=avr25" מנהל ההדר
יוסיף או יסיר אפשרות זו משורת הפקודה של המהדר, מכיוון ש-
מהדר אז יודע אם למכשיר או לארכיטקטורה יש מצביע מחסנית של 8 סיביות וכך
אין רישום "SPH" או לא.

-mstrict-X
השתמש ברישום הכתובות "X" באופן שהוצע על ידי החומרה. זה אומר ש"X" הוא
משמש רק בכתובת עקיפה, לאחר תוספת או לפני ירידה.

ללא אפשרות זו, ניתן להשתמש ברישום "X" באותו אופן כמו "Y" או "Z" אשר
לאחר מכן מחקה על ידי הוראות נוספות. לדוגמה, טעינת ערך עם
"X+const" מפנה עם "const < 64" קטן לא שלילי לרישום Rn is
בוצע כ

adiw r26, const; X += const
ld , איקס ; = *X
sbiw r26, const; X -= קונסט

-mtiny-stack
שנה רק את 8@tie{}הסיביות התחתונות של מצביע המחסנית.

"EIND" ומכשירים עם יותר מ-128 Ki Bytes של פלאש

המצביעים ביישום הם ברוחב של 16@tie{}סיביות. הכתובת של פונקציה או תווית
מיוצג ככתובת מילה כך שקפיצות ושיחות עקיפות יכולות למקד לכל קוד
כתובת בטווח של 64@tie{}מילים קי.

על מנת לאפשר קפיצה עקיפה למכשירים עם יותר מ-128@tie{}Ki bytes של
שטח זיכרון תוכנית, קיים אוגר פונקציות מיוחד בשם "EIND" המשמש כ
החלק המשמעותי ביותר של כתובת היעד כאשר הוראות "EICALL" או "EIJMP".
מְשׁוּמָשׁ.

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

· המהדר אף פעם לא מגדיר "EIND".

· המהדר משתמש ב-"EIND" באופן מרומז בהוראות "EICALL"/"EIJMP" או עשוי לקרוא
"EIND" ישירות על מנת לחקות קריאה/קפיצה עקיפה באמצעות "RET"
הוראה.

· המהדר מניח ש"EIND" לעולם לא משתנה במהלך קוד האתחול או במהלך
יישום. בפרט, "EIND" אינו נשמר/שוחזר בתפקוד או בפסיקה
פרולוג/אפילוג שגרתי שירות.

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

· יש להפעיל הרפיית קישור כך שהמקשר יפיק את הסטאבים
כהלכה מצב הכל. ראה את אפשרות המהדר "-mrelax" ואת אפשרות ה-linler
"--לְהִרָגַע". ישנם מקרים פינתיים שבהם המקשר אמור ליצור בדל אבל
מפסיק ללא הרפיה וללא הודעת שגיאה מועילה.

· סקריפט המקשר המוגדר כברירת מחדל מסודר לקוד עם "EIND = 0". אם קוד אמור
כדי לעבוד עבור הגדרה עם "EIND != 0", יש להשתמש בסקריפט קישור מותאם אישית לפי הסדר
למקם את הקטעים ששמם מתחיל ב-".טרמפולינות" לתוך הקטע שבו
"EIND" מצביע על.

· קוד האתחול מ-libgcc אף פעם לא מגדיר "EIND". שימו לב שקוד ההפעלה הוא שילוב
של קוד מ-libgcc ו-AVR-LibC. להשפעה של AVR-LibC על "EIND", ראה את AVR-
מדריך למשתמש LibC ("http://nongnu.org/avr-libc/user-manual/").

· זה לגיטימי עבור קוד הפעלה ספציפי למשתמש להגדיר את "EIND" מוקדם, למשל על ידי
אמצעי אתחול קוד הממוקם בסעיף ".init3". קוד כזה פועל לפני
קוד הפעלה כללי שמאתחל את זיכרון ה-RAM וקורא לבנאים, אך לאחר ה-bit of
קוד הפעלה מ-AVR-LibC שמגדיר "EIND" למקטע שבו נמצאת הטבלה הוקטורית
ממוקם.

#לִכלוֹל

חלל סטטי
__attribute__((section(".init3"),naked,used,no_instrument_function))
init3_set_eind (ריק)
{
__asm ​​volatile ("ldi r24,pm_hh8(__trampolines_start)\n\t"
"out %i0,r24" :: "n" (&EIND) : "r24","memory");
}

הסמל "__trampolines_start" מוגדר בסקריפט המקשר.

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

-
(קיצור ל ליצור תלים) ככה:

LDI r24, lo8(gs( ))
LDI r25, hi8(gs( ))

-
בחוץ הקטע שבו נמצאים הבדלים.

· המהדר פולט מתני "gs" כאלה עבור תוויות קוד במצבים הבאים:

-
-
- -mcall-פרולוגים>
אפשרות שורת פקודה.

-
טבלאות שאתה יכול לציין את -fno-jump-tables אפשרות שורת פקודה.

-
-
· קפיצה לכתובות לא סמליות כמו כך לֹא נתמך:

int main (ריק)
{
/* התקשר לפונקציה בכתובת המילה 0x2 */
return ((int(*)(void)) 0x2)();
}

במקום זאת, יש להגדיר בדל, כלומר יש לקרוא לפונקציה באמצעות סמל
("func_4" בדוגמה):

int main (ריק)
{
extern int func_4 (ריק);

/* פונקציית התקשרות בכתובת בייט 0x4 ​​*/
החזר func_4();
}

והאפליקציה תהיה מקושרת עם "-Wl,--defsym,func_4=0x4". לחלופין, "func_4"
ניתן להגדיר בסקריפט המקשר.

טיפול בפנקסי הפונקציות המיוחדות "RAMPD", "RAMPX", "RAMPY" ו-"RAMPZ"

חלק ממכשירי הרסיבר תומכים בזיכרונות גדולים יותר מטווח 64@tie{}KiB שניתן לגשת אליו
עם מצביעים של 16 סיביות. כדי לגשת למיקומי זיכרון מחוץ לטווח 64@tie{}KiB הזה, ה
התוכן של אוגר "RAMP" משמש כחלק גבוה של הכתובת: ה-"X", "Y", "Z"
אוגר הכתובות משורשר עם הפונקציה המיוחדת "RAMPX", "RAMPY", "RAMPZ".
הירשם, בהתאמה, כדי לקבל כתובת רחבה. באופן דומה, "RAMPD" משמש יחד עם
פנייה ישירה.

· קוד האתחול מאתחל את אוגרי הפונקציה המיוחדת "RAMP" באפס.

· אם AVR שם כתובת רווחים, בשם כתובת שטח מלבד גנרי או "__flash" הוא
בשימוש, אז "RAMPZ" מוגדר לפי הצורך לפני הפעולה.

· אם המכשיר תומך בזיכרון RAM גדול מ-64@tie{KiB} והקומפיילר צריך להשתנות
"RAMPZ" כדי לבצע פעולה, "RAMPZ" מאופס לאפס לאחר הפעולה.

· אם המכשיר מגיע עם אוגר "RAMP" ספציפי, הפרולוג/אפילוג של ISR
שומר/משחזר את ה-SFR הזה ומאתחל אותו באפס למקרה שקוד ה-ISR עלול
(במרומז) להשתמש בו.

· זיכרון RAM גדול מ-64@tie{KiB} אינו נתמך על ידי GCC עבור יעדי AVR. אם אתה משתמש
אסמבלר מוטבע כדי לקרוא ממיקומים מחוץ לטווח הכתובות של 16 סיביות ולשנות
אחד מהאוגרים של "RAMP", עליך לאפס אותו לאפס לאחר הגישה.

AVR מובנים מאקרו

GCC מגדיר מספר פקודות מאקרו מובנות כך שקוד המשתמש יכול לבדוק את הנוכחות או
היעדר תכונות. כמעט כל אחת מהפקודות המאקרו המובנות הבאות נגזרת מהמכשיר
יכולות ובכך מופעלות על ידי אפשרות שורת הפקודה "-mmcu=".

לעוד יותר פקודות מאקרו מובנות ספציפיות לרסיבר ראה AVR שם כתובת רווחים ו AVR Built-in
פונקציות.

"__AVR_ARCH__"
מאקרו מובנה שפותר למספר עשרוני המזהה את הארכיטקטורה ו
תלוי ב-"-mmcu=mcu" אוֹפְּצִיָה. ערכים אפשריים הם:

2, 25, 3, 31, 35, 4, 5, 51, 6, 102, 104, 105, 106, 107

ל מקו="avr2", "avr25", "avr3", "avr31", "avr35", "avr4", "avr5", "avr51", "avr6",
"avrxmega2", "avrxmega4", "avrxmega5", "avrxmega6", "avrxmega7", בהתאמה. אם מקו
מציין מכשיר, מאקרו מובנה זה מוגדר בהתאם. למשל, עם
"-mmcu=atmega8" המאקרו יוגדר ל-4.

"__AVR_מכשיר__"
הגדרת "-mmcu=התקן" מגדיר מאקרו מובנה זה המשקף את שם המכשיר.
לדוגמה, "-mmcu=atmega8" מגדיר את המאקרו המובנה "__AVR_ATmega8__",
"-mmcu=attiny261a" מגדיר "__AVR_ATtiny261A__", וכו'.

שמות פקודות המאקרו המובנות עוקבים אחר הסכימה "__AVR_מכשיר__" איפה מכשיר האם ה
שם המכשיר כמו ממדריך למשתמש של הרסיבר. ההבדל בין מכשיר במובנה
מאקרו ו מכשיר ב-"-mmcu=התקן" הוא שהאחרון הוא תמיד באותיות קטנות.

If מכשיר אינו מכשיר אלא רק ארכיטקטורת ליבה כמו "avr51", המאקרו הזה יעשה זאת
לא להיות מוגדר.

"__AVR_XMEGA__"
המכשיר/ארכיטקטורה שייכים למשפחת המכשירים XMEGA.

"__AVR_HAVE_ELPM__"
למכשיר יש את הוראת "ELPM".

"__AVR_HAVE_ELPMX__"
למכשיר יש את "ELPM Rn,Z" ו"ELPM Rn,Z+" הוראות.

"__AVR_HAVE_MOVW__"
למכשיר יש את ההוראה "MOVW" לבצע מהלכי אוגר-אוגר של 16 סיביות.

"__AVR_HAVE_LPMX__"
למכשיר יש את "LPM Rn,Z" ו"LPM Rn,Z+" הוראות.

"__AVR_HAVE_MUL__"
למכשיר יש מכפיל חומרה.

"__AVR_HAVE_JMP_CALL__"
למכשיר יש את ההוראות "JMP" ו-"CALL". זה המקרה עבור מכשירים עם
לפחות 16@tie{}KiB של זיכרון תוכנית ואם "-mshort-calls" לא מוגדר.

"__AVR_HAVE_EIJMP_EICALL__"
"__AVR_3_BYTE_PC__"
למכשיר יש את ההוראות "EIJMP" ו-"EICALL". זה המצב לגבי מכשירים
עם יותר מ-128@tie{}KiB של זיכרון תוכנית. זה גם אומר שהתוכנית
מונה (PC) הוא ברוחב של 3@tie{}בתים.

"__AVR_2_BYTE_PC__"
מונה התוכניות (PC) הוא ברוחב של 2@tie{}בתים. זה המקרה עבור מכשירים עם עד
128@tie{}KiB של זיכרון תוכנית.

"__AVR_HAVE_8BIT_SP__"
"__AVR_HAVE_16BIT_SP__"
האוגר מצביע מחסנית (SP) מטופל כאוגר של 8 סיביות בהתאמה של 16 סיביות על ידי
המהדר. ההגדרה של פקודות מאקרו אלו מושפעת מ-"-mtiny-stack".

"__AVR_HAVE_SPH__"
"__AVR_SP8__"
למכשיר יש את פנקס הפונקציות המיוחד SPH (חלק גבוה של מחסנית) או יש
מצביע מחסנית של 8 סיביות, בהתאמה. ההגדרה של פקודות מאקרו אלו מושפעת מ
"-mmcu=" ובמקרים של "-mmcu=avr2" ו-"-mmcu=avr25" גם על-ידי "-msp8".

"__AVR_HAVE_RAMPD__"
"__AVR_HAVE_RAMPX__"
"__AVR_HAVE_RAMPY__"
"__AVR_HAVE_RAMPZ__"
למכשיר יש את פנקס הפונקציות המיוחדות "RAMPD", "RAMPX", "RAMPY", "RAMPZ",
בהתאמה.

"__NO_INTERRUPTS__"
מאקרו זה משקף את אפשרות שורת הפקודה "-mno-interrupts".

"__AVR_ERRATA_SKIP__"
"__AVR_ERRATA_SKIP_JMP_CALL__"
לחלק מהתקני רסיבר (AT90S8515, ATmega103) אסור לדלג על הוראות של 32 סיביות בגלל
תקלה בחומרה. הוראות הדילוג הן "SBRS", "SBRC", "SBIS", "SBIC" ו-"CPSE".
המאקרו השני מוגדר רק אם "__AVR_HAVE_JMP_CALL__" מוגדר גם כן.

"__AVR_SFR_OFFSET__=לְקַזֵז"
הוראות שיכולות להתייחס ישירות ל-I/O פונקציות מיוחדות כמו "IN",
"OUT", "SBI" וכו' עשויים להשתמש בכתובת אחרת כאילו מועברת בהוראה אל
גישה ל-RAM כמו "LD" או "STS". היסט זה תלוי בארכיטקטורת המכשיר ויש לו
לחסר מכתובת ה-RAM כדי לקבל את כתובת ה-I/O@tie{} המתאימה.

"__WITH_AVRLIBC__"
המהדר מוגדר לשימוש יחד עם AVR-Libc. ראה את
אפשרות תצורה של "--with-avrlibc".

שחור אפשרויות

-mcpu=מעבד[-סירטוויזיון]
מציין את השם של מעבד היעד Blackfin. כַּיוֹם, מעבד יכול להיות אחד מ
bf512, bf514, bf516, bf518, bf522, bf523, bf524, bf525, bf526, bf527, bf531, bf532,
bf533, bf534, bf536, bf537, bf538, bf539, bf542, bf544, bf547, bf548, bf549, bf542m,
bf544m, bf547m, bf548m, bf549m, bf561, bf592. האופציונלי סירטוויזיון מציין את
עדכון סיליקון של מעבד Blackfin היעד. כל דרכים לעקיפת הבעיה הזמינות עבור
תיקון סיליקון ממוקד תופעל. אם סירטוויזיון is אף לא אחד, אין דרכים לעקיפת הבעיה
מופעל. אם סירטוויזיון is כל, כל הדרכים לעקיפת המעבד המיועד יהיו
מופעל. המאקרו "__SILICON_REVISION__" מוגדר לשתי ספרות הקסדצימליות
המייצגים את המספרים העיקריים והקטנים ברוויזיית הסיליקון. אם סירטוויזיון is
אף לא אחד, ה-"__SILICON_REVISION__" אינו מוגדר. אם סירטוויזיון is כל, ה
"__SILICON_REVISION__" מוגדר כ-0xffff. אם זה אופציונלי סירטוויזיון לא
בשימוש, GCC מניח את הגרסה האחרונה הידועה של סיליקון של Blackfin הממוקד
מעבד.

תמיכה bf561 אינו שלם. ל bf561, רק מאקרו המעבד מוגדר.
ללא אפשרות זו, bf532 משמש כמעבד כברירת מחדל. המקביל
פקודות מאקרו של מעבד מוגדרות מראש עבור מעבד יש להגדיר. ועבור bfin-elf שרשרת כלים,
זה גורם ל-BSP החומרה שסופק על ידי libgloss להיות מקושר ב-if -מסים לא
נָתוּן.

-מסים
מציין שהתוכנית תופעל בסימולטור. זה גורם לסימולטור
BSP מסופק על ידי libgloss לקישור. אפשרות זו משפיעה רק על bfin-elf
שרשרת כלים. אפשרויות מסוימות אחרות, כגון -אמצע הספרייה המשותפת ו -mfdpic, רומז
-מסים.

-momit-leaf-frame-pointer
אל תשמור את מצביע המסגרת בפנקס עבור פונקציות עלים. זה נמנע את
הוראות לשמירה, הגדרה ושחזור של מצביעי מסגרת ועושה רישום נוסף
זמין בפונקציות עלים. האפשרות -fomit-frame-pointer מסיר את המסגרת
מצביע עבור כל הפונקציות, מה שעשוי להקשות על ניפוי באגים.

-mspekld-anomaly
כאשר הוא מופעל, המהדר יבטיח שהקוד שנוצר אינו מכיל
עומסים ספקולטיביים לאחר הוראות קפיצה. אם נעשה שימוש באפשרות זו,
"__WORKAROUND_SPECULATIVE_LOADS" מוגדר.

-mno-specld-anomaly
אל תיצור קוד נוסף כדי למנוע עומסים ספקולטיביים להתרחש.

-mcsync-anomaly
כאשר הוא מופעל, המהדר יבטיח שהקוד שנוצר אינו מכיל CSYNC
או הוראות SSYNC מוקדם מדי לאחר סניפים מותנים. אם נעשה שימוש באפשרות זו,
"__WORKAROUND_SPECULATIVE_SYNCS" מוגדר.

-mno-csync-anomaly
אל תיצור קוד נוסף כדי למנוע גם מהוראות CSYNC או SSYNC
זמן קצר לאחר סניף מותנה.

-חלב-64k
כאשר הוא מופעל, המהדר חופשי לנצל את הידע שכולו
התוכנית מתאימה לזיכרון הנמוך של 64k.

-mno-low-64k
נניח שהתוכנית גדולה באופן שרירותי. זוהי ברירת המחדל.

-mstack-check-l1
בצע בדיקת ערימה באמצעות מידע שהוכנס לזיכרון L1 של משטח השרטוט על ידי ה-uClinux
גַרעִין.

-אמצע הספרייה המשותפת
צור קוד התומך בספריות משותפות באמצעות שיטת מזהה הספרייה. זה מאפשר
לביצוע במקום וספריות משותפות בסביבה ללא זיכרון וירטואלי
הַנהָלָה. אפשרות זו מרמזת -fPIC. עם bfin-elf יעד, אפשרות זו מרמזת
-מסים.

-mno-id-shared-library
צור קוד שאינו מניח שמשתמשים בספריות משותפות מבוססות מזהה. זה
ברירת המחדל.

-mleaf-id-shared-library
צור קוד שתומך בספריות משותפות באמצעות שיטת מזהה הספרייה, אך מניח
שהספרייה או קובץ ההפעלה הזה לא יקשרו עם ספריות משותפות אחרות של מזהה.
זה מאפשר למהדר להשתמש בקוד מהיר יותר לקפיצות ושיחות.

-mno-leaf-id-shared-library
אל תניח שהקוד הנערך לא יקשר אל ספריות משותפות של מזהים כלשהם.
יווצר קוד איטי יותר עבור כניסות קפיצה והתקשרות.

-mshared-library-id=n
ציין את מספר הזיהוי של הספרייה המשותפת המבוססת על מזהה הנערך.
ציון ערך של 0 ייצור קוד קומפקטי יותר, ציון ערכים אחרים ייצור
לכפות את הקצאת המספר הזה לספרייה הנוכחית אבל אין יותר מקום או
זמן יעיל מאשר השמטת אפשרות זו.

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

-mno-sep-data
צור קוד שמניח שקטע הנתונים עוקב אחר קטע הטקסט. זה
ברירת המחדל.

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

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

-mfast-fp
קישור עם ספריית הנקודה הצפה המהירה. ספריה זו מרגיעה חלק מה-IEEE
הכללים של תקן נקודה צפה לבדיקת תשומות מול Not-a-Number (NAN), ב-
אינטרס של ביצועים.

-minline-plt
אפשר הטמעה של ערכי PLT בקריאות פונקציה לפונקציות שאינן מוכרות להן
לאגד באופן מקומי. אין לזה השפעה בלי -mfdpic.

-רב ליבות
בנו אפליקציה עצמאית למעבד Blackfin מרובה ליבות. קבצי התחלה תקינים ו
סקריפטים של קישור ישמשו לתמיכה בריבוי ליבות. אפשרות זו מגדירה
"__BFIN_MULTICORE". ניתן להשתמש בו רק עם -mcpu=bf561[-סירטוויזיון]. ניתן להשתמש בו
עם -mcorea or -מקורב. אם משתמשים בו בלי -mcorea or -מקורב, יחיד
נעשה שימוש במודל תכנות יישומים/ליבה כפולה. במודל זה, הפונקציה העיקרית של
ליבה B צריכה להיקרא coreb_main. אם משתמשים בו עם -mcorea or -מקורב, אחד
נעשה שימוש ביישום לכל מודל תכנות ליבה. אם אפשרות זו אינה בשימוש, יחיד
נעשה שימוש במודל תכנות יישומים הליבה.

-mcorea
בנו אפליקציה עצמאית עבור Core A של BF561 בעת שימוש באפליקציה אחת לכל ליבה
מודל תכנות. קבצי התחלה תקינים וסקריפטים של קישור ישמשו לתמיכה ב-Core A.
אפשרות זו מגדירה "__BFIN_COREA". יש להשתמש בו עם -רב ליבות.

-מקורב
בנה אפליקציה עצמאית עבור Core B של BF561 בעת שימוש באפליקציה אחת לכל ליבה
מודל תכנות. קבצי התחלה תקינים וסקריפטים של קישור ישמשו לתמיכה ב-Core B.
אפשרות זו מגדירה "__BFIN_COREB". כאשר משתמשים באפשרות זו, coreb_main צריך להיות
בשימוש במקום הראשי. יש להשתמש בו עם -רב ליבות.

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

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

C6X אפשרויות

-מרץ=שם
זה מציין את השם של ארכיטקטורת היעד. GCC משתמש בשם זה כדי לקבוע
איזה סוג של הוראות הוא יכול לפלוט בעת יצירת קוד הרכבה. מוּתָר
השמות הם: c62x, c64x, c64x+, c67x, c67x+, c674x.

-mbig-endian
צור קוד עבור יעד גדול.

-מעט-אנדיאן
צור קוד עבור יעד קטן. זוהי ברירת המחדל.

-מסים
בחר קבצי הפעלה וסקריפט קישור מתאים לסימולטור.

-msdata = ברירת מחדל
שים נתונים גלובליים וסטטיים קטנים ב- .neardata סעיף, אשר מצביע על ידי
רשום "B14". שים נתונים גלובליים וסטטיים קטנים לא מאותחלים ב- .bss סָעִיף,
אשר צמוד ל .neardata סָעִיף. הכנס נתונים קטנים לקריאה בלבד לתוך .rodata
סָעִיף. הקטעים המקבילים המשמשים עבור פיסות נתונים גדולות הם .fardata, .רָחוֹק
ו .const.

-msdata=הכל
שים את כל הנתונים, לא רק אובייקטים קטנים, בקטעים השמורים לנתונים קטנים, ו
השתמש בכתובת ביחס לרשום "B14" כדי לגשת אליהם.

-msdata=אין
אל תעשה שימוש בקטעים השמורים לנתונים קטנים, והשתמש בכתובות מוחלטות כדי
לגשת לכל הנתונים. שים את כל הנתונים הגלובאליים והסטטיים המאותחלים ב- .fardata סָעִיף,
וכל הנתונים הלא מאותחלים ב- .רָחוֹק סָעִיף. שים את כל הנתונים הקבועים לתוך .const
סָעִיף.

Cris אפשרויות

אפשרויות אלו מוגדרות במיוחד עבור יציאות CRIS.

-מרץ=סוג אדריכלות
-mcpu=סוג אדריכלות
צור קוד עבור הארכיטקטורה שצוינה. הבחירות עבור סוג אדריכלות יש לו
v3, v8 ו v10 עבור ETRAX 4, ETRAX 100 ו-ETRAX 100 LX בהתאמה. ברירת המחדל היא v0
מלבד cris-axis-linux-gnu, שם ברירת המחדל היא v10.

-mtune=סוג אדריכלות
כוון ל סוג אדריכלות כל מה שישים לגבי הקוד שנוצר, למעט
ה-ABI וקבוצת ההוראות הזמינות. הבחירות עבור סוג אדריכלות יש לו
אותו דבר כמו עבור -מרץ=סוג אדריכלות.

-mmax-stack-frame=n
אזהרה כאשר מסגרת המחסנית של פונקציה חורגת n בתים.

-מטרקס4
-מטרקס100
האפשרויות -מטרקס4 ו -מטרקס100 הן מילים נרדפות ל -מרץ=v3 ו -מרץ=v8
בהתאמה.

-mmul-bug-around
-mno-mul-bug-around
עקוף באג בהוראות "muls" ו-"mulu" עבור דגמי CPU שבהם הוא
חל. אפשרות זו פעילה כברירת מחדל.

-mpdebug
אפשר מידע מפורט על ניפוי באגים ספציפי ל-CRIS בקוד ה-assembly. זֶה
לאפשרות יש גם את האפקט לכבות את #NO_APP מחוון קוד מעוצב ל-
assembler בתחילת קובץ ההרכבה.

-mcc-init
אל תשתמש בתוצאות קוד מצב מהוראה קודמת; תמיד פולט השווה ו
הוראות בדיקה לפני השימוש בקודי מצב.

-mno-תופעות לוואי
אין לפלוט הוראות עם תופעות לוואי במצבי התייחסות מלבד לאחר
תוֹסֶפֶת.

-mstack-align
-mno-stack-align
-mdata-align
-mno-data-align
-mconst-align
-mno-const-align
אפשרויות אלה (ללא אפשרויות) מסדרות (לבטל סידורים) עבור מסגרת המחסנית,
נתונים בודדים וקבועים שיש ליישור לגודל הגישה המקסימלית לנתונים בודדים
עבור דגם המעבד הנבחר. ברירת המחדל היא לארגן יישור של 32 סיביות. ABI
פרטים כגון פריסת המבנה אינם מושפעים מהאפשרויות הללו.

-m32-bit
-m16-bit
-m8-bit
בדומה לאפשרויות מחסנית-נתונים ו-const-align שלמעלה, אפשרויות אלו מתאימות
נתונים סטאק-פריים, ניתנים לכתיבה וקבועים שיהיו כולם מיושרים ב-32 סיביות, 16 סיביות או 8 סיביות.
ברירת המחדל היא יישור של 32 סיביות.

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

-mno-gotplt
-mgotplt
עם -fpic ו -fPIC, אל תיצור (תייצר) רצפי הוראות שנטענים
כתובות עבור פונקציות מחלק ה-PLT של GOT ולא (מסורתי באחר
ארכיטקטורות) קריאות ל-PLT. ברירת המחדל היא -mgotplt.

-מלף
אפשרות ללא הפעלה מדור קודם מזוהה רק עם ה-cris-axis-elf ו-cris-axis-linux-gnu
מטרות.

-mlinux
אפשרות מדור קודם ללא הפעלה מזוהה רק עם היעד cris-axis-linux-gnu.

-סים
אפשרות זו, המוכרת עבור ה-cris-axis-elf, מסדרת קישור עם קלט-פלט
פונקציות מספריית סימולטור. קוד, נתונים מאתחלים ונתונים מאתחלים אפס
מוקצים ברציפות.

-sim2
כמו -סים, אבל העבר אפשרויות קישור לאיתור נתונים מאתחלים ב-0x40000000 ואפס-
נתונים מאתחלים ב-0x80000000.

CR16 אפשרויות

אפשרויות אלו מוגדרות במיוחד עבור יציאות CR16.

-ממק
אפשר את השימוש בהוראות כפל-צבור. מושבת כברירת מחדל.

-mcr16cplus
-mcr16c
צור קוד עבור ארכיטקטורת CR16C או CR16C+. ארכיטקטורת CR16C+ היא ברירת מחדל.

-מסים
מקשר את הספרייה libsim.a אשר תואמת לסימולטור. חל על שדון
מהדר בלבד.

-מנטה32
בחר סוג מספר שלם ברוחב של 32 סיביות.

-mbit-ops
יוצר הוראות sbit/cbit עבור מניפולציות של סיביות.

-mdata-model=מודל
בחר מודל נתונים. הבחירות עבור מודל יש לו ליד, רחוק or בינוני. בינוני הוא ברירת מחדל.
עם זאת, רחוק אינו חוקי כאשר האפשרות -mcr16c נבחרה מכיוון שארכיטקטורת CR16C אינה
תמיכה במודל נתונים רחוק.

דרווין אפשרויות

אפשרויות אלו מוגדרות עבור כל הארכיטקטורות המרצות את מערכת ההפעלה Darwin.

FSF GCC על דרווין אינו יוצר קבצי אובייקט "שמנים"; זה יצור קובץ אובייקט עבור
הארכיטקטורה היחידה שהיא נבנתה להתמקד בה. ה-GCC של אפל על דארווין אכן יוצר
קבצים "שמנים" אם הם מרובים -קֶשֶׁת נעשה שימוש באפשרויות; הוא עושה זאת על ידי הפעלת המהדר או
מקשר מספר פעמים ומצרף את התוצאות יחד עם ליפו.

תת-הסוג של הקובץ שנוצר (כמו ppc7400 or ppc970 or i686) נקבע על ידי
דגלים המציינים את ה-ISA ש-GCC מכוון אליו, כמו -mcpu or -מרץ. ה
-force_cpusubtype_ALL ניתן להשתמש באפשרות כדי לעקוף זאת.

הכלים של דארווין משתנים בהתנהגותם כאשר מוצגים להם חוסר התאמה של ISA. ה
מאסף, as, יאפשר רק שימוש בהוראות שתקפות עבור תת-הסוג של
הקובץ שהוא מייצר, אז אתה לא יכול לשים הוראות 64 סיביות ב-a ppc750 קובץ אובייקט.
המקשר לספריות משותפות, /usr/bin/libtool, ייכשל וידפיס שגיאה אם ​​תתבקש
כדי ליצור ספרייה משותפת עם תת-סוג פחות מגביל מקובצי הקלט שלה (עבור
למשל, מנסה לשים א ppc970 קובץ אובייקט ב-a ppc7400 סִפְרִיָה). המקשר עבור
קובצי הפעלה, ld, ייתן בשקט לקובץ ההפעלה את תת-הסוג המגביל ביותר מכל אחד מהם
קבצי הקלט שלו.

-Fdir
הוסף את ספריית המסגרת dir לראש רשימת הספריות שיש לחפש
עבור קבצי כותרות. ספריות אלה משולבות עם אלה שצוינו על ידי -I
אפשרויות ונסרקות בסדר משמאל לימין.

ספריית פריימים היא ספרייה עם מסגרות בתוכה. מסגרת היא א
ספרייה עם א "כותרות" ו / או "PrivateHeaders" ספרייה הכלולה ישירות בו
שמסתיים ב ".מִסגֶרֶת". שם המסגרת הוא השם של ספרייה זו
לא כולל את ".מִסגֶרֶת". כותרות המשויכות למסגרת נמצאות באחת מהן
שתי המדריכים האלה, עם "כותרות" חיפוש ראשון. מסגרת משנה היא א
ספריית framework שנמצאת ב-framework של "מסגרות" מַדרִיך. כולל של
כותרות תת-מסגרת יכולות להופיע רק בכותרת של מסגרת המכילה את
תת מסגרת, או בכותרת משנה של מסגרת משנה. שתי מסגרות משנה הן אחים אם
הם מתרחשים באותה מסגרת. תת-מסגרת לא צריך להיות שם זהה לזה של a
מסגרת, תינתן אזהרה אם זו תופר. כרגע תת-מסגרת
לא יכול להיות מסגרת משנה, בעתיד, המנגנון עשוי להיות מורחב לתמיכה
זֶה. ניתן למצוא את המסגרות הסטנדרטיות ב "/System/Library/Frameworks" ו
"/ספרייה/מסגרות". דוגמה ל-include נראית כמו "#include ",
איפה מסגרת מציין את שם המסגרת ו-header.h נמצא ב-
"PrivateHeaders" or "כותרות" במדריך.

-iframeworkdir
כמו -F אלא שהספרייה מטופלת כאל ספריית מערכת. ההבדל העיקרי
בין זה -iframework ו -F האם זה עם -iframework המהדר לא מזהיר
אודות מבנים הכלולים בתוך קבצי כותרות שנמצאו באמצעות dir. אפשרות זו תקפה
רק למשפחת השפות C.

נחש
פלט מידע ניפוי באגים עבור סמלים שבהם נעשה שימוש. עבור פורמט ניפוי באגים STABS,
זה מאפשר סמלים-feliminate-unused-debug-symbols. זה כברירת מחדל מופעל.

-מלא
פלט מידע ניפוי באגים עבור כל הסמלים והסוגים.

-mmacosx-version-min=גרסה
הגרסה המוקדמת ביותר של MacOS X שעליה ירוץ קובץ ההפעלה הזה היא גרסה. אופייני
ערכים של גרסה כוללים את 10.1, 10.2 ו-10.3.9.

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

-מקרנל
אפשר מצב פיתוח ליבה. ה -מקרנל ערכות אפשרויות -סטָטִי, -fno-נפוץ,
-fno-cxa-atexit, -fno-חריגים, -fno-non-call-exceptions, -fapple-kext, -fno-חלש
ו -fno-rtti במקרים רלוונטיים. מצב זה גם קובע -mno-altivec, -msoft-float,
-fno-builtin ו -מלונג-ענף עבור יעדי PowerPC.

-mone-byte-bool
עוקף את ברירות המחדל עבור bool כדי ש sizeof(bool)==1. כברירת מחדל sizeof(bool) is 4
בעת קומפילציה עבור Darwin/PowerPC ו 1 בעת קומפילציה עבור Darwin/x86, אז אפשרות זו
אין השפעה על x86.

אַזהָרָה: אל האני -mone-byte-bool switch גורם ל-GCC ליצור קוד שאינו בינארי
תואם לקוד שנוצר ללא המתג הזה. שימוש במתג זה עשוי לדרוש
קומפילציה מחדש של כל המודולים האחרים בתוכנית, כולל ספריות מערכת. השתמש בזה
לעבור כדי להתאים למודל נתונים שאינו ברירת מחדל.

-mfix-and-continue
-תקן-ו-המשך
-finddirect-נתונים
צור קוד מתאים לפיתוח מהיר. נדרש כדי להפעיל את gdb ל
טען באופן דינמי קבצי ".o" לתוכניות שכבר פועלות. -finddirect-נתונים ו
-תקן-ו-המשך מסופקים עבור תאימות לאחור.

-כל_עומס
טוען את כל החברים בספריות ארכיון סטטי. ראה גבר ld(1) למידע נוסף.

-arch_errors_fatal
גורם לשגיאות הקשורות לקבצים שיש להם ארכיטקטורה שגויה להיות קטלניות.

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

-חבילה
הפק קובץ בפורמט חבילה של Mach-o. ראה גבר ld(1) למידע נוסף.

-bundle_loader הפעלה
אפשרות זו מציינת את הפעלה שיטען את קובץ הפלט ה-building
צָמוּד. ראה גבר ld(1) למידע נוסף.

-דינאמיליב
כאשר תעבור אפשרות זו, GCC יפיק ספרייה דינמית במקום קובץ הפעלה
בעת קישור, שימוש ב-Darwin libtool פקודה.

-force_cpusubtype_ALL
זה גורם לקובץ הפלט של GCC לקבל את הכל תת סוג, במקום אחד שנשלט על ידי
מה היא -mcpu or -מרץ אוֹפְּצִיָה.

-מותר_לקוח שם לקוח
-שם הלקוח
-גרסה_תאימות
-גרסה נוכחית
-רצועה_מתה
-תלות-קובץ
-dylib_file
-שם_התקנה_dylinker
-דִינָמִי
-רשימת_סמלים_מיוצאים
-רשימת קבצים
-שטח שם_flat
-force_flat_namespace
-headerpad_max_install_names
-תמונה_בסיס
-ניט
-שם_התקנה
-שמור_פרטי_externs
-מולטי_מודול
-מוגדר_הכפיל
-כפיל_ מוגדר_לא בשימוש
-noall_load
-אין_מתים_חפצים_ותנאים
-nofixprebinding
-נומולטידף
-noprebind
-noseglinkedit
-pagezero_size
-קשירה מראש
-prebind_all_twolevel_modules
-חבילה_פרטית
-קריאה בלבד_relocs
-סקטליין
-סמלי אובייקטים של כת
-למה לטעון
-seg1addr
-ליצור
-סמלי אובייקטים של כת
-מגזר
-סגדדר
-segs_read_only_addr
-segs_read_write_addr
-seg_addr_table
-seg_addr_table_filename
-seglinkedit
-סגפרוט
-segs_read_only_addr
-segs_read_write_addr
-יחיד_מודול
-סטָטִי
-ספריית_תת
-משנה_מטריה
-רווח_שם_שניים
-מִטְרִיָה
-לא מוגדר
-רשימת_סמלים_לא מיוצאים
-אי-התאמות_התייחסות_חלשה
-מה שנטען
אפשרויות אלו מועברות למקשר של דארווין. דף האיש של Darwin Linker מתאר
אותם בפירוט.

דצמבר אלפא אפשרויות

אלה -m אפשרויות מוגדרות עבור יישומי DEC Alpha:

-מנו-רך-צף
-msoft-float
השתמש (אל תשתמש) בהוראות החומרה לנקודה צפה עבור נקודה צפה
פעולות. מתי -msoft-float מצוין, מתפקד ב libgcc.a יהיה רגיל ל
לבצע פעולות נקודה צפה. אלא אם כן יוחלפו בשגרה שמחקה
את פעולות הנקודה הצפה, או הידור בצורה כזו שתקרא אמולציות כאלה
שגרות, שגרות אלו יוציאו פעולות נקודה צפה. אם אתה מקמפל
עבור אלפא ללא פעולות נקודה צפה, עליך לוודא שהספרייה כן
בנוי כדי לא לקרוא להם.

שים לב שיש צורך ביישום אלפא ללא פעולות נקודה צפה
אוגרי נקודה צפה.

-mfp-reg
-mno-fp-regs
צור קוד שמשתמש (אינו משתמש) בערכת האוגר של הנקודה הצפה. -mno-fp-regs
מרמז -msoft-float. אם לא נעשה שימוש בערכת הנקודה הצפה, נקודה צפה
אופרנדים מועברים באוגרים שלמים כאילו היו מספרים שלמים ונקודה צפה
התוצאות מועברות ב-$0 במקום ב-$f0. זהו רצף שיחות לא סטנדרטי, אז
כל פונקציה עם ארגומנט נקודה צפה או ערך החזרה שנקראת על ידי קוד קומפילציה
עם -mno-fp-regs חייב להיות מורכב גם עם אפשרות זו.

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

-מיי
ארכיטקטורת אלפא מיישמת חומרת נקודה צפה מותאמת למקסימום
ביצועים. הוא תואם בעיקר את תקן הנקודה הצפה IEEE. למרות זאת,
לתאימות מלאה, נדרש סיוע בתוכנה. אפשרות זו יוצרת קוד
קוד תואם IEEE לחלוטין אלא כי דגל לא מדויק אינו מתוחזק (ראה להלן).
אם אפשרות זו מופעלת, המאקרו הקדם-מעבד "_IEEE_FP" מוגדר במהלך
הַהדָרָה. הקוד המתקבל פחות יעיל אך מסוגל לתמוך בצורה נכונה
מספרים מפושטים וערכי IEEE יוצאי דופן כגון לא-מספר ופלוס/מינוס
אינסוף. מהדרים אחרים של אלפא קוראים לאפשרות הזו -איי_עם_לא_לא מדויק.

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

-mfp-trap-mode=מלכודת
אפשרות זו שולטת אילו מלכודות הקשורות לנקודה צפה מופעלות. אלפא אחר
מהדרים קוראים לאפשרות הזו -fptm מלכודת. ניתן להגדיר את מצב המלכודת לאחד מארבעה
ערכים:

n זוהי הגדרת ברירת המחדל (רגילה). המלכודות היחידות שמופעלות הן
כאלה שלא ניתן להשבית בתוכנה (למשל, חלוקה במלכודת אפס).

u בנוסף למלכודות המופעלות על ידי n, מלכודות תת זרימה מופעלות גם כן.

su כמו u, אך ההוראות מסומנות כבטוחות להשלמת תוכנה (ראה
מדריך אדריכלות אלפא לפרטים).

סווי כמו su, אבל מלכודות לא מדויקות מופעלות גם כן.

-mfp-rounding-mode=מצב עיגול
בוחר את מצב עיגול IEEE. מהדרים אחרים של אלפא קוראים לאפשרות הזו -fprm
מצב עיגול. ה מצב עיגול יכול להיות אחד מ:

n מצב עיגול IEEE רגיל. מספרי נקודה צפה מעוגלים לכיוון הקרוב ביותר
מספר מכונה או לכיוון מספר המכונה הזוגי במקרה של תיקו.

m סיבוב לעבר מינוס אינסוף.

c מצב עיגול קצוץ. מספרי נקודה צפה מעוגלים לאפס.

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

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

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

f דיוק תפקוד. מטפל המלכודות יכול לקבוע את הפונקציה שגרמה ל-a
חריג נקודה צפה.

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

מהדרים אחרים של אלפא מספקים את האפשרויות המקבילות שנקראות -scope_safe ו
-resumption_safe.

-מיי-תואם
אפשרות זו מסמנת את הקוד שנוצר כתואם IEEE. אסור להשתמש באפשרות זו
אלא אם כן תפרט -mtrap-precision=i וגם -mfp-trap-mode=su or
-mfp-trap-mode=sui. ההשפעה היחידה שלו היא פליטת הקו .flag 48 בפונקציה
פרולוג של קובץ ההרכבה שנוצר. תחת DEC Unix, זה משפיע על כך
שגרות ספריית מתמטיקה תואמות IEEE יהיו מקושרות.

-mbuild-קבועים
בדרך כלל GCC בוחן קבוע מספר שלם של 32 או 64 סיביות כדי לראות אם הוא יכול לבנות אותו
מקבועים קטנים יותר בשתיים או שלוש הוראות. אם זה לא יכול, זה יוציא את
קבוע בתור מילולי ויצירת קוד כדי לטעון אותו מקטע הנתונים בזמן הריצה.

השתמש באפשרות זו כדי לדרוש מ-GCC לבנות את כל קבועים שלמים באמצעות קוד, גם אם
זה דורש יותר הוראות (המקסימום הוא שש).

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

-malpha-as
-מגז
בחר אם להפיק קוד להרכבה על ידי ה-assembler שסופק על ידי הספק
(-malpha-as) או על ידי ה-GNU assembler -מגז.

-mbwx
-mno-bwx
-mcix
-mno-cix
-mfix
-mno-fix
-ממקס
-mno-max
ציין אם GCC צריך ליצור קוד כדי להשתמש ב-BWX, CIX, FIX ו-MAX האופציונליים
ערכות הוראות. ברירת המחדל היא להשתמש בערכות ההוראות הנתמכות על ידי המעבד
סוג שצוין באמצעות -mcpu= אפשרות או זו של ה-CPU שעליו נבנה GCC אם לא הייתה כזו
נָקוּב.

-mfloat-vax
-mfloat-ieee
צור קוד שמשתמש (לא משתמש) בחשבון VAX F ו-G במקום זאת
של IEEE דיוק יחיד וכפול.

-מפורש-רילוקים
-mno-explicit-relocs
מרכיבי אלפא מבוגרים לא סיפקו שום דרך ליצור העברת סמלים מלבד באמצעות
מאקרו מאקרו. השימוש בפקודות מאקרו אלו אינו מאפשר תזמון הוראות מיטבי.
GNU binutils החל מגרסה 2.12 תומכת בתחביר חדש המאפשר למהדר לעשות זאת
סמן במפורש אילו רילוקיישן צריך לחול על אילו הוראות. אפשרות זו היא
שימושי בעיקר לניפוי באגים, מכיוון ש-GCC מזהה את היכולות של ה-assembler כאשר הוא
בנוי ומגדיר את ברירת המחדל בהתאם.

-msmall-data
-הגדלה-נתונים
מתי -מפורש-רילוקים בתוקף, ניתן לגשת לנתונים סטטיים באמצעות קרוב משפחה
רילוקיישן. מתי -msmall-data בשימוש, מונחים אובייקטים באורך 8 בתים או פחות
a קטן נתונים אזור (הסעיפים ".sdata" ו-".sbss") והגישה אליהם היא באמצעות 16 סיביות
רילוקיישן מחוץ לפנקס $gp. זה מגביל את גודל אזור הנתונים הקטן ל
64KB, אך מאפשר גישה ישירה למשתנים באמצעות הוראה אחת.

ברירת המחדל היא -הגדלה-נתונים. עם אפשרות זו אזור הנתונים מוגבל ממש מתחת
2GB. תוכניות הדורשות יותר מ-2GB של נתונים חייבות להשתמש ב-"malloc" או "mmap" כדי
להקצות את הנתונים בערימה במקום בקטע הנתונים של התוכנית.

בעת יצירת קוד עבור ספריות משותפות, -fpic מרמז -msmall-data ו -fPIC
מרמז -הגדלה-נתונים.

-msmall-text
-טקסט גדול
מתי -msmall-text משמש, המהדר מניח שהקוד של התוכנית כולה
(או ספרייה משותפת) מתאים ל-4MB, ולכן ניתן להגיע אליו עם הוראת סניף.
מתי -msmall-data משמש, המהדר יכול להניח שכל הסמלים המקומיים חולקים את
אותו ערך $gp, ובכך להפחית את מספר ההוראות הנדרשות לפונקציה
להתקשר מ-4 עד 1.

ברירת המחדל היא -טקסט גדול.

-mcpu=cpu_type
הגדר את ערכת ההוראות ופרמטרי תזמון ההוראות עבור סוג המכונה
cpu_type. אתה יכול לציין או את EV שם הסגנון או מספר השבב המתאים.
GCC תומך בפרמטרי תזמון עבור משפחת המעבדים EV4, EV5 ו-EV6
יבחר את ערכי ברירת המחדל עבור ערכת ההוראות מהמעבד שתציין.
אם לא תציין סוג מעבד, GCC יקבע כברירת מחדל את המעבד שבו
מהדר נבנה.

ערכים נתמכים עבור cpu_type יש לו

Ev4
Ev45
21064
לוח זמנים כ-EV4 ואין לו הרחבות של ערכת הוראות.

Ev5
21164
לוח זמנים כ-EV5 ואין לו הרחבות של ערכת הוראות.

Ev56
21164a
מתזמן כ-EV5 ותומך בהרחבה BWX.

pca56
21164pc
21164PC
מתזמן כ-EV5 ותומך בהרחבות BWX ו-MAX.

Ev6
21264
מתזמן כ-EV6 ותומך בהרחבות BWX, FIX ו-MAX.

Ev67
21264a
מתזמן כ-EV6 ותומך בהרחבות BWX, CIX, FIX ו-MAX.

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

-mtune=cpu_type
הגדר רק את פרמטרי תזמון ההוראות עבור סוג המכונה cpu_type. ה
ערכת ההוראות לא משתנה.

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

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

אפשרויות תקפות עבור זמן יש לו

מספר
מספר עשרוני המייצג מחזורי שעון.

L1
L2
L3
ראשי
המהדר מכיל אומדנים של מספר מחזורי השעון עבור EV4 & "טיפוסיים"
חומרת EV5 עבור המטמונים ברמה 1, 2 ו-3 (נקראים גם Dcache, Scache ו-
Bcache), כמו גם לזיכרון הראשי. שימו לב ש-L3 תקף רק עבור EV5.

דצמבר אלפא/VMS אפשרויות

אלה -m אפשרויות מוגדרות עבור יישומי DEC Alpha/VMS:

-mvms-return-codes
החזר קודי תנאי VMS מהראשי. ברירת המחדל היא החזרת מצב בסגנון POSIX
(למשל שגיאה) קודי.

-mdebug-main=קידומת
סמן את השגרה הראשונה ששמה מתחיל בה קידומת כשגרה העיקרית עבור
מנפה.

-mmalloc64
ברירת מחדל לשגרות הקצאת זיכרון של 64 סיביות.

FR30 אפשרויות

אפשרויות אלה מוגדרות במיוחד עבור יציאת FR30.

-msmall-model
השתמש במודל מרחב הכתובות הקטן. זה יכול לייצר קוד קטן יותר, אבל זה מניח
שכל הערכים והכתובות הסמליים יתאימו לטווח של 20 סיביות.

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

FRV אפשרויות

-mgpr-32
השתמש רק ב-32 הרשמים הראשונים לשימוש כללי.

-mgpr-64
השתמש בכל 64 האוגרים לשימוש כללי.

-mfpr-32
השתמש רק ב-32 הרשמים הראשונים של הנקודה הצפה.

-mfpr-64
השתמש בכל 64 אוגרי הנקודה הצפה.

-mhard-float
השתמש בהוראות חומרה לפעולות בנקודה צפה.

-msoft-float
השתמש בשגרה של ספרייה עבור פעולות נקודה צפה.

-malloc-cc
הקצאה דינמית של אוגרי קוד מצב.

-mfixed-cc
אל תנסה להקצות באופן דינמי אוגרי קוד מצבים, השתמש רק ב- "icc0" ו
"fcc0".

-mdword
שנה ABI לשימוש ב-insns של מילים כפולות.

-mno-dword
אל תשתמש בהוראות מילה כפולות.

-mdouble
השתמש בהוראות כפולות של נקודה צפה.

-mno-כפול
אל תשתמש בהוראות כפולות של נקודה צפה.

-ממדיה
השתמש בהוראות מדיה.

-mno-media
אל תשתמש בהוראות מדיה.

-מולאד
השתמש בהוראות הכפל וחיבור/הורדה.

-mno-muladd
אין להשתמש בהוראות הכפל וחיבור/הפחתה.

-mfdpic
בחר את ה-FDPIC ABI, המשתמש בתיאורי פונקציות כדי לייצג מצביעים
פונקציות. ללא כל אפשרויות הקשורות ל-PIC/PIE, זה מרמז -fPIE. עם -fpic or
-fpie, הוא מניח שכניסות GOT ונתונים קטנים נמצאים בטווח של 12 סיביות מה-GOT
כתובת הבסיס; עם -fPIC or -fPIE, קיזוז GOT מחושבים עם 32 סיביות. עם
bfin-elf יעד, אפשרות זו מרמזת -מסים.

-minline-plt
אפשר הטמעה של ערכי PLT בקריאות פונקציה לפונקציות שאינן מוכרות להן
לאגד באופן מקומי. אין לזה השפעה בלי -mfdpic. זה מופעל כברירת מחדל אם
אופטימיזציה למהירות והידור עבור ספריות משותפות (כלומר, -fPIC or -fpic), או
כאשר אפשרות אופטימיזציה כגון -O3 או למעלה קיים בשורת הפקודה.

-mTLS
הנח מקטע TLS גדול בעת יצירת קוד מקומי.

-mtls
אל תניח מקטע TLS גדול בעת יצירת קוד מקומי.

-mgprel-ro
אפשר את השימוש ברילוקיישן "GPREL" ב-FDPIC ABI עבור נתונים שידוע שהם נמצאים ב
סעיפים לקריאה בלבד. זה מופעל כברירת מחדל, למעט -fpic or -fpie: למרות ש
זה עשוי לעזור להקטין את טבלת הקיזוז העולמית, הוא סוחר בהוראה אחת ב-1. עם
-fPIC or -fPIE, הוא סוחר ב-3 הוראות תמורת 4, שאחת מהן עשויה להיות משותפת למספרים
סמלים, וזה מונע את הצורך בהזנת GOT עבור הסמל שאליו מתייחסים, אז זהו
יותר סיכוי לניצחון. אם זה לא, -mno-gprel-ro ניתן להשתמש כדי להשבית אותו.

-רב-ספרייה-תמונה
קישור עם ספריות התמונות (ספרייה, לא FD). זה משתמע על ידי -mlibrary-תמונה, גם כן
כמו על ידי -fPIC ו -fpic לְלֹא -mfdpic. לעולם לא תצטרך להשתמש בו באופן מפורש.

-mlinked-fp
עקוב אחר דרישת EABI של יצירת מצביע מסגרת תמיד בכל פעם שיש מסגרת מחסנית
מוקצה. אפשרות זו מופעלת כברירת מחדל וניתן לבטל אותה באמצעות
-mno-linked-fp.

-מלונג-שיחות
השתמש בכתובת עקיפה כדי לקרוא לפונקציות מחוץ ליחידת ההידור הנוכחית. זֶה
מאפשר למקם את הפונקציות בכל מקום במרחב הכתובות של 32 סיביות.

-ממאיר-תוויות
נסה ליישר את התוויות לגבול של 8 בתים על ידי הוספת nops לחבילה הקודמת.
אפשרות זו משפיעה רק כאשר אריזה VLIW מופעלת. זה לא יוצר חדש
מנות; זה רק מוסיף נופים לאלה הקיימים.

-mlibrary-תמונה
צור קוד EABI בלתי תלוי במיקום.

-mac-4
השתמש רק בארבעת אוגרי צבירת המדיה הראשונים.

-mac-8
השתמש בכל שמונת אוגרי מצבורי המדיה.

-mpack
ארוז הוראות VLIW.

-מנו-חבילה
אין לארוז הוראות VLIW.

-mno-flags
אין לסמן מתגי ABI ב-e_flags.

-mcond-move
אפשר את השימוש בהוראות תנועה מותנית (ברירת מחדל).

מתג זה נועד בעיקר לאיתור באגים במהדר וכנראה יוסר ב-a
גרסה עתידית.

-mno-cond-move
השבת את השימוש בהוראות להזזה מותנית.

מתג זה נועד בעיקר לאיתור באגים במהדר וכנראה יוסר ב-a
גרסה עתידית.

-mscc
אפשר את השימוש בהוראות סט מותנה (ברירת מחדל).

מתג זה נועד בעיקר לאיתור באגים במהדר וכנראה יוסר ב-a
גרסה עתידית.

-mno-scc
השבת את השימוש בהוראות סט מותנה.

מתג זה נועד בעיקר לאיתור באגים במהדר וכנראה יוסר ב-a
גרסה עתידית.

-mcond-exec
אפשר את השימוש בביצוע מותנה (ברירת מחדל).

מתג זה נועד בעיקר לאיתור באגים במהדר וכנראה יוסר ב-a
גרסה עתידית.

-mno-cond-exec
השבת את השימוש בביצוע מותנה.

מתג זה נועד בעיקר לאיתור באגים במהדר וכנראה יוסר ב-a
גרסה עתידית.

-mvliw-ענף
הפעל מעבר לאריזת ענפים בהוראות VLIW (ברירת מחדל).

מתג זה נועד בעיקר לאיתור באגים במהדר וכנראה יוסר ב-a
גרסה עתידית.

-מנו-פליוו-ענף
אל תפעיל כרטיס לאריזת ענפים בהוראות VLIW.

מתג זה נועד בעיקר לאיתור באגים במהדר וכנראה יוסר ב-a
גרסה עתידית.

-multi-cond-exec
אפשר אופטימיזציה של "&&" ו-"||" בביצוע מותנה (ברירת מחדל).

מתג זה נועד בעיקר לאיתור באגים במהדר וכנראה יוסר ב-a
גרסה עתידית.

-mno-multi-cond-exec
השבת אופטימיזציה של "&&" ו-"||" בביצוע מותנה.

מתג זה נועד בעיקר לאיתור באגים במהדר וכנראה יוסר ב-a
גרסה עתידית.

-mnested-cond-exec
אפשר אופטימיזציות של ביצוע מותנה מקונן (ברירת מחדל).

מתג זה נועד בעיקר לאיתור באגים במהדר וכנראה יוסר ב-a
גרסה עתידית.

-mno-nested-cond-exec
השבת אופטימיזציות של ביצוע מותנה מקוננות.

מתג זה נועד בעיקר לאיתור באגים במהדר וכנראה יוסר ב-a
גרסה עתידית.

-moptimize-membar
מתג זה מסיר הוראות "ממבר" מיותרות מהקוד שנוצר מהמהדר.
הוא מופעל כברירת מחדל.

-mno-optimize-membar
מתג זה משבית את ההסרה האוטומטית של הוראות "ממבר" מיותרות מה-
קוד שנוצר.

-mtomcat-stats
גרם לגז להדפיס סטטיסטיקות של חתולים.

-mcpu=מעבד
בחר את סוג המעבד שעבורו ליצור קוד. ערכים אפשריים הם frv, fr550,
חתול, fr500, fr450, fr405, fr400, fr300 ו פשוט.

גנו / לינוקס אפשרויות

אלה -m אפשרויות מוגדרות עבור יעדי GNU/Linux:

-mglibc
השתמש בספריית GNU C. זוהי ברירת המחדל למעט מופעל *-*-linux-*uclibc* ו
*-*-linux-*אנדרואיד* מטרות.

-muclibc
השתמש בספריית uClibc C. זוהי ברירת המחדל פועלת *-*-linux-*uclibc* מטרות.

-מביוני
השתמש בספריית Bionic C. זוהי ברירת המחדל פועלת *-*-linux-*אנדרואיד* מטרות.

-מאנדרואיד
הידור קוד תואם לפלטפורמת אנדרואיד. זוהי ברירת המחדל פועלת
*-*-linux-*אנדרואיד* מטרות.

בעת הקומפילציה, אפשרות זו מאפשרת -מביוני, -fPIC, -fno-חריגים ו -fno-rtti by
בְּרִירַת מֶחדָל. בעת הקישור, אפשרות זו גורמת למנהל התקן GCC לעבור אפשרויות ספציפיות לאנדרואיד
למקשר. לבסוף, אפשרות זו גורמת למאקרו הקדם-מעבד "__ANDROID__" להיות
מוּגדָר.

-tno-android-cc
השבת אפקטי קומפילציה של -מאנדרואיד, כלומר, אל תפעיל -מביוני, -fPIC,
-fno-חריגים ו -fno-rtti כברירת מחדל.

-tno-android-ld
השבת את אפקטי הקישור של -מאנדרואיד, כלומר, להעביר אפשרויות קישור סטנדרטיות של לינוקס ל-
מקשר.

H8 / 300 אפשרויות

אלה -m אפשרויות מוגדרות עבור יישומי H8/300:

-להירגע
קצר כמה הפניות לכתובות בזמן הקישור, במידת האפשר; משתמש באפשרות קישור
-לְהִרָגַע.

-מ"ה צור קוד עבור H8/300H.

-גברת צור קוד עבור H8S.

-מנ צור קוד עבור H8S ו-H8/300H במצב רגיל. יש להשתמש במתג זה
או עם -מ"ה or -גברת.

-ms2600
צור קוד עבור H8S/2600. יש להשתמש במתג זה עם -גברת.

-מנטה32
הפוך נתוני "int" ל-32 סיביות כברירת מחדל.

-ממאיר-300
ב-H8/300H וב-H8S, השתמש באותם כללי יישור כמו ב-H8/300. ברירת המחדל
עבור H8/300H ו-H8S היא ליישר אורך וצף על גבולות של 4 בתים.
-ממאיר-300 גורם להם להיות מיושרים על גבולות של 2 בתים. לאפשרות זו אין השפעה
ב-H8/300.

HPPA אפשרויות

אלה -m אפשרויות מוגדרות עבור משפחת מחשבי HPPA:

-מרץ=סוג אדריכלות
צור קוד עבור הארכיטקטורה שצוינה. הבחירות עבור סוג אדריכלות יש לו
1.0 עבור PA 1.0, 1.1 עבור PA 1.1, ו 2.0 עבור מעבדי PA 2.0. מתייחס
/usr/lib/sched.models על מערכת HP-UX כדי לקבוע את אפשרות הארכיטקטורה המתאימה
עבור המכונה שלך. קוד הידור עבור ארכיטקטורות עם מספר נמוך יותר יפעל על גבוה יותר
ארכיטקטורות ממוספרות, אבל לא להיפך.

-mpa-risc-1-0
-mpa-risc-1-1
-mpa-risc-2-0
מילים נרדפות ל -מרץ=1.0, -מרץ=1.1, ו -מרץ=2.0 בהתאמה.

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

-mjump-in-delay
מלא משבצות עיכוב של קריאות פונקציה עם הוראות קפיצה ללא תנאי על ידי שינוי
מצביע ההחזרה עבור קריאת הפונקציה תהיה היעד של הקפיצה המותנית.

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

-mdisable-indexing
מנע מהמהדר להשתמש במצבי כתובת אינדקס. זה נמנע קצת יותר
בעיות מעורפלות בעת קומפילציה של קוד שנוצר ב-MIG תחת MACH.

-mno-space-regs
צור קוד שמניח שלמטרה אין אוגרי שטח. זה מאפשר ל-GCC לעשות זאת
ליצור שיחות עקיפות מהירות יותר ולהשתמש במצבי כתובת אינדקס לא מותאמים.

קוד כזה מתאים למערכות PA וקרנלים ברמה 0.

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

אפשרות זו לא תעבוד בנוכחות ספריות משותפות או פונקציות מקוננות.

-mfixed-range=רישום-טווח
צור קוד המתייחס לטווח האוגר הנתון כאל אוגרים קבועים. פנקס קבוע
הוא כזה שמקצי הרשומות לא יכול להשתמש בו. זה שימושי בעת הידור ליבה
קוד. טווח רישום מצוין כשני אוגרים מופרדים באמצעות מקף. מרובות
ניתן לציין טווחי רישום מופרדים באמצעות פסיק.

-מלונג-load-store
צור עומס של 3 הוראות ואחסן רצפים כפי שנדרש לפעמים על ידי HP-UX 10
מקשר. זה שווה ערך ל +k אפשרות למהדרים של HP.

-זמן ריצה נייד
השתמש במוסכמות השיחות הניידות המוצעות על ידי HP עבור מערכות ELF.

-מגז
אפשר את השימוש בהנחיות assembler שרק GAS מבין.

-mschedule=סוג מעבד
תזמן קוד בהתאם לאילוצים עבור סוג המכונה סוג מעבד. הבחירות
ל סוג מעבד יש לו 700 7100, 7100LC, 7200, 7300 ו 8000. מתייחס
/usr/lib/sched.models על מערכת HP-UX כדי לקבוע את אפשרות התזמון הנכונה עבור
המכונה שלך. תזמון ברירת המחדל הוא 8000.

-mlinker-opt
אפשר את מעבר האופטימיזציה במקשר HP-UX. שים לב שזה גורם לניפוי באגים סמלי
בלתי אפשרי. זה גם מעורר באג במקשרים HP-UX 8 ו-HP-UX 9 שבהם הם
תן הודעות שגיאה מזויפות בעת קישור של תוכניות מסוימות.

-msoft-float
צור פלט המכיל קריאות לספרייה עבור נקודה צפה. אַזהָרָה: הנדרש
ספריות אינן זמינות עבור כל יעדי HPPA. בדרך כלל המתקנים של
נעשה שימוש במהדר C הרגיל של המכונה, אך לא ניתן לעשות זאת ישירות ב-cross-
הַהדָרָה. עליך לעשות סידורים משלך כדי לספק ספרייה מתאימה
פונקציות עבור קומפילציה צולבת.

-msoft-float משנה את מוסכמות השיחות בקובץ הפלט; לכן, זה רק
שימושי אם אתה קומפילציה את כל של תוכנית עם אפשרות זו. בפרט, אתה צריך
לעבד libgcc.a, הספרייה שמגיעה עם GCC, עם -msoft-float על מנת לכך
לעבודה.

-msio
צור את ההגדרה מראש, "_SIO", עבור שרת IO. ברירת המחדל היא -mwsio. זה מייצר
המגדירים מראש, "__hp9000s700", "__hp9000s700__" ו-"_WSIO", עבור תחנת עבודה IO.
אפשרויות אלה זמינות תחת HP-UX ו-HI-UX.

-מגנו-לד
השתמש באפשרויות ספציפיות של GNU ld. זה עובר -מְשׁוּתָף ל-ld בעת בניית משותף
סִפְרִיָה. זוהי ברירת המחדל כאשר GCC מוגדר, באופן מפורש או מרומז, עם ה-
מקשר GNU. לאפשרות זו אין השפעה על איזה ld נקרא, היא בלבד
משנה אילו פרמטרים מועברים לאותו ld. ה-ld שנקרא נקבע על ידי
מה היא --with-ld אפשרות הגדרה, נתיב החיפוש של התוכנית של GCC, ולבסוף על ידי המשתמש
נתיב. ניתן להדפיס את הקישור המשמש את GCC באמצעות אשר `gcc -נחש-prog- name = ld`.
אפשרות זו זמינה רק ב-64-bit HP-UX GCC, כלומר מוגדר עם
hppa*64*-*-hpux*.

-mhp-ld
השתמש באפשרויות ספציפיות ל-HP ld. זה עובר -b ל-ld בעת בניית ספרייה משותפת ו
מעברי +קבל סוג אי התאמה ל-ld בכל הקישורים. זוהי ברירת המחדל כאשר GCC היא
מוגדר, במפורש או במשתמע, עם מקשר HP. אפשרות זו אין
כל השפעה עליה נקרא ld, זה רק משנה אילו פרמטרים מועברים לזה
ld. ה-ld שנקרא נקבע על ידי ה- --with-ld אפשרות תצורה, של GCC
נתיב החיפוש של התוכנית, ולבסוף על ידי המשתמש נתיב. המקשר בשימוש GCC יכול להיות
מודפס באמצעות אשר `gcc -נחש-prog- name = ld`. אפשרות זו זמינה רק ב-
64 סיביות HP-UX GCC, כלומר מוגדר עם hppa*64*-*-hpux*.

-מלונג-שיחות
צור קוד שמשתמש ברצפי שיחות ארוכים. זה מבטיח שהשיחה תמיד אפשרית
כדי להגיע לקטעים שנוצרו על ידי קישור. ברירת המחדל היא ליצור שיחות ארוכות רק כאשר
מרחק מאתר השיחה לתחילת הפונקציה או יחידת התרגום, כמו
המקרה עשוי להיות, חורג ממגבלה מוגדרת מראש שנקבעה על ידי סוג הסניף בשימוש. ה
המגבלות עבור שיחות רגילות הן 7,600,000 ו-240,000 בתים, בהתאמה עבור PA 2.0
וארכיטקטורות PA 1.X. שיחות סיב מוגבלות תמיד ל-240,000 בתים.

מרחקים נמדדים מתחילת הפונקציות בעת שימוש ב-
-פפונקציה-סעיפים אפשרות, או בעת שימוש ב- -מגז ו -mno-portable-time אפשרויות
יחד תחת HP-UX עם מקשר SOM.

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

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

-munix=unix-std
צור הגדרות מוקדמות של מהדר ובחר קובץ התחלה עבור תקן UNIX שצוין.
הבחירות עבור unix-std יש לו 93, 95 ו 98. 93 נתמך בכל גרסאות HP-UX.
95 זמין ב-HP-UX 10.10 ואילך. 98 זמין ב-HP-UX 11.11 ואילך.
ערכי ברירת המחדל הם 93 עבור HP-UX 10.00, 95 עבור HP-UX 10.10 אך עד 11.00, ו 98
עבור HP-UX 11.11 ואילך.

-munix=93 מספק את אותן הגדרות מוקדמות כמו GCC 3.3 ו-3.4. -munix=95 מספק
הגדרות מוקדמות נוספות עבור "XOPEN_UNIX" ו-"_XOPEN_SOURCE_EXTENDED", וקובץ ההתחלה
unix95.o. -munix=98 מספק הגדרות מוקדמות נוספות עבור "_XOPEN_UNIX",
"_XOPEN_SOURCE_EXTENDED", "_INCLUDE__STDC_A1_SOURCE" ו-"_INCLUDE_XOPEN_SOURCE_500",
ואת קובץ ההתחלה unix98.o.

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

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

-nolibdld
דחק את יצירת אפשרויות הקישור לחיפוש libdld.sl כאשר -סטָטִי האפשרות היא
המצוין ב-HP-UX 10 ואילך.

-סטָטִי
למימוש HP-UX של setlocale ב-libc יש תלות ב-libdld.sl. שם
היא לא גרסת ארכיון של libdld.sl. לפיכך, כאשר ה -סטָטִי אפשרות מוגדרת,
יש צורך באפשרויות קישור מיוחדות כדי לפתור את התלות הזו.

ב-HP-UX 10 ואילך, מנהל ההתקן של GCC מוסיף את האפשרויות הדרושות לקישור
libdld.sl כאשר -סטָטִי אפשרות מוגדרת. זה גורם לבינארי שהתקבל
להיות דינאמי. ביציאת 64 סיביות, המקשרים מייצרים קבצים בינאריים דינמיים כברירת מחדל ב
כל מקרה. ה -nolibdld ניתן להשתמש באפשרות כדי למנוע הוספת מנהל התקן GCC
אפשרויות הקישור הללו.

-חוטים
הוסף תמיכה עבור ריבוי השרשורים עם dce חוט ספרייה תחת HP-UX. אפשרות זו
מגדיר דגלים הן עבור המעבד הקדם והן עבור המקשר.

אינטל 386 ו AMD x86-64 אפשרויות

אלה -m אפשרויות מוגדרות עבור משפחת המחשבים i386 ו-x86-64:

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

גנרית
הפק קוד מותאם למעבדי IA32/AMD64/EM64T הנפוצים ביותר. אם אתה
לדעת את ה-CPU שעליו יפעל הקוד שלך, אז עליך להשתמש בקוד המתאים
-mtune אפשרות במקום -mtune=גנרי. אבל, אם אתה לא יודע בדיוק איזה מעבד
למשתמשים באפליקציה שלך יהיו, אז עליך להשתמש באפשרות זו.

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

אין -מרץ=גנרי אפשרות בגלל -מרץ מציין את ערכת ההוראות את
מהדר יכול להשתמש, ואין ערכת הוראות גנרית החלה על כולם
מעבדים. בניגוד, -mtune מציין את המעבד (או, במקרה זה,
אוסף מעבדים) שעבורם הקוד מותאם.

יליד
זה בוחר את ה-CPU לכוון בזמן הקומפילציה על ידי קביעת המעבד
סוג מכונת ההידור. באמצעות -mtune=native יפיק קוד מותאם
עבור המכונה המקומית תחת האילוצים של ערכת ההוראות שנבחרה.
שימוש -צעדה = יליד יאפשר את כל תת-קבוצות ההוראות הנתמכות על ידי המקומי
מכונה (ולכן ייתכן שהתוצאה לא תפעל במכונות שונות).

i386
מעבד i386 המקורי של אינטל.

i486
מעבד i486 של אינטל. (אין תזמון מיושם עבור השבב הזה.)

i586, פנטיום
מעבד Intel Pentium ללא תמיכה ב-MMX.

פנטיום-mmx
Intel PentiumMMX CPU מבוסס על ליבת Pentium עם תמיכה בערכת הוראות MMX.

pentiumpro
מעבד Intel PentiumPro.

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

פנטיום2
מעבד Intel Pentium2 מבוסס על ליבת PentiumPro עם תמיכה בערכת הוראות MMX.

פנטיום 3, פנטיום 3m
מעבד Intel Pentium3 מבוסס על ליבת PentiumPro עם ערכת הוראות MMX ו-SSE
תומכים.

פנטיום-מ
גרסת צריכת חשמל נמוכה של Intel Pentium3 CPU עם ערכת הוראות MMX, SSE ו-SSE2
תמיכה. בשימוש על ידי מחברות Centrino.

פנטיום 4, פנטיום 4m
Intel Pentium4 CPU עם תמיכה בערכת הוראות MMX, SSE ו-SSE2.

פרסקוט
גרסה משופרת של Intel Pentium4 CPU עם הוראות MMX, SSE, SSE2 ו-SSE3
להגדיר תמיכה.

נוקונה
גרסה משופרת של Intel Pentium4 CPU עם הרחבות של 64 סיביות, MMX, SSE, SSE2 ו
תמיכה בערכת הוראות SSE3.

2
מעבד Intel Core2 עם הרחבות של 64 סיביות, הוראות MMX, SSE, SSE2, SSE3 ו-SSSE3
להגדיר תמיכה.

Corei7
Intel Core i7 CPU עם הרחבות של 64 סיביות, MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1 ו
תמיכה בערכת הוראות SSE4.2.

corei7-avx
מעבד Intel Core i7 עם הרחבות של 64 סיביות, MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1,
תמיכה בערכת הוראות SSE4.2, AVX, AES ו-PCLMUL.

core-avx-i
Intel Core CPU עם הרחבות של 64 סיביות, MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1,
תמיכה בערכת הוראות SSE4.2, AVX, AES, PCLMUL, FSGSBASE, RDRND ו-F16C.

אטום
Intel Atom CPU עם הרחבות של 64 סיביות, הוראות MMX, SSE, SSE2, SSE3 ו-SSSE3
להגדיר תמיכה.

k6 מעבד AMD K6 עם תמיכה בערכת הוראות MMX.

k6-2, k6-3
גרסאות משופרות של מעבד AMD K6 עם MMX ו-3DNow! תמיכה בערכת הוראות.

אתלון, אתלון-tbird
מעבד AMD Athlon עם MMX, 3dNOW!, 3DNow משופר! והוראות אחזור מראש של SSE
תומכים.

אתלון-4, athlon-xp, אתלון-mp
מעבד AMD Athlon משופר עם MMX, 3DNow!, 3DNow משופר! והוראת SSE מלאה
להגדיר תמיכה.

k8, אופטרון, atlon64, athlon-fx
מעבדים מבוססי ליבות AMD K8 עם תמיכה בערכת הוראות x86-64. (זה מחליף את MMX,
SSE, SSE2, 3DNow!, 3DNow משופר! והרחבות של ערכת הוראות של 64 סיביות.)

k8-sse3, opteron-sse3, athlon64-sse3
גרסאות משופרות של k8, opteron ו-athlon64 עם תמיכה בערכת הוראות SSE3.

amdfam10, ברצלונה
מעבדי AMD Family 10h מבוססי ליבה עם תמיכה בערכת הוראות x86-64. (זֶה
ערכות-על MMX, SSE, SSE2, SSE3, SSE4A, 3DNow!, 3DNow! משופרות, ABM ו-64-bit
הרחבות של ערכות הוראות.)

bdver1
מעבדי AMD Family 15h מבוססי ליבה עם תמיכה בערכת הוראות x86-64. (זֶה
ערכות-על FMA4, AVX, XOP, LWP, AES, PCL_MUL, CX16, MMX, SSE, SSE2, SSE3, SSE4A,
הרחבות SSSE3, SSE4.1, SSE4.2, ABM ו-64 סיביות.)

bdver2
מעבדי AMD Family 15h מבוססי ליבה עם תמיכה בערכת הוראות x86-64. (זֶה
ערכות-על BMI, TBM, F16C, FMA, AVX, XOP, LWP, AES, PCL_MUL, CX16, MMX, SSE, SSE2,
הרחבות SSE3, SSE4A, SSSE3, SSE4.1, SSE4.2, ABM ו-64 סיביות.)

btver1
מעבדי AMD Family 14h מבוססי ליבה עם תמיכה בערכת הוראות x86-64. (זֶה
ערכות-על MMX, SSE, SSE2, SSE3, SSSE3, SSE4A, CX16, ABM ו-64 סיביות
הרחבות.)

winchip-c6
IDT Winchip C6 CPU, מטופל באותו אופן כמו i486 עם ערכת הוראות MMX נוספת
תומכים.

winchip2
IDT Winchip2 CPU, מטופל באותו אופן כמו i486 עם MMX נוספים ו-3DNow!
תמיכה בערכת הוראות.

c3 דרך מעבד C3 עם MMX ו-3DNow! תמיכה בערכת הוראות. (אין תזמון
מיושם עבור השבב הזה.)

c3-2
באמצעות מעבד C3-2 עם תמיכה בערכת הוראות MMX ו-SSE. (אין תזמון
מיושם עבור השבב הזה.)

גאוד
מעבד AMD משובץ עם MMX ו-3DNow! תמיכה בערכת הוראות.

תוך כדי בחירת ספציפי סוג מעבד יתזמן דברים כראוי לכך
שבב מסוים, המהדר לא יפיק שום קוד שלא רץ על
סוג מכונה ברירת מחדל ללא -מרץ=סוג מעבד אפשרות בשימוש. לדוגמה, אם
לאחר מכן, GCC מוגדר עבור i686-pc-linux-gnu -mtune=pentium4 יפיק קוד זה
מכוון ל-Pentium4 אך עדיין יפעל על מכונות i686.

-מרץ=סוג מעבד
צור הוראות עבור סוג המכונה סוג מעבד. הבחירות עבור סוג מעבד הם
אותו דבר לגבי -mtune. יתר על כן, מפרט -מרץ=סוג מעבד מרמז -mtune=סוג מעבד.

-mcpu=סוג מעבד
מילה נרדפת שהוצאה משימוש עבור -mtune.

-mfpmath=יחידה
צור אריתמטיקה של נקודה צפה עבור היחידה שנבחרה יחידה. הבחירות עבור יחידה הם:

387 השתמש במעבד המשנה הסטנדרטי של 387 נקודות צפה הקיים ברוב השבבים
וחיקוי אחרת. קוד הידור עם אפשרות זו פועל כמעט בכל מקום.
התוצאות הזמניות מחושבות בדיוק של 80 סיביות במקום בדיוק
מוגדר לפי הסוג, וכתוצאה מכך תוצאות מעט שונות בהשוואה לרוב
צ'יפס אחרים. לִרְאוֹת -ffloat-store לתיאור מפורט יותר.

זוהי בחירת ברירת המחדל עבור מהדר i386.

ESS השתמש בהוראות נקודה צפה סקלריות הקיימות בערכת ההוראות של SSE. זֶה
ערכת ההוראות נתמכת על ידי Pentium3 ושבבים חדשים יותר, בסדרת AMD by
שבבי Athlon-4, Athlon-xp ו-Athlon-mp. הגרסה הקודמת של הוראת SSE
הסט תומך רק בחשבון בעל דיוק יחיד, ולכן הכפול והמורחב-
אריתמטיקה מדויקת עדיין נעשית באמצעות 387. גרסה מאוחרת יותר, קיימת רק ב
Pentium4 ושבבי AMD x86-64 העתידיים, תומכים בחשבון דיוק כפול
מדי.

עבור מהדר i386, אתה צריך להשתמש -מרץ=סוג מעבד, -msse or -msse2 מתגים
כדי לאפשר הרחבות SSE ולהפוך אפשרות זו ליעילה. עבור מהדר x86-64,
הרחבות אלו מופעלות כברירת מחדל.

הקוד המתקבל אמור להיות מהיר בהרבה ברוב המקרים ו
הימנע מבעיות חוסר היציבות המספריות של קוד 387, אך עשוי לשבור חלק מהקיים
קוד שמצפה שהזמניים יהיו 80 סיביות.

זוהי בחירת ברירת המחדל עבור מהדר x86-64.

sse, 387
sse+387
שניהם
נסה להשתמש בשני ערכות ההוראות בבת אחת. זה למעשה להכפיל את
כמות הרשמים הזמינים ובשבבים עם יחידות ביצוע נפרדות עבור 387
ו-SSE גם את משאבי הביצוע. השתמש באפשרות זו בזהירות, כפי שהיא עדיין
ניסיוני, מכיוון שמקצה האוגר של GCC אינו נפרד במודל
יחידות פונקציונליות היטב וכתוצאה מכך ביצועים לא יציבים.

-masm=נִיב
פלט הוראות asm באמצעות נבחר נִיב. בחירות נתמכות הן אינטל or אל
(ברירת המחדל). דרווין לא תומך אינטל.

-mieee-fp
-mno-ieee-fp
שליטה אם המהדר משתמש בהשוואות IEEE של נקודה צפה או לא. אלה
לטפל נכון במקרה בו תוצאת ההשוואה אינה מסודרת.

-msoft-float
צור פלט המכיל קריאות לספרייה עבור נקודה צפה. אַזהָרָה: הנדרש
ספריות אינן חלק מ-GCC. בדרך כלל המתקנים של ה-C הרגיל של המכונה
נעשה שימוש במהדר, אך לא ניתן לעשות זאת ישירות בהידור צולב. אתה חייב
ערכו סידורים משלכם כדי לספק פונקציות מתאימות בספרייה עבור חוצה-
הַהדָרָה.

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

-mno-fp-ret-in-387
אל תשתמש באוגרי FPU עבור ערכי החזרה של פונקציות.

למוסכמה הרגילה יש פונקציות להחזיר ערכי מסוג "float" ו-"double"
בפנקס FPU, גם אם אין FPU. הרעיון הוא שמערכת ההפעלה
צריך לחקות FPU.

האפשרות -mno-fp-ret-in-387 גורם להחזרת ערכים כאלה במעבד רגיל
נרשם במקום.

-mno-fancy-math-387
כמה אמולטורים של 387 אינם תומכים בהוראות "sin", "cos" ו-"sqrt" עבור
387. ציין אפשרות זו כדי להימנע מיצירת הוראות אלו. אפשרות זו היא
ברירת המחדל ב-FreeBSD, OpenBSD ו-NetBSD. אפשרות זו נדחפת כאשר -מרץ
מציין שלמעבד היעד יהיה תמיד FPU ולכן ההוראה לא תהיה
צריך חיקוי. החל מגרסה 2.6.1, הוראות אלו אינן נוצרות אלא אם כן
השתמש גם ב- -אופטימיזציות-funsafe-math מתג.

-ממאיר-כפול
-mno-align-double
קבע אם GCC מיישר משתנים "כפול", "כפול ארוך" ו"ארוך ארוך" על a
גבול של שתי מילים או גבול של מילה אחת. יישור משתנים "כפולים" על שתי מילים
boundary מייצר קוד שרץ קצת יותר מהר על a פנטיום על חשבון יותר
זיכרון.

ב-x86-64, -ממאיר-כפול מופעל כברירת מחדל.

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

-m96bit-long-double
-m128bit-long-double
מתגים אלה שולטים בגודל של סוג "כפול ארוך". היישום הבינארי של i386
ממשק מציין את הגודל להיות 96 סיביות, אז -m96bit-long-double הוא ברירת המחדל ב
מצב 32 סיביות.

ארכיטקטורות מודרניות (פנטיום וחדשות יותר) מעדיפות "כפול ארוך" להיות מיושר ל-8-
או גבול של 16 בתים. במערכים או במבנים התואמים את ABI, זה לא
אפשרי. כל כך מפרט -m128bit-long-double מיישר את "כפול ארוך" ל-16 בתים
גבול על ידי ריפוד ה"כפול הארוך" באפס נוסף של 32 סיביות.

במהדר x86-64, -m128bit-long-double הוא ברירת המחדל כ-ABI שלו
מציין ש"כפול ארוך" אמור להיות מיושר על גבול של 16 בתים.

שימו לב שאף אחת מהאפשרויות הללו לא מאפשרת דיוק נוסף על תקן x87
של 80 סיביות עבור "כפול ארוך".

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

-mlarge-data-threshold=מספר
מתי -mcmodel = בינוני מצוין, הנתונים גדולים מ סף ממוקמים בגדול
סעיף הנתונים. ערך זה חייב להיות זהה בכל האובייקטים המקושרים לתוך הבינארי
וברירת המחדל היא 65535.

-mrtd
השתמש במוסכמה אחרת של קריאת פונקציות, שבה פונקציות שלוקחות קבוע
מספר ארגומנטים חוזרים עם ה-"ret" NUM הוראה, שמציגה את הטיעונים שלהם
בזמן החזרה. זה חוסך הוראה אחת אצל המתקשר מכיוון שאין צורך בכך
להעלות את הטיעונים שם.

אתה יכול לציין שפונקציה בודדת תיקרא עם רצף הקריאה הזה עם
תכונת הפונקציה stdcall. אתה יכול גם לעקוף את -mrtd אפשרות באמצעות
תכונת פונקציה cdecl.

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

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

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

-mregparm=NUM
שליטה בכמה אוגרים משמשים להעברת ארגומנטים של מספרים שלמים. כברירת מחדל, לא
אוגרים משמשים להעברת ארגומנטים, ולכל היותר ניתן להשתמש ב-3 אוגרים. אתה יכול
לשלוט בהתנהגות זו עבור פונקציה ספציפית באמצעות תכונת הפונקציה regparm.

אַזהָרָה: אם אתה משתמש במתג זה, ו NUM אינו אפס, אז עליך לבנות את כל המודולים
עם אותו ערך, כולל כל ספריות. זה כולל את ספריות המערכת ו
מודולי הפעלה.

-msseregparm
השתמש במוסכמות העברת רישום SSE עבור ארגומנטים צפים וכפולים וערכי החזרה.
אתה יכול לשלוט בהתנהגות זו עבור פונקציה מסוימת באמצעות תכונת הפונקציה
sseregparm.

אַזהָרָה: אם אתה משתמש במתג זה, עליך לבנות את כל המודולים עם אותו ערך,
כולל כל ספריות. זה כולל את ספריות המערכת ומודול האתחול.

-mvect8-ret-in-mem
החזר וקטורים של 8 בתים בזיכרון במקום אוגרי MMX. זוהי ברירת המחדל המופעלת
Solaris@tie{}8 ו-9 ו-VxWorks כדי להתאים ל-ABI של מהדרים של Sun Studio עד
גרסה 12. גרסאות מהדר מאוחרות יותר (החל מ-Studio 12 Update@tie{}1) בהמשך
ה-ABI בשימוש על ידי יעדי x86 אחרים, שהיא ברירת המחדל ב-Solaris@tie{}10 ​​ואילך.
רק השתמש באפשרות זו אם אתה צריך להישאר תואם לקוד הקיים המיוצר על ידי
אותן גרסאות מהדר קודמות או גרסאות ישנות יותר של GCC.

-mpc32
-mpc64
-mpc80
הגדר את דיוק הנקודה צפה 80387 ל-32, 64 או 80 סיביות. מתי -mpc32 מצוין,
המשמעות של תוצאות של פעולות נקודה צפה מעוגלת ל-24 סיביות
(דיוק יחיד); -mpc64 מעגל את המשמעות של תוצאות של נקודה צפה
פעולות ל-53 סיביות (דיוק כפול) ו -mpc80 מעגל את משמעויות התוצאות
של פעולות נקודה צפה ל-64 סיביות (דיוק כפול מורחב), שזהו
בְּרִירַת מֶחדָל. כאשר משתמשים באפשרות זו, פעולות נקודה צפה ברמת דיוק גבוהה יותר
לא זמין למתכנת מבלי להגדיר במפורש את מילת הבקרה של FPU.

הגדרת העיגול של פעולות נקודה צפה לפחות מאשר ברירת המחדל של 80 סיביות יכולה
להאיץ תוכניות מסוימות ב-2% או יותר. שים לב שחלק מהספריות המתמטיות מניחות זאת
פעולות נקודה צפה עם דיוק מורחב (80 סיביות) מופעלות כברירת מחדל; שגרות
בספריות כאלה עלולים לסבול מאובדן דיוק משמעותי, בדרך כלל באמצעות כך-
נקרא "ביטול קטסטרופלי", כאשר אפשרות זו משמשת להגדרת הדיוק ל
פחות מדיוק מורחב.

-mstackrealign
יישר מחדש את הערימה בכניסה. ב-Intel x86, ה -mstackrealign אפשרות תיצור
פרולוג ואפילוג חלופיים שמיישרים מחדש את ערימת זמן הריצה במידת הצורך.
זה תומך בערבוב קודים מדור קודם השומרים על מחסנית מיושרת של 4 בתים עם קודים מודרניים
ששומרים על מחסנית של 16 בתים עבור תאימות SSE. ראה גם את התכונה
"force_align_arg_pointer", ישים לפונקציות בודדות.

-mreferred-stack-boundary=NUM
נסה לשמור על גבול הערימה מיושר ל-2 מורם ל NUM גבול בתים. אם
-גבול-מחסנית לא צוין, ברירת המחדל היא 4 (16 בתים או 128 סיביות).

אַזהָרָה: בעת יצירת קוד עבור ארכיטקטורת x86-64 עם הרחבות SSE
נָכֶה, -mreferred-stack-boundary=3 ניתן להשתמש כדי לשמור את גבול הערימה מיושר
לגבול 8 בתים. אתה חייב לבנות את כל המודולים עם -mreferred-stack-boundary=3,
כולל כל ספריות. זה כולל את ספריות המערכת ומודול האתחול.

-mincoming-stack-boundary=NUM
נניח שהמחסנית הנכנסת מיושרת ל-2 שהועלתה ל NUM גבול בתים. אם
-גבול-מחסנית-mincoming לא צוין, זה שצוין על ידי
-גבול-מחסנית יהיה בשימוש.

ב-Pentium ו-PentiumPro, ערכי "כפול" ו"כפול ארוך" צריכים להיות מיושרים ל-
גבול של 8 בתים (ראה -ממאיר-כפול) או סובלים מביצועים משמעותיים בזמן ריצה
עונשים. ב-Pentium III, סוג הנתונים של הזרמת SIMD Extension (SSE) "__m128" עשוי
אינו פועל כראוי אם הוא אינו מיושר ל-16 בתים.

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

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

-מממקס
-mno-mmx
-msse
-מנו-סס
-msse2
-mno-sse2
-msse3
-mno-sse3
-mssse3
-mno-ssse3
-msse4.1
-mno-sse4.1
-msse4.2
-mno-sse4.2
-msse4
-mno-sse4
-mavx
-mno-avx
-mavx2
-mno-avx2
-מייס
-mno-aes
-mpclmul
-mno-pclmul
-mfsgsbase
-mno-fsgsbase
-mrdrnd
-mno-rdrnd
-mf16c
-mno-f16c
-mfma
-mno-fma
-msse4a
-mno-sse4a
-mfma4
-mno-fma4
-mxop
-mno-xop
-mlwp
-mno-lwp
-m3dnow
-mno-3dnow
-mpopcnt
-mno-popcnt
-מאבם
-מנו-אבם
-מבמי
-mbmi2
-mno-bmi
-mno-bmi2
-mlzcnt
-mno-lzcnt
-mtbm
-mno-tbm
מתגים אלה מאפשרים או משביתים את השימוש בהוראות ב-MMX, SSE, SSE2, SSE3,
SSSE3, SSE4.1, AVX, AVX2, AES, PCLMUL, FSGSBASE, RDRND, F16C, FMA, SSE4A, FMA4, XOP,
LWP, ABM, BMI, BMI2, LZCNT או 3DNow!
ערכות הוראות מורחבות. הרחבות אלו זמינות גם כמובנות
פונקציות: ראה X86 Built-in פונקציות, לפרטים על הפונקציות המופעלות ו
מושבת על ידי מתגים אלה.

כדי שהוראות SSE/SSE2 יופקו אוטומטית מקוד נקודה צפה (כמו
בניגוד להוראות 387), ראה -mfpmath = sse.

GCC מדכא הוראות SSEx כאשר -mavx משמש. במקום זאת, הוא מייצר AVX חדש
הוראות או שקילות AVX עבור כל הוראות ה-SSEx בעת הצורך.

אפשרויות אלו יאפשרו ל-GCC להשתמש בהוראות המורחבות הללו בקוד שנוצר,
אפילו בלי -mfpmath = sse. יישומים המבצעים זיהוי CPU בזמן ריצה חייבים
הידור קבצים נפרדים עבור כל ארכיטקטורה נתמכת, תוך שימוש בדגלים המתאימים.
בפרט, הקובץ המכיל את קוד זיהוי ה-CPU צריך להיות הידור ללא
אפשרויות אלה.

-mcld
אפשרות זו מורה ל-GCC לפלוט הוראת "cld" בפרולוג הפונקציות
המשתמשים בהוראות מחרוזת. הוראות מחרוזת תלויות בדגל ה-DF לבחירה
בין מצב הגדלה אוטומטית או הפחתה אוטומטית. בעוד ה-ABI מציין את דגל ה-DF ל
יש לנקות בהזנת פונקציה, חלק ממערכות ההפעלה מפרות מפרט זה בכך שלא
ניקוי דגל DF בשולחי החריג שלהם. המטפל חריג יכול להיות
מופעל עם סט דגל DF, מה שמוביל למצב כיוון שגוי בעת מחרוזת
נעשה שימוש בהוראות. ניתן להפעיל אפשרות זו כברירת מחדל ביעדי x32 של 86 סיביות על ידי
הגדרת GCC עם ה --enable-cld אפשרות להגדיר. דור של "cld"
ניתן לדכא הוראות באמצעות ה -mno-cld אפשרות מהדר במקרה זה.

-mvzeroupper
אפשרות זו מורה ל-GCC לפלוט הוראת "vzeroupper" לפני העברה של
לשלוט בזרימת הפונקציה כדי למזער את עונש המעבר של AVX ל-SSE כמו גם
הסר מרכיבי zeroupper מיותרים.

-mrefer-avx128
אפשרות זו מורה ל-GCC להשתמש בהוראות 128-bit AVX במקום 256-bit AVX
הוראות ב-Vectorizer האוטומטי.

-mcx16
אפשרות זו תאפשר ל-GCC להשתמש בהוראת CMPXCHG16B בקוד שנוצר.
CMPXCHG16B מאפשר פעולות אטומיות על נתוני 128 סיביות כפולות מרובע מילים (או oword)
סוגים. זה שימושי עבור מונים ברזולוציה גבוהה שיכולים להתעדכן במספר רב
מעבדים (או ליבות). הוראה זו נוצרת כחלק מ-Atomic מובנה
פונקציות: ראה __סינכרון מובנה or __אָטוֹמִי מובנה לקבלת פרטים.

-משף
אפשרות זו תאפשר ל-GCC להשתמש בהוראת SAHF בקוד 64 סיביות שנוצר. מוקדם
מעבדי אינטל עם אינטל 64 היו חסרים הוראות LAHF ו-SAHF הנתמכות על ידי AMD64 עד
הצגת שלב פנטיום 4 G1 בדצמבר 2005. LAHF ו-SAHF הם עומס ואחסון
הוראות, בהתאמה, לדגלי סטטוס מסוימים. במצב 64 סיביות, SAHF
ההוראה משמשת לאופטימיזציה של פונקציות מובנות "fmod", "drem" או "שארית": ראה
אחר מובנה לקבלת פרטים.

-ממוב
אפשרות זו תאפשר ל-GCC להשתמש בהוראות movbe כדי ליישם את "__builtin_bswap32"
ו-"__builtin_bswap64".

-mcrc32
אפשרות זו תאפשר פונקציות מובנות, "__builtin_ia32_crc32qi",
"__builtin_ia32_crc32hi". "__builtin_ia32_crc32si" ו-"__builtin_ia32_crc32di" ל
הפק את הוראת מכונת crc32.

-mrecip
אפשרות זו תאפשר ל-GCC להשתמש בהוראות RCPSS ו-RSQRTSS (ושלהן
גרסאות וקטוריות RCPPS ו-RSQRTPS) עם צעד נוסף של ניוטון-ראפסון
להגביר את הדיוק במקום DIVSS ו-SQRTSS (והווריאציות הווקטוריות שלהם) עבור
טיעונים של נקודה צפה עם דיוק יחיד. הוראות אלו נוצרות רק כאשר
-אופטימיזציות-funsafe-math מופעל יחד עם -סופית-מתמטיקה-בלבד ו
-fno-מלכודת-מתמטיקה. שימו לב שבעוד התפוקה של הרצף גבוהה מה-
תפוקה של ההוראה הלא הדדית, הדיוק של הרצף יכול להיות
ירד בעד 2 ulp (כלומר ההיפוך של 1.0 שווה ל-0.99999994).

שים לב ש-GCC מיישמת את "1.0f/sqrtf(איקס)" במונחים של RSQRTSS (או RSQRTPS) כבר עם
-מהיר-מתמטיקה (או שילוב האפשרויות לעיל), ואינו צריך -mrecip.

שימו לב גם ש-GCC פולט את הרצף לעיל עם צעד נוסף של ניוטון-ראפסון עבור
חלוקה מוצפת אחת וקטורית "sqrtf(איקס)" כבר עם -מהיר-מתמטיקה
(או שילוב האפשרויות לעיל), ואינו צריך -mrecip.

-mrecip=לִבחוֹר
אפשרות זו מאפשרת לשלוט באילו הוראות אומדן הדדי ניתן להשתמש. לִבחוֹר
היא רשימה מופרדת בפסיקים של אפשרויות, אשר עשויה להיות קודמת לה "!" להפוך את
אפשרות: "הכל": אפשר את כל הוראות האומדן, "ברירת מחדל": אפשר את ברירת המחדל
הוראות, שווה ערך ל -mrecip, "ללא": השבת את כל הוראות האומדן,
שווה ערך ל -mno-recip, "div": אפשר את הקירוב לחלוקה סקלרית,
"vec-div": אפשר את הקירוב לחלוקה וקטורית, "sqrt": אפשר את
קירוב לשורש ריבועי סקלרי, "vec-sqrt": אפשר את הקירוב עבור
שורש ריבועי וקטורי.

אז למשל, -mrecip=all,!sqrt יאפשר את כל הקירוב ההדדיים,
חוץ מהשורש הריבועי.

-mveclibabi=סוג
מציין את סוג ABI לשימוש עבור וקטוריזציה פנימית באמצעות ספרייה חיצונית.
הסוגים הנתמכים הם "svml" עבור ספריית המתמטיקה הווקטורית הקצרה של Intel ו-"acml" עבור
סגנון התממשקות של ספריית ליבת המתמטיקה של AMD. GCC תשלח כעת שיחות אל
"vmldExp2", "vmldLn2", "vmldLog102", "vmldLog102", "vmldPow2", "vmldTanh2",
"vmldTan2", "vmldAtan2", "vmldAtanh2", "vmldCbrt2", "vmldSinh2", "vmldSin2",
"vmldAsinh2", "vmldAsin2", "vmldCosh2", "vmldCos2", "vmldAcosh2", "vmldAcos2",
"vmlsExp4", "vmlsLn4", "vmlsLog104", "vmlsLog104", "vmlsPow4", "vmlsTanh4",
"vmlsTan4", "vmlsAtan4", "vmlsAtanh4", "vmlsCbrt4", "vmlsSinh4", "vmlsSin4",
"vmlsAsinh4", "vmlsAsin4", "vmlsCosh4", "vmlsCos4", "vmlsAcosh4" ו-"vmlsAcos4" עבור
סוג הפונקציה התואם כאשר -mveclibabi=svml הוא בשימוש ו-"__vrd2_sin",
"__vrd2_cos", "__vrd2_exp", "__vrd2_log", "__vrd2_log2", "__vrd2_log10",
"__vrs4_sinf", "__vrs4_cosf", "__vrs4_expf", "__vrs4_logf", "__vrs4_log2f",
"__vrs4_log10f" ו-"__vrs4_powf" עבור סוג הפונקציה המתאים כאשר
-mveclibabi=acml משמש. שניהם -ftree-vectorize ו -אופטימיזציות-funsafe-math יש
להיות מופעל. ספרייה תואמת SVML או ACML ABI תצטרך לציין בקישור
הזמן.

-מאבי=שם
צור קוד עבור מוסכמות השיחות שצוינה. הערכים המותרים הם: sysv ל
ה-ABI המשמש ב-GNU/Linux ומערכות אחרות ו ms עבור Microsoft ABI. ברירת המחדל
הוא להשתמש ב-Microsoft ABI בעת מיקוד ל-Windows. בכל שאר המערכות, ברירת המחדל
הוא SYSV ABI. אתה יכול לשלוט בהתנהגות זו עבור פונקציה מסוימת על ידי שימוש ב-
תכונת פונקציה ms_abi/sysv_abi.

-mtls-dialect=סוג
צור קוד כדי לגשת לאחסון מקומי באמצעות גנו or gnu2 מוסכמות. גנו
הוא ברירת המחדל השמרנית; gnu2 הוא יעיל יותר, אבל הוא עשוי להוסיף קומפיל-והפעלה-
דרישות זמן שלא ניתן לעמוד בהן בכל המערכות.

-מפוש-ארגס
-mno-push-args
השתמש בפעולות PUSH כדי לאחסן פרמטרים יוצאים. שיטה זו קצרה יותר ובדרך כלל
מהירה באותה מידה כמו שיטה המשתמשת בפעולות SUB/MOV והיא מופעלת כברירת מחדל. בחלק
מקרים השבתת אותו עשויה לשפר את הביצועים בגלל תזמון משופר ומופחת
תלות.

-צבור-יוצא-ארגים
אם מופעל, כמות השטח המקסימלית הנדרשת עבור ארגומנטים יוצאים תהיה
מחושבים בפרולוג הפונקציה. זה מהיר יותר ברוב המעבדים המודרניים בגלל
תלות מופחתת, תזמון משופר ושימוש מופחת בערימה כאשר מחסנית מועדפת
הגבול אינו שווה ל-2. החיסרון הוא עלייה בולטת בגודל הקוד. זֶה
מתג מרמז -mno-push-args.

-חוטים
תומך בטיפול חריג בטוח בחוט Mingw32. קוד המסתמך על שרשור בטוח
טיפול חריג חייב להדר ולקשר את כל הקוד עם ה- -חוטים אוֹפְּצִיָה. מתי
קומפילציה, -חוטים מגדיר -D_MT; כאשר מקשרים, זה מקשר במסייע שרשור מיוחד
ספריה -lmingwthrd שמנקה את נתוני הטיפול בחריג שרשור.

-mno-align-stringops
אל תיישר את היעד של פעולות המחרוזת המוטבעת. מתג זה מקטין את גודל הקוד
ומשפר את הביצועים במקרה שהיעד כבר מיושר, אבל GCC לא
לדעת על זה.

-מינליין-כל-stringops
כברירת מחדל, פעולות מחרוזות מוטבעות של GCC רק כאשר ידוע שהיעד הוא
מיושר לגבול של 4 בתים לפחות. זה מאפשר שילוב רב יותר, הגדלת גודל הקוד,
אבל עשוי לשפר את הביצועים של קוד התלוי ב-memcpy מהיר, strlen ו-memset עבור
אורכים קצרים.

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

-mstringop-strategy=ALG
החלף היוריסטית החלטה פנימית לגבי אלגוריתם מסוים למחרוזת מוטבעת
פעולה עם. הערכים המותרים הם "rep_byte", "rep_4byte", "rep_8byte" עבור
הרחבה באמצעות i386 "rep" קידומת בגודל שצוין, "byte_loop", "לולאה",
"unrolled_loop" להרחבת לולאה מוטבעת, "libcall" להרחבת ספרייה תמידית
שיחה.

-momit-leaf-frame-pointer
אל תשמור את מצביע המסגרת בפנקס עבור פונקציות עלים. זה נמנע את
הוראות לשמירה, הגדרה ושחזור של מצביעי מסגרת ועושה רישום נוסף
זמין בפונקציות עלים. האפשרות -fomit-frame-pointer מסיר את המסגרת
מצביע עבור כל הפונקציות, מה שעשוי להקשות על ניפוי באגים.

-mtls-direct-seg-refs
-mno-tls-direct-seg-refs
שולט אם ניתן לגשת למשתני TLS עם היסטים מקטע TLS
לרשום (%gs עבור 32 סיביות, %fs עבור 64 סיביות), או אם מצביע בסיס השרשור חייב להיות
הוסיף. האם זה חוקי או לא תלוי במערכת ההפעלה, והאם זה
ממפה את הקטע כך שיכסה את כל אזור ה-TLS.

עבור מערכות המשתמשות ב-GNU libc, ברירת המחדל מופעלת.

-msse2avx
-mno-sse2avx
ציין שהאסמבלר צריך לקודד הוראות SSE עם קידומת VEX. האפשרות
-mavx מפעיל את זה כברירת מחדל.

-מפנטרי
-מנו-פנטרי
אם הפרופיל פעיל -עמוד שים את שיחת מונה הפרופיל לפני הפרולוג. הערה: פועל
ארכיטקטורות x86 התכונה "ms_hook_prologue" אינה אפשרית כרגע עבור
-מפנטרי ו -עמוד.

-m8bit-idiv
-mno-8bit-idiv
במעבדים מסוימים, כמו Intel Atom, חלוקת מספרים שלמים ללא סימנים של 8 סיביות היא הרבה יותר מהירה
חלוקת מספרים שלמים של 32 סיביות/64 סיביות. אפשרות זו יוצרת בדיקת זמן ריצה. אם שניהם
דיבידנד ומחלק נמצאים בטווח של 0 עד 255, חלוקת מספר שלם ללא סימן של 8 סיביות היא
בשימוש במקום חלוקת מספרים שלמים של 32 סיביות/64 סיביות.

-mavx256-split-unaligned-load
-mavx256-split-unaligned-store
פיצול 32-בייט AVX לא מיושר עומס ואחסון.

אלה -m מתגים נתמכים בנוסף לאמור לעיל במעבדי AMD x86-64 ב
סביבות 64 סיביות.

-מ 32
-מ 64
-mx32
צור קוד עבור סביבת 32 סיביות או 64 סיביות. ה -מ 32 הגדרות אפשרויות int, long ו
מצביע ל-32 סיביות ומייצר קוד שפועל בכל מערכת i386. ה -מ 64 אוֹפְּצִיָה
מגדיר int ל-32 סיביות וארוך ומצביע ל-64 סיביות ומייצר קוד עבור AMD
ארכיטקטורת x86-64. ה -mx32 אפשרות מגדירה int, long ו-pointer ל-32 סיביות ו
מייצר קוד לארכיטקטורת x86-64 של AMD. עבור דרווין רק את -מ 64 סיבובי אפשרות
.. -fno-pic ו -מדינמית-ללא-תמונה אפשרויות.

-mno-red-zone
אל תשתמש באזור אדום עבור קוד x86-64. האזור האדום מוטל על ידי
x86-64 ABI, זהו אזור של 128 בתים מעבר למיקום של מצביע המחסנית
לא ניתן לשנות על ידי מטפלי אותות או פסיקות ולכן ניתן להשתמש בו עבור
נתונים זמניים מבלי להתאים את מצביע הערימה. הדגל -mno-red-zone משבית
האזור האדום הזה.

-mcmodel=small
צור קוד עבור מודל הקוד הקטן: יש לקשר את התוכנית והסמלים שלה
ה-2 GB התחתונים של מרחב הכתובות. מצביעים הם 64 סיביות. תוכניות יכולות להיות
מקושר סטטי או דינמי. זהו מודל הקוד המוגדר כברירת מחדל.

-mcmodel=kernel
צור קוד עבור מודל קוד הליבה. הקרנל פועל ב-2 GB השלילי של ה-
מרחב כתובת. יש להשתמש במודל זה עבור קוד ליבת לינוקס.

-mcmodel = בינוני
צור קוד עבור הדגם הבינוני: התוכנית מקושרת ב-2 GB התחתונים של
מרחב כתובת. גם סמלים קטנים ממוקמים שם. סמלים בגדלים גדולים מ
-הגדלת-נתונים-סף מוכנסים לקטעי נתונים גדולים או bss וניתן לאתר אותם
מעל 2GB. תוכניות יכולות להיות מקושרות באופן סטטי או דינמי.

-mcmodel=גדול
צור קוד עבור המודל הגדול: מודל זה אינו מניח הנחות לגבי כתובות ו
גדלים של קטעים.

-מדdress-mode=ארוך
צור קוד למצב כתובת ארוכה. זה נתמך רק עבור 64 סיביות ו-x32
סביבות. זהו מצב הכתובת המוגדר כברירת מחדל עבור סביבות 64 סיביות.

-maddress-mode=קצר
צור קוד למצב כתובת קצרה. זה נתמך רק עבור 32 סיביות ו-x32
סביבות. זהו מצב הכתובת המוגדר כברירת מחדל עבור סביבות 32 סיביות ו-x32.

i386 ו x86-64 Windows אפשרויות

אפשרויות נוספות אלו זמינות עבור יעדי Windows:

-mconsole
אפשרות זו זמינה עבור יעדי Cygwin ו-MinGW. זה מציין כי קונסולה
יש ליצור יישום, על ידי הוראה למקשר להגדיר את כותרת ה-PE
סוג המשנה הנדרש עבור יישומי מסוף. זוהי התנהגות ברירת המחדל עבור
יעדי Cygwin ו-MinGW.

-mdll
אפשרות זו זמינה עבור יעדי Cygwin ו-MinGW. זה מציין ש-DLL - א
ספריית קישורים דינמיים - יש ליצור, המאפשרת את הבחירה של הדרוש
אובייקט הפעלה ונקודת כניסה בזמן ריצה.

-mnop-fun-dllimport
אפשרות זו זמינה עבור יעדי Cygwin ו-MinGW. הוא מציין כי
יש להתעלם מתכונת dllimport.

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

-מוניקוד
אפשרות זו זמינה עבור מטרות mingw-w64. זה מציין שהמאקרו UNICODE
מוגדר מראש ושנבחר קוד ההפעלה המתאים ל-Unicode.

-mwin32
אפשרות זו זמינה עבור יעדי Cygwin ו-MinGW. זה מציין כי טיפוסי
יש להגדיר פקודות מאקרו מוגדרות מראש של Windows במעבד המוקדם, אך אינן משפיעות
הבחירה של ספריית זמן ריצה/קוד הפעלה.

-mwindows
אפשרות זו זמינה עבור יעדי Cygwin ו-MinGW. זה מציין ש-GUI
יש ליצור יישום על ידי הוראה למקשר להגדיר את כותרת PE
סוג תת מערכת כראוי.

-fno-set-stack-ניתן להפעלה
אפשרות זו זמינה עבור יעדי MinGW. זה מציין שדגל ההפעלה עבור
מחסנית בשימוש על ידי פונקציות מקוננות לא מוגדרת. זה הכרחי עבור ריצה בינאריים
מצב ליבה של Windows, כמו שם ה-API של user32, המשמש להגדרת קובץ הפעלה
הרשאות, אינו זמין.

-mpe-aligned-commons
אפשרות זו זמינה עבור יעדי Cygwin ו-MinGW. זה מציין שה-GNU
הרחבה לפורמט הקובץ PE המאפשר יישור נכון של משתני COMMON
יש להשתמש בעת יצירת קוד. זה יופעל כברירת מחדל אם GCC יזהה
שמרכיב היעד שנמצא במהלך התצורה תומך בתכונה.

ראה גם תחת i386 ו x86-64 אפשרויות עבור אפשרויות סטנדרטיות.

IA-64 אפשרויות

אלה -m אפשרויות שהוגדרו עבור ארכיטקטורת Intel IA-64.

-mbig-endian
צור קוד עבור יעד גדול. זוהי ברירת המחדל עבור HP-UX.

-מעט-אנדיאן
צור קוד עבור יעד קטן. זוהי ברירת המחדל עבור AIX5 ו-GNU/Linux.

-mgnu-as
-mno-gnu-as
צור (או אל תעשה) קוד עבור ה-GNU assembler. זוהי ברירת המחדל.

-מגנו-לד
-mno-gnu-ld
צור (או לא) קוד עבור מקשר GNU. זוהי ברירת המחדל.

-מנו-תמונה
צור קוד שאינו משתמש באוגר מצביע גלובלי. התוצאה היא לא מיקום
קוד עצמאי, ומפר את IA-64 ABI.

-mvolatile-asm-stop
-MNO-VOLATILE-ASM-STOP
צור (או אל תעשה) סטופ ביט מיד לפני ואחרי הצהרות asm נדיפות.

-mregister-names
-מנו-רישום-שמות
ליצור (או לא) in, loc, ו הַחוּצָה רישום שמות עבור האוגרים המוערמים. זֶה
עשוי להפוך את פלט ה-assembler לקריאה יותר.

-mno-sdata
-msdata
השבת (או הפעל) אופטימיזציות המשתמשות בקטע הנתונים הקטנים. זה עשוי להיות שימושי
לעקוף באגים למיטוב.

-mconstant-gp
צור קוד שמשתמש בערך מצביע גלובלי קבוע אחד. זה שימושי כאשר
קומפילציה של קוד ליבה.

-תמונה אוטומטית
צור קוד שניתן להעברה עצמית. זה מרמז -mconstant-gp. זה שימושי
בעת הידור קוד קושחה.

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

-מיניליין-float-divide-max-throughput
צור קוד לחלוקה מוטבעת של ערכי נקודה צפה תוך שימוש בתפוקה המקסימלית
אלגוריתם.

-mno-inline-float-divide
אל תיצור קוד מוטבע עבור חלוקות של ערכי נקודה צפה.

-minline-int-divide-min-latency
צור קוד עבור חלוקות מוטבעות של ערכי מספר שלמים תוך שימוש בהשהייה המינימלית
אלגוריתם.

-minline-int-divide-max-throughput
צור קוד עבור חלוקות מוטבעות של ערכי מספרים שלמים באמצעות התפוקה המקסימלית
אלגוריתם.

-mno-inline-int-divide
אל תיצור קוד מוטבע עבור חלוקות של ערכים שלמים.

-minline-sqrt-min-latency
צור קוד עבור שורשים מרובעים מוטבעים באמצעות אלגוריתם השהייה המינימלית.

-minline-sqrt-max-throughput
צור קוד עבור שורשים מרובעים מוטבעים באמצעות אלגוריתם התפוקה המקסימלית.

-mno-inline-sqrt
אל תיצור קוד מוטבע עבור sqrt.

-מfused-madd
-mno-fused-madd
האם (אל תיצור) קוד שמשתמש בכפל/הוספה או הכפל/החסר
הוראות. ברירת המחדל היא להשתמש בהוראות אלה.

-mno-dwarf2-asm
-mdwarf2-asm
אל תיצור (או תעשה) קוד אסמבלר עבור מידע איתור באגים של מספר קו DWARF2. זֶה
עשוי להיות שימושי כאשר לא משתמשים ב-GNU assembler.

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

-mfixed-range=רישום-טווח
צור קוד המתייחס לטווח האוגר הנתון כאל אוגרים קבועים. פנקס קבוע
הוא כזה שמקצי הרשומות לא יכול להשתמש בו. זה שימושי בעת הידור ליבה
קוד. טווח רישום מצוין כשני אוגרים מופרדים באמצעות מקף. מרובות
ניתן לציין טווחי רישום מופרדים באמצעות פסיק.

-mtls-size=tls-גודל
ציין גודל סיביות של קיזוז TLS מיידי. ערכים חוקיים הם 14, 22 ו-64.

-mtune=סוג מעבד
כוונן את תזמון ההוראות עבור מעבד מסוים, ערכים חוקיים הם itanium,
itanium1, merced, itanium2 ומקינלי.

-מילפ32
-mlp64
צור קוד עבור סביבת 32 סיביות או 64 סיביות. סביבת 32 סיביות מגדירה int,
ארוך ומצביע ל-32 סיביות. סביבת 64 סיביות מגדירה int ל-32 סיביות וארוך ו
מצביע ל-64 סיביות. אלו הם דגלים ספציפיים ל-HP-UX.

-mno-sched-br-data-spec
-msched-br-data-spec
(Di/En) אפשר תזמון ספקולטיבי של נתונים לפני טעינה מחדש. זה יביא ל
יצירת הוראות ld.a והוראות הבדיקה המתאימות (ld.c /
chk.a). ברירת המחדל היא 'נטרול'.

-msched-ar-data-spec
-mno-sched-ar-data-spec
(Iw/Di) תזמון ספקולטיבי לנתונים לאחר טעינה מחדש. זה יגרום לדור
של הוראות ld.a והוראות הבדיקה המתאימות (ld.c / chk.a). ה
ברירת המחדל היא 'אפשר'.

-mno-sched-control-spec
-msched-control-spec
(Dis/En) אפשר לשלוט בתזמון ספקולטיבי. תכונה זו זמינה רק במהלך
תזמון אזור (כלומר לפני טעינה מחדש). זה יגרום ליצירת ה-ld.s
הוראות והוראות הבדיקה המתאימות chk.s . ברירת המחדל היא
'להשבית'.

-msched-br-in-data-spec
-mno-sched-br-in-data-spec
(He/Dis) תזמון ספקולטיבי של ההוראות התלויות בנתונים
עומסים ספקולטיביים לפני טעינה מחדש. זה יעיל רק עם -msched-br-data-spec
מופעל. ברירת המחדל היא 'אפשר'.

-msched-ar-in-data-spec
-mno-sched-ar-in-data-spec
(He/Dis) תזמון ספקולטיבי של ההוראות התלויות בנתונים
עומסים ספקולטיביים לאחר טעינה מחדש. זה יעיל רק עם -msched-ar-data-spec
מופעל. ברירת המחדל היא 'אפשר'.

-Mched-in-control-spec
-mno-sched-in-control-spec
(He/Dis) תזמון ספקולטיבי של ההוראות התלויות ב-
לשלוט בעומסים ספקולטיביים. זה יעיל רק עם -msched-control-spec מאופשר.
ברירת המחדל היא 'אפשר'.

-mno-sched-prefer-non-data-spec-insns
-msched-prefer-non-data-spec-insns
אם מופעל, הוראות ספקולטיביות של נתונים ייבחרו ללוח הזמנים רק אם ישנן
אין אפשרויות אחרות כרגע. זה יעשה שימוש בספקולציות הנתונים
הרבה יותר שמרני. ברירת המחדל היא 'נטרול'.

-mno-sched-prefer-non-control-spec-insns
-msched-prefer-non-control-spec-insns
אם מופעל, הוראות ספקולטיביות בקרה ייבחרו ללוח הזמנים רק אם קיימות
אין אפשרויות אחרות כרגע. זה יעשה שימוש בספקולציות השליטה
הרבה יותר שמרני. ברירת המחדל היא 'נטרול'.

-mno-sched-count-spec-in-critical-path
-msched-count-spec-in-critical-path
אם מופעל, תלות ספקולטיבית תיחשב במהלך חישוב ה-
הוראות עדיפויות. זה יהפוך את השימוש בספקולציות לקצת יותר
שמרני. ברירת המחדל היא 'נטרול'.

-msched-spec-ldc
השתמש בבדיקת ספקולציות נתונים פשוטה. אפשרות זו מופעלת כברירת מחדל.

-msched-control-spec-ldc
השתמש בצ'ק פשוט לספקולציות בקרה. אפשרות זו מופעלת כברירת מחדל.

-msched-stop-bits-after-every-cycle
הנח ביט עצירה לאחר כל מחזור בעת תזמון. אפשרות זו מופעלת כברירת מחדל.

-msched-fp-mem-deps-XNUMX-עלות
נניח שמאגרי נקודה צפה ועומסים לא צפויים לגרום להתנגשות כאשר
הוכנס לאותה קבוצת הדרכה. אפשרות זו מושבתת כברירת מחדל.

-msel-sched-dont-check-control-spec
צור צ'קים לספקולציות בקרה בתזמון סלקטיבי. הדגל הזה הוא
מושבת כברירת מחדל.

-msched-max-memory-insns=max-insns
הגבלה על מספר כניסות הזיכרון לקבוצת הוראות, מתן עדיפות נמוכה יותר ל
זכרונות עוקבים המנסים לתזמן באותה קבוצת הוראות.
שימושי לעתים קרובות כדי למנוע התנגשויות בבנק מטמון. ערך ברירת המחדל הוא 1.

-msched-max-memory-insns-hard-limit
אסור לאפשר יותר מ-'msched-max-memory-insns' בקבוצת ההוראות. אחרת, הגבל
הוא 'רך' כלומר נעדיף פעולות שאינן זיכרון כאשר הגבול הושג אבל
עדיין עשוי לתזמן פעולות זיכרון.

IA-64/VMS אפשרויות

אלה -m אפשרויות מוגדרות עבור יישומי IA-64/VMS:

-mvms-return-codes
החזר קודי תנאי VMS מהראשי. ברירת המחדל היא החזרת מצב בסגנון POSIX
(למשל שגיאה) קודי.

-mdebug-main=קידומת
סמן את השגרה הראשונה ששמה מתחיל בה קידומת כשגרה העיקרית עבור
מנפה.

-mmalloc64
ברירת מחדל לשגרות הקצאת זיכרון של 64 סיביות.

LM32 אפשרויות

אלה -m אפשרויות מוגדרות עבור ארכיטקטורת Lattice Mico32:

-mbarrel-shift-enabled
אפשר הוראות העברת חבית.

-mdivide מאופשר
אפשר הוראות חלוקה ומודולוס.

-מופעל מרובה
אפשר הכפל הוראות.

-msign-extend-enabled
אפשר הוראות להרחבת שלט.

-מופעל על ידי muser
אפשר הוראות בהגדרת משתמש.

M32C אפשרויות

-mcpu=שם
בחר את המעבד שעבורו נוצר הקוד. שם עשוי להיות אחד מהם r8c עבור R8C/Tiny
סִדרָה, m16c עבור סדרת M16C (עד /60), m32 ס"מ עבור סדרת M16C/80, או m32c
עבור סדרת M32C/80.

-מסים
מציין שהתוכנית תופעל בסימולטור. זה גורם לחילופין
ספריית זמן ריצה לקישור בה תומכת, למשל, ב-I/O של קבצים. אסור לך
השתמש באפשרות זו בעת יצירת תוכניות שיפעלו על חומרה אמיתית; אתה חייב
ספק ספריית זמן ריצה משלך עבור כל פונקציות I/O הדרושות.

-memregs=מספר
מציין את מספר הרשמים הפסאודו מבוססי הזיכרון ש-GCC ישתמש במהלך הקוד
דוֹר. פסאודו-רגיסטרים אלה ישמשו כמו רגיסטרים אמיתיים, אז יש א
פשרה בין היכולת של GCC להתאים את הקוד לרשמים זמינים, לבין
עונש ביצועים של שימוש בזיכרון במקום אוגרים. שימו לב שכל המודולים ב-a
יש להרכיב את התוכנית עם אותו ערך עבור אפשרות זו. בגלל זה, אתה
אסור להשתמש באפשרות זו עם ספריות ברירת המחדל של זמן הריצה gcc builds.

M32R/D אפשרויות

אלה -m אפשרויות מוגדרות עבור ארכיטקטורות Renesas M32R/D:

-M32R2.
צור קוד עבור M32R/2.

-m32rx
צור קוד עבור M32R/X.

-m32r
צור קוד עבור M32R. זוהי ברירת המחדל.

-mmodel=קטן
נניח שכל האובייקטים חיים ב-16MB התחתון של הזיכרון (כך שהכתובות שלהם יכולות להיות
נטען בהוראה "ld24"), ותניח שכל תת-השגרות ניתנות לגישה עם ה-
הוראת "bl". זוהי ברירת המחדל.

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

-mmodel=בינוני
נניח שאובייקטים עשויים להיות בכל מקום במרחב הכתובות של 32 סיביות (המהדר יפיק
"seth/add3" הוראות לטעינת הכתובות שלהם), ותניח שכל תתי השגרות כן
ניתן להגיע עם הוראת "bl".

-mmodel=גדול
נניח שאובייקטים עשויים להיות בכל מקום במרחב הכתובות של 32 סיביות (המהדר יפיק
"seth/add3" הוראות לטעינת הכתובות שלהם), ולהניח שייתכן שלא יהיו תתי שגרות
ניתן להגיע עם הפקודה "bl" (המהדר יפיק את האיטי הרבה יותר
"seth/add3/jl" רצף הוראות).

-msdata=אין
השבת את השימוש באזור הנתונים הקטן. משתנים יוכנסו לאחד מהם נתונים, BSS, או
.rodata (אלא אם צוינה תכונת "סעיף"). זוהי ברירת המחדל.

אזור הנתונים הקטן מורכב מקטעים .sdata ו .sbss. אובייקטים עשויים להיות במפורש
הכנס לאזור הנתונים הקטן עם התכונה "קטע" באמצעות אחד מהסעיפים האלה.

-msdata=sdata
שים נתונים גלובליים וסטטיים קטנים באזור הנתונים הקטנים, אך אל תייצר מיוחדים
קוד שיפנה אליהם.

-msdata=שימוש
שים נתונים גלובליים וסטטיים קטנים באזור הנתונים הקטנים, והפק מיוחד
הוראות להתייחס אליהם.

-G NUM
שים אובייקטים גלובליים וסטטיים פחות או שווה ל NUM בתים לתוך הנתונים הקטנים או
קטעי bss במקום הנתונים הרגילים או קטעי bss. ערך ברירת המחדל של NUM is
8. -msdata יש להגדיר את האפשרות לאחד מ sdata or להשתמש כדי שתהיה אפשרות זו
השפעה.

כל המודולים צריכים להיות מורכבים עם אותו הדבר -G NUM ערך. קומפילציה עם שונים
ערכים של NUM עשוי לעבוד או לא; אם לא, המקשר ייתן שגיאה
הודעה --- לא ייווצר קוד שגוי.

-mdebug
גורם לקוד הספציפי של M32R במהדר להציג כמה סטטיסטיקות שעשויות לעזור
בתוכניות איתור באגים.

-ממאיר-לולאות
יישר את כל הלולאות לגבול של 32 בתים.

-mno-align-לולאות
אל תאכוף יישור של 32 בתים עבור לולאות. זוהי ברירת המחדל.

-שיעור חסר=מספר
גיליון מספר הוראות לכל מחזור. מספר יכול להיות רק 1 או 2.

-brranch-cost=מספר
מספר יכול להיות רק 1 או 2. אם זה 1 אז ענפים יועדפו על פני
קוד מותנה, אם הוא 2, ההפך יחול.

-mflush-trap=מספר
מציין את מספר המלכודת לשימוש כדי לשטוף את המטמון. ברירת המחדל היא 12. חוקי
המספרים הם בין 0 ל-15 כולל.

-מנו-פלוש-מלכודת
מציין שלא ניתן לשטוף את המטמון באמצעות מלכודת.

-mflush-func=שם
מציין את השם של פונקציית מערכת ההפעלה להתקשר כדי לשטוף את המטמון. ה
ברירת המחדל היא _flush_cache, אבל קריאת פונקציה תשמש רק אם לא מלכודת
זמין.

-mno-flush-func
מציין שאין פונקציית מערכת הפעלה לניקוי המטמון.

M680x0 אפשרויות

אלה -m אפשרויות שהוגדרו עבור מעבדי M680x0 ו- ColdFire. הגדרות ברירת המחדל
תלוי באיזו ארכיטקטורה נבחרה כאשר המהדר הוגדר; ברירות המחדל
עבור הבחירות הנפוצות ביותר ניתנות להלן.

-מרץ=קשת
צור קוד עבור ארכיטקטורת ערכת הוראות ספציפית של M680x0 או ColdFire.
ערכים מותרים של קשת עבור ארכיטקטורות M680x0 הן: 68000, 68010, 68020, 68030,
68040, 68060 ו cpu32. ארכיטקטורות ColdFire נבחרות בהתאם לארכיטקטורות של Freescale
סיווג ISA והערכים המותרים הם: איסאא, isaaplus, איזאב ו איזק.

gcc מגדיר מאקרו __mcfקשת__ בכל פעם שהוא מייצר קוד עבור יעד ColdFire.
אל האני קשת במאקרו זה הוא אחד מה -מרץ הטיעונים שניתנו לעיל.

בשימוש יחד, -מרץ ו -mtune בחר קוד שפועל על משפחה של דומה
מעבדים אבל זה מותאם למיקרו ארכיטקטורה מסוימת.

-mcpu=מעבד
צור קוד עבור מעבד M680x0 או ColdFire ספציפי. ה-M680x0 מעבדs הם:
68000, 68010, 68020, 68030, 68040, 68060, 68302, 68332 ו cpu32. ה-ColdFire מעבדs
ניתנים על ידי הטבלה שלהלן, אשר מסווגת גם את המעבדים למשפחות:

משפחה: -mcpu טיעונים
51 : 51 51ac 51cn 51em 51qe
5206 : 5202 5204 5206
5206e : 5206e
5208 : 5207 5208
5211a : 5210a 5211a
5213 : 5211 5212 5213
5216 : 5214 5216
52235 : 52230 52231 52232 52233 52234 52235
5225 : 5224 5225
52259 : 52252 52254 52255 52256 52258 52259
5235 : 5232 5233 5234 5235 523x
5249 : 5249
5250 : 5250
5271 : 5270 5271
5272 : 5272
5275 : 5274 5275
5282 : 5280 5281 5282 528x
53017 : 53011 53012 53013 53014 53015 53016 53017
5307 : 5307
5329 : 5327 5328 5329 532x
5373 : 5372 5373 537x
5407 : 5407
5475 : 5470 5471 5472 5473 5474 5475 547x 5480 5481 5482 5483 5484 5485

-mcpu=מעבד מבטל -מרץ=קשת if קשת תואם מעבד. שילובים אחרים של
-mcpu ו -מרץ נדחים.

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

-mtune=מנגינה
כוונן את הקוד עבור מיקרו-ארכיטקטורה מסוימת, במסגרת האילוצים שנקבעו על ידי -מרץ
ו -mcpu. המיקרו-ארכיטקטורות של M680x0 הן: 68000, 68010, 68020, 68030, 68040,
68060 ו cpu32. המיקרו-ארכיטקטורות של ColdFire הן: cfv1, cfv2, cfv3, cfv4 ו
cfv4e.

אתה יכול גם להשתמש -mtune=68020-40 עבור קוד שצריך לפעול בצורה טובה יחסית ב-68020,
68030 ו-68040 יעדים. -mtune=68020-60 דומה אך כולל 68060 יעדים כמו
נו. שתי אפשרויות אלה בוחרות את אותן החלטות כוונון כמו -m68020-40 ו -m68020-60
בהתאמה.

gcc מגדיר את פקודות המאקרו __mcקשת ו __mcקשת__ בעת כוונון לארכיטקטורת 680x0
קשת. זה גם מגדיר mcקשת אלא אם כן -אנסי או שאינו גנו -סטד נעשה שימוש באופציה.
אם gcc מכוון למגוון ארכיטקטורות, כפי שנבחר על ידי -mtune=68020-40 or
-mtune=68020-60, הוא מגדיר את פקודות המאקרו עבור כל ארכיטקטורה בטווח.

gcc מגדיר גם את המאקרו __Mמוקדם__ בעת כוונון עבור מיקרו-ארכיטקטורת ColdFire
מוקדם, שם מוקדם הוא אחד הטיעונים שהועלו לעיל.

-מ 68000
-mc68000
צור פלט עבור 68000. זוהי ברירת המחדל כאשר המהדר מוגדר עבור
מערכות מבוססות 68000. זה שווה ערך ל -מרץ=68000.

השתמש באפשרות זו עבור מיקרו-בקרים עם ליבת 68000 או EC000, כולל 68008,
68302, 68306, 68307, 68322, 68328 ו -68356.

-מ 68010
צור פלט עבור 68010. זוהי ברירת המחדל כאשר המהדר מוגדר עבור
מערכות מבוססות 68010. זה שווה ערך ל -מרץ=68010.

-מ 68020
-mc68020
צור פלט עבור 68020. זוהי ברירת המחדל כאשר המהדר מוגדר עבור
מערכות מבוססות 68020. זה שווה ערך ל -מרץ=68020.

-מ 68030
צור פלט עבור 68030. זוהי ברירת המחדל כאשר המהדר מוגדר עבור
מערכות מבוססות 68030. זה שווה ערך ל -מרץ=68030.

-מ 68040
צור פלט עבור 68040. זוהי ברירת המחדל כאשר המהדר מוגדר עבור
מערכות מבוססות 68040. זה שווה ערך ל -מרץ=68040.

אפשרות זו מונעת את השימוש בהוראות 68881/68882 שיש לחקות על ידי
תוכנה ב-68040. השתמש באפשרות זו אם ל-68040 שלך אין קוד לחיקוי
ההוראות האלה.

-מ 68060
צור פלט עבור 68060. זוהי ברירת המחדל כאשר המהדר מוגדר עבור
מערכות מבוססות 68060. זה שווה ערך ל -מרץ=68060.

אפשרות זו מונעת את השימוש בהוראות 68020 ו-68881/68882 שחייבות להיות
חיקוי על ידי תוכנה ב-68060. השתמש באפשרות זו אם ל-68060 שלך אין קוד
לחקות את ההוראות האלה.

-mcpu32
צור פלט עבור CPU32. זוהי ברירת המחדל כאשר המהדר מוגדר עבור
מערכות מבוססות CPU32. זה שווה ערך ל -march=cpu32.

השתמש באפשרות זו עבור מיקרו-בקרים עם ליבת CPU32 או CPU32+, כולל 68330,
68331, 68332, 68333, 68334, 68336, 68340, 68341, 68349 ו-68360.

-מ 5200
צור פלט עבור מעבד ColdFire 520X. זוהי ברירת המחדל כאשר המהדר הוא
מוגדר עבור מערכות מבוססות 520X. זה שווה ערך ל -mcpu=5206, ועכשיו
נדחה לטובת אפשרות זו.

השתמש באפשרות זו עבור מיקרו-בקר עם ליבה 5200, כולל MCF5202, MCF5203,
MCF5204 ו-MCF5206.

-m5206e
צור פלט עבור מעבד 5206e ColdFire. האפשרות הוצאה כעת משימוש לטובת
המקבילה -mcpu=5206e.

-מ528x
צור פלט עבור חבר במשפחת ColdFire 528X. האפשרות היא עכשיו
נדחה לטובת המקבילה -mcpu=528x.

-מ 5307
צור פלט עבור מעבד ColdFire 5307. האופציה הוצאה כעת משימוש לטובת ה
שווה -mcpu=5307.

-מ 5407
צור פלט עבור מעבד ColdFire 5407. האופציה הוצאה כעת משימוש לטובת ה
שווה -mcpu=5407.

-mcfv4e
צור פלט עבור מעבד ColdFire V4e ממשפחת ColdFire (למשל 547x/548x). זה כולל שימוש ב
הוראות נקודה צפה בחומרה. האופציה מקבילה ל -mcpu=547x, והוא
נדחה כעת לטובת אפשרות זו.

-m68020-40
צור פלט עבור 68040, מבלי להשתמש באף אחת מההוראות החדשות. התוצאות האלה
בקוד שיכול לפעול ביעילות יחסית על 68020/68881 או 68030 או על
68040. הקוד שנוצר אכן משתמש בהוראות 68881 שמחקות ב-
68040.

האופציה מקבילה ל -מרץ=68020 -mtune=68020-40.

-m68020-60
צור פלט עבור 68060, מבלי להשתמש באף אחת מההוראות החדשות. התוצאות האלה
בקוד שיכול לפעול ביעילות יחסית על 68020/68881 או 68030 או על
68040. הקוד שנוצר אכן משתמש בהוראות 68881 שמחקות ב-
68060.

האופציה מקבילה ל -מרץ=68020 -mtune=68020-60.

-mhard-float
-מ 68881
צור הוראות נקודה צפה. זוהי ברירת המחדל עבור 68020 ומעלה, ו
עבור התקני ColdFire בעלי FPU. זה מגדיר את המאקרו __HAVE_68881__ על M680x0
מטרות ו __mcffpu__ על מטרות ColdFire.

-msoft-float
אל תיצור הוראות נקודה צפה; השתמש בשיחות ספרייה במקום זאת. זה
ברירת מחדל עבור יעדים 68000, 68010 ו-68832. זוהי גם ברירת המחדל עבור ColdFire
מכשירים שאין להם FPU.

-מדיב
-mno-div
צור (אל תיצור) הוראות לחלוקת חומרה של ColdFire. אם
-מרץ משמש בלי -mcpu, ברירת המחדל היא "מופעל" עבור ארכיטקטורות ColdFire ו"כבוי"
עבור ארכיטקטורות M680x0. אחרת, ברירת המחדל נלקחת ממעבד היעד (או
מעבד ברירת המחדל, או זה שצוין על ידי -mcpu). לדוגמה, ברירת המחדל היא "כבוי"
ל -mcpu=5206 ו"על" עבור -mcpu=5206e.

gcc מגדיר את המאקרו __mcfhwdiv__ כאשר אפשרות זו מופעלת.

-מקצר
שקול את סוג "int" ברוחב 16 סיביות, כמו "short int". בנוסף, פרמטרים
שהועברו על המחסנית מיושרים גם לגבול של 16 סיביות אפילו על יעדים שה-API שלהם
מחייב קידום ל-32 סיביות.

-מנו-קצר
אל תחשוב על סוג "int" ברוחב של 16 סיביות. זוהי ברירת המחדל.

-מנוביטפילד
-mno-bitfield
אל תשתמש בהוראות שדה סיביות. ה -מ 68000, -mcpu32 ו -מ 5200 אפשרויות מרמזות
-מנוביטפילד.

-מביטפילד
השתמש בהוראות שדה הסיביות. ה -מ 68020 האופציה מרמזת -מביטפילד. זה
ברירת המחדל אם אתה משתמש בתצורה המיועדת ל-68020.

-mrtd
השתמש במוסכמה אחרת של קריאת פונקציות, שבה פונקציות שלוקחות קבוע
מספר הארגומנטים חוזרים עם הוראת "rtd", שמציגה את הטיעונים שלהם
בזמן החזרה. זה חוסך הוראה אחת אצל המתקשר מכיוון שאין צורך בכך
להעלות את הטיעונים שם.

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

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

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

הוראת "rtd" נתמכת על ידי 68010, 68020, 68030, 68040, 68060 ו-CPU32
מעבדים, אבל לא לפי 68000 או 5200.

-mno-rtd
אל תשתמש במוסכמות השיחות שנבחרו על ידי -mrtd. זוהי ברירת המחדל.

-מalign-int
-mno-align-int
שליטה אם GCC מיישר את "int", "long", "long long", "float", "double" ו-"long"
משתנים כפולים על גבול של 32 סיביות (-מalign-int) או גבול של 16 סיביות
(-mno-align-int). יישור משתנים על גבולות 32 סיביות מייצר קוד שרץ
קצת יותר מהיר במעבדים עם אפיקי 32 סיביות על חשבון יותר זיכרון.

אַזהָרָה: אם אתה משתמש ב- -מalign-int מתג, GCC יישר מבנים המכילים את
הסוגים לעיל בצורה שונה מרוב הממשק הבינארי של היישומים שפורסמו
מפרטים עבור ה-m68k.

-mpcrel
השתמש במצב הכתובת היחסית למחשב של ה-68000 ישירות, במקום להשתמש בגלובל
טבלת אופסט. נכון לעכשיו, אפשרות זו מרמזת -fpic, המאפשר היסט של 16 סיביות לכל היותר
עבור כתובת יחסית למחשב. -fPIC אינו נתמך כעת עם -mpcrel, אם כי
זה יכול להיות נתמך עבור מעבדים 68020 ומעלה.

-mno-strict-align
-mstrict-align
אל תניח שהמערכת תטפל בהפניות זיכרון לא מיושרות.

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

-mno-sep-data
צור קוד שמניח שקטע הנתונים עוקב אחר קטע הטקסט. זה
ברירת המחדל.

-אמצע הספרייה המשותפת
צור קוד התומך בספריות משותפות באמצעות שיטת מזהה הספרייה. זה מאפשר
לביצוע במקום וספריות משותפות בסביבה ללא זיכרון וירטואלי
הַנהָלָה. אפשרות זו מרמזת -fPIC.

-mno-id-shared-library
צור קוד שאינו מניח שמשתמשים בספריות משותפות מבוססות מזהה. זה
ברירת המחדל.

-mshared-library-id=n
ציין את מספר הזיהוי של הספרייה המשותפת המבוססת על מזהה הנערך.
ציון ערך של 0 ייצור קוד קומפקטי יותר, ציון ערכים אחרים ייצור
לכפות את הקצאת המספר הזה לספרייה הנוכחית אבל אין יותר מקום או
זמן יעיל מאשר השמטת אפשרות זו.

-mxgot
-mno-xgot
בעת יצירת קוד בלתי תלוי במיקום עבור ColdFire, צור קוד שעובד אם
ל-GOT יש יותר מ-8192 ערכים. קוד זה גדול ואיטי יותר מקוד
נוצר ללא אפשרות זו. במעבדי M680x0, אפשרות זו אינה נחוצה; -fPIC
מספיק.

GCC משתמש בדרך כלל בהוראה יחידה כדי לטעון ערכים מה-GOT. בזמן שזה כן
יעיל יחסית, זה עובד רק אם ה-GOT קטן מ-64k בערך. כל דבר
גדול יותר גורם למקשר לדווח על שגיאה כגון:

רילוקיישן קטוע כדי להתאים: R_68K_GOT16O foobar

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

שימו לב שחלק מהמקשרים, כולל גרסאות חדשות יותר של המקשר GNU, יכולים ליצור
מספר GOTs ומיון ערכי GOT. אם יש לך מקשר כזה, אתה צריך רק
כדי להשתמש -mxgot בעת הידור של קובץ אובייקט בודד הניגש ליותר מ-8192 GOT
ערכים. מעט מאוד עושים זאת.

לאפשרויות אלה אין השפעה אלא אם כן GCC מייצר קוד בלתי תלוי במיקום.

MCore אפשרויות

אלה -m אפשרויות שהוגדרו עבור מעבדי Motorola M*Core.

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

-מדיב
-mno-div
השתמש בהוראת החלוקה. (מופעל כברירת מחדל).

-mrelax-מיידי
-מנו-להירגע-מיידי
אפשר מיידיות בגודל שרירותי בפעולות סיביות.

-mwide-bitfields
-mno-wide-bitfields
התייחס תמיד לשדות סיביות כאל בגודל אינטנסיבי.

-m4byte-פונקציות
-mno-4byte-functions
כפה על כל הפונקציות להיות מיושרות לגבול של 4 בתים.

-mcallgraph-data
-mno-callgraph-data
פלט מידע קולגרף.

-mslow-bytes
-mno-slow-bytes
העדיפו גישה למילים בעת קריאת כמויות בתים.

-מעט-אנדיאן
-mbig-endian
צור קוד עבור יעד קטן.

-מ 210
-מ 340
צור קוד עבור מעבד 210.

-מנו-לסים
נניח שסופקה תמיכה בזמן ריצה ולכן השמיט את ספריית הסימולטור
(libsim.a) משורת הפקודה המקשרת.

-mstack-increment=גודל
הגדר את הכמות המקסימלית עבור פעולת תוספת מחסנית בודדת. ערכים גדולים יכולים
להגביר את המהירות של תוכניות המכילות פונקציות שצריכות כמות גדולה של
שטח מחסנית, אבל הם יכולים גם להפעיל תקלת פילוח אם הערימה מורחבת
יותר מדי. ערך ברירת המחדל הוא 0x1000.

MeP אפשרויות

-mabsdiff
מאפשר את הוראת "abs", שהיא ההבדל המוחלט בין שני אוגרים.

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

-ממוצע
מאפשר את הוראת "ave", אשר מחשבת את הממוצע של שני אוגרים.

-mbased=n
משתנים של גודל n בתים ומטה ימוקם בקטע ".based" על ידי
בְּרִירַת מֶחדָל. משתנים מבוססים משתמשים באוגר $tp כאוגר בסיס, ויש א
מגבלה של 128 בתים לקטע ".based".

-מביטופים
מאפשר את הוראות פעולת הסיביות - bit test ("btstm"), set ("bsetm"), clear
("bclrm"), הפוך ("bnotm"), ו-test-and-set ("tas").

-mc=שם
בוחר באיזה קטע נתונים קבועים יוצבו. שם יכול להיות "קטנטן", "קרוב", או
"רָחוֹק".

-mclip
מאפשר את הוראת "קליפ". שים לב ש"-mclip" אינו שימושי אלא אם כן אתה גם
לספק "-mminmax".

-mconfig=שם
בוחר אחת מתצורות הליבה המובנות. לכל שבב MeP יש אחד או יותר
מודולים בו; לכל מודול יש מעבד ליבה ומגוון מעבדי שותפים, אופציונלי
הוראות וציוד היקפי. הכלי "MeP-Integrator", שאינו חלק מ-GCC, מספק
תצורות אלה דרך אפשרות זו; השימוש באפשרות זו זהה לשימוש בכולם
אפשרויות שורת הפקודה המתאימות. תצורת ברירת המחדל היא "ברירת מחדל".

-מקופ
מאפשר את הוראות המעבד. כברירת מחדל, זהו מעבד משותף של 32 סיביות. הערה
שהמעבד המשנה מופעל בדרך כלל באמצעות האפשרות "-mconfig=".

-MCOP32.
מאפשר הוראות של מעבד 32 סיביות.

-MCOP64.
מאפשר הוראות של מעבד 64 סיביות.

-mivc2
מאפשר תזמון IVC2. IVC2 הוא מעבד שותף VLIW של 64 סיביות.

-mdc
גורם להצבת משתנים קבועים בסעיף ".near".

-מדיב
מאפשר את ההוראות "div" ו-"divu".

-מב
צור קוד גדול.

-מל
צור קוד קטן-אנדיאן.

-מיו נדיף
אומר למהדר שכל משתנה המסומן בתכונת "io" אמור להיות
נחשב נדיף.

-מל גורם להקצאת משתנים למקטע ".far" כברירת מחדל.

-מלאדז
מאפשר את הוראת "leadz" (אפס מוביל).

-מ גורם להקצאת משתנים למקטע ".near" כברירת מחדל.

-ממינמקס
מאפשר את ההוראות "מינימום" ו"מקסימום".

-מולט
מאפשר הכפל והוראות כפל-צבירה.

-mno-opts
משבית את כל ההוראות האופציונליות המופעלות על ידי "-mall-opts".

-חוזר על עצמו
מאפשר את ההוראות "חזרה" ו"חזרה", המשמשות ללולאה נמוכה.

-גברת גורם לכל המשתנים להיכנס כברירת מחדל לקטע ". זעיר". שימו לב שיש א
מגבלה של 65536 בתים לסעיף זה. גישה למשתנים אלה משתמשת בבסיס %gp
להירשם.

-מסטור
מאפשר את הוראות הרוויה. שימו לב שהמהדר לא עושה זאת כרגע
ליצור את אלה בעצמו, אבל אפשרות זו כלולה עבור תאימות עם כלים אחרים,
כמו "כמו".

-msdram
קשר את זמן הריצה מבוסס SDRAM במקום את ברירת המחדל של זמן הריצה מבוסס ה-ROM.

-מסים
קשר את ספריות זמן הריצה של הסימולטור.

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

-mtf
גורם לכל הפונקציות לעבור כברירת מחדל לקטע ".far". ללא אפשרות זו, מתפקד
ברירת המחדל לקטע ".near".

-mtiny=n
משתנים שהם n בתים ומטה יוקצו לקטע ". זעיר". אלה
משתנים משתמשים באוגר הבסיס של $gp. ברירת המחדל עבור אפשרות זו היא 4, אך שים לב לכך
יש מגבלה של 65536 בתים לקטע ". זעיר".

MicroBlaze אפשרויות

-msoft-float
השתמש באמולציית תוכנה עבור נקודה צפה (ברירת מחדל).

-mhard-float
השתמש בהוראות נקודה צפה בחומרה.

-מממפי
אל תבצע אופטימיזציה של מהלכי בלוק, השתמש ב-"memcpy".

-mno-clearbss
אפשרות זו הוצאה משימוש. להשתמש -fno-zero-initialized-in-bss במקום.

-mcpu=סוג מעבד
השתמש בתכונות של ותזמון קוד עבור מעבד נתון. הערכים הנתמכים הם בפורמט
vX.YY.Z, שם X היא גרסה מרכזית, YY היא הגרסה המשנית, ו Z הוא תאימות
קוד. ערכים לדוגמה הם v3.00.a, v4.00.b, v5.00.a, v5.00.b, v5.00.b, v6.00.a.

-mxl-soft-mul
השתמש באמולציית כפל תוכנה (ברירת מחדל).

-mxl-soft-div
השתמש באמולציית תוכנה לחלוקה (ברירת מחדל).

-mxl-barrel-shift
השתמש במשמרת חבית החומרה.

-mxl-pattern-compare
השתמש בהוראות להשוואת דפוסים.

-מסמול-מחלק
השתמש באופטימיזציה של חיפוש טבלה עבור חטיבות מספר שלם חתומות קטנות.

-mxl-stack-check
אפשרות זו הוצאה משימוש. השתמש ב-fstack-check במקום זאת.

-mxl-gp-opt
השתמש במדורי sdata/sbss יחסית לרופא המשפחה.

-mxl-כפיל-גבוה
השתמש בהוראות כפל גבוה עבור חלק גבוה של כפל 32x32.

-mxl-float-convert
השתמש בהוראות המרת נקודה צפה בחומרה.

-mxl-float-sqrt
השתמש בהוראת שורש נקודה צפה בחומרה.

-mxl-mode-דגם אפליקציה
בחר דגם יישום דגם אפליקציה. דגמים תקפים הם

הפעלה
קובץ הפעלה רגיל (ברירת מחדל), משתמש בקוד הפעלה crt0.o.

xmdstub
לשימוש עם ניפוי באגים פולשני בתוכנה מבוססת תוכנה Xilinx Microprocessor Debugger (XMD).
סוכן בשם xmdstub. זה משתמש בקובץ הפעלה crt1.o וקובע את כתובת ההתחלה של
התוכנית תהיה 0x800.

אֹזֶן הַנַעַל
עבור יישומים שנטענים באמצעות טוען אתחול. מודל זה משתמש בקובץ הפעלה
crt2.o שאינו מכיל מטפל וקטור לאיפוס מעבד. זה מתאים
להעברת שליטה על איפוס מעבד למטען האתחול ולא ל-
יישום.

נובקטורים
עבור יישומים שאינם דורשים אף אחד מהווקטורים של MicroBlaze. אפשרות זו
עשוי להיות שימושי עבור יישומים הפועלים בתוך יישום ניטור. הדגם הזה
שימושים crt3.o כקובץ הפעלה.

אפשרות -xl-mode-דגם אפליקציה הוא כינוי שהוצא משימוש עבור -mxl-mode-דגם אפליקציה.

MIPS אפשרויות

-EB צור קוד גדול.

-ה צור קוד קטן-אנדיאן. זוהי ברירת המחדל עבור מיפ*אל-*-* תצורות.

-מרץ=קשת
צור קוד שיפעל על קשת, שיכול להיות השם של MIPS ISA גנרי, או
שם של מעבד מסוים. שמות הרשות הם: mips1, mips2, mips3, mips4,
mips32, MIPS32R2, mips64 ו MIPS64R2. שמות המעבדים הם: 4kc, 4km, 4kp, 4שק,
4kec, 4 ק"מ, 4 קפ, 4ksd, 5kc, 5 קילוגרם, 20kc, 24kc, 24KF2_1, 24KF1_1, 24kec, 24kef2_1,
24kef1_1, 34kc, 34KF2_1, 34KF1_1, 74kc, 74KF2_1, 74KF1_1, 74KF3_2, 1004kc, 1004KF2_1,
1004KF1_1, loongson2e, longson2f, longson3a, M4K, אוקטאון, אוקטאון+, אוקטאון2, אוריון,
r2000, r3000, r3900, r4000, r4400, r4600, r4650, r6000, r8000, rm7000, rm9000, r10000,
r12000, r14000, r16000, sb1, sr71000, vr4100, vr4111, vr4120, vr4130, vr4300, vr5000,
vr5400, vr5500 ו xlr. הערך המיוחד מ-abi בוחר את התואם ביותר
ארכיטקטורה עבור ABI שנבחר (כלומר, mips1 עבור 32 סיביות ABI ו mips3 עבור 64 סיביות
ABIs).

שרשרת כלים מקורית של Linux/GNU ו-IRIX תומכת גם היא בערך יליד, שבוחר את ה
אפשרות הארכיטקטורה הטובה ביותר עבור המעבד המארח. -צעדה = יליד אין השפעה אם GCC
לא מזהה את המעבד.

בשמות המעבדים, סופי 000 ניתן לקיצור כ- k (לדוגמה, -מרץ=r2k).
קידומות הן אופציונליות, ו vr עשוי להיכתב r.

שמות הטופס nf2_1 עיין במעבדים עם FPUs עם שעון במחצית מהקצב של
ליבה, שמות הצורה nf1_1 מתייחסים למעבדים עם FPUs עם שעון באותו קצב
בתור הליבה, ושמות הצורה nf3_2 עיין במעבדים עם FPUs עם יחס שעון
של 3:2 ביחס לליבה. מטעמי תאימות, nf מתקבל בתור א
מילה נרדפת ל nf2_1 בזמן nx ו bfx מתקבלים כמילים נרדפות עבור nf1_1.

GCC מגדיר שתי פקודות מאקרו על סמך הערך של אפשרות זו. הראשון הוא _MIPS_ARCH,
מה שנותן את השם של ארכיטקטורת המטרה, כמחרוזת. לשני יש את הצורה
_MIPS_ARCH_Foo, שם Foo הוא הערך המהוון של _MIPS_ARCH. לדוגמה,
-March=r2000 יקבע _MIPS_ARCH ל "r2000" ולהגדיר את המאקרו _MIPS_ARCH_R2000.

שים לב כי _MIPS_ARCH מאקרו משתמש בשמות המעבדים שצוינו למעלה. במילים אחרות,
תהיה לו הקידומת המלאה ולא תקצר 000 as k. במקרה של מ-
אבי, המאקרו שם את הארכיטקטורה שנפתרה (או "mips1" or "mips3"). זה שמות
ארכיטקטורת ברירת המחדל כאשר לא -מרץ ניתנת אפשרות.

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

כאשר אפשרות זו אינה בשימוש, GCC יבצע אופטימיזציה עבור המעבד שצוין על ידי -מרץ.
על ידי שימוש -מרץ ו -mtune יחד, אפשר ליצור קוד שיפעל על
משפחה של מעבדים, אבל בצע אופטימיזציה של הקוד עבור חבר מסוים של זה
מִשׁפָּחָה.

-mtune מגדיר את פקודות המאקרו _MIPS_TUNE ו _MIPS_TUNE_Foo, אשר פועלים באותו אופן כמו
מה היא -מרץ אלה שתוארו לעיל.

-מיפס1
שווה ערך ל -march=mips1.

-מיפס2
שווה ערך ל -march=mips2.

-מיפס3
שווה ערך ל -march=mips3.

-מיפס4
שווה ערך ל -march=mips4.

-מיפס32
שווה ערך ל -march=mips32.

-mips32r2
שווה ערך ל -march=mips32r2.

-מיפס64
שווה ערך ל -march=mips64.

-mips64r2
שווה ערך ל -march=mips64r2.

-מיפס16
-mno-mips16
צור (אל תיצור) קוד MIPS16. אם GCC מכוון ל-MIPS32 או MIPS64
ארכיטקטורה, הוא יעשה שימוש ב-MIPS16e ASE.

ניתן לשלוט בהפקת קוד MIPS16 גם על בסיס פונקציה באמצעות
תכונות "mips16" ו-"nomips16".

-mflip-mips16
צור קוד MIPS16 על פונקציות מתחלפות. אפשרות זו ניתנת עבור רגרסיה
בדיקה של יצירת קוד מעורב MIPS16/לא MIPS16, ואינה מיועדת לרגיל
להשתמש בהידור קוד משתמש.

-minterlink-mips16
-mno-interlink-mips16
דרוש (לא דורש) שקוד שאינו MIPS16 יהיה תואם קישור לקוד MIPS16.

לדוגמה, קוד שאינו MIPS16 אינו יכול לקפוץ ישירות לקוד MIPS16; זה חייב להשתמש ב-a
שיחה או קפיצה עקיפה. -minterlink-mips16 לכן משבית קפיצות ישירות אלא אם כן
GCC יודע שיעד הקפיצה אינו MIPS16.

-מאבי=32
-mabi=o64
-mabi=n32
-מאבי=64
-mabi=eabi
צור קוד עבור ה-ABI הנתון.

שימו לב של-EABI יש גרסה של 32 סיביות ו-64 סיביות. GCC יוצר בדרך כלל 64 סיביות
קוד כאשר אתה בוחר ארכיטקטורת 64 סיביות, אבל אתה יכול להשתמש -mgp32 כדי לקבל קוד 32 סיביות
במקום.

למידע על O64 ABI, ראהhttp://gcc.gnu.org/projects/mipso64-abi.html>.

GCC תומך בגרסה של o32 ABI שבה אוגרי נקודה צפה הם 64 במקום זאת
רוחב של יותר מ-32 ביטים. אתה יכול לבחור את השילוב הזה עם -מאבי=32 -mfp64. ה-ABI הזה
מסתמך על ה mthc1 ו mfhc1 הוראות ולכן הוא נתמך רק עבור
מעבדי MIPS32R2.

הקצאות האוגר עבור ארגומנטים וערכי החזר נשארות זהות, אבל כל אחת מהן
ערך סקלרי מועבר באוגר בודד של 64 סיביות ולא בזוג של 32 סיביות
רושמת. לדוגמה, ערכי נקודה צפה סקלרית מוחזרים פנימה $f0 רק, לא א
$f0/$f1 זוג. סט האוגרים שנשמרו בשיחות נשאר זהה, אבל כל 64 הסיביות
נשמרים.

-מאביקלים
-מנו-אביקל
צור (אל תיצור) קוד שמתאים לאובייקטים דינמיים בסגנון SVR4.
-מאביקלים הוא ברירת המחדל עבור מערכות מבוססות SVR4.

-mshared
-mno-משותף
צור (אל תיצור) קוד שאינו תלוי מיקום לחלוטין, וזה יכול
לכן להיות מקושרים לספריות משותפות. אפשרות זו משפיעה רק -מאביקלים.

תעשיות -מאביקלים הקוד היה באופן מסורתי בלתי תלוי במיקום, ללא קשר לאפשרויות
כמו -fPIC ו -fpic. עם זאת, כהרחבה, שרשרת הכלים של GNU מאפשרת קובצי הפעלה
להשתמש בגישה מוחלטת עבור סמלים מחייבים מקומית. זה יכול גם להשתמש ב-GP קצר יותר
רצפי אתחול ויצירת קריאות ישירות לפונקציות המוגדרות מקומית. זֶה
מצב נבחר על ידי -mno-משותף.

-mno-משותף תלוי ב-binutils 2.16 ומעלה ומייצר אובייקטים שיכולים להיות רק
מקושר על ידי מקשר GNU. עם זאת, האופציה אינה משפיעה על ה-ABI של הגמר
בר הפעלה; זה משפיע רק על ABI של אובייקטים הניתנים להזזה. באמצעות -mno-משותף יצטרך
בדרך כלל הופכים את קובצי ההפעלה לקטנים יותר ומהירים יותר.

-mshared הוא ברירת המחדל.

-mplt
-mno-plt
נניח (אל תניח) שהמקשרים הסטטיים והדינמיים תומכים ב-PLTs והעתקה
רילוקיישן. אפשרות זו משפיעה רק -mno-משותף -מאביקלים. עבור ה-n64 ABI, זה
לאופציה אין השפעה בלעדיו -msym32.

אתה יכול להרוויח -mplt ברירת המחדל על ידי הגדרת GCC עם --with-mips-plt. ברירת המחדל
is -mno-plt אחרת.

-mxgot
-mno-xgot
הרם (אל תרים) את ההגבלות הרגילות על גודל טבלת הקיזוז העולמית.

GCC משתמש בדרך כלל בהוראה יחידה כדי לטעון ערכים מה-GOT. בזמן שזה כן
יעיל יחסית, זה יעבוד רק אם ה-GOT קטן מ-64k בערך.
כל דבר גדול יותר יגרום למקשר לדווח על שגיאה כגון:

רילוקיישן קטוע כדי להתאים: R_MIPS_GOT16 foobar

אם זה קורה, עליך להרכיב מחדש את הקוד שלך עם -mxgot. אז זה אמור לעבוד עם
GOTs גדולים מאוד, אם כי זה גם יהיה פחות יעיל, שכן זה ייקח שלושה
הוראות לאחזור הערך של סמל גלובלי.

שים לב שחלק מהמקשרים יכולים ליצור GOT מרובים. אם יש לך מקשר כזה, אתה
צריך רק להשתמש -mxgot כאשר קובץ אובייקט בודד ניגש ליותר מ-64k
בשווי כניסות GOT. מעט מאוד עושים זאת.

לאפשרויות אלו אין השפעה אלא אם כן GCC מייצר קוד בלתי תלוי במיקום.

-mgp32
נניח שהרגיסטרים לשימוש כללי הם ברוחב של 32 סיביות.

-mgp64
נניח שהרגיסטרים לשימוש כללי הם ברוחב של 64 סיביות.

-mfp32
נניח שרוחב אוגרי נקודה צפה הם 32 סיביות.

-mfp64
נניח שרוחב אוגרי נקודה צפה הם 64 סיביות.

-mhard-float
השתמש בהוראות מעבד שותף בנקודה צפה.

-msoft-float
אל תשתמש בהוראות מעבד שותף בנקודה צפה. יישם נקודה צפה
חישובים באמצעות שיחות ספרייה במקום.

ציפה אחת
נניח שהמעבד המשנה בנקודה צפה תומך רק בפעולות בעלות דיוק יחיד.

-mdouble-float
נניח שהמעבד המשנה בנקודה צפה תומך בפעולות דיוק כפול. זֶה
הוא ברירת המחדל.

-mllsc
-mno-llsc
השתמש (לא להשתמש) ll, sc, ו לסנכרן הוראות ליישום זיכרון אטומי מובנה
פונקציות. כאשר אף אחת מהאפשרויות לא צוינה, GCC ישתמש בהוראות אם
ארכיטקטורת היעד תומכת בהם.

-mllsc שימושי אם סביבת זמן הריצה יכולה לחקות את ההוראות ו -mno-llsc
יכול להיות שימושי בעת קומפילציה עבור ISAs לא סטנדרטיים. אתה יכול להפוך כל אחת מהאפשרויות ל-
ברירת מחדל על ידי הגדרת GCC עם --with-llsc ו --ללא-llsc בהתאמה.
--with-llsc הוא ברירת המחדל עבור תצורות מסוימות; עיין בתיעוד ההתקנה
לקבלת פרטים.

-mdsp
-mno-dsp
השתמש (אל תשתמש) בגרסה 1 של MIPS DSP ASE.
אפשרות זו מגדירה את המאקרו הקדם-מעבד __mips_dsp. זה גם מגדיר
__mips_dsp_rev אל 1.

-mdspr2
-mno-dspr2
השתמש (אל תשתמש) בגרסה 2 של MIPS DSP ASE.
אפשרות זו מגדירה את פקודות המאקרו הקדם-מעבד __mips_dsp ו __mips_dspr2. גם זה
מגדיר __mips_dsp_rev אל 2.

-msmartmips
-mno-smartmips
השתמש (אל תשתמש) ב-MIPS SmartMIPS ASE.

-לקוי-רווק
-mno-זוגי-סינגל
השתמש (אל תשתמש) בהוראות של נקודה צפה יחידה זוגית.
אפשרות זו מחייבת תמיכה בנקודה צפה בחומרה כדי להיות זמינה.

-mdmx
-mno-mdmx
השתמש (אל תשתמש) בהוראות MIPS Digital Media Extension. אפשרות זו יכולה להיות רק
משמש בעת יצירת קוד 64 סיביות ודורש תמיכת חומרה בנקודה צפה
מאופשר.

-mips3d
-mno-mips3d
השתמש (אל תשתמש) ב-MIPS-3D ASE. האפשרות -mips3d מרמז -לקוי-רווק.

-ממץ
-מנו-מט
השתמש (אל תשתמש) בהוראות MT Multithreading.

-מלונג64
כפה על סוגי "ארוכים" להיות ברוחב של 64 סיביות. לִרְאוֹת -מלונג32 להסבר על ברירת המחדל
והדרך שבה נקבע גודל המצביע.

-מלונג32
כפה על סוגי "long", "int" ו-pointer להיות ברוחב של 32 סיביות.

גודל ברירת המחדל של "int"s, "long" ו-pointers תלוי ב-ABI. כל ה
ABI נתמכים משתמשים ב-"int" של 32 סיביות. ה-n64 ABI משתמש ב"ארוכים" של 64 סיביות, וכך גם ב-64 סיביות
EABI; האחרים משתמשים ב"ארוכים" של 32 סיביות. מצביעים זהים בגודל של "ארוכים" או של
זהה לגודל של אוגרים שלמים, הקטן מביניהם.

-msym32
-mno-sym32
נניח (אל תניח) שלכל הסמלים יש ערכי 32 סיביות, ללא קשר לבחירה
ABI. אפשרות זו שימושית בשילוב עם -מאבי=64 ו -מנו-אביקל כי זה
מאפשר ל-GCC ליצור הפניות קצרות ומהירות יותר לכתובות סמליות.

-G NUM
שים הגדרות של נתונים גלויים כלפי חוץ בקטע נתונים קטן אם הנתונים האלה אינם
גדול יותר מ NUM בתים. לאחר מכן, GCC יכול לגשת לנתונים בצורה יעילה יותר; לִרְאוֹת -mgpopt ל
פרטים.

ברירת המחדל -G האפשרות תלויה בתצורה.

-mlocal-sdata
-mno-local-sdata
להאריך (לא להאריך) את -G התנהגות גם לנתונים מקומיים, כמו משתנים סטטיים
ב- C. -mlocal-sdata הוא ברירת המחדל עבור כל התצורות.

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

-mextern-sdata
-mno-extern-sdata
נניח (אל תניח) שהנתונים המוגדרים חיצונית יהיו בקטע נתונים קטן אם
שהנתונים נמצאים בתוך -G מגבלה. -mextern-sdata הוא ברירת המחדל עבור כולם
תצורות.

אם תרכיב מודול דרך עם -mextern-sdata -G NUM -mgpopt, ו דרך הפניות א
משתנה כל שזה לא יותר גדול מ NUM בתים, עליך לוודא זאת כל ממוקם
בקטע נתונים קטן. אם כל מוגדר על ידי מודול אחר, עליך לבצע קומפילציה
המודול הזה עם גבוה מספיק -G להגדיר או לצרף תכונה "סעיף". כל's
הַגדָרָה. אם כל נפוץ, עליך לקשר את היישום עם גבוה מספיק -G
הגדרה.

הדרך הקלה ביותר לעמוד בהגבלות אלו היא להדר ולקשר כל מודול
עם אותו -G אוֹפְּצִיָה. עם זאת, ייתכן שתרצה לבנות ספרייה שתומכת
מספר מגבלות שונות של נתונים קטנים. אתה יכול לעשות זאת על ידי קומפילציה של הספרייה עם
הנתמכת הגבוהה ביותר -G הגדרה ובנוסף שימוש -mno-extern-sdata לעצור את
הספרייה מלהניח הנחות לגבי נתונים מוגדרים חיצונית.

-mgpopt
-mno-gpopt
השתמש (אל תשתמש) בגישה יחסית ל-GP עבור סמלים שידוע שהם נמצאים בנתונים קטנים
סָעִיף; לִרְאוֹת -G, -mlocal-sdata ו -mextern-sdata. -mgpopt הוא ברירת המחדל עבור כולם
תצורות.

-mno-gpopt שימושי למקרים שבהם האוגר $gp עשוי שלא להכיל את הערך של
"_gp". לדוגמה, אם הקוד הוא חלק מספריה שעשוי לשמש באתחול
monitor, תוכניות הקוראות לשגרות אתחול מוניטור יעבירו ערך לא ידוע ב-$gp.
(במצבים כאלה, מוניטור האתחול עצמו בדרך כלל יהיה מורכב עם -G0.)

-mno-gpopt מרמז -mno-local-sdata ו -mno-extern-sdata.

-נתונים משובצים
-mno-embedded-data
הקצאת משתנים למקטע הנתונים לקריאה בלבד אם אפשר תחילה, ואז לאחר מכן ב-
קטע נתונים קטן אם אפשר, אחרת בנתונים. זה נותן קוד קצת יותר איטי
מאשר ברירת המחדל, אך מפחית את כמות ה-RAM הנדרשת בעת ביצוע, וכך עשוי
להיות מועדף עבור כמה מערכות משובצות.

-muninit-const-in-rodata
-mno-uninit-const-in-rodata
שים משתני "const" לא מאותחלים בקטע הנתונים לקריאה בלבד. אפשרות זו היא
משמעותי רק בשילוב עם -נתונים משובצים.

-mcode-readable=הצבה
ציין אם GCC עשוי ליצור קוד שקורא מקטעי הפעלה. יש
שלוש הגדרות אפשריות:

-mcode-readable=כן
הוראות עשויות לגשת באופן חופשי לקטעי הפעלה. זוהי הגדרת ברירת המחדל.

-mcode-readable=pcrel
MIPS16 הוראות טעינה יחסית למחשב יכולות לגשת לקטעי הפעלה, אך אחרות
אסור לעשות זאת בהוראות. אפשרות זו שימושית במעבדי 4KSc ו-4KSd
כאשר ל-TLBs הקוד מוגדר ה-Read Inhibit bit. זה שימושי גם במעבדים
שניתן להגדיר שיהיה לו ממשק SRAM כפול הוראות/נתונים וש,
כמו ה-M4K, מפנה אוטומטית עומסים יחסיים למחשב ל-RAM ההוראות.

-mcode-readable=לא
אסור להוראות לגשת לקטעי הפעלה. אפשרות זו יכולה להיות שימושית ב
יעדים המוגדרים לבעלי ממשק SRAM כפול הוראות/נתונים אבל
ש(בניגוד ל-M4K) אינם מפנים אוטומטית עומסים יחסיים למחשב האישי
הוראות RAM.

-mssplit-כתובות
-mno-split-כתובות
אפשר (השבת) שימוש באופרטורים של העברת ההרכבים "%hi()" ו-"%lo()". זֶה
האופציה הוחלפה על ידי -מפורש-רילוקים אבל נשמר לאחור
תאימות.

-מפורש-רילוקים
-mno-explicit-relocs
השתמש (אל תשתמש) במפעילי רילוקיישן של אסמבלר בעת התמודדות עם כתובות סמליות.
האלטרנטיבה, שנבחרה על ידי -mno-explicit-relocs, הוא להשתמש בפקודות מאקרו של אסמבלר במקום זאת.

-מפורש-רילוקים הוא ברירת המחדל אם GCC הוגדר להשתמש ב-assembler ש
תומך במפעילי רילוקיישן.

-מצ'ק-אפס-חלוקה
-מנו-צ'ק-אפס-חלוקה
מלכודת (אל תלכוד) בחלוקה של מספר שלם באפס.

ברירת המחדל היא -מצ'ק-אפס-חלוקה.

-מחלק-מלכודות
-מחלק-הפסקות
מערכות MIPS בודקות חלוקה באפס על ידי יצירת מלכודת מותנית או א
הפסקת הוראה. שימוש במלכודות מביא לקוד קטן יותר, אך הוא נתמך רק ב-MIPS
II ומאוחר יותר. כמו כן, בחלק מהגרסאות של ליבת לינוקס יש באג שמונע מלכודות
מיצירת האות המתאים ("SIGFPE"). להשתמש -מחלק-מלכודות לאפשר מותנה
מלכודות על ארכיטקטורות התומכות בהן ו -מחלק-הפסקות לכפות שימוש ב
נשבר.

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

-מממפי
-mno-memcpy
לאלץ (לא לכפות) את השימוש ב-"memcpy()" עבור מהלכי בלוק לא טריוויאליים. ברירת המחדל
is -mno-memcpy, המאפשר ל-GCC להטמיע את רוב העותקים בגודל קבוע.

-מלונג-שיחות
-שיחות ארוכות
השבת (אל תבטל) את השימוש בהוראה "jal". קריאה לפונקציות באמצעות "jal"
הוא יעיל יותר אך מחייב את המתקשר והמתקשר להיות באותו 256 מגה בייט
מגזר.

לאפשרות זו אין השפעה על קוד abicalls. ברירת המחדל היא -שיחות ארוכות.

-מאד
-מנון-משוגע
אפשר (השבת) שימוש בהוראות "mad", "madu" ו-"mul", כפי שסופקו על ידי
R4650 ISA.

-מfused-madd
-mno-fused-madd
אפשר (השבת) שימוש בהוראות הכפלה-צבירה של נקודה צפה, כאשר הן
פנויים. ברירת המחדל היא -מfused-madd.

כאשר נעשה שימוש בהוראות כפל-צבירה, תוצר הביניים מחושב
לדיוק אינסופי ואינו כפוף ל-FCSR Flush to Zero bit. זה יכול להיות
לא רצוי בנסיבות מסוימות.

-nocpp
אמור ל-MIPS assembler לא להפעיל את מעבד הקדם שלו על קבצי assembler של משתמש (עם א
.s סיומת) בעת הרכבתם.

-mfix-24k
-mno-fix-24k
עקוף את התקלה של 24K E48 (אבוד נתונים בחנויות במהלך מילוי חוזר). הדרכים לעקיפת הבעיה
מיושמים על ידי ה-assembler ולא על ידי GCC.

-mfix-r4000
-mno-fix-r4000
עקיפת שגיאות מעבד R4000 מסוימות:

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

- מילה כפולה או שינוי משתנה עלולים לתת תוצאה שגויה אם הם מבוצעים תוך כדי
כפל שלמים מתבצע.

- חלוקה של מספרים שלמים עלולה לתת תוצאה שגויה אם מתחילים במשבצת השהיה של a
לקח ענף או קפיצה.

-mfix-r4400
-mno-fix-r4400
עקיפת שגיאות מעבד R4400 מסוימות:

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

-mfix-r10000
-mno-fix-r10000
עקיפת שגיאות מסוימות של R10000:

- ייתכן שרצפי "ll"/"sc" לא יתנהגו בצורה אטומית על גרסאות לפני 3.0. הם עלולים
מבוי סתום בגרסאות 2.6 ואילך.

ניתן להשתמש באפשרות זו רק אם ארכיטקטורת היעד תומכת בסניף סביר
הוראות. -mfix-r10000 הוא ברירת המחדל מתי -March=r10000 משמש; -mno-fix-r10000
היא ברירת המחדל אחרת.

-mfix-vr4120
-mno-fix-vr4120
עקיפת שגיאות מסוימות של VR4120:

- "dmultu" לא תמיד מניב את התוצאה הנכונה.

- "div" ו-"ddiv" לא תמיד מייצרים את התוצאה הנכונה אם אחד מהאופרנדים
הוא שלילי.

הדרכים לעקיפת הבעיה של שגיאות החלוקה מסתמכות על פונקציות מיוחדות ב libgcc.a. ליד
בהווה, פונקציות אלו מסופקות רק על ידי תצורות "mips64vr*-elf".

שגיאות אחרות של VR4120 דורשות הוספת Nop בין זוגות מסוימים של
הוראות. שגיאות אלו מטופלות על ידי המרכיב, לא על ידי GCC עצמו.

-mfix-vr4130
עקף את VR4130 "mflo"/"mfhi" errata. הדרכים לעקיפת הבעיה מיושמות על ידי
assembler ולא על ידי GCC, אם כי GCC ימנע משימוש ב-"mflo" ו-"mfhi" אם
הוראות VR4130 "macc", "macchi", "dmacc" ו-"dmacchi" זמינות במקום זאת.

-mfix-sb1
-mno-fix-sb1
עקיפת שגיאות הליבה של מעבד SB-1 מסוימות. (דגל זה פועל כעת סביב ה-SB-1
גרסה 2 "F1" ו-"F2" שגיאות בנקודה צפה.)

-mr10k-cache-barrier=הצבה
ציין אם GCC צריך להכניס מחסומי מטמון כדי למנוע את תופעות הלוואי של
ספקולציות לגבי מעבדי R10K.

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

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

דרך אחת לעקיפת הבעיה היא להוסיף הוראות מחסום מטמון לפני כל גישה לזיכרון
עשוי להיות מבוצע באופן ספקולטיבי ועשויות להיות לכך תופעות לוואי גם אם יופלו.
-mr10k-cache-barrier=הצבה שולט ביישום של פתרון זה על ידי GCC. זה
מניח שלגישות שבוטלו לכל בייט באזורים הבאים לא תהיה צד
אפקטים:

1. הזיכרון שנכבש על ידי מסגרת המחסנית של הפונקציה הנוכחית;

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

3. הזיכרון שנכבש על ידי אובייקט עם כתובת קבועה בזמן קישור.

באחריות הקרנל להבטיח גישה ספקולטיבית לאזורים אלה
הם אכן בטוחים.

אם תוכנית הקלט מכילה הצהרת פונקציה כגון:

void foo (ריק);

אז היישום של "foo" חייב לאפשר ביצוע של "j foo" ו-"jal foo".
באופן ספקולטיבי. GCC מכבדת מגבלה זו עבור פונקציות שהיא מרכיבה בעצמה. זה
מצפה מפונקציות שאינן GCC (כגון קוד הרכבה בכתב יד) לעשות את אותו הדבר.

לאפשרות שלוש צורות:

-mr10k-cache-barrier=load-store
הכנס מחסום מטמון לפני טעינה או חנות שעלולים להתבצע באופן ספקולטיבי
ולכך עשויות להיות תופעות לוואי גם אם יופלו.

-mr10k-cache-barrier=חנות
הכנס מחסום מטמון לפני חנות שאולי תבוצע באופן ספקולטיבי ו
שיכולות להיות להן תופעות לוואי גם אם יופלו.

-mr10k-cache-barrier=none
השבת את הכנסת מחסומי המטמון. זוהי הגדרת ברירת המחדל.

-mflush-func=func
-mno-flush-func
מציין את הפונקציה להתקשר כדי לשטוף את המטמון I ו-D, או לא לקרוא לאף אחד כזה
פוּנקצִיָה. אם נקראת, הפונקציה חייבת לקבל את אותם ארגומנטים כמו ה-common
"_flush_func()", כלומר, הכתובת של טווח הזיכרון שעבורו נמצא המטמון
flushed, גודל טווח הזיכרון והמספר 3 (כדי לשטוף את שני המטמונים). ה
ברירת המחדל תלויה ביעד ש-GCC הוגדר עבורו, אך בדרך כלל הוא גם כן
_flush_func or __cpu_flush.

mbranch-cost=NUM
הגדר את עלות הסניפים לערך NUM הוראות "פשוטות". עלות זו היא רק א
היוריסטית ואינה מובטחת להפיק תוצאות עקביות בכל מהדורות. אפס
עלות בוחרת באופן מיותר את ברירת המחדל, המבוססת על -mtune הגדרה.

-סביר ענף
-מונו-ענף-סביר
אפשר או השבת את השימוש בהוראות Branch Likely, ללא קשר לברירת המחדל עבור
ארכיטקטורה נבחרה. כברירת מחדל, ניתן להפיק הוראות Branch Likely אם
הם נתמכים על ידי הארכיטקטורה שנבחרה. חריג הוא עבור MIPS32 ו
ארכיטקטורות ומעבדים MIPS64 המיישמים את הארכיטקטורות הללו; לאלה,
הוראות סניף סבירות לא יופקו כברירת מחדל מכיוון שה-MIPS32 ו
ארכיטקטורות MIPS64 פוסלות באופן ספציפי את השימוש בהן.

-mfp-חריגים
-mno-fp-חריגים
מציין אם חריגות FP מופעלות. זה משפיע על האופן שבו אנו מתזמנים FP
הוראות עבור מעבדים מסוימים. ברירת המחדל היא שחריגות FP מופעלות.

לדוגמה, ב-SB-1, אם חריגות FP מושבתות, ואנו פולטים 64 סיביות
קוד, אז נוכל להשתמש בשני צינורות ה-FP. אחרת, נוכל להשתמש רק בצינור FP אחד.

-mvr4130-align
-mno-vr4130-align
צינור ה-VR4130 הוא דו-כיווני על-סקלארי, אך יכול להוציא שתי הוראות בלבד
יחד אם הראשון מיושר ל-8 בתים. כאשר אפשרות זו מופעלת, GCC יעשה זאת
ליישר זוגות של הוראות שלדעתה צריך לבצע במקביל.

אפשרות זו משפיעה רק בעת אופטימיזציה עבור ה-VR4130. זה בדרך כלל עושה קוד
מהר יותר, אבל על חשבון הפיכתו לגדול יותר. זה מופעל כברירת מחדל ב
רמת אופטימיזציה -O3.

-msynci
-mno-synci
אפשר (השבת) יצירת הוראות "סינקי" בארכיטקטורות התומכות בכך.
הוראות ה-"synci" (אם מופעלות) יופקו מתי
"__builtin___clear_cache()" מורכב.

ברירת המחדל של אפשרות זו היא "-mno-synci", אך ניתן לעקוף את ברירת המחדל על ידי הגדרה
עם "--with-synci".

בעת הידור קוד עבור מערכות מעבד בודד, זה בדרך כלל בטוח להשתמש ב-"synci".
עם זאת, במערכות מרובות ליבות (SMP) רבות, זה לא יבטל את תוקף ההוראה
מטמון בכל הליבות ועלול להוביל להתנהגות לא מוגדרת.

-mrelax-pic-calls
-mno-relax-pic-calls
נסה להפוך שיחות PIC הנשלחות בדרך כלל באמצעות 25$ לרשום לשיחות ישירות.
זה אפשרי רק אם המקשר יכול לפתור את היעד בזמן הקישור ואם
היעד נמצא בטווח לשיחה ישירה.

-mrelax-pic-calls הוא ברירת המחדל אם GCC הוגדר להשתמש ב-assembler ו-a
מקשר שתומך בהנחיית הרכבה ".reloc" ו-"-mexplicit-relocs" נמצא ב
השפעה. עם "-mno-explicit-relocs", אופטימיזציה זו יכולה להתבצע על ידי
assembler והמקשר לבד ללא עזרה מהמהדר.

-mmcount-ra-address
-mno-mcount-ra-address
שלח (אל תפליט) קוד המאפשר ל-"_mcount" לשנות את החזרת הפונקציה הקוראת
כתובת. כאשר מופעלת, אפשרות זו מרחיבה את הממשק הרגיל "_mcount" עם ממשק חדש
כתובת ra פרמטר, בעל הסוג "intptr_t *" ומועבר ברישום $12.
לאחר מכן, "_mcount" יכול לשנות את כתובת ההחזרה על ידי ביצוע שתי הפעולות הבאות:

· החזרת הכתובת החדשה בפנקס 31$.

· אחסון הכתובת החדשה ב"*כתובת ra", אם כתובת ra אינו בטל.

ברירת המחדל היא -mno-mcount-ra-address.

MMIX אפשרויות

אפשרויות אלה מוגדרות עבור ה-MMIX:

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

-מפסילון
-מנו-אפסילון
צור הוראות השוואה של נקודה צפה שמשוות ביחס ל-"rE"
רישום אפסילון.

-mabi=mmixware
-מאבי=גנו
צור קוד שמעביר פרמטרים של פונקציה ומחזיר ערכים ש(ב-call
function) נתפסים כריסטרים של $0 ומעלה, בניגוד ל-GNU ABI שמשתמש גלובלי
רושם $231 ומעלה.

-mzero-extend
-mno-zero-extend
בעת קריאת נתונים מהזיכרון בגדלים קצרים מ-64 סיביות, השתמש (אל תשתמש) אפס-
הרחבת הוראות הטעינה כברירת מחדל, במקום הרחבת סימנים.

-mknuthdiv
-מנו-קנוטדייב
הפוך את התוצאה של חלוקה שמניבה שארית להיות בעל סימן זהה למחלק.
עם ברירת המחדל, -מנו-קנוטדייב, סימן השארית עוקב אחר סימן ה
דיבידנד. שתי השיטות תקפות מבחינה אריתמטית, כאשר האחרונה היא כמעט בלעדית
מְשׁוּמָשׁ.

-mtoplevel-סמלים
-mno-toplevel-סמלים
להקדים (לא להקדים) א : לכל הסמלים הגלובאליים, כך שניתן להשתמש בקוד ההרכבה
עם הוראת ההרכבה "PREFIX".

-מלף
צור קובץ הפעלה בפורמט ELF, במקום ברירת המחדל mmo פורמט בשימוש על ידי
מה היא ממיקס מַדמֶה.

-ענף-ניבוי
-מנו-ענף-ניבוי
השתמש (אל תשתמש) בהוראות הסניף הסביר, כאשר חיזוי ענף סטטי
מציין ענף סביר.

-כתובות-base
-כתובות-mno-base
צור (אל תיצור) קוד שמשתמש בסיס כתובות. שימוש בכתובת בסיס
מייצר אוטומטית בקשה (מטופלת על ידי האסמבלר והמקשר) עבור א
קבוע שיוקם במרשם עולמי. האוגר משמש לבסיס אחד או יותר
בקשות כתובת בטווח של 0 עד 255 מהערך המוחזק במאגר. ה
בדרך כלל מוביל לקוד קצר ומהיר, אבל מספר פריטי נתונים שונים זה
ניתן לטפל מוגבל. זה אומר שתוכנית שמשתמשת בהרבה נתונים סטטיים
עשוי לדרוש -כתובות-mno-base.

-יציאה-יחידה
-mno-יציאה-יחידה
כפה (אל תכריח) קוד שנוצר שתהיה לו נקודת יציאה אחת בכל פונקציה.

MN10300 אפשרויות

אלה -m אפשרויות מוגדרות עבור ארכיטקטורות Matsushita MN10300:

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

-mno-mult-bug
אל תיצור קוד כדי למנוע באגים בהוראות הכפל של ה-MN10300
מעבדים.

-אמא33
צור קוד באמצעות תכונות ספציפיות למעבד AM33.

-mno-am33
אל תיצור קוד באמצעות תכונות ספציפיות למעבד AM33. זה
ברירת המחדל.

-מאמ33-2
צור קוד באמצעות תכונות ספציפיות למעבד AM33/2.0.

-אמא34
צור קוד באמצעות תכונות ספציפיות למעבד AM34.

-mtune=סוג מעבד
השתמש במאפייני התזמון של סוג המעבד המצוין בעת ​​תזמון הוראות.
זה לא משנה את סוג המעבד הממוקד. סוג המעבד חייב להיות אחד
mn10300, am33, בבוקר 33-2 or am34.

-mreturn-pointer-on-d0
בעת יצירת פונקציה שמחזירה מצביע, החזר את המצביע גם ב-"a0" וגם
"d0". אחרת, המצביע מוחזר רק ב-a0, ומנסה לקרוא לזה
פונקציות ללא אב טיפוס יגרמו לשגיאות. שימו לב שהאפשרות הזו פועלת עד
בְּרִירַת מֶחדָל; להשתמש -mno-return-pointer-on-d0 כדי להשבית אותו.

-mno-crt0
אין לקשר בקובץ אובייקט האתחול בזמן ריצה C.

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

אפשרות זו הופכת איתור באגים סמלי לבלתי אפשרי.

-mliw
אפשר למהדר ליצור ארוך הוראה Word הוראות אם המטרה היא
AM33 או מאוחר יותר. זוהי ברירת המחדל. אפשרות זו מגדירה את המאקרו הקדם-מעבד
__LIW__.

-מנוליב
אל תאפשר למהדר ליצור ארוך הוראה Word הוראות. אפשרות זו
מגדיר את המאקרו הקדם-מעבד __NO_LIW__.

-מסתלב
אפשר למהדר ליצור את ה SETLB ו Lcc הוראות אם המטרה היא
AM33 או מאוחר יותר. זוהי ברירת המחדל. אפשרות זו מגדירה את המאקרו הקדם-מעבד
__SETLB__.

-mnosetlb
אל תאפשר למהדר ליצור SETLB or Lcc הוראות. אפשרות זו מגדירה
המאקרו הקדם-מעבד __NO_SETLB__.

PDP-11 אפשרויות

אפשרויות אלה מוגדרות עבור PDP-11:

-mfpu
השתמש בחומרה FPP נקודה צפה. זוהי ברירת המחדל. (נקודה צפה FIS על
PDP-11/40 אינו נתמך.)

-msoft-float
אל תשתמש בנקודה צפה חומרה.

-mac0
החזר תוצאות נקודה צפה ב-ac0 (fr0 בתחביר אסמבלר יוניקס).

-mno-ac0
החזר תוצאות נקודה צפה בזיכרון. זוהי ברירת המחדל.

-מ 40
צור קוד עבור PDP-11/40.

-מ 45
צור קוד עבור PDP-11/45. זוהי ברירת המחדל.

-מ 10
צור קוד עבור PDP-11/10.

-mbcopy-builtin
השתמש בתבניות "movmemhi" מוטבעות להעתקת זיכרון. זוהי ברירת המחדל.

-mbcopy
אל תשתמש בתבניות "movmemhi" מוטבעות להעתקת זיכרון.

-מנטה16
-mno-int32
השתמש ב-16 סיביות "int". זוהי ברירת המחדל.

-מנטה32
-mno-int16
השתמש ב-32 סיביות "int".

-mfloat64
-mno-float32
השתמש ב-"float" של 64 סיביות. זוהי ברירת המחדל.

-mfloat32
-mno-float64
השתמש ב-"float" של 32 סיביות.

-מבשי
השתמש בתבנית "abshi2". זוהי ברירת המחדל.

-מנו-אבשי
אל תשתמש בתבנית "abshi2".

-ענף-יקר
העמידו פנים שהסניפים יקרים. זה בשביל להתנסות ביצירת קוד
בלבד.

-ענף-זול
אל תעמיד פנים שהסניפים יקרים. זוהי ברירת המחדל.

-munix-asm
השתמש בתחביר ה-Unix assembler. זוהי ברירת המחדל כאשר היא מוגדרת עבור pdp11-*-bsd.

-mdec-asm
השתמש בתחביר DEC assembler. זוהי ברירת המחדל כאשר היא מוגדרת עבור כל יעד PDP-11
אחר מאשר pdp11-*-bsd.

picoChip אפשרויות

אלה -m אפשרויות מוגדרות עבור יישומי picoChip:

-מיי=ae_type
הגדר את ערכת ההוראות, ערכת הרישום ותזמון ההוראות עבור מערך
סוג אלמנט ae_type. ערכים נתמכים עבור ae_type יש לו כל, MUL, ו מק.

-mae=כל בוחר סוג AE גנרי לחלוטין. קוד שנוצר עם אפשרות זו יעשה זאת
לרוץ על כל אחד מסוגי AE אחרים. הקוד לא יהיה יעיל כפי שהיה אם
הידור עבור סוג AE ספציפי, וסוגים מסוימים של פעולה (למשל, כפל)
לא יפעל כראוי על כל סוגי AE.

-mae=MUL בוחר סוג MUL AE. זהו סוג ה-AE השימושי ביותר עבור קוד הידור,
והוא ברירת המחדל.

-mae=MAC בוחר MAC AE בסגנון DSP. קוד שנערך עם אפשרות זו עלול לסבול
ביצועים גרועים של מניפולציה של בתים (char), מכיוון שה-DSP AE אינו מספק
תמיכת חומרה לעומס בתים/חנויות.

-msymbol-as-address
אפשר למהדר להשתמש ישירות בשם סמל ככתובת בטעינה/חנות
הוראה, מבלי לטעון אותה תחילה לפנקס. בדרך כלל, השימוש בזה
option תיצור תוכניות גדולות יותר, אשר פועלות מהר יותר מאשר כאשר האפשרות אינה
בשימוש. עם זאת, התוצאות משתנות מתוכנית לתוכנית, ולכן היא נשארת כמשתמש
אפשרות, במקום להיות זמין לצמיתות.

-אזהרות-לא-יעילות
משבית אזהרות לגבי יצירת קוד לא יעיל. אזהרות אלה יכולות להיות
נוצר, למשל, בעת הידור קוד שמבצע פעולות זיכרון ברמת בתים
על סוג MAC AE. ל-MAC AE אין תמיכה בחומרה עבור זיכרון ברמת בתים
פעולות, כך שכל הטעינה/מאגרי הבתים חייבים להיות מסונתזים מ-load/store של מילים
פעולות. זה לא יעיל ותיווצר אזהרה המציינת את
מתכנת שעליהם לשכתב את הקוד כדי להימנע מפעולות בתים, או כדי לכוון ל-
סוג AE שיש לו את תמיכת החומרה הדרושה. אפשרות זו מאפשרת את האזהרה ל
להיות כבוי.

PowerPC אפשרויות

אלה מפורטים למטה

RL78 אפשרויות

-מסים
קישורים בספריות יעד נוספות לתמיכה בהפעלה בתוך סימולטור.

-ממול=אין
-mmul=g13
-mmul=rl78
מציין את סוג התמיכה בכפל החומרה שיש להשתמש בה. ברירת המחדל היא
"ללא", המשתמש בפונקציות כפל תוכנה. האפשרות "g13" מיועדת ל-
הכפל/חלק ציוד היקפי של חומרה רק ביעדי RL78/G13. אפשרות "rl78".
מיועד לכפל החומרה הסטנדרטי המוגדר במדריך התוכנה RL78.

יבמ RS/6000 ו PowerPC אפשרויות

אלה -m אפשרויות מוגדרות עבור IBM RS/6000 ו-PowerPC:

-מכוח
-מנו-כוח
-mpower2
-mno-power2
-mpowerpc
-mno-powerpc
-mpowerpc-gpopt
-mno-powerpc-gpopt
-mpowerpc-gfxopt
-mno-powerpc-gfxopt
-mpowerpc64
-mno-powerpc64
-mmfcrf
-mno-mfcrf
-mpopcntb
-mno-popcntb
-mpopcntd
-mno-popcntd
-mfprnd
-mno-fprnd
-mcmpb
-mno-cmpb
-mmfpgpr
-mno-mfpgpr
-mhard-dfp
-mno-hard-dfp
GCC תומך בשתי ארכיטקטורות ערכות הוראות קשורות עבור RS/6000 ו-PowerPC.
אל האני כוח ערכת הוראות הן ההוראות הנתמכות על ידי נהרות נעשה שימוש בסט שבבים
במערכות RS/6000 המקוריות וב- PowerPC ערכת ההוראות היא הארכיטקטורה של
המיקרו-מעבדים Freescale MPC5xx, MPC6xx, MPC8xx ו-IBM 4xx, 6xx ו-
מעבדי המשך.

אף ארכיטקטורה אינה תת-קבוצה של השנייה. עם זאת, יש תת-קבוצה משותפת גדולה
של הוראות הנתמכות על ידי שניהם. אוגר MQ כלול במעבדים
תמיכה בארכיטקטורת POWER.

אתה משתמש באפשרויות אלה כדי לציין אילו הוראות זמינות במעבד שאתה
משתמשים. ערך ברירת המחדל של אפשרויות אלה נקבע בעת הגדרת GCC.
ציון ה- -mcpu=cpu_type עוקף את המפרט של אפשרויות אלה. אָנוּ
ממליץ לך להשתמש ב -mcpu=cpu_type אפשרות במקום האפשרויות המפורטות למעלה.

אל האני -מכוח האפשרות מאפשרת ל-GCC ליצור הוראות שנמצאות רק ב-
ארכיטקטורת POWER ושימוש ברישום MQ. מפרט -mpower2 מרמז צריכת חשמל ו
מאפשר גם ל-GCC ליצור הוראות הקיימות בארכיטקטורת POWER2
אבל לא ארכיטקטורת POWER המקורית.

אל האני -mpowerpc האפשרות מאפשרת ל-GCC ליצור הוראות שנמצאות רק ב-
קבוצת משנה של 32 סיביות של ארכיטקטורת PowerPC. מפרט -mpowerpc-gpopt מרמז
-mpowerpc וכן מאפשר ל-GCC להשתמש בהוראות הארכיטקטורה האופציונליות של PowerPC ב
קבוצת המטרה הכללית, כולל שורש נקודה צפה. מפרט
-mpowerpc-gfxopt מרמז -mpowerpc וכן מאפשר ל-GCC להשתמש ב-PowerPC האופציונלי
הוראות ארכיטקטורה בקבוצת גרפיקה, כולל בחירת נקודה צפה.

אל האני -mmfcrf האפשרות מאפשרת ל-GCC ליצור את המעבר משדה אוגר התנאים
הוראה המיושמת על מעבד POWER4 ומעבדים אחרים התומכים ב
ארכיטקטורת PowerPC V2.01. ה -mpopcntb האפשרות מאפשרת ל-GCC ליצור את ה-popcount
והוראת אומדן הדדית FP בעלת דיוק כפול המיושמת ב-POWER5
מעבד ומעבדים אחרים התומכים בארכיטקטורת PowerPC V2.02. ה
-mpopcntd האפשרות מאפשרת ל-GCC ליצור את הוראת ה-popcount המיושמת ב-
מעבד POWER7 ומעבדים אחרים התומכים בארכיטקטורת PowerPC V2.06.
אל האני -mfprnd האפשרות מאפשרת ל-GCC ליצור את הוראות הסיבוב של ה-FP למספר שלם
מיושם במעבד POWER5+ ובמעבדים אחרים התומכים ב-PowerPC
ארכיטקטורת V2.03. ה -mcmpb אפשרות מאפשרת ל-GCC ליצור את הבתים להשוואה
הוראה המיושמת על מעבד POWER6 ומעבדים אחרים התומכים ב
ארכיטקטורת PowerPC V2.05. ה -mmfpgpr האפשרות מאפשרת ל-GCC ליצור את מהלך ה-FP
אל/מהוראות רישום למטרות כלליות המיושמות במעבד POWER6X ו
מעבדים אחרים התומכים בארכיטקטורת PowerPC V2.05 המורחבת. ה -mhard-dfp
אפשרות מאפשרת ל-GCC ליצור את הוראות הנקודה הצפה העשרונית המיושמת על
כמה מעבדי POWER.

אל האני -mpowerpc64 האפשרות מאפשרת ל-GCC ליצור את ההוראות הנוספות של 64 סיביות
נמצאים בארכיטקטורת PowerPC64 המלאה וכדי להתייחס ל-GPR כאל 64-bit, doubleword
כמיות. ברירת המחדל של GCC היא -mno-powerpc64.

אם תציין את שניהם -מנו-כוח ו -mno-powerpc, GCC ישתמש רק בהוראות ב
תת-הקבוצה המשותפת של שתי הארכיטקטורות בתוספת כמה קריאות AIX מיוחדות במצב משותף, ו
לא ישתמש ברישום MQ. מפרט את שניהם -מכוח ו -mpowerpc מאפשר ל-GCC
להשתמש בכל הוראה משתי הארכיטקטורות וכדי לאפשר שימוש באוגר MQ;
ציין זאת עבור Motorola MPC601.

-mnew-mnemonics
-עובש-מנמוניות
בחר באיזה זיכרון זיכרון להשתמש בקוד האסמבלר שנוצר. עם -mnew-mnemonics,
GCC משתמש במנמונית האסמבלר שהוגדרה עבור ארכיטקטורת PowerPC. עם
-עובש-מנמוניות הוא משתמש במנמונית האסמבלר שהוגדרה עבור ארכיטקטורת POWER.
להוראות המוגדרות בארכיטקטורה אחת בלבד יש רק מנמוניק אחד; GCC משתמש בזה
זכרון ללא קשר לאיזו מהאפשרויות הללו צוינה.

ברירת המחדל של GCC היא ה-Mnemonic המתאימה לארכיטקטורה שבשימוש. מפרט
-mcpu=cpu_type לפעמים גובר על הערך של אפשרויות אלה. אלא אם כן אתה בונה
מהדר צולב, בדרך כלל לא צריך לציין גם -mnew-mnemonics or
-עובש-מנמוניות, אך במקום זאת צריך לקבל את ברירת המחדל.

-mcpu=cpu_type
הגדר את סוג הארכיטקטורה, רישום השימוש, בחירת הזיכרון ותזמון הוראות
פרמטרים לסוג המכונה cpu_type. ערכים נתמכים עבור cpu_type יש לו 401, 403,
405, 405fp, 440, 440fp, 464, 464fp, 476, 476fp, 505, 601, 602, 603, 603e, 604, 604e,
620, 630, 740, 7400, 7450, 750, 801, 821, 823, 860, 970, 8540, a2, e300c2, e300c3,
e500mc, E500MC64, EC603E, G3, G4, G5, עֲנָק, כּוֹחַ, power2, power3, power4, power5,
power5+, power6, כוח 6x, power7, משותף, מחשב כוח, powerpc64, נהרות, 1, 2, RSC,
ו rs64.

-mcpu=נפוץ בוחר במעבד גנרי לחלוטין. קוד שנוצר תחת אפשרות זו
יפעל על כל מעבד POWER או PowerPC. GCC תשתמש רק בהוראות ב-
תת-קבוצה משותפת של שתי הארכיטקטורות, ולא תשתמש ברישום MQ. GCC מניח א
מודל מעבד גנרי למטרות תזמון.

-mcpu=כוח, -mcpu=power2, -mcpu=powerpc, ו -mcpu=powerpc64 ציין POWER גנרי,
POWER2, ​​PowerPC טהור של 32 סיביות (כלומר, לא MPC601), וארכיטקטורת PowerPC של 64 סיביות
סוגי מכונות, עם מודל מעבד מתאים וגנרי שהונחה לתזמון
מטרות.

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

אל האני -mcpu אפשרויות מאפשרות או משביתות באופן אוטומטי את האפשרויות הבאות:

-maltivec -mfprnd -mhard-float -mmfcrf -מרובה -mnew-mnemonics -mpopcntb
-mpopcntd -מכוח -mpower2 -mpowerpc64 -mpowerpc-gpopt -mpowerpc-gfxopt
ציפה אחת -mdouble-float -msimple-fpu -mstring -ממולהוו -mdlmzb -mmfpgpr -mvsx

האפשרויות הספציפיות שהוגדרו עבור כל מעבד מסוים ישתנו בין גרסאות המהדר,
תלוי באיזו הגדרה נראה לייצור קוד אופטימלי עבור אותו מעבד; זה לא
משקף בהכרח את יכולות החומרה בפועל. אם ברצונך להגדיר an
אפשרות אינדיבידואלית לערך מסוים, תוכל לציין אותה לאחר ה- -mcpu אוֹפְּצִיָה,
כמו -mcpu=970 -mno-altivec.

ב-AIX, ה -maltivec ו -mpowerpc64 האפשרויות אינן מופעלות או מושבתות על ידי -mcpu
אפשרות כרגע מכיוון של-AIX אין תמיכה מלאה באפשרויות אלו. אתה יכול
עדיין הפעל או השבת אותם בנפרד אם אתה בטוח שזה יעבוד אצלך
סביבה.

-mtune=cpu_type
הגדר את פרמטרי תזמון ההוראות עבור סוג המכונה cpu_type, אבל לא להגדיר
סוג הארכיטקטורה, השימוש ברישום, או בחירת הזיכרון, כמו -mcpu=cpu_type
היה. אותם ערכים עבור cpu_type משמשים ל -mtune בנוגע ל -mcpu. אם שניהם
שצוין, הקוד שנוצר ישתמש בערכת הארכיטקטורה, הרגיסטרים והמנמוניות
by -mcpu, אבל פרמטרי התזמון שנקבעו על ידי -mtune.

-mcmodel=small
צור קוד PowerPC64 עבור הדגם הקטן: ה-TOC מוגבל ל-64k.

-mcmodel = בינוני
צור קוד PowerPC64 עבור הדגם הבינוני: ה-TOC ונתונים סטטיים אחרים עשויים להיות למעלה
בגודל כולל של 4G.

-mcmodel=גדול
צור קוד PowerPC64 עבור הדגם הגדול: ה-TOC עשוי להיות בגודל של עד 4G. אַחֵר
נתונים וקוד מוגבלים רק על ידי מרחב הכתובות של 64 סיביות.

-maltivec
-mno-altivec
צור קוד המשתמש (לא משתמש) בהוראות AltiVec, ואפשר גם את השימוש
של פונקציות מובנות המאפשרות גישה ישירה יותר לסט ההוראות של AltiVec.
ייתכן שתצטרך גם להגדיר -mabi=altivec כדי להתאים את ה-ABI הנוכחי עם AltiVec ABI
שיפורים.

-mvrsave
-mno-vrsave
צור הוראות VRSAVE בעת הפקת קוד AltiVec.

-mgen-cell-microcode
צור הוראות מיקרוקוד של תא

-mwarn-cell-microcode
אזהרה כאשר הולכת להיפלט הוראת מיקרוקוד של תא. דוגמה לתא
הוראת מיקרוקוד היא שינוי משתנה.

-msecure-plt
צור קוד המאפשר ל-ld ו-ld.so לבנות איתם קובצי הפעלה וספריות משותפות
קטעי .plt ו- .got שאינם ל-exec. זוהי אפשרות PowerPC 32 סיביות SYSV ABI.

-mbss-plt
צור קוד שמשתמש בקטע BSS .plt ש-ld.so ממלא, ודורש .plt ו
יש קטעים שניתנים לכתיבה וגם להפעלה. זהו PowerPC 32 סיביות SYSV
אפשרות ABI.

-מיזל
-mno-isel
מתג זה מאפשר או משבית את יצירת הוראות ISEL.

-מיזל=כן לא
מתג זה הוצא משימוש. להשתמש -מיזל ו -mno-isel במקום.

-mspe
-מנו-ספ
מתג זה מאפשר או משבית את יצירת הוראות SPE simd.

-פגוע
-מוצמדים
מתג זה מאפשר או משבית את היצירה של PAIRED הוראות simd.

-mspe=כן לא
אפשרות זו הוצאה משימוש. להשתמש -mspe ו -מנו-ספ במקום.

-mvsx
-mno-vsx
צור קוד שמשתמש (לא משתמש) בהוראות וקטור/סקלר (VSX), וגם
לאפשר שימוש בפונקציות מובנות המאפשרות גישה ישירה יותר ל-VSX
סט הוראות.

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

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

הוויכוח לְהַכפִּיל מאפשר שימוש בנקודה צפה בעלת דיוק יחיד וכפול
פעולות.

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

אפשרות זו זמינה כרגע רק ב-MPC854x.

-מ 32
-מ 64
צור קוד עבור סביבות 32 סיביות או 64 סיביות של יעדי Darwin ו-SVR4 (כולל
GNU/Linux). סביבת 32 סיביות מגדירה int, long ו-pointer ל-32 סיביות ו
יוצר קוד שרץ על כל וריאציה של PowerPC. סביבת 64 סיביות מוגדרת ל
32 סיביות וארוך ומצביע ל-64 סיביות, ומייצר קוד עבור PowerPC64, כמו עבור
-mpowerpc64.

-mfull-toc
-mno-fp-in-toc
-mno-sum-in-toc
-מינימלי-טוק
שנה את הדור של TOC (תוכן עניינים), שנוצר עבור כל
קובץ הרצה. ה -mfull-toc האפשרות נבחרה כברירת מחדל. במקרה כזה, GCC
יקצה לפחות ערך TOC אחד לכל התייחסות משתנה לא אוטומטית ייחודית
בתוכנית שלך. GCC גם יציב קבועי נקודה צפה ב-TOC. למרות זאת,
רק 16,384 ערכים זמינים ב-TOC.

אם אתה מקבל הודעת שגיאה מקשר שאומרת שהגזמת את הזמין
שטח TOC, אתה יכול להפחית את כמות שטח TOC בשימוש עם -mno-fp-in-toc ו
-mno-sum-in-toc אפשרויות. -mno-fp-in-toc מונע מ-GCC לשים נקודה צפה
קבועים ב-TOC ו -mno-sum-in-toc מאלץ את GCC ליצור קוד כדי לחשב את
סכום של כתובת וקבוע בזמן ריצה במקום להכניס את הסכום הזה ל-TOC.
אתה יכול לציין את אחת מהאפשרויות הללו או את שתיהן. כל אחד גורם ל-GCC לייצר מאוד
קוד מעט איטי וגדול יותר על חשבון שימור שטח TOC.

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

-מאיקס 64
-מאיקס 32
אפשר 64 סיביות AIX ABI ומוסכמות שיחות: מצביעי 64 סיביות, סוג "ארוך" של 64 סיביות, ו
התשתית הדרושה כדי לתמוך בהם. מפרט -מאיקס 64 מרמז -mpowerpc64 ו
-mpowerpcתוך -מאיקס 32 משבית את ה-ABI של 64 סיביות ומשתמע -mno-powerpc64. GCC
ברירת מחדל ל -מאיקס 32.

-mxl-compat
-mno-xl-compat
הפק קוד התואם יותר לסמנטיקה של מהדר IBM XL בעת שימוש ב-AIX-
ABI תואם. העבר ארגומנטים של נקודה צפה לפונקציות עם אב טיפוס מעבר ל-
רשום אזור שמירה (RSA) בערימה בנוסף ל-FPRs של ארגומנטים. אל תניח
הכפל המשמעותי ביותר בערך הכפול הארוך של 128 סיביות מעוגל כראוי כאשר
השוואת ערכים והמרה לכפולה. השתמש בשמות סמלים XL עבור כפול ארוך
שגרות תמיכה.

אמנת שיחות AIX הוארכה אך לא תועדה בתחילה לטיפול ב-
מקרה מעורפל של K&R C של קריאה לפונקציה שלוקחת את הכתובת של הארגומנטים שלה
פחות ויכוחים ממה שהוצהר. מהדרים של IBM XL ניגשים לארגומנטים של נקודה צפה
אינם מתאימים ל-RSA מהמחסנית כאשר תת שגרת קומפילציה ללא
אופטימיזציה. כי תמיד אחסון ארגומנטים של נקודה צפה על הערימה היא
לא יעיל ולעתים רחוקות צורך, אפשרות זו אינה מופעלת כברירת מחדל ורק היא
הכרחי בעת קריאה לשגרות משנה שהידור על ידי מהדרים של IBM XL ללא אופטימיזציה.

-מפה
תמיכה יבמ RS/6000 SP מקביל סביבה (פ). קישור אפליקציה שנכתבה לשימוש
הודעה עוברת עם קוד הפעלה מיוחד כדי לאפשר לאפליקציה לפעול. ה
המערכת חייבת להתקין PE במיקום הסטנדרטי (/usr/lpp/ppe.poe/), או ה
מפרט טכני יש לעקוף את הקובץ עם ה- -מפרט = אפשרות לציין את המתאים
מיקום ספרייה. הסביבה המקבילה אינה תומכת בשרשורים, ולכן -מפה
אפשרות וה -phthread האפשרויות אינן תואמות.

-ממאיר-טבעי
-ממאיר-כוח
ב-AIX, 32-bit Darwin ו-64-bit PowerPC GNU/Linux, האפשרות -ממאיר-טבעי
עוקף את היישור המוגדר ב-ABI של סוגים גדולים יותר, כגון כפל נקודה צפה,
על הגבול הטבעי מבוסס הגודל שלהם. האפשרות -ממאיר-כוח מורה ל-GCC לעשות זאת
פעל לפי כללי היישור שצוינו ב-ABI. ברירת המחדל של GCC היא היישור הסטנדרטי
מוגדר ב-ABI.

ב-Darwin 64 סיביות, יישור טבעי הוא ברירת המחדל, ו -ממאיר-כוח לא
נתמך.

-msoft-float
-mhard-float
צור קוד שאינו משתמש (משתמש) בערכת האוגר של הנקודה הצפה. תוֹכנָה
אמולציית נקודה צפה מסופקת אם אתה משתמש ב- -msoft-float אפשרות, והעבירו את
אפשרות ל-GCC בעת הקישור.

ציפה אחת
-mdouble-float
צור קוד עבור פעולות נקודה צפה בעלת דיוק יחיד או כפול.
-mdouble-float מרמז ציפה אחת.

-msimple-fpu
אל תיצור הוראות sqrt ו-div עבור יחידת נקודה צפה בחומרה.

-mfpu
ציין את סוג יחידת הנקודה צפה. ערכים חוקיים הם sp_lite (שווה ערך ל
-msingle-float -msimple-fpu), dp_lite (מקביל ל-mdouble-float -msimple-fpu),
sp_full (מקביל ל-single-float), ו dp_full (מקביל ל-mdouble-float).

-mxilinx-fpu
בצע אופטימיזציות עבור יחידת הנקודה הצפה ב- Xilinx PPC 405/440.

-מרובה
-mno-כפול
צור קוד שמשתמש (לא משתמש) בהוראות הטעינה של מילים מרובות וב-
אחסן הוראות מילים מרובות. הוראות אלו נוצרות כברירת מחדל ב-
מערכות POWER, ולא נוצרות על מערכות PowerPC. אל תשתמש -מרובה על קטן-
מערכות endian PowerPC, מכיוון שהוראות אלו אינן פועלות כאשר המעבד נמצא
מצב little-endian. החריגים הם PPC740 ו-PPC750 שמתירים זאת
הוראות במצב little-endian.

-mstring
-mno-מחרוזת
צור קוד שמשתמש (לא משתמש) בהוראות מחרוזת הטעינה ובחנות
מחרוזת הוראות מילים לשמירת אוגרים מרובים ולבצע מהלכי בלוק קטנים. אלה
הוראות מופקות כברירת מחדל במערכות POWER, ולא מופקות ב-PowerPC
מערכות. אל תשתמש -mstring על מערכות PowerPC הקטנות, מאז אלה
ההוראות אינן פועלות כאשר המעבד במצב little-endian. החריגים
הם PPC740 ו-PPC750 המאפשרים הוראות אלה במצב little-endian.

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

-mavoid-אינדקס-כתובות
-mno-avoid-אינדקס-כתובות
צור קוד שמנסה להימנע (לא להימנע) משימוש בעומס או בחנות באינדקס
הוראות. הוראות אלו עלולות לגרור עונש ביצועים במעבדי Power6
במצבים מסויימים, כמו למשל כאשר עוברים דרך מערכים גדולים שחוצים 16M
גְבוּל. אפשרות זו מופעלת כברירת מחדל בעת מיקוד ל-Power6 ומושבתת
אחרת.

-מfused-madd
-mno-fused-madd
צור קוד שמשתמש (אינו משתמש) בנקודה הצפה כפולה וצבירה
הוראות. הוראות אלה נוצרות כברירת מחדל אם חומרה נקודה צפה
משמש. התלוי במכונה -מfused-madd האפשרות ממופה כעת למכונה-
עצמאי -ffp-contract=מהיר אפשרות ו -mno-fused-madd ממופה ל
-ffp-contract=off.

-ממולהוו
-מנו-מולהוו
צור קוד שמשתמש (לא משתמש) בחצי המילה כפל וכפל-צבור
הוראות על מעבדי IBM 405, 440, 464 ו-476. הוראות אלו הן
נוצר כברירת מחדל בעת מיקוד למעבדים אלה.

-mdlmzb
-mno-dlmzb
צור קוד שמשתמש (לא משתמש) ב-string-search dlmzb הדרכה על IBM
מעבדי 405, 440, 464 ו-476. הוראה זו נוצרת כברירת מחדל כאשר
התמקדות במעבדים האלה.

-mno-bit-align
-mbit-align
במערכת V.4 ומערכות PowerPC משובצות אינן (עושים) מאלצות מבנים ואיגודים
המכילים שדות סיביות שיש ליישור לסוג הבסיס של שדה הסיביות.

לדוגמה, כברירת מחדל מבנה המכיל רק 8 שדות סיביות "לא חתומים" של
אורך 1 מיושר לגבול של 4 בתים ויש לו גודל של 4 בתים. על ידי שימוש ב
-mno-bit-align, המבנה מיושר לגבול של 1 בייט וגודלו של בייט אחד.

-mno-strict-align
-mstrict-align
במערכת V.4 ומערכות PowerPC משובצות אינן (עושים) מניחות כי זיכרון לא מיושר
הפניות יטופלו על ידי המערכת.

-ניתן להזזה
-mno-relocationable
צור קוד שמאפשר (לא מאפשר) העברה של קובץ הפעלה סטטי ל-a
כתובת שונה בזמן ריצה. מטעין מערכת PowerPC פשוט משובץ צריך
העבר את כל התוכן של מיקומי ".got2" ו-4 בתים המפורטים ב-".fixup"
סעיף, טבלה של כתובות של 32 סיביות שנוצרה על ידי אפשרות זו. כדי שזה יעבוד, הכל
יש לבצע קומפילציה עם אובייקטים המקושרים יחד -ניתן להזזה or -mrelocatable-lib.
-ניתן להזזה קוד מיישר את המחסנית לגבול של 8 בתים.

-mrelocatable-lib
-mno-relocatable-lib
כמו -ניתן להזזה, -mrelocatable-lib יוצר קטע ".fixup" כדי לאפשר סטטי
קובצי הפעלה שיועברו בזמן ריצה, אבל -mrelocatable-lib אינו משתמש ב-
יישור מחסנית קטן יותר של -ניתן להזזה. אובייקטים הידור עם -mrelocatable-lib אולי
להיות מקושר עם אובייקטים המורכבים עם כל שילוב של ה -ניתן להזזה אפשרויות.

-mno-toc
-מטוק
במערכת V.4 ומערכות PowerPC משובצות אינן (עושים) מניחות שהאוגר 2 מכיל
מצביע לאזור גלובלי המצביע על הכתובות המשמשות בתוכנית.

-מעט
-מעט-אנדיאן
במערכת V.4 ומערכות PowerPC משובצות קומפלט קוד עבור המעבד ב-
מצב אנדיאן. ה -מעט-אנדיאן אפשרות זהה ל -מעט.

-מביג
-mbig-endian
במערכת V.4 ומערכות PowerPC משובצות קומפלט קוד עבור המעבד ב-
מצב אנדיאן. ה -mbig-endian אפשרות זהה ל -מביג.

-מדינמית-ללא-תמונה
במערכות Darwin ו-Mac OS X, קומפילו קוד כך שלא ניתן יהיה להעביר אותו מחדש, אבל זה
הפניות החיצוניות שלו ניתנות להזזה. הקוד המתקבל מתאים ל
יישומים, אך לא ספריות משותפות.

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

-mprioritize-restricted-insns=עדיפות
אפשרות זו שולטת בעדיפות המוקצה ל-dispatch-slot מוגבל
הוראות במהלך מעבר התזמון השני. הטיעון עדיפות לוקח את הערך
0/1/2 להקצות לא/הגבוהה/השניה הגבוהה ביותר עדיפות לשידור חריץ מוגבל
הוראות.

-msched-costly-dep=סוג_תלות
אפשרות זו שולטת אילו תלות נחשבות יקרות על ידי היעד במהלך
תזמון הוראות. הטיעון סוג_תלות לוקח אחד מהדברים הבאים
ערכים: לא: שום תלות אינה יקרה, את כל: כל התלות יקרות,
true_store_to_load: תלות אמיתית מחנות לעומס היא יקרה, store_to_load: כל
תלות מחנות לעומס היא יקרה, מספר: כל תלות שעבורה חביון >=
מספר הוא יקר.

-minsert-sched-nops=תכנית
אפשרות זו שולטת באיזו סכימת הוספת nop תשמש במהלך השני
כרטיס תזמון. הטיעון תכנית לוקח אחד מהערכים הבאים: לא: אל תעשה
הכנס לא. נתיב: רפד ללא נקודות על כל קבוצת שיגור שיש לה חריצי נושא פנויים,
לפי הקיבוץ של המתזמן. regroup_exact: הכנס nops כדי לאלץ יקר
מנות תלויות לקבוצות נפרדות. הכנס בדיוק כמה פעימות לפי הצורך כדי לאלץ
תוספת לקבוצה חדשה, לפי קיבוץ המעבדים המשוער. מספר: הכנס
לא, לאלץ אינסנס תלויים יקרים לקבוצות נפרדות. לְהַכנִיס מספר לא ל
להכריח אינס לקבוצה חדשה.

-mcall-sysv
במערכת V.4 ומערכות PowerPC משובצות, קומפלט קוד באמצעות מוסכמות קורא זה
מצייתת לטיוטה של ​​מרץ 1995 של System V Application Binary Interface, PowerPC
תוספת מעבד. זוהי ברירת המחדל אלא אם הגדרת את GCC באמצעות
powerpc-*-eabiaix.

-mcall-sysv-eabi
-mcall-eabi
ציין את שניהם -mcall-sysv ו -מאבי אפשרויות.

-mcall-sysv-noeabi
ציין את שניהם -mcall-sysv ו -מנו-איבי אפשרויות.

-mcall-aixdesc
במערכת V.4 ומערכות PowerPC משובצות, קומפלטו קוד עבור מערכת ההפעלה AIX.

-mcall-linux
במערכת V.4 ומערכות PowerPC מוטמעות, קומפלטו קוד עבור GNU מבוסס לינוקס
מערכת.

-mcall-freebsd
במערכת V.4 ומערכות PowerPC משובצות, קומפלטו קוד עבור פעולת FreeBSD
מערכת.

-mcall-netbsd
במערכת V.4 ומערכות PowerPC משובצות, קומפלטו קוד עבור פעולת NetBSD
מערכת.

-mcall-openbsd
במערכת V.4 ומערכות PowerPC משובצות, קומפלטו קוד עבור פעולת OpenBSD
מערכת.

-maix-struct-return
החזר את כל המבנים בזיכרון (כפי שצוין על ידי AIX ABI).

-msvr4-struct-return
החזר מבנים קטנים מ-8 בתים באוגרים (כפי שצוין על ידי SVR4 ABI).

-מאבי=טיפוס אבי
הרחב את ה-ABI הנוכחי עם הרחבה מסוימת, או הסר הרחבה כזו. תָקֵף
הערכים הם altivec, no-altivec, ספציפי, לא-ספ, ibmlongdouble, ieeelongdouble.

-מאבי=ספ
הרחב את ה-ABI הנוכחי עם הרחבות SPE ABI. זה לא משנה את ברירת המחדל של ABI,
במקום זאת הוא מוסיף את הרחבות SPE ABI ל-ABI הנוכחי.

-מאבי=לא-ספ
השבת תוספי ABI של Booke SPE עבור ה-ABI הנוכחי.

-mabi=ibmlongdouble
שנה את ה-ABI הנוכחי לשימוש ב-IBM עם דיוק ארוך כפול מורחב. זה PowerPC
אפשרות SYSV ABI של 32 סיביות.

-mabi=ieeelongdouble
שנה את ה-ABI הנוכחי לשימוש ב-IEEE דיוק ארוך כפול מורחב. זה PowerPC
אפשרות 32-bit Linux ABI.

-אפרוטוטייפ
-mno-אב טיפוס
במערכת V.4 ומערכות PowerPC משובצות מניחות שכל הקריאות לארגומנט משתנה
פונקציות הן אב טיפוס כראוי. אחרת, המהדר חייב להוסיף הוראה
לפני כל קריאה ללא אב טיפוס להגדיר או לנקות סיביות 6 של אוגר קוד התנאים
(CR) כדי לציין אם ערכי נקודה צפה הועברו בנקודה צפה
רושם במקרה שהפונקציה לוקחת ארגומנטים משתנים. עם -אפרוטוטייפ, רק שיחות
פונקציות ארגומנט משתנה של אב טיפוס יגדירו או ימקו את הביט.

-מסים
במערכות PowerPC משובצות, נניח שמודול האתחול נקרא sim-crt0.o ו
שספריות C הסטנדרטיות הן ליבסים.א ו libc.a. זוהי ברירת המחדל עבור
powerpc-*-eabisim תצורות.

-ממממה
במערכות PowerPC משובצות, נניח שמודול האתחול נקרא crt0.o ו
ספריות C סטנדרטיות הן libmvme.a ו libc.a.

-משוגעים
במערכות PowerPC משובצות, נניח שמודול האתחול נקרא crt0.o ו
ספריות C סטנדרטיות הן ליבדס.א ו libc.a.

-myellowknife
במערכות PowerPC משובצות, נניח שמודול האתחול נקרא crt0.o ו
ספריות C סטנדרטיות הן libyk.a ו libc.a.

-mvxworks
במערכת V.4 ומערכות PowerPC משובצות, ציין שאתה מבצע קומפילציה עבור א
מערכת VxWorks.

-חבר
במערכות PowerPC משובצות, הגדר את PPC_EMB קצת בכותרת דגלי ELF כדי לציין
זֶה eabi נעשה שימוש ברילוקיישן ממושך.

-מאבי
-מנו-איבי
במערכת V.4 ומערכות PowerPC משובצות (אינן) נצמדות ל-Embedded
ממשק בינארי של יישומים (eabi) שהוא סט של שינויים במערכת V.4
מפרטים. בחירה -מאבי פירושו שהמחסנית מיושרת ל-8 בתים
גבול, פונקציה "__eabi" נקראת מ-"main" כדי להגדיר את סביבת eabi,
ו -msdata אפשרות יכולה להשתמש גם ב-"r2" וגם "r13" כדי להצביע על שני נתונים קטנים נפרדים
אזורים. בחירה -מנו-איבי פירושו שהמחסנית מיושרת לגבול של 16 בתים, עשה
לא לקרוא לפונקציית אתחול מ-"main", וה- -msdata האפשרות תשתמש רק
"r13" כדי להצביע על אזור נתונים קטן יחיד. ה -מאבי האפשרות מופעלת כברירת מחדל אם אתה
הגדיר את GCC באמצעות אחד מה- powerpc*-*-eabi* אפשרויות.

-msdata=eabi
על מערכת V.4 ומערכות PowerPC משובצות, שים את "קונסט" גלובליות קטן מאותחל ו
נתונים סטטיים ב- .sdata2 סעיף, שאליו מצביע הרשום "r2". לשים קטן
נתונים גלובליים וסטטיים מאתחלים שאינם "קונסטטים" ב- .sdata סעיף, שהוא מחודד
על ידי הרשמה "r13". שים נתונים גלובליים וסטטיים קטנים לא מאותחלים ב- .sbss
קטע, אשר צמוד ל .sdata סָעִיף. ה -msdata=eabi האפשרות היא
לא תואם את -ניתן להזזה אוֹפְּצִיָה. ה -msdata=eabi אפשרות מגדיר גם את
-חבר אוֹפְּצִיָה.

-msdata=sysv
במערכת V.4 ומערכות PowerPC משובצות, הכנס נתונים גלובליים וסטטיים קטנים ב-
.sdata סעיף, שאליו מצביע הרשום "r13". שים עולמי קטן לא מאותחל
ונתונים סטטיים ב- .sbss קטע, אשר צמוד ל .sdata סָעִיף. ה
-msdata=sysv האפשרות אינה תואמת את -ניתן להזזה אוֹפְּצִיָה.

-msdata = ברירת מחדל
-msdata
במערכת V.4 ומערכות PowerPC משובצות, אם -מאבי נעשה שימוש, קוד קומפילציה זהה
as -msdata=eabi, אחרת הידור קוד זהה ל -msdata=sysv.

-msdata=נתונים
במערכת V.4 ומערכות PowerPC משובצות, הכנס נתונים גלובליים קטנים ב- .sdata
סָעִיף. שים נתונים גלובליים קטנים לא מאותחלים ב- .sbss סָעִיף. אל תשתמש
עם זאת, רשום "r13" כדי לטפל בנתונים קטנים. זוהי התנהגות ברירת המחדל אלא אם כן
אַחֵר -msdata נעשה שימוש באפשרויות.

-msdata=אין
-mno-sdata
במערכות PowerPC משובצות, שים את כל הנתונים הגלובאליים והסטטיים המאתחלים ב- נתונים
סעיף, וכל הנתונים הלא מאותחלים ב- .bss סָעִיף.

-mblock-move-inline-limit=NUM
כל מהלכי הבלוק (כגון קריאות ל-"memcpy" או עותקי מבנה) מוטבעים פחות מ- או
שווה ל NUM בתים. הערך המינימלי עבור NUM הוא 32 בתים על יעדים של 32 סיביות ו-64
בתים על יעדים של 64 סיביות. ערך ברירת המחדל הוא יעד ספציפי.

-G NUM
במערכות PowerPC משובצות, שים פריטים גלובליים וסטטיים פחות או שווה ל NUM
בתים לתוך קטעי הנתונים הקטנים או bss במקום לקטע הנתונים הרגיל או bss.
כברירת מחדל, NUM הוא בן 8. ה -G NUM מתג מועבר גם למקשר. כל המודולים
צריך להיות מורכב עם אותו הדבר -G NUM ערך.

-מרגשמות
-mno-regnames
במערכת V.4 ומערכות PowerPC משובצות (לא) פולטות שמות רישום ב-
פלט שפת assembly באמצעות צורות סמליות.

-mlongcall
-mno-longcall
כברירת מחדל, נניח שכל השיחות רחוקות, כך שהשיחות יקרות יותר
נדרש רצף. זה נדרש עבור שיחות מעבר ל-32 מגה-בייט
(33,554,432 בתים) מהמיקום הנוכחי. תיווצר שיחה קצרה אם
המהדר יודע שהשיחה לא יכולה להיות כל כך רחוקה. ניתן לעקוף הגדרה זו על ידי
תכונת הפונקציה "shortcall", או לפי "#pragma שיחה ארוכה(0) ".

חלק מהמקשרים מסוגלים לזהות שיחות מחוץ לטווח ולהפיק קוד דבק
הזבוב. במערכות אלו שיחות ארוכות מיותרות ומייצרות קוד איטי יותר. כפי ש
לפי כתיבת שורות אלה, מקשר AIX יכול לעשות זאת, וכך גם מקשר GNU עבור PowerPC/64. זה
מתוכנן להוסיף תכונה זו למקשר של GNU גם עבור מערכות PowerPC של 32 סיביות.

במערכות Darwin/PPC, "#pragma longcall" יפיק "jbsr callee, L42", פלוס
"אי סניף" (קוד דבק). שתי כתובות היעד מייצגות את הנקרא ואת
"אי סניף". המקשר של Darwin/PPC יעדיף את הכתובת הראשונה וייצור א
"bl callee" אם הוראת ה-PPC "bl" תגיע ישירות אל הקורא; אחרת ה
מקשר יפיק "bl L42" כדי לקרוא ל"האי הסניף". "האי הסניף" הוא
מצורף לגוף הפונקציה המתקשרת; הוא מחשב את הכתובת המלאה של 32 סיביות
המוקדן וקופץ אליו.

במערכות Mach-O (Darwin), אפשרות זו מכוונת את פליטת המהדר לדבק עבור
כל שיחה ישירה, והמקשר של דארווין מחליט אם להשתמש בה או להשליך אותה.

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

-mtls-markers
-mno-tls-markers
סמן (אל תסמן) קריאות ל-"__tls_get_addr" עם רילוקיישן המציין את הפונקציה
טַעֲנָה. ה-relocation מאפשר ל-ld לשייך באופן אמין את קריאת הפונקציה לארגומנט
הוראות הגדרה לאופטימיזציה של TLS, אשר בתורה מאפשרת ל-gcc לתזמן טוב יותר
הרצף.

-phthread
מוסיף תמיכה בריבוי השחלות עם חוטים סִפְרִיָה. אפשרות זו מגדירה דגלים עבור
גם הפרהמעבד וגם המקשר.

-mrecip
-mno-recip
אפשרות זו תאפשר ל-GCC להשתמש באומדן ההדדיות ובשורש הריבועי ההדדי
הערכת הוראות עם שלבים נוספים של ניוטון-ראפסון כדי להגביר את הדיוק
במקום לעשות חלוקה או שורש ריבועי ולחלק עבור ארגומנטים של נקודה צפה. אתה
צריך להשתמש ב -מהיר-מתמטיקה אפשרות בעת השימוש -mrecip (או לפחות
-אופטימיזציות-funsafe-math, -סופית-מתמטיקה-בלבד, -תדמיתי-מתמטיקה ו
-fno-מלכודת-מתמטיקה). שים לב שאמנם התפוקה של הרצף היא בדרך כלל
גבוה מהתפוקה של ההוראה הלא הדדית, הדיוק של ה
ניתן להקטין את הרצף עד 2 ulp (כלומר, ההיפוך של 1.0 שווה ל-0.99999994)
לשורשים ריבועיים הדדיים.

-mrecip=לִבחוֹר
אפשרות זו מאפשרת לשלוט באילו הוראות אומדן הדדי ניתן להשתמש. לִבחוֹר
היא רשימה מופרדת בפסיקים של אפשרויות, אשר עשויה להיות קודמת לה "!" להפוך את
אפשרות: "הכל": אפשר את כל הוראות האומדן, "ברירת מחדל": אפשר את ברירת המחדל
הוראות, שווה ערך ל -mrecip, "ללא": השבת את כל הוראות האומדן,
שווה ערך ל -mno-recip; "div": אפשר את הוראות הקירוב ההדדיות עבור
גם דיוק בודד וגם כפול; "divf": אפשר את ההדדיות עם דיוק יחיד
הוראות קירוב; "divd": אפשר את ההדדיות עם דיוק כפול
הוראות קירוב; "rsqrt": אפשר את קירוב השורש הריבועי ההדדי
הוראות לדיוק יחיד וכפול כאחד; "rsqrtf": אפשר את הסינגל-
הוראות קירוב שורש ריבועי הדדי מדויק; "rsqrtd": אפשר את
הוראות קירוב שורש ריבועי הדדי בעל דיוק כפול;

אז למשל, -mrecip=all,!rsqrtd יאפשר את כל ההערכה ההדדית
הוראות, למעט ההוראות "FRSQRTE", "XSRSQRTEDP" ו-"XVRSQRTEDP"
המטפלים בחישובי שורש ריבועי הדדי בעל דיוק כפול.

-mrecip-דיוק
-מנו-מתכונים-דיוק
נניח (אל תניח) שהוראות האומדן ההדדיות מספקות יותר-
אומדני דיוק ממה שמחייב ה- PowerPC ABI. בחירה -mcpu=power6 or
-mcpu=power7 בוחר אוטומטית -mrecip-דיוק. הריבוע בעל הדיוק הכפול
הוראות הערכת שורש אינן נוצרות כברירת מחדל במכונות בעלות דיוק נמוך,
מכיוון שהם אינם מספקים אומדן שמתכנס לאחר שלושה שלבים.

-mveclibabi=סוג
מציין את סוג ABI לשימוש עבור וקטוריזציה פנימית באמצעות ספרייה חיצונית.
הסוג היחיד הנתמך כרגע הוא "מסה", שמציין להשתמש ב-IBM
ספריות תת-מערכת תאוצה מתמטית (MASS) עבור וקטוריזציה של מרכיבים פנימיים באמצעות
ספריות חיצוניות. GCC ישדר כרגע קריאות ל-"acosd2", "acosf4", "acoshd2",
"acoshf4", "asind2", "asinf4", "asinhd2", "asinhf4", "atan2d2", "atan2f4", "atand2",
"atanf4", "atanhd2", "atanhf4", "cbrtd2", "cbrtf4", "cosd2", "cosf4", "coshd2",
"coshf4", "erfcd2", "erfcf4", "erfd2", "erff4", "exp2d2", "exp2f4", "expd2", "expf4",
"expm1d2", "expm1f4", "hypotd2", "hypotf4", "lgammad2", "lgammaf4", "log10d2",
"log10f4", "log1pd2", "log1pf4", "log2d2", "log2f4", "logd2", "logf4", "powd2",
"powf4", "sind2", "sinf4", "sinhd2", "sinhf4", "sqrtd2", "sqrtf4", "tand2", "tanf4",
"tanhd2", ו-"tanhf4" בעת הפקת קוד עבור power7. שניהם -ftree-vectorize ו
-אופטימיזציות-funsafe-math יש להפעיל. ספריות MASS יצטרכו להיות
צוין בזמן הקישור.

-מפריז
-מנו-פריז
צור (אל תיצור) את הוראת ה-"friz" כאשר -אופטימיזציות-funsafe-math
האופציה משמשת לאופטימיזציה של עיגול ערכי נקודה צפה למספר שלם של 64 סיביות ו
חזרה לנקודה צפה. ההוראה "friz" לא מחזירה את אותו ערך אם
מספר הנקודה הצפה גדול מכדי להתאים למספר שלם.

-mpointers-to-nested-functions
-mno-pointers-to-nested-functions
צור (אל תיצור) קוד כדי לטעון את אוגר השרשרת הסטטי (r11) מתי
קריאה דרך מצביע במערכות AIX ו-64 סיביות לינוקס שבהן מצביע פונקציה
מצביע על מתאר בן 3 מילים שנותן את כתובת הפונקציה, ערך TOC לטעינה
הירשם r2, וערך שרשרת סטטי שייטען במאגר r11. ה
-mpointers-to-nested-functions מופעל כברירת מחדל. לא תוכל להתקשר דרך
מצביעים לפונקציות מקוננות או מצביעים לפונקציות שהורכבו בשפות אחרות
השתמש בשרשרת הסטטית אם אתה משתמש ב- -mno-pointers-to-nested-functions.

-msave-toc-עקיף
-mno-save-toc-עקיף
צור (אל תיצור) קוד כדי לשמור את ערך ה-TOC במיקום המחסנית השמורה
בפרולוג הפונקציה אם הפונקציה קוראת דרך מצביע ב-AIX וב-64 סיביות
מערכות לינוקס. אם ערך ה-TOC לא נשמר בפרולוג, הוא נשמר ממש לפני
השיחה דרך המצביע. ה -mno-save-toc-עקיף אפשרות היא ברירת המחדל.

RX אפשרויות

אפשרויות שורת הפקודה האלה מוגדרות עבור יעדי RX:

-m64bit-כפילים
-m32bit-כפילים
הפוך את סוג הנתונים "כפול" להיות 64 סיביות (-m64bit-כפילים) או 32 סיביות (-m32bit-כפילים)
במידה. ברירת המחדל היא -m32bit-כפילים. הערות חומרת נקודה צפה RX עובדת רק
על ערכי 32 סיביות, וזו הסיבה שברירת המחדל היא -m32bit-כפילים.

-fpu
-nofpu
מאפשר (-fpu) או משבית (-nofpu) השימוש בחומרת נקודה צפה RX. ה
ברירת המחדל מופעלת עבור RX600 סדרה ומושבת עבור RX200 סדרה.

הוראות נקודה צפה יופקו רק עבור ערכי נקודה צפה של 32 סיביות
עם זאת, אז אם ה -m64bit-כפילים האפשרות נמצאת בשימוש אז חומרת ה-FPU לא תהיה
משמש לזוגות.

הערות אם -fpu האפשרות מופעלת אז -אופטימיזציות-funsafe-math מופעל גם
אוטומטית. הסיבה לכך היא שהוראות RX FPU אינן בטוחות בעצמן.

-mcpu=שם
בוחר את סוג ה-RX CPU שאליו יש למקד. נכון לעכשיו, שלושה סוגים נתמכים, ה
גנרית RX600 ו RX200 חומרת הסדרה והספציפי RX610 מעבד. ברירת המחדל היא
RX600.

ההבדל היחיד בין RX600 ו RX610 הוא כי RX610 אינו תומך ב
הוראת "MVTIPL".

אל האני RX200 לסדרה אין יחידת נקודה צפה בחומרה וכן -nofpu מאופשר
כברירת מחדל כאשר סוג זה נבחר.

-mbig-endian-data
-mlittle-endian-data
אחסן נתונים (אך לא קוד) בפורמט הגדול. ברירת המחדל היא
-mlittle-endian-data, כלומר לאחסן נתונים בפורמט הקטן-אנדיאן.

-msmall-data-limit=N
מציין את הגודל המרבי בבתים של משתנים גלובליים וסטטיים שניתן למקם
לתוך אזור הנתונים הקטן. שימוש באזור הנתונים הקטן יכול להוביל לקטן ומהיר יותר
קוד, אך גודל השטח מוגבל ותלוית המתכנת להבטיח זאת
האזור אינו עולה על גדותיו. גם כאשר נעשה שימוש באזור הנתונים הקטן באחד מה-RX
registers (בדרך כלל "r13") שמור לשימוש המצביע על אזור זה, כך שהוא לא
זמין יותר לשימוש על ידי המהדר. זה יכול לגרום לאט יותר ו/או גדול יותר
קוד אם משתנים שפעם יכלו להישמר במאגר השמור נמצאים כעת
נדחף על הערימה.

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

ערך ברירת המחדל הוא אפס, מה שמבטל את התכונה הזו. שימו לב, תכונה זו לא
מופעל כברירת מחדל עם רמות אופטימיזציה גבוהות יותר (-O2 וכו') בגלל ה
השפעות מזיקות פוטנציאליות של שמירת פנקס. זה תלוי במתכנת
להתנסות ולגלות אם תכונה זו מועילה לתוכנית שלהם. לִרְאוֹת
התיאור של ה -mpid אפשרות לתיאור של אופן הרישום בפועל
החזק את מצביע אזור הנתונים הקטן נבחר.

-מסים
-מנו-סים
השתמש בזמן הריצה של הסימולטור. ברירת המחדל היא להשתמש בזמן ריצה ספציפי ללוח libgloss.

-mas100-תחביר
-mno-as100-תחביר
בעת יצירת פלט assembler השתמש בתחביר שתואם ל-AS100 של Renesas
מאסף. תחביר זה יכול להיות מטופל גם על ידי ה-GAS assembler אבל יש לו כמה
הגבלות ולכן יצירתו אינה אפשרות ברירת המחדל.

-mmax-constant-size=N
מציין את הגודל המקסימלי, בבתים, של קבוע שניתן להשתמש בו כאופרנד ב
הוראת RX. למרות שסט ההוראות של RX כן מאפשר קבועים של עד 4
אורך בתים לשימוש בהוראות, ערך ארוך יותר שווה ערך ארוך יותר
הוראה. לכן בנסיבות מסוימות זה יכול להיות מועיל להגביל את הגודל של
קבועים המשמשים בהוראות. קבועים גדולים מדי הם במקום זאת
ממוקמים לתוך מאגר קבוע ומתייחסים אליו באמצעות עקיפה של רישום.

הערך N יכול להיות בין 0 ל-4. ערך של 0 (ברירת המחדל) או 4 אומר ש
קבועים בכל גודל מותרים.

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

-mint-register=N
ציין את מספר האוגרים שיש לשמור עבור פונקציות מטפל בפסיקה מהירה. ה
ערך N יכול להיות בין 0 ל-4. ערך של 1 אומר שהאוגר "r13" יהיה
שמור לשימוש בלעדי של מטפלים בפסיקה מהירה. ערך של 2 רזרבות
"r13" ו-"r12". ערך של 3 רזרבות "r13", "r12" ו-"r11", וערך של 4
שומרת "r13" עד "r10". ערך של 0, ברירת המחדל, אינו שומר שום
רושמים.

-msave-acc-in-interrupts
מציין שפונקציות מטפל בפסיקה צריכות לשמר את אוגר המצבר.
זה הכרחי רק אם קוד רגיל עשוי להשתמש באוגר המצבר, למשל
מכיוון שהוא מבצע הכפלות של 64 סיביות. ברירת המחדל היא להתעלם מהמצבר
מכיוון שזה הופך את מטפלי ההפרעות למהירים יותר.

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

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

האוגר בפועל שנבחר להחזיק את כתובת בסיס הנתונים הקבועה תלוי אם
מה היא -msmall-data-limit ו / או -מנטה-רישום אפשרויות שורת הפקודה מופעלות.
החל מהאוגר "r13" והמשך כלפי מטה, רישומים מוקצים תחילה
כדי לעמוד בדרישות של -מנטה-רישום, לאחר מכן -mpid ולבסוף
-msmall-data-limit. לפיכך זה אפשרי עבור אוגר שטח הנתונים הקטן להיות "r8"
אם שניהם -mint-register=4 ו -mpid מצוינים בשורת הפקודה.

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

הערה: אפשרות שורת הפקודה הגנרית של GCC -תוקן-רג יש חשיבות מיוחדת ל-RX
יציאה בשימוש עם תכונת הפונקציה "הפסקה". תכונה זו מציינת א
פונקציה שנועדה לעבד הפסקות מהירות. GCC תבטיח שהיא משתמשת רק ב-
רושם "r10", "r11", "r12" ו/או "r13" ורק בתנאי שהשימוש הרגיל ב-
רישומים מתאימים הוגבלו באמצעות ה- -תוקן-רג or -מנטה-רישום
אפשרויות שורת הפקודה.

S / 390 ו zSeries אפשרויות

אלה -m אפשרויות שהוגדרו עבור ארכיטקטורת S/390 ו-zSeries.

-mhard-float
-msoft-float
השתמש (אל תשתמש) בהוראות הנקודה הצפה והרשומות של החומרה עבור צפה-
פעולות נקודתיות. מתי -msoft-float מצוין, מתפקד ב libgcc.a יהיה בשימוש
לבצע פעולות נקודה צפה. מתי -mhard-float מצוין, המהדר
יוצר הוראות נקודה צפה IEEE. זוהי ברירת המחדל.

-mhard-dfp
-mno-hard-dfp
השתמש (אל תשתמש) בהוראות החומרה של נקודה עשרונית-צפה צפה עבור עשרוניות-
פעולות נקודה צפה. מתי -mno-hard-dfp מצוין, מתפקד ב libgcc.a
ישמש לביצוע פעולות נקודה צפה עשרונית. מתי -mhard-dfp is
שצוין, המהדר מייצר הוראות חומרה של נקודה צפה עשרונית. זֶה
הוא ברירת המחדל עבור -march=z9-ec או גבוה יותר.

-מלונג-כפול-64
-מלונג-כפול-128
מתגים אלה שולטים בגודל של סוג "כפול ארוך". גודל של 64 סיביות עושה את
סוג "כפול ארוך" שווה ערך לסוג "כפול". זוהי ברירת המחדל.

-mbackchain
-mno-backchain
אחסן (לא לאחסן) את הכתובת של המסגרת של המתקשר בתור מצביע בשרשרת אחורית ב-
מסגרת המחסנית של Callee. ייתכן שיהיה צורך בשרשרת אחורית כדי לאפשר איתור באגים באמצעות כלים
לא מבין מידע על מסגרת שיחה של DWARF-2. מתי -מנו-ארוז-מחסנית הוא ב
אפקט, מצביע השרשרת האחורית מאוחסן בתחתית מסגרת הערימה; מתי
-מחסנית-מחסנית בתוקף, השרשרת האחורית ממוקמת במילה העליונה ביותר של
אזור שמירה של רישום 96/160 בתים.

באופן כללי, קוד קומפילד עם -mbackchain תואם שיחה עם קוד הידור עם
-mmo-backchain; עם זאת, שימוש בשרשרת האחורית למטרות ניפוי באגים מצריך בדרך כלל
שכל הבינארי בנוי איתו -mbackchain. שימו לב שהשילוב של
-mbackchain, -מחסנית-מחסנית ו -mhard-float לא נתמך. על מנת לבנות א
שימוש בליבת לינוקס -msoft-float.

ברירת המחדל היא לא לשמור על השרשרת האחורית.

-מחסנית-מחסנית
-מנו-ארוז-מחסנית
השתמש (אל תשתמש) בפריסת הערימה הארוזה. מתי -מנו-ארוז-מחסנית מוגדר, ה-
המהדר משתמש בכל השדות של אזור השמירה של אוגר 96/160 בתים רק עבור שלהם
מטרת ברירת מחדל; שדות שאינם בשימוש עדיין תופסים מקום בערימה. מתי -מחסנית-מחסנית is
שצוין, חריצי שמירת הרישום ארוזים בצפיפות בחלק העליון של שמירת הרישום
אֵזוֹר; נעשה שימוש חוזר בחלל לא בשימוש למטרות אחרות, מה שמאפשר שימוש יעיל יותר של
שטח הערימה הפנוי. עם זאת, מתי -mbackchain הוא גם בתוקף, העליון ביותר
המילה של אזור השמירה משמשת תמיד לאחסון השרשרת האחורית, וכתובת ההחזרה
register נשמר תמיד שתי מילים מתחת לשרשרת האחורית.

כל עוד לא נעשה שימוש בשרשרת האחורית של מסגרת המחסנית, הקוד נוצר עם -מחסנית-מחסנית
תואם שיחה עם קוד שנוצר עם -מנו-ארוז-מחסנית. שים לב שחלקם שאינם FSF
מהדורות של GCC 2.95 עבור קוד שנוצר ב-S/390 או zSeries שמשתמש במסגרת המחסנית
שרשרת אחורית בזמן ריצה, לא רק למטרות ניפוי באגים. קוד כזה הוא לא שיחה-
תואם עם קוד הידור עם -מחסנית-מחסנית. כמו כן, שימו לב שהשילוב של
-mbackchain, -מחסנית-מחסנית ו -mhard-float לא נתמך. על מנת לבנות א
שימוש בליבת לינוקס -msoft-float.

ברירת המחדל היא לא להשתמש בפריסת הערימה הארוזה.

-msmall-exec
-mno-small-exec
צור (או אל תיצור) קוד באמצעות הוראת "חזיות" לעשות תת שגרה
שיחות. זה עובד בצורה מהימנה רק אם גודל ההפעלה הכולל אינו עולה על 64k.
ברירת המחדל היא להשתמש בהוראה "basr" במקום זאת, שאין לה זאת
הַגבָּלָה.

-מ 64
-מ 31
מתי -מ 31 צוין, צור קוד תואם ל-GNU/Linux עבור S/390 ABI. מתי
-מ 64 צוין, צור קוד תואם ל-GNU/Linux עבור zSeries ABI. זֶה
מאפשר ל-GCC במיוחד ליצור הוראות של 64 סיביות. בשביל ה s390 מטרות, ה
ברירת המחדל היא -מ 31, בזמן ש S390x יעדים כברירת מחדל -מ 64.

-מזרך
-מסה
מתי -מזרך צוין, צור קוד באמצעות ההוראות הזמינות ב
z/אדריכלות. מתי -מסה צוין, צור קוד באמצעות ההוראות
זמין ב-ESA/390. ציין זאת -מסה לא אפשרי עם -מ 64. בעת יצירת
קוד תואם ל-GNU/Linux עבור S/390 ABI, ברירת המחדל היא -מסה. בעת יצירת
קוד תואם ל-GNU/Linux עבור zSeries ABI, ברירת המחדל היא -מזרך.

-mmvcle
-mno-mvcle
צור (או אל תיצור) קוד באמצעות הוראת "mvcle" לביצוע בלוק
מהלכים. מתי -mno-mvcle צוין, השתמש בלולאת "mvc" במקום זאת. זוהי ברירת המחדל
אלא אם כן מבצעים אופטימיזציה לגודל.

-mdebug
-mno-debug
הדפס (או אל תדפיס) מידע נוסף על ניפוי באגים בעת ההידור. ברירת המחדל היא
כדי לא להדפיס מידע על ניפוי באגים.

-מרץ=סוג מעבד
צור קוד שיפעל על סוג מעבד, שהוא שמה של מערכת המייצגת את א
סוג מעבד מסוים. ערכים אפשריים עבור סוג מעבד יש לו g5, g6, z900, z990, z9-109,
z9-ec ו z10. בעת יצירת קוד באמצעות ההוראות הזמינות ב
z/אדריכלות, ברירת המחדל היא -מרץ=z900. אחרת, ברירת המחדל היא -מרץ=g5.

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

-mtpf-trace
-mno-tpf-trace
צור קוד שמוסיף (לא מוסיף) בענפים ספציפיים ל-TPF OS כדי להתחקות אחר שגרות
במערכת ההפעלה. אפשרות זו כבויה כברירת מחדל, גם בעת קומפילציה עבור ה
מערכת הפעלה TPF.

-מfused-madd
-mno-fused-madd
צור קוד שמשתמש (אינו משתמש) בנקודה הצפה כפולה וצבירה
הוראות. הוראות אלה נוצרות כברירת מחדל אם חומרה נקודה צפה
משמש.

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

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

-mstack-guard=מחסנית
-mstack-size=גודל ערימה
אם האפשרויות הללו מסופקות, ה-s390 האחורי פולט הוראות נוספות ב-
פרולוג פונקציות אשר מפעילים מלכודת אם גודל הערימה הוא מחסנית בתים למעלה
מה היא גודל ערימה (זכור שהמחסנית ב-s390 גדלה כלפי מטה). אם ה מחסנית
האפשרות מושמטת את החזקה הקטן ביותר של 2 גדול מגודל המסגרת של הקומפילציה
הפונקציה נבחרת. אפשרויות אלה מיועדות לשמש כדי לסייע באיתור באגים
בעיות הצפה. הקוד הנפלט בנוסף גורם רק מעט תקורה ו
לפיכך ניתן להשתמש גם בייצור כמו מערכות ללא ביצועים גדולים יותר
הַשׁפָּלָה. הערכים הנתונים צריכים להיות בחזקות מדויקות של 2 ו גודל ערימה צריך להיות
גדול מ מחסנית מבלי לחרוג מ-64k. על מנת להיות יעיל התוספת
קוד עושה את ההנחה שהמחסנית מתחילה בכתובת מיושרת לערך
ניתנו על ידי גודל ערימה. ה מחסנית ניתן להשתמש באפשרות רק בשילוב עם
גודל ערימה.

ציון אפשרויות

אפשרויות אלה מוגדרות עבור יישומי ציון:

-מב
הידור קוד עבור מצב גדול. זוהי ברירת המחדל.

-מל
הידור קוד עבור מצב little-endian.

-מןהולופ
השבת את הוראת יצירת bcnz.

-מולס
אפשר ליצור עומס לא מיושר ולשמור הוראות.

-ממק
אפשר את השימוש בהוראות כפל-צבור. מושבת כברירת מחדל.

-mscore5
ציין את SCORE5 כארכיטקטורת היעד.

-mscore5u
ציין את SCORE5U של ארכיטקטורת היעד.

-mscore7
ציין את SCORE7 כארכיטקטורת היעד. זוהי ברירת המחדל.

-mscore7d
ציין את SCORE7D כארכיטקטורת היעד.

SH אפשרויות

אלה -m אפשרויות מוגדרות עבור יישומי SH:

-מ 1 צור קוד עבור SH1.

-מ 2 צור קוד עבור SH2.

-m2e
צור קוד עבור ה-SH2e.

-m2a-nofpu
צור קוד עבור SH2a ללא FPU, או עבור SH2a-FPU בצורה כזו שה
לא נעשה שימוש ביחידת נקודה צפה.

-m2a-יחיד בלבד
צור קוד עבור SH2a-FPU, בצורה כזו שאין נקודה צפה בעלת דיוק כפול
נעשה שימוש בפעולות.

-m2a-סינגל
צור קוד עבור SH2a-FPU בהנחה שיחידת הנקודה הצפה היא ברמת דיוק יחידה
מצב כברירת מחדל.

-m2a
צור קוד עבור SH2a-FPU בהנחה שיחידת הנקודה הצפה היא בדייקנות כפולה
מצב כברירת מחדל.

-מ 3 צור קוד עבור SH3.

-m3e
צור קוד עבור ה-SH3e.

-m4-nofpu
צור קוד עבור SH4 ללא יחידת נקודה צפה.

-m4-יחיד בלבד
צור קוד עבור ה-SH4 עם יחידת נקודה צפה התומכת רק ביחידה אחת
אריתמטיקה מדויקת.

-m4-סינגל
צור קוד עבור SH4 בהנחה שיחידת הנקודה הצפה נמצאת במצב דיוק יחיד
כברירת מחדל.

-מ 4 צור קוד עבור SH4.

-m4a-nofpu
צור קוד עבור SH4al-dsp, או עבור SH4a בצורה כזו שהנקודה הצפה
היחידה אינה בשימוש.

-m4a-יחיד בלבד
צור קוד עבור SH4a, בצורה כזו שאין נקודה צפה בעלת דיוק כפול
נעשה שימוש בפעולות.

-m4a-סינגל
צור קוד עבור SH4a בהנחה שיחידת הנקודה הצפה היא ברמת דיוק יחידה
מצב כברירת מחדל.

-m4a
צור קוד עבור SH4a.

-m4al
כמו -m4a-nofpu, אלא שזה עובר במרומז -dsp להרכבה. GCC
לא מייצר הוראות DSP כרגע.

-מב הידור קוד עבור המעבד במצב big-endian.

-מל הידור קוד עבור המעבד במצב little-endian.

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

-להירגע
קצר כמה הפניות לכתובות בזמן הקישור, במידת האפשר; משתמש באפשרות קישור
-לְהִרָגַע.

- mbigtable
השתמש בקיזוזים של 32 סיביות בטבלאות "בורר". ברירת המחדל היא להשתמש בהיסטים של 16 סיביות.

-מביטופים
אפשר את השימוש בהוראות מניפולציה של סיביות ב-SH2A.

-mfmovd
אפשר את השימוש בהוראה "fmovd". חשבון -מדליין עבור אילוצי יישור.

-מהיטאצ'י
ציית למוסכמות השיחות שהוגדרו על ידי Renesas.

-mrenesas
ציית למוסכמות השיחות שהוגדרו על ידי Renesas.

-mno-renesas
ציית למוסכמות השיחות שהוגדרו עבור GCC לפני אמנות Renesas
היו זמינים. אפשרות זו היא ברירת המחדל עבור כל היעדים של שרשרת הכלים של SH.

-mnomacsave
סמן את רישום ה-"MAC" כ-Call-clobbered, גם אם -מהיטאצ'י נתון.

-מיי
-מנו-איי
שלוט בתאימות IEEE של השוואות נקודה צפה, מה שמשפיע על הטיפול
של מקרים שבהם תוצאת ההשוואה אינה מסודרת. כברירת מחדל -מיי is
מופעל באופן מרומז. אם -סופית-מתמטיקה-בלבד מאופשר -מנו-איי מוגדר באופן מרומז,
מה שגורם להשוואות מהירות יותר של נקודה צפה גדולה יותר-שוות ופחות שוות. ה
ניתן לעקוף הגדרות implcit על ידי ציון אחת מהן -מיי or -מנו-איי.

-minline-ic_invalidate
קוד מוטבע לביטול ערכי מטמון הוראות לאחר הגדרת פונקציה מקוננת
טרמפולינות. לאפשרות זו אין השפעה אם -musermode פועל והנבחר
אפשרות יצירת קוד (למשל -m4) אינה מאפשרת שימוש בהוראה icbi. אם
אפשרות יצירת הקוד שנבחרה אינה מאפשרת שימוש בהוראת icbi,
ו-musermode אינו בתוקף, הקוד המוטבע יבצע מניפולציה על ההוראה
מערך כתובת מטמון ישירות עם כתיבה אסוציאטיבית. זה לא רק דורש
מצב מיוחס, אבל הוא גם ייכשל אם שורת המטמון הייתה ממופה דרך ה-TLB
והפך ללא מיפוי.

-הגדלה
גודל ההוראה ומיקום ההנחיה בקוד ההרכבה.

-mpadstruct
אפשרות זו הוצאה משימוש. זה מרפד מבנים לכפולה של 4 בתים, כלומר
אינו תואם את SH ABI.

-msoft-atomic
צור רצפים אטומיים של תוכנת GNU/Linux תואמי GNU/Linux עבור אטומי מובנה
פונקציות. הרצפים האטומיים שנוצרו דורשים תמיכה מהפסיק /
קוד טיפול חריג של המערכת ומתאימים רק למערכות ליבה אחת.
הם לא יפעלו כהלכה במערכות מרובות ליבות. אפשרות זו מופעלת על ידי
ברירת מחדל כאשר היעד הוא "sh-*-linux*". לפרטים על מובנה האטומי
פונקציות לראות __אָטוֹמִי מובנה.

-mspace
בצע אופטימיזציה למרחב במקום למהירות. נרמז על ידי -אוס.

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

-מצב מוסר
אל תיצור קוד במצב מיוחס בלבד; מרמז על -mno-inline-ic_invalidate אם
קוד מוטבע לא יעבוד במצב משתמש. זוהי ברירת המחדל כאשר היעד הוא
"sh-*-linux*".

-multcost=מספר
הגדר את העלות שיש להניח עבור כפל insn.

-mdiv=אסטרטגיה
הגדר את אסטרטגיית החלוקה שתשמש עבור פעולות החלוקה במספרים שלמים. עבור SHmedia
אסטרטגיה יכול להיות אחד מ:

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

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

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

שיחה
קורא לפונקציית ספרייה המיישמת בדרך כלל את inv:minlat אִסטרָטֶגִיָה. זֶה
נותן צפיפות קוד גבוהה עבור קומפילציות "m5-*media-nofpu".

Call2
משתמש בנקודת כניסה שונה של אותה פונקציית ספרייה, שם הוא מניח ש-a
מצביע לטבלת חיפוש כבר הוגדר, מה שחושף את עומס המצביעים
ל-CSE ולאופטימיזציות של הנפת קוד.

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

inv20u
inv20l
גרסאות של ה inv:minlat אִסטרָטֶגִיָה. במקרה שהחישוב ההפוך הוא
לא מופרדים מהכפל, הם מאיצים את החלוקה היכן שהדיבידנד מתאים
ל-20 סיביות (סימן פלוס במידת הצורך) על ידי הוספת בדיקה כדי לדלג על מספר
פעולות במקרה זה; מבחן זה מאט את המקרה של דיבידנדים גדולים יותר.
inv20u מניח שהמקרה של דיבידנד כה קטן אינו סביר, ו inv20l
מניח שזה סביר.

למטרות אחרות מלבד SHmedia אסטרטגיה יכול להיות אחד מ:

call-div1
קורא לפונקציית ספרייה שמשתמשת בהוראת החלוקה החד-שלבית "div1" ל
לבצע את הפעולה. חלוקה באפס מחשבת תוצאה לא מוגדרת ועושה זאת
לא מלכודת. זוהי ברירת המחדל למעט SH4, SH2A ו-SHcompact.

call-fp
קורא לפונקציית ספרייה המבצעת את הפעולה בציפה דיוק כפול
נְקוּדָה. חלוקה באפס גורמת לחריג נקודה צפה. זוהי ברירת המחדל
עבור SHcompact עם FPU. ציון זאת עבור יעדים שאין להם כפיל
FPU מדויק יקבע כברירת מחדל "call-div1".

שולחן שיחה
קורא לפונקציית ספרייה שמשתמשת בטבלת חיפוש עבור מחלקים קטנים ו-
הוראת "div1" עם הבחנה במקרה עבור מחלקים גדולים יותר. חלוקה באפס
מחשב תוצאה לא מוגדרת ואינו מלכוד. זוהי ברירת המחדל עבור SH4.
ציון זאת עבור יעדים שאין להם הוראות הסטות דינמיות
ברירת המחדל היא "call-div1".

כאשר לא צוינה אסטרטגיית חלוקה, אסטרטגיית ברירת המחדל תיבחר
בהתבסס על היעד הנוכחי. עבור SH2A אסטרטגיית ברירת המחדל היא להשתמש ב-"divs" ו
הוראות "divu" במקום קריאות לפונקציות בספרייה.

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

-mdivsi3_libfunc=שם
הגדר את השם של פונקציית הספרייה המשמשת לחלוקה חתומה של 32 סיביות ל שם. זֶה
משפיעים רק על השם המשמש באסטרטגיות חלוקת שיחה ו-inv:call, ועל
המהדר עדיין יצפה לאותן קבוצות של אוגרי קלט/פלט/קלוברים כאילו
אפשרות זו לא הייתה קיימת.

-mfixed-range=רישום-טווח
צור קוד המתייחס לטווח האוגר הנתון כאל אוגרים קבועים. פנקס קבוע
הוא כזה שמקצי הרשומות לא יכול להשתמש בו. זה שימושי בעת הידור ליבה
קוד. טווח רישום מצוין כשני אוגרים מופרדים באמצעות מקף. מרובות
ניתן לציין טווחי רישום מופרדים באמצעות פסיק.

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

-כתובת-mindexed
אפשר את השימוש במצב הכתובת באינדקס עבור SHmedia32/SHcompact. זה רק
בטוח אם החומרה ו/או מערכת ההפעלה מיישמת סמנטיקה של 32 סיביות ל-wrap-around עבור האינדקסים
מצב פנייה. הארכיטקטורה מאפשרת הטמעה של מעבדים עם 64 סיביות
MMU, שבו מערכת ההפעלה יכולה להשתמש כדי לקבל כתובת של 32 סיביות, אך מכיוון שאין חומרה עדכנית
יישום תומך בדרך זו או בכל דרך אחרת להפוך את מצב הכתובת האינדקס בטוח
לשימוש ב- ABI של 32 סיביות, ברירת המחדל היא -כתובת-mno-indexed.

-mgettrcost=מספר
הגדר את העלות המשוערת עבור הוראת gettr ל מספר. ברירת המחדל היא 2 if
-mpt-תוקן בתוקף, 100 אחרת.

-mpt-תוקן
נניח שהוראות PT* לא ילכודו. זה בדרך כלל ייצור מתוזמן טוב יותר
קוד, אך אינו בטוח בחומרה הנוכחית. הגדרת האדריכלות הנוכחית אומרת
ש-ptabs ו-ptrel מלכודות כאשר המטרה ועם 3 היא 3. יש לזה את
השפעה לא מכוונת של הפיכת זה לא בטוח לתזמן ptabs / ptrel לפני סניף, או
להרים אותו מתוך לולאה. לדוגמה, __do_global_ctors, חלק מ-libgcc שפועל
בנאים בעת הפעלת התוכנית, קורא לפונקציות ברשימה המופרדת ב-1.
עם האפשרות -mpt-fixed, ה-ptabs יבוצעו לפני בדיקה מול -1. זֶה
זה אומר שכל הבנאים יופעלו קצת יותר מהר, אבל כשהלולאה מגיעה
בסוף הרשימה, התוכנית קורסת מכיוון ש-ptabs טוענת -1 למטרה
הירשם. מכיוון שאופציה זו אינה בטוחה עבור כל חומרה המיישמת את הנוכחי
מפרט ארכיטקטורה, ברירת המחדל היא -mno-pt-fixed. אלא אם המשתמש מציין א
עלות ספציפית עם -mgettrcost, -mno-pt-fixed גם מרמז -mgettrcost=100; זה
מרתיע הקצאת רישום באמצעות אוגרי יעד לאחסון מספרים שלמים רגילים.

-מינvalid-סמלים
נניח שסמלים עשויים להיות לא חוקיים. סמלי פונקציות רגילות שנוצרו על ידי המהדר
תמיד יהיה תקף לטעינה עם movi/shori/ptabs או movi/shori/ptrel, אבל עם
אסמבלר ו/או מקשר טריקים אפשר ליצור סמלים שיגרמו
ptabs / ptrel ללכוד. אפשרות זו היא בעלת משמעות רק כאשר -mno-pt-fixed הוא ב
השפעה. אז זה ימנע CSE חוצה בלוקים בסיסיים, הרמה ורוב תזמון של
סמל נטען. ברירת המחדל היא -mno-invalid-symbols.

-brranch-cost=NUM
נניח NUM להיות העלות עבור הוראה בסניף. מספרים גבוהים יותר יהפכו את
מהדר נסה ליצור יותר קוד נטול סניפים במידת האפשר. אם לא צוין את
הערך נבחר בהתאם לסוג המעבד שעבורו הידור.

-mcbranchdi
אפשר את דפוס ההוראות "cbranchdi4".

-מקמפקדי
פלט את דפוס ההוראות "cmpeqdi_t" גם כאשר -mcbranchdi הוא בתוקף.

-מfused-madd
אפשר את השימוש בהוראה "fmac" (כפל נקודה צפה-צבור) אם
סוג המעבד תומך בזה. הפעלת אפשרות זו עשויה ליצור קוד שמפיק
תוצאות מספריות שונות של נקודה צפה בהשוואה לאריתמטיקה קפדנית של IEEE 754.

-mpretend-cmove
העדיפו ענפים מותנים באפס תזוזה להוראת תנועה מותנית
דפוסים. זה יכול לגרום לקוד מהיר יותר במעבד SH4.

Solaris 2 אפשרויות

אלה -m אפשרויות נתמכות על Solaris 2:

-טקסט-מימפור
-טקסט-מימפור, בשימוש בנוסף ל -מְשׁוּתָף, אומר למהדר לא לעבור -z טֶקסט ל
המקשר בעת קישור אובייקט משותף. באמצעות אפשרות זו, תוכל לקשר מיקום-
קוד תלוי לאובייקט משותף.

-טקסט-מימפור מדכא את "ההעברות נשארות נגד ניתנות להקצאה אך לא ניתנות לכתיבה
הודעת שגיאה מקשר מקטעים. עם זאת, ההעברות הנדרשות יפעילו העתקה-
on-write, והאובייקט המשותף אינו משותף למעשה בין תהליכים. במקום
באמצעות -טקסט-מימפור, עליך להרכיב את כל קוד המקור עם -fpic or -fPIC.

מתגים אלה נתמכים בנוסף לאמור לעיל ב- Solaris 2:

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

-phthread
זוהי מילה נרדפת ל -phthreads.

SPARC אפשרויות

אלה -m אפשרויות נתמכות ב-SPARC:

-mno-app-regs
-mapp-regs
לפרט -mapp-regs ליצור פלט באמצעות האוגרים הגלובאליים 2 עד 4, אשר
רזרבות SPARC SVR4 ABI ליישומים. כמו הרישום הגלובלי 1, כל אחד גלובלי
לאחר מכן מתייחסים לרגר 2 עד 4 כאל רישום בר-הקצאה אשר נלקח על ידי
קריאות פונקציה. זוהי ברירת המחדל.

כדי להיות תואם לחלוטין ל-SVR4 ABI במחיר של אובדן ביצועים מסוים, ציין
-mno-app-regs. כדאי להרכיב ספריות ותוכנת מערכת עם אפשרות זו.

-mflat
-מנו-שטוח
עם -mflat, המהדר אינו מייצר הוראות שמירה/שחזור ומשתמש ב-a
דגם "שטוח" או יחיד חלון. דגם זה תואם לרגיל
לרשום דגם חלון. האוגרים המקומיים ואוגרי הקלט (0--5) עדיין
יטופל כאל רושמים "שמרה שיחות" ויישמר בערימה לפי הצורך.

עם -מנו-שטוח (ברירת המחדל), המהדר יוצר הוראות שמירה/שחזור (למעט
עבור פונקציות עלים). זהו מצב ההפעלה הרגיל.

-mfpu
-mhard-float
צור פלט המכיל הוראות נקודה צפה. זוהי ברירת המחדל.

-mno-fpu
-msoft-float
צור פלט המכיל קריאות לספרייה עבור נקודה צפה. אַזהָרָה: הנדרש
ספריות אינן זמינות עבור כל יעדי SPARC. בדרך כלל המתקנים של
נעשה שימוש במהדר C הרגיל של המכונה, אך לא ניתן לעשות זאת ישירות ב-cross-
הַהדָרָה. עליך לעשות סידורים משלך כדי לספק ספרייה מתאימה
פונקציות עבור קומפילציה צולבת. המטרות המוטבעות sparc-*-aout ו sparclite-*-*
מספקים תמיכה בתוכנה בנקודה צפה.

-msoft-float משנה את מוסכמות השיחות בקובץ הפלט; לכן, זה רק
שימושי אם אתה קומפילציה את כל של תוכנית עם אפשרות זו. בפרט, אתה צריך
לעבד libgcc.a, הספרייה שמגיעה עם GCC, עם -msoft-float על מנת לכך
לעבודה.

-mhard-quad-float
צור פלט המכיל הוראות נקודה צפה של ארבע מילים (כפול ארוך).

-msoft-quad-float
צור פלט המכיל קריאות לספרייה עבור נקודה צפה של ארבע מילים (כפול ארוך).
הוראות. הפונקציות הנקראות הן אלו שצוינו ב-SPARC ABI. זה
ברירת המחדל.

נכון לכתיבת שורות אלה, אין יישומי SPARC שיש להם תמיכה בחומרה
הוראות הנקודה הצפה בארבע מילים. כולם קוראים מטפל במלכודות עבור אחד מהם
הוראות אלה, ולאחר מכן מטפל המלכודות מחקה את השפעת ההוראה.
בגלל מטפל המלכודות מעל הראש, זה הרבה יותר איטי מאשר לקרוא לספריית ABI
שגרות. כך ה -msoft-quad-float אפשרות היא ברירת המחדל.

-mno-unaligned-doubles
-מונaligned-כפילים
נניח שלכפולים יש יישור של 8 בתים. זוהי ברירת המחדל.

עם -מונaligned-כפילים, GCC מניח שלכפולים יש יישור של 8 בתים רק אם הם
כלולים בסוג אחר, או אם יש להם כתובת מוחלטת. אחרת זה
מניח שיש להם יישור של 4 בתים. ציון אפשרות זו מונע כמה נדירים
בעיות תאימות עם קוד שנוצר על ידי מהדרים אחרים. זה לא ברירת המחדל
כי זה גורם לאובדן ביצועים, במיוחד עבור קוד נקודה צפה.

-mno-faster-structs
-mfaster-structs
עם -mfaster-structs, המהדר מניח שלמבנים צריכים להיות 8-בתים
יישור. זה מאפשר שימוש בצמדים של הוראות "ldd" ו-"std" עבור עותקים
בהקצאת מבנה, במקום פי שניים צמדי "ld" ו-"st". אולם, ה
השימוש ביישור המשתנה הזה מפר ישירות את ה-SPARC ABI. לפיכך, זה נועד
רק לשימוש ביעדים שבהם המפתח מכיר בקוד שהתקבל
לא יהיה בהתאם לכללי ה-ABI.

-mcpu=cpu_type
הגדר את ערכת ההוראות, ערכת הרישום ותזמון ההוראות עבור
סוג מכונה cpu_type. ערכים נתמכים עבור cpu_type יש לו v7, ברוש, v8, supersparc,
hypersparc, לאון, ספרקליט, f930, f934, sparclite86x, ספרקל, tsc701, v9,
ultrasparc, ultrasparc3, ניאגרה, ניאגרה 2, ניאגרה 3, ו ניאגרה 4.

רשתות הכלים המקוריות של Solaris ו-GNU/Linux תומכות גם הן בערך יליד, אשר בוחר
אפשרות הארכיטקטורה הטובה ביותר עבור המעבד המארח. -mcpu = יליד אין לו השפעה אם
GCC לא מזהה את המעבד.

פרמטרים של תזמון הוראות ברירת מחדל משמשים עבור ערכים הבוחרים ב-
ארכיטקטורה ולא יישום. אלו הם v7, v8, ספרקליט, ספרקל, v9.

להלן רשימה של כל ארכיטקטורה נתמכת והיישומים הנתמכים שלה.

ברוש v7

v8 supersparc, hypersparc, leon

ספרקליט
f930, f934, sparclite86x

ספרקל
tsc701

v9 ultrasparc, ultrasparc3, ​​niagara, niagara2, niagara3, niagara4

כברירת מחדל (אלא אם הוגדר אחרת), GCC יוצר קוד עבור גרסת V7 של
ארכיטקטורת SPARC. עם -mcpu=ברוש, המהדר גם מייעל אותו עבורו
שבב Cypress CY7C602, כפי שמשמש בסדרת SPARCStation/SPARCServer 3xx. זה
מתאים גם ל-SPARCStation 1, 2, IPX וכו '.

עם -mcpu=v8, GCC מייצר קוד עבור גרסת V8 של ארכיטקטורת SPARC. ה
ההבדל היחיד מקוד V7 הוא שהמהדר פולט את הכפל השלם ו
הוראות חלוקת מספרים שלמים הקיימות ב-SPARC-V8 אך לא ב-SPARC-V7. עם
-mcpu=supersparc, המהדר גם מייעל אותו עבור שבב SuperSPARC, כמו
בשימוש בסדרות SPARCStation 10, 1000 ו-2000.

עם -mcpu=sparclite, GCC יוצר קוד עבור גרסת SPARClite של ה-SPARC
ארכיטקטורה. זה מוסיף את הכפל של המספרים השלם, שלב חלוקת המספרים השלמים וסריקה ("ffs")
הוראות שקיימות ב-SPARClite אך לא ב-SPARC-V7. עם -mcpu=f930, ה
המהדר גם מייעל אותו עבור שבב Fujitsu MB86930, שהוא המקור
SPARClite, ללא FPU. עם -mcpu=f934, המהדר גם מייעל אותו עבורו
שבב Fujitsu MB86934, שהוא ה-SPARClite העדכני יותר עם FPU.

עם -mcpu=ספרclet, GCC יוצר קוד עבור גרסת SPARClet של SPARC
ארכיטקטורה. זה מוסיף את המספר השלם כפל, כפל/צבר, חלוקת מספר שלם
שלב וסריקה ("ffs") הוראות שקיימות ב-SPARClet אך לא ב-SPARC-V7. עם
-mcpu=tsc701, המהדר גם מייעל אותו עבור שבב TEMIC SPARClet.

עם -mcpu=v9, GCC מייצר קוד עבור גרסת V9 של ארכיטקטורת SPARC. זֶה
מוסיף הוראות תנועה של מספר שלם ונקודה צפה של 64 סיביות, 3 נקודות צפה נוספות
אוגרי קוד תנאי והוראות מעבר מותנה. עם -mcpu=ultrasparc,
המהדר גם מייעל אותו עבור שבבי Sun UltraSPARC I/II/IIi. עם
-mcpu=ultrasparc3, המהדר גם מייעל אותו עבור ה-Sun UltraSPARC
שבבים III/III+/IIIi/IIIi+/IV/IV+. עם -mcpu=ניאגרה, המהדר בנוסף
מייעל אותו עבור שבבי Sun UltraSPARC T1. עם -mcpu=niagara2, המהדר
בנוסף מייעל אותו עבור שבבי Sun UltraSPARC T2. עם -mcpu=niagara3, ה
המהדר גם מייעל אותו עבור שבבי Sun UltraSPARC T3. עם -mcpu=niagara4,
המהדר גם מייעל אותו עבור שבבי Sun UltraSPARC T4.

-mtune=cpu_type
הגדר את פרמטרי תזמון ההוראות עבור סוג המכונה cpu_type, אבל לא להגדיר
ערכת ההוראות או הרשמה קבעה את האפשרות -mcpu=cpu_type היה.

אותם ערכים עבור -mcpu=cpu_type ניתן להשתמש בו עבור -mtune=cpu_type, אבל היחיד
ערכים שימושיים הם אלה שבוחרים ביישום CPU מסוים. אלה הם
ברוש, supersparc, hypersparc, לאון, f930, f934, sparclite86x, tsc701, ultrasparc,
ultrasparc3, ניאגרה, ניאגרה 2, ניאגרה 3 ו ניאגרה 4. עם Solaris ו
שרשרת כלים של GNU/Linux, יליד יכול לשמש גם.

-mv8plus
-mno-v8plus
עם -mv8plus, GCC מייצר קוד עבור SPARC-V8+ ABI. ההבדל מה-V8
ABI הוא שהרגיסטרים הגלובלי והחוץ נחשבים ברוחב של 64 סיביות. זה מופעל
כברירת מחדל ב- Solaris במצב 32 סיביות עבור כל מעבדי SPARC-V9.

-mvis
-mno-vis
עם -mvis, GCC מייצר קוד שמנצל את ה- UltraSPARC Visual
הרחבות סט הוראות. ברירת המחדל היא -mno-vis.

-mvis2
-mno-vis2
עם -mvis2, GCC מייצר קוד שמנצל את גרסה 2.0 של ה-UltraSPARC
הרחבות סט הוראות חזותיות. ברירת המחדל היא -mvis2 כאשר ממקדים למעבד זה
תומך בהוראות כאלה, כגון UltraSPARC-III ואילך. הגדרה -mvis2 גם
סטים -mvis.

-mvis3
-mno-vis3
עם -mvis3, GCC מייצר קוד שמנצל את גרסה 3.0 של ה-UltraSPARC
הרחבות סט הוראות חזותיות. ברירת המחדל היא -mvis3 כאשר ממקדים למעבד זה
תומך בהוראות כאלה, כגון niagara-3 ואילך. הגדרה -mvis3 גם סטים
-mvis2 ו -mvis.

-mpopc
-mno-popc
עם -mpopc, GCC מייצר קוד שמנצל את אוכלוסיית ה-UltraSPARC
הוראה לספור. ברירת המחדל היא -mpopc כאשר מתמקדים במעבד התומך בכזה
הוראות, כגון ניאגרה-2 ואילך.

-mfmaf
-mno-fmaf
עם -mfmaf, GCC מייצר קוד שמנצל את ה- UltraSPARC Fused Multiply-
הוסף הרחבות לנקודה צפה. ברירת המחדל היא -mfmaf כאשר ממקדים למעבד זה
תומך בהוראות כאלה, כגון Niagara-3 ואילך.

-mfix-at697f
אפשר את הפתרון המתועד לעקיפת הבעיה הבודדת של מעבד Atmel AT697F
(מה שתואם לשגיאה מס' 13 של מעבד AT697E).

אלה -m אפשרויות נתמכות בנוסף לאמור לעיל במעבדי SPARC-V9 ב-64 סיביות
סביבות:

-מ 32
-מ 64
צור קוד עבור סביבת 32 סיביות או 64 סיביות. סביבת 32 סיביות מגדירה int,
ארוך ומצביע ל-32 סיביות. סביבת 64 סיביות מגדירה int ל-32 סיביות וארוך ו
מצביע ל-64 סיביות.

-mcmodel=אשר
הגדר את מודל הקוד לאחד מ

מדלו
מודל הקוד הבינוני/נמוך: כתובות של 64 סיביות, תוכניות חייבות להיות מקושרות ב-32 הנמוכים
פיסות זיכרון. ניתן לקשר תוכניות באופן סטטי או דינמי.

medmid
מודל הקוד הבינוני/אמצעי: כתובות של 64 סיביות, תוכניות חייבות להיות מקושרות בתחתית
44 סיביות של זיכרון, קטעי הטקסט והנתונים חייבים להיות בגודל של פחות מ-2GB ו
קטע הנתונים חייב להיות ממוקם בתוך 2GB מקטע הטקסט.

עםני
מודל הקוד Medium/Anywhere: כתובות של 64 סיביות, תוכניות עשויות להיות מקושרות בכל מקום
בזיכרון, קטעי הטקסט והנתונים חייבים להיות בגודל של פחות מ-2GB והנתונים
הקטע חייב להיות ממוקם בתוך 2GB מקטע הטקסט.

emmbmedany
מודל הקוד Medium/Anywhere למערכות משובצות: כתובות 64 סיביות, הטקסט
ומקטעי נתונים חייבים להיות בגודל של פחות מ-2GB, שניהם מתחילים בכל מקום בזיכרון
(נקבע בזמן הקישור). האוגר הגלובלי %g4 מצביע על בסיס הנתונים
מִגזָר. תוכניות מקושרות סטטית ו-PIC אינו נתמך.

-זיכרון-מודל=דגם mem
הגדר את דגם הזיכרון בתוקף על המעבד לאחד מ

ברירת מחדל
דגם הזיכרון המוגדר כברירת מחדל עבור המעבד ומערכת ההפעלה.

rmo סדר זיכרון רגוע

pso הזמנת חנות חלקית

tso סך ההזמנה בחנות

sc עקביות רציפה

דגמי זיכרון אלה מוגדרים רשמית בנספח D של ארכיטקטורת Sparc V9
ידני, כפי שהוגדר בשדה "PSTATE.MM" של המעבד.

-mstack-bias
-mno-stack-bias
עם -mstack-bias, GCC מניח שמצביע המחסנית ומצביע המסגרת אם קיימים,
מקוזזים ב-2047 אשר יש להוסיף בחזרה בעת ביצוע הפניות למסגרת מחסנית. זֶה
הוא ברירת המחדל במצב 64 סיביות. אחרת, נניח שלא קיים קיזוז כזה.

SPU אפשרויות

אלה -m אפשרויות נתמכות ב-SPU:

-mwarn-reloc
-מרור-reloc
המעמיס עבור SPU אינו מטפל ברילוקיישן דינמי. כברירת מחדל, GCC ייתן
שגיאה כאשר הוא יוצר קוד הדורש רילוקיישן דינמי. -mno-error-reloc
משבית את השגיאה, -mwarn-reloc יפיק אזהרה במקום.

-msafe-dma
-munsafe-dma
אין להזמין מחדש הוראות שיוזמות או בודקות השלמת DMA
כבוד לעומסים ומאגרים של הזיכרון שאליו ניגשים. משתמשים בדרך כלל
לטפל בבעיה זו באמצעות מילת המפתח הפכפכה, אבל זה יכול להוביל לקוד לא יעיל
במקומות שבהם ידוע שהזיכרון אינו משתנה. במקום לסמן את הזיכרון בתור
נדיפים אנו מתייחסים להוראות ה-DMA כעל פוטנציאל להשפיע על כל הזיכרון. עם
-munsafe-dma משתמשים חייבים להשתמש במילת המפתח ההפכפכה כדי להגן על גישה לזיכרון.

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

-msmall-mem
-mlarge-mem
כברירת מחדל, GCC יוצר קוד בהנחה שהכתובות לעולם אינן גדולות מ-18 סיביות.
עם -mlarge-mem נוצר קוד שמניח כתובת מלאה של 32 סיביות.

-mstdmain
כברירת מחדל, GCC מקשר לקוד הפעלה שנוטל את הפונקציה הראשית בסגנון SPU
ממשק (שיש לו רשימת פרמטרים לא שגרתית). עם -mstdmain, GCC יקשר
התוכנית שלך נגד קוד הפעלה שמניח ממשק בסגנון C99 ל"ראשי",
כולל עותק מקומי של מחרוזות "argv".

-mfixed-range=רישום-טווח
צור קוד המתייחס לטווח האוגר הנתון כאל אוגרים קבועים. פנקס קבוע
הוא כזה שמקצי הרשומות לא יכול להשתמש בו. זה שימושי בעת הידור ליבה
קוד. טווח רישום מצוין כשני אוגרים מופרדים באמצעות מקף. מרובות
ניתן לציין טווחי רישום מופרדים באמצעות פסיק.

-mea32
-mea64
קומפילציה של קוד בהנחה שמצביעים למרחב הכתובות של ה-PPU שאליהם ניגש דרך ה-"__ea"
מוקד מרחב הכתובות הנקרא הם ברוחב של 32 או 64 סיביות. ברירת המחדל היא 32 סיביות.
מכיוון שזוהי אפשרות לשינוי ABI, יש להדר את כל קוד האובייקטים בקובץ הפעלה
עם אותה הגדרה.

-טירוף-חלל-המרה
-mno-address-space-conversion
אפשר/אסור להתייחס למרחב הכתובות "__ea" כעל ערכת-על של הכתובת הגנרית
מֶרחָב. זה מאפשר הטלות מפורשות בין "__ea" לבין מצביע גנרי וכן
המרות מרומזות של מצביעים גנריים למצביעים "__ea". ברירת המחדל היא לאפשר
המרות מצביע במרחב כתובת.

-mcache-size=גודל המטמון
אפשרות זו שולטת בגרסה של libgcc שהמהדר מקשר לקובץ הפעלה
ובוחר מטמון מנוהל תוכנה לגישה למשתנים בכתובת "__ea".
שטח עם גודל מטמון מסוים. אפשרויות אפשריות עבור גודל המטמון יש לו 8, 16, 32, 64
ו 128. גודל המטמון המוגדר כברירת מחדל הוא 64KB.

-מטומי-עדכונים
-עדכונים-מנו-אטומיים
אפשרות זו שולטת בגרסה של libgcc שהמהדר מקשר לקובץ הפעלה
ובוחר אם עדכונים אטומיים למטמון המנוהל בתוכנה של משתני צד PPU
משומשים. אם אתה משתמש בעדכונים אטומיים, שינויים למשתנה PPU מקוד SPU באמצעות
ה-"__ea" בעל השם של מרחב הכתובות לא יפריע לשינויים ב-PPU אחרים
משתנים השוכנים באותה שורת מטמון מקוד PPU. אם אתה לא משתמש באטומי
עדכונים, הפרעה כזו עלולה להתרחש; עם זאת, כתיבת שורות מטמון חזרה תהיה יותר
יָעִיל. התנהגות ברירת המחדל היא שימוש בעדכונים אטומיים.

-מדואל-לא
-mdual-nops=n
כברירת מחדל, GCC יוסיף nops כדי להגדיל את הבעיות הכפולות כאשר היא מצפה שהיא תגדל
ביצועים. n יכול להיות ערך מ-0 עד 10. A קטן יותר n יכניס פחות פעימות. 10
הוא ברירת המחדל, 0 זהה ל -מנו-דואל-נופס. מושבת עם -אוס.

-מהיינט-מקס-נופס=n
מספר מרבי של תנועות להוספת רמז ענף. רמז ענף חייב להיות לפחות 8
הוראות הרחק מהענף שהוא מבצע. GCC יוסיף עד n לא ל
לאכוף זאת, אחרת זה לא יפיק את הרמז לסניף.

-מהיינט-מקס-מרחק=n
הקידוד של הוראת הרמז בענף מגביל את הרמז להיות בטווח של 256
הוראות הסניף שהוא מבצע. כברירת מחדל, GCC מוודא שהוא נמצא בפנים
125.

-msafe-רמזים
עקיפת באג חומרה שגורם ל-SPU להיעצר ללא הגבלת זמן. כברירת מחדל, GCC
יכניס את ההוראה "hbrp" כדי לוודא שהסטייה הזו לא תתרחש.

אפשרויות ל מערכת V

אפשרויות נוספות אלו זמינות במערכת V מהדורה 4 לצורך תאימות עם אחרים
מהדרים במערכות אלו:

-G צור אובייקט משותף. זה מומלץ ש -סִמלִי or -מְשׁוּתָף לשמש במקום.

-Qy זהה את הגירסאות של כל כלי המשמש את המהדר, בהרכב ".ident".
הנחיה בפלט.

-Qn הימנע מהוספת הנחיות ".ident" לקובץ הפלט (זו ברירת המחדל).

-YP,דירס
חפש במדריכים דירס, ולא אחרים, עבור ספריות שצוינו עם -l.

-ימ,dir
חפש בספרייה dir כדי למצוא את ה-Preprocessor M4. האסמבלר משתמש בזה
אוֹפְּצִיָה.

TILE-Gx אפשרויות

אלה -m אפשרויות נתמכות ב-TILE-Gx:

-mcpu=שם
בוחר את סוג המעבד למיקוד. כרגע הסוג הנתמך היחיד הוא tilegx.

-מ 32
-מ 64
צור קוד עבור סביבת 32 סיביות או 64 סיביות. סביבת 32 סיביות מגדירה int,
ארוך, ומצביע ל-32 סיביות. סביבת 64 סיביות מגדירה את int ל-32 סיביות וארוך ו
מצביע ל-64 סיביות.

TILEPro אפשרויות

אלה -m אפשרויות נתמכות ב-TILEPro:

-mcpu=שם
בוחר את סוג המעבד למיקוד. כרגע הסוג הנתמך היחיד הוא tilepro.

-מ 32
צור קוד עבור סביבת 32 סיביות, אשר מגדירה int, long ו-pointer ל-32 סיביות.
זוהי ההתנהגות הנתמכת היחידה ולכן למעשה מתעלמים מהדגל.

V850 אפשרויות

אלה -m אפשרויות מוגדרות עבור יישומי V850:

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

-mno-ep
-ממפי
אל תבצע אופטימיזציה (עשה אופטימיזציה) בלוקים בסיסיים המשתמשים באותו מצביע אינדקס 4 או יותר
פעמים כדי להעתיק את המצביע לרשום "ep", ולהשתמש ב-"sld" ו-"sst" הקצרים יותר
הוראות. ה -ממפי האפשרות מופעלת כברירת מחדל אם תבצע אופטימיזציה.

-mno-prolog-function
-מפרופלוג-פונקציה
אל תשתמש (תשתמש) בפונקציות חיצוניות כדי לשמור ולשחזר אוגרים בפרולוג
ואפילוג של פונקציה. הפונקציות החיצוניות איטיות יותר, אך משתמשות בפחות קוד
רווח אם יותר מפונקציה אחת שומרת את אותו מספר אוגרים. ה
-מפרופלוג-פונקציה האפשרות מופעלת כברירת מחדל אם תבצע אופטימיזציה.

-mspace
נסו לעשות את הקוד קטן ככל האפשר. נכון לעכשיו, זה רק מדליק את -ממפי
ו -מפרופלוג-פונקציה אפשרויות.

-mtda=n
שים משתנים סטטיים או גלובליים שגודלם הוא n בתים או פחות לתוך אזור הנתונים הזעיר
שהרישום "ep" מצביע עליו. אזור הנתונים הזעיר יכול להכיל עד 256 בתים בסך הכל
(128 בתים להפניות בתים).

-msda=n
שים משתנים סטטיים או גלובליים שגודלם הוא n בתים או פחות לאזור הנתונים הקטן
שהרישום "gp" מצביע עליו. אזור הנתונים הקטן יכול להכיל עד 64 קילובייט.

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

-mv850
ציין שמעבד היעד הוא ה-V850.

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

-mapp-regs
אפשרות זו תגרום לשימוש ב-r2 ו-r5 בקוד שנוצר על ידי המהדר.
הגדרה זו היא ברירת המחדל.

-mno-app-regs
אפשרות זו תגרום להתייחסות ל-r2 ו-r5 כאל אוגרים קבועים.

-mv850e2v3
ציין שמעבד היעד הוא V850E2V3. הקבועים הקדם-מעבדים
__v850e2v3__ יוגדר אם תשתמש באפשרות זו.

-mv850e2
ציין שמעבד היעד הוא ה-V850E2. הקבועים הקדם-מעבדים
__v850e2__ יוגדר אם תשתמש באפשרות זו.

-mv850e1
ציין שמעבד היעד הוא ה-V850E1. הקבועים הקדם-מעבדים
__v850e1__ ו __v850e__ יוגדר אם תשתמש באפשרות זו.

-mv850es
ציין שמעבד היעד הוא ה-V850ES. זהו כינוי ל- -mv850e1
אוֹפְּצִיָה.

-mv850e
ציין שמעבד היעד הוא ה-V850E. הקבוע הקדם-מעבד __v850e__
יוגדר אם תשתמש באפשרות זו.

אם גם לא -mv850 ולא -mv850e ולא -mv850e1 ולא -mv850e2 ולא -mv850e2v3 מוגדרים
אז ייבחר מעבד יעד ברירת מחדל והרלוונטי __v850*__ מעבד מקדים
קבוע יוגדר.

הקבועים הקדם-מעבדים __v850 ו __v851__ תמיד מוגדרים, ללא קשר לאיזה
גרסת המעבד היא היעד.

-mdisable-call
אפשרות זו תדכא את יצירת הוראת ה-CALLT עבור v850e, v850e1,
הטעמים v850e2 ו-v850e2v3 של ארכיטקטורת v850. ברירת המחדל היא
-mno-disable-call המאפשרת שימוש בהוראת CALLT.

VAX אפשרויות

אלה -m אפשרויות מוגדרות עבור VAX:

-מוניקס
אל תוציא הוראות קפיצה מסוימות ("aobleq" וכן הלאה) מה-Unix assembler
שכן ה-VAX לא יכול להתמודד עם טווחים ארוכים.

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

-מג קוד פלט עבור מספרי נקודה צפה בפורמט G במקום בפורמט D.

VxWorks אפשרויות

האפשרויות בסעיף זה מוגדרות עבור כל יעדי VxWorks. אפשרויות ספציפיות ל-
חומרת היעד מופיעות עם האפשרויות האחרות עבור יעד זה.

-mrtp
GCC יכול ליצור קוד הן עבור ליבות VxWorks והן עבור תהליכים בזמן אמת (RTP). זֶה
אופציה עוברת מהראשון לאחר. זה גם מגדיר את המאקרו הקדם-מעבד
"__RTP__".

-לא סטטי
קשר קובץ RTP נגד ספריות משותפות ולא ספריות סטטיות. ה
אפשרויות -סטָטִי ו -מְשׁוּתָף יכול לשמש גם עבור RTPs; -סטָטִי הוא ברירת המחדל.

-בסטטיק
-בדינמי
אפשרויות אלו מועברות למקשר. הם מוגדרים עבור תאימות עם
דיאב.

-Xbind-עצלן
אפשר כריכה עצלה של קריאות פונקציה. אפשרות זו מקבילה ל -Wl,-z,עכשיו והוא
מוגדר לתאימות עם Diab.

-Xbind-עכשיו
השבת כריכה עצלה של קריאות פונקציה. אפשרות זו היא ברירת המחדל והיא מוגדרת עבור
תאימות עם Diab.

x86-64 אפשרויות

אלה מפורטים למטה

Xstormy16 אפשרויות

אפשרויות אלה מוגדרות עבור Xstormy16:

-מסים
בחר קבצי הפעלה וסקריפט קישור מתאים לסימולטור.

Xtensa אפשרויות

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

-mconst16
-mno-const16
אפשר או השבת את השימוש בהוראות "CONST16" לטעינת ערכים קבועים. ה
הוראת "CONST16" היא כרגע לא אופציה סטנדרטית של Tensilica. מתי
מופעלת, הוראות "CONST16" משמשות תמיד במקום הסטנדרטי "L32R"
הוראות. השימוש ב-"CONST16" מופעל כברירת מחדל רק אם ה-"L32R"
הדרכה אינה זמינה.

-מfused-madd
-mno-fused-madd
אפשר או השבת את השימוש בהוראות הכפל/הוספה והכפל/הפחתה מתמזגות ב-
אפשרות לנקודה צפה. אין לכך השפעה אם אפשרות הנקודה הצפה אינה גם כן
מופעל. השבתת הוראות הכפל/הוספה והכפל/הפחתה מתמזגות מאלצת את
מהדר להשתמש בהוראות נפרדות עבור פעולות הכפל וחיבור/חיסור.
זה עשוי להיות רצוי במקרים מסוימים שבהם תוצאות קפדניות תואמות IEEE 754
נדרש: הוראות החיבור/ההפחתה של הכפל המתוכה אינן מעגלות את התווך
תוצאה, ובכך לייצר תוצאות עם יותר פיסות דיוק ממה שצוין על ידי
תקן IEEE. השבתת הוראות הוספה/חיסור של כפל מתוכה גם מבטיחה זאת
פלט התוכנית אינו רגיש ליכולתו של המהדר לשלב כפל ו
פעולות הוספה/הורדה.

-מסריאליזה-נדיף
-mno-serialize-נדיף
כאשר אפשרות זו מופעלת, GCC מוסיף הוראות "MEMW" לפני זיכרון "נדיף".
הפניות כדי להבטיח עקביות ברצף. ברירת המחדל היא -מסריאליזה-נדיף.
השתמש -mno-serialize-נדיף להשמיט את הוראות "MEMW".

-mforce-no-pic
עבור יעדים, כמו GNU/Linux, שבהם כל קוד Xtensa במצב משתמש חייב להיות מיקום-
קוד עצמאי (PIC), אפשרות זו משביתה את ה-PIC להידור קוד ליבה.

-mtext-section-literals
-mno-text-section-literals
שליטה בטיפול בבריכות תרתי משמע. ברירת המחדל היא -mno-text-section-literals,
מה שמציב מילים בקטע נפרד בקובץ הפלט. זה מאפשר את
מאגר מילולי למקם ב-RAM/ROM נתונים, והוא גם מאפשר לקישור לשלב
מאגרים מילוליים מקובצי אובייקט נפרדים כדי להסיר מילוליות מיותרות ולשפר קוד
גודל. עם -mtext-section-literals, המילולים משובצים בקטע הטקסט
על מנת לשמור אותם קרובים ככל האפשר להפניות שלהם. זה עשוי להיות נחוץ
עבור קבצי הרכבה גדולים.

-mtarget-align
-mno-target-align
כאשר אפשרות זו מופעלת, GCC מורה להרכב ליישר אוטומטית
הוראות להפחתת עונשי ענף על חשבון צפיפות מסוימת של קוד. ה
אסמבלר מנסה להרחיב את הוראות הצפיפות כדי ליישר את מטרות הסניף וה-
הוראות בעקבות הוראות השיחה. אם אין מספיק קודמים בטוחים
הוראות צפיפות ליישור מטרה, לא תבוצע הרחבה. ברירת המחדל היא
-mtarget-align. אפשרויות אלו אינן משפיעות על הטיפול ב-auto-aligned
הוראות כמו "LOOP", שאותן ההרכב תמיד יישר, או על ידי הרחבה
הוראות צפיפות או על ידי הכנסת הוראות ללא הפעלה.

-מלונג שיחות
-מנו-לונג שיחות
כאשר אפשרות זו מופעלת, GCC מורה להרכב לתרגם שיחות ישירות
שיחות עקיפות אלא אם הוא יכול לקבוע שהיעד של שיחה ישירה נמצא ב-
טווח המותר לפי הוראת השיחה. תרגום זה מתרחש בדרך כלל עבור שיחות אל
פונקציות בקבצי מקור אחרים. באופן ספציפי, האסמבלר מתרגם ישיר
הוראת "CALL" לתוך "L32R" ואחריה הוראה "CALLX". ברירת המחדל היא
-מנו-לונג שיחות. יש להשתמש באפשרות זו בתוכניות שבהן יעד השיחה יכול
עלול להיות מחוץ לטווח. אפשרות זו מיושמת ב-assembler, לא ב-
מהדר, כך שקוד ההרכבה שנוצר על ידי GCC עדיין יציג קריאה ישירה
הוראות --- הסתכל בקוד האובייקט המפורק כדי לראות את ההוראות בפועל.
שימו לב שהאסמבלר ישתמש בקריאה עקיפה לכל קריאה צולבת קבצים, לא רק
אלה שבאמת יהיו מחוץ לטווח.

zSeries אפשרויות

אלה מפורטים למטה

אפשרויות ל קופונים דור אמנות
אפשרויות אלו שאינן תלויות במכונה שולטות במוסכמות הממשק המשמשות בקוד
דוֹר.

לרובם יש צורות חיוביות ושליליות כאחד; הצורה השלילית של -ffoo. יהיה
-fno-foo. בטבלה למטה, רק אחד מהטפסים מופיע --- זה שאינו ה-
בְּרִירַת מֶחדָל. אתה יכול להבין את הטופס האחר על ידי הסרה לא- או הוספתו.

-fbounds-check
עבור ממשקי קצה שתומכים בזה, צור קוד נוסף כדי לבדוק מה נהגו המדדים
מערכי גישה נמצאים בטווח המוצהר. זה נתמך כרגע רק על ידי
ממשקי קצה של Java ו-Fortran, כאשר אפשרות זו מוגדרת כברירת מחדל כ-true ו-false
בהתאמה.

-ftrapv
אפשרות זו יוצרת מלכודות עבור גלישה חתומה בחיבור, חיסור,
פעולות כפל.

-fwrapv
אפשרות זו מורה למהדר להניח כי גלישה אריתמטית בסימן של
חיבור, חיסור וכפל עוטפים באמצעות משלים שניים
יִצוּג. דגל זה מאפשר אופטימיזציות מסוימות ומשבית אחרות. זֶה
האפשרות מופעלת כברירת מחדל עבור ממשק הקצה של Java, כנדרש על ידי שפת Java
מפרט.

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

- חריגים ללא שיחות
צור קוד המאפשר הוראות לכידה כדי לזרוק חריגים. שימו לב שזה
דורש תמיכה בזמן ריצה ספציפית לפלטפורמה שאינה קיימת בכל מקום. יתר על כך,
זה רק מאפשר לְכִידָה הוראות לזרוק חריגים, כלומר הפניות לזיכרון או
הוראות נקודה צפה. זה לא מאפשר לזרוק חריגים משרירותיות
מטפלי אותות כגון "SIGALRM".

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

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

-fpcc-struct-return
החזר ערכי "קצר" "מבנה" ו"איחוד" בזיכרון כמו ארוכים יותר, במקום ב
רושמת. האמנה הזו פחות יעילה, אבל יש לה יתרון בכך שהיא מאפשרת
יכולת התקשרות בין קבצים מהידורים של GCC וקבצים שהודפו עם מהדרים אחרים,
במיוחד מהדר C Portable C (pcc).

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

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

אַזהָרָה: קוד הידור עם ה -fpcc-struct-return המתג אינו תואם בינארי
עם קוד הידור עם ה -freg-struct-return החלף. השתמש בו כדי להתאים לא-
ממשק בינארי של יישום ברירת המחדל.

-freg-struct-return
החזר ערכי "struct" ו-"union" ברגיסטרים במידת האפשר. זה יותר יעיל
עבור מבנים קטנים מאשר -fpcc-struct-return.

אם אתה לא מציין את שניהם -fpcc-struct-return ולא -freg-struct-return, ברירת המחדל של GCC היא
כל מוסכמה שהיא סטנדרטית עבור היעד. אם אין מוסכמה סטנדרטית,
ברירת המחדל של GCC היא -fpcc-struct-return, למעט יעדים שבהם GCC הוא המנהל
מַהְדֵר. באותם מקרים נוכל לבחור בתקן, ובחרנו ביעיל יותר
רשום חלופה להחזרה.

אַזהָרָה: קוד הידור עם ה -freg-struct-return המתג אינו תואם בינארי
עם קוד הידור עם ה -fpcc-struct-return החלף. השתמש בו כדי להתאים לא-
ממשק בינארי של יישום ברירת המחדל.

-fshort-enums
הקצו לסוג "enum" רק כמה בתים שהוא צריך עבור הטווח המוצהר של
ערכים אפשריים. באופן ספציפי, סוג ה-"enum" יהיה שווה ערך לקטן ביותר
סוג מספר שלם שיש לו מספיק מקום.

אַזהָרָה: מה היא -fshort-enums switch גורם ל-GCC ליצור קוד שאינו בינארי
תואם לקוד שנוצר ללא המתג הזה. השתמש בו כדי להתאים לא-
ממשק בינארי של יישום ברירת המחדל.

-קצר-כפול
השתמש באותו גודל עבור "כפול" כמו עבור "צף".

אַזהָרָה: מה היא -קצר-כפול switch גורם ל-GCC ליצור קוד שאינו בינארי
תואם לקוד שנוצר ללא המתג הזה. השתמש בו כדי להתאים לא-
ממשק בינארי של יישום ברירת המחדל.

-fshort-wchar
לעקוף את הסוג הבסיסי עבור wchar_t להיות קצר לא חתום int במקום ה
ברירת המחדל עבור היעד. אפשרות זו שימושית לבניית תוכניות לרוץ בהן
יַיִן.

אַזהָרָה: מה היא -fshort-wchar switch גורם ל-GCC ליצור קוד שאינו בינארי
תואם לקוד שנוצר ללא המתג הזה. השתמש בו כדי להתאים לא-
ממשק בינארי של יישום ברירת המחדל.

-fno-נפוץ
בקוד C, שולט במיקום של משתנים גלובליים לא מאותחלים. מהדרים של Unix C
באופן מסורתי אפשרו מספר הגדרות של משתנים כאלה בשונות
יחידות קומפילציה על ידי הצבת המשתנים בבלוק משותף. זו ההתנהגות
שצוין על ידי -נפוץ, והוא ברירת המחדל עבור GCC ברוב היעדים. מצד שני,
התנהגות זו אינה נדרשת על ידי ISO C, ובמטרות מסוימות עשויה לשאת מהירות או קוד
קנס גודל על הפניות משתנות. ה -fno-נפוץ האפשרות מציינת כי
מהדר צריך למקם משתנים גלובליים לא מאותחלים בקטע הנתונים של האובייקט
קובץ, במקום ליצור אותם כבלוקים נפוצים. יש לכך השפעה שאם ה
אותו משתנה מוצהר (ללא "extern") בשני קומפילציות שונות, אתה תעשה זאת
מקבלים שגיאה מרובה הגדרות כאשר אתה מקשר אותם. במקרה זה, עליך לבצע קומפילציה
עם -נפוץ במקום זאת. קומפילציה עם -fno-נפוץ שימושי במטרות שעבורן זה
מספק ביצועים טובים יותר, או אם ברצונך לוודא שהתוכנית תעבוד
מערכות אחרות שתמיד מתייחסות כך להצהרות משתנות לא מאותחלות.

-fno-ident
התעלם מה- #זהה הוראה.

-finhibit-size-directive
אל תוציא הנחיית assembler מסוג ".size", או כל דבר אחר שיגרום לבעיות
אם הפונקציה מפוצלת באמצע, ושני החצאים ממוקמים במקומות רחוקים
בנפרד בזיכרון. אפשרות זו משמשת בעת קומפילציה crtstuff.c; אתה לא צריך
להשתמש בו לכל דבר אחר.

-fverbose-asm
שים מידע פרשנות נוסף בקוד ההרכבה שנוצר כדי להפוך אותו ליותר
קָרִיא. אפשרות זו מועילה בדרך כלל רק למי שבאמת צריך לקרוא את
קוד assembly שנוצר (אולי תוך איתור באגים במהדר עצמו).

-fno-verbose-asm, ברירת המחדל, גורמת להשמטת המידע הנוסף והוא קיים
שימושי בעת השוואת שני קבצי אסמבלר.

-frecord-gcc-מתגים
מתג זה גורם לשורת הפקודה ששימשה להפעלת המהדר
מוקלט בקובץ האובייקט שנוצר. מתג זה מיושם רק
בכמה יעדים והפורמט המדויק של ההקלטה הוא פורמט יעד וקובץ בינארי
תלוי, אבל זה בדרך כלל לובש צורה של קטע המכיל טקסט ASCII. זֶה
מתג קשור ל- -fverbose-asm מתג, אבל המתג הזה רק מתעד
מידע בקובץ הפלט של ה-assembler כהערות, כך שהוא לעולם לא מגיע לאובייקט
קוֹבֶץ. ראה גם -grecord-gcc-מתגים לדרך אחרת לאחסן אפשרויות מהדר לתוך
קובץ האובייקט.

-fpic
צור קוד בלתי תלוי במיקום (PIC) המתאים לשימוש בספרייה משותפת, אם
נתמך עבור מכונת היעד. קוד כזה ניגש לכל הכתובות הקבועות דרך a
טבלת אופסט גלובלית (GOT). המטען הדינמי פותר את ערכי ה-GOT כאשר
התוכנית מתחילה (המטעין הדינמי אינו חלק מ-GCC; הוא חלק מההפעלה
מערכת). אם גודל ה-GOT עבור קובץ ההפעלה המקושר חורג ממקסימום ספציפי למכונה
גודל, אתה מקבל הודעת שגיאה מהמקשר שמציינת זאת -fpic לא עובד; ב
במקרה זה, הידור מחדש עם -fPIC במקום זאת. (המקסימום הוא 8k ב-SPARC ו-32k
ב-m68k וב-RS/6000. ל-386 אין מגבלה כזו.)

קוד בלתי תלוי במיקום דורש תמיכה מיוחדת, ולכן עובד רק על
מכונות מסוימות. עבור ה-386, GCC תומך ב-PIC עבור System V אך לא עבור ה-Sun
386i. הקוד שנוצר עבור IBM RS/6000 הוא תמיד בלתי תלוי במיקום.

כאשר הדגל הזה מוגדר, פקודות המאקרו "__pic__" ו-"__PIC__" מוגדרות ל-1.

-fPIC
אם נתמך עבור מכונת היעד, פלט קוד בלתי תלוי במיקום, מתאים ל
קישור דינמי והימנעות מכל הגבלה על גודל טבלת ההיסט הגלובלית. זֶה
אפשרות עושה את ההבדל ב-m68k, PowerPC ו-SPARC.

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

כאשר הדגל הזה מוגדר, פקודות המאקרו "__pic__" ו-"__PIC__" מוגדרות ל-2.

-fpie
-fPIE
אפשרויות אלה דומות ל -fpic ו -fPIC, אבל נוצר קוד עצמאי במיקום
ניתן לקשר רק לקובצי הפעלה. בדרך כלל משתמשים באפשרויות אלו כאשר -פַּאִי GCC
האפשרות תשמש במהלך הקישור.

-fpie ו -fPIE שניהם מגדירים את פקודות המאקרו "__pie__" ו- "__PIE__". לפקודות המאקרו יש את
ערך 1 עבור -fpie ו 2 עבור -fPIE.

-fno-jump-tables
אל תשתמש בטבלאות קפיצה להצהרות מתג, אפילו אם זה יהיה יעיל יותר
מאשר אסטרטגיות יצירת קוד אחרות. אפשרות זו שימושית בשילוב עם
-fpic or -fPIC לבניית קוד שמהווה חלק ממקשר דינמי ואינו יכול
התייחס לכתובת של טבלת קפיצה. בחלק מהמטרות, טבלאות קפיצה אינן דורשות א
GOT ואפשרות זו אינה נחוצה.

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

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

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

-fcall-used-רג
התייחסו לפנקס ששמו רג כפנקס בר-הקצאה הנתון לפי פונקציה
שיחות. זה עשוי להיות מוקצה עבור זמניים או משתנים שאינם חיים על פני a
שִׂיחָה. פונקציות שהידור בדרך זו לא ישמרו וישחזרו את האוגר רג.

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

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

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

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

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

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

-fpack-struct[=n]
ללא ערך שצוין, ארזו את כל איברי המבנה יחד ללא חורים. כש
הערך מצוין (שחייב להיות כוח קטן של שניים), חברי מבנה חבילה
לפי ערך זה, המייצג את היישור המקסימלי (כלומר, אובייקטים עם
ברירת המחדל של דרישות יישור גדולות מזה תופיע בפלט שעלול להיות בלתי מיושר
במיקום ההתאמה הבא.

אַזהָרָה: מה היא -fpack-struct switch גורם ל-GCC ליצור קוד שאינו בינארי
תואם לקוד שנוצר ללא המתג הזה. בנוסף, זה עושה את הקוד
לא אופטימלי. השתמש בו כדי להתאים לממשק בינארי של יישום שאינו ברירת מחדל.

-finstrument-פונקציות
צור קריאות מכשור לכניסה ויציאה לפונקציות. רק אחרי פונקציה
כניסה וממש לפני יציאת הפונקציה, ייקראו פונקציות הפרופיל הבאות
עם כתובת הפונקציה הנוכחית ואתר ההתקשרות שלה. (בכמה פלטפורמות,
"__builtin_return_address" לא עובד מעבר לפונקציה הנוכחית, אז אתר ההתקשרות
ייתכן שמידע לא יהיה זמין לפונקציות הפרופיל אחרת.)

void __cyg_profile_func_enter (void *this_fn,
void *call_site);
void __cyg_profile_func_exit (void *this_fn,
void *call_site);

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

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

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

-finstrument-functions-exclude-file-list=פילה,פילה, ...
הגדר את רשימת הפונקציות שאינן נכללות במכשור (ראה את התיאור
של "-finstrument-functions"). אם הקובץ שמכיל הגדרת פונקציה תואם
עם אחד מ פילה, אז הפונקציה הזו אינה מכשירה. ההתאמה מתבצעת ב
מחרוזות משנה: אם ה פילה פרמטר הוא מחרוזת משנה של שם הקובץ, הוא נחשב ל
להיות התאמה.

לדוגמה:

-finstrument-functions-exclude-file-list=/bits/stl,include/sys

לא יכלול כל פונקציה מוטבעת המוגדרת בקבצים ששמות הנתיבים שלהם מכילים "/bits/stl"
או "include/sys".

אם, מסיבה כלשהי, אתה רוצה לכלול את האות ',' באחת מהן SYM, כתוב ','. ל
דוגמה, "-finstrument-functions-exclude-file-list=',,tmp'" (שימו לב למרטוט היחיד
סביב האפשרות).

-finstrument-functions-exclude-function-list=SYM,SYM, ...
זה דומה ל-"-finstrument-functions-exclude-file-list", אבל אפשרות זו נקבעת
רשימת שמות הפונקציות שיש להוציא מהמכשיר. שם הפונקציה ל
be matched הוא השם הגלוי למשתמש, כגון "vector blah(const vector &)",
לא השם המעוות הפנימי (למשל, "_Z4blahRSt6vectorIiSaIiEE"). השידוך נעשה
על מחרוזות משנה: אם ה SYM פרמטר הוא מחרוזת משנה של שם הפונקציה, הוא כן
נחשב לשידוך. עבור מזהים מורחבים C99 ו-C++, שם הפונקציה
חייב להינתן ב-UTF-8, לא באמצעות שמות תווים אוניברסליים.

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

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

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

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

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

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

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

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

-fstack-limit-register=רג
-fstack-limit-symbol=SYM
-fno-stack-limit
צור קוד כדי להבטיח שגם המחסנית לא תגדל מעבר לערך מסוים
הערך של פנקס או כתובת של סמל. אם הערימה תגדל מעבר
הערך, אות מועלה. עבור רוב המטרות, האות מורם לפני ה-
מחסנית חוצה את הגבול, כך שניתן לתפוס את האות מבלי לקחת
אמצעי זהירות מיוחדים.

למשל, אם המחסנית מתחילה בכתובת מוחלטת 0x80000000 וגדל כלפי מטה,
אתה יכול להשתמש בדגלים -fstack-limit-symbol=__stack_limit ו
-Wl,--defsym,__stack_limit=0x7ffe0000 לאכוף מגבלת מחסנית של 128KB. ציין זאת
זה עשוי לעבוד רק עם מקשר GNU.

-fsplit-מחסנית
צור קוד כדי לפצל אוטומטית את הערימה לפני שהיא עולה על גדותיה. המתקבל
לתוכנית יש מחסנית לא רציפה שיכולה לעלות על גדותיה רק ​​אם התוכנית אינה מסוגלת
להקצות עוד זיכרון. זה שימושי ביותר בעת הפעלת תוכניות משורשרות, שכן
אין עוד צורך לחשב גודל ערימה טוב לשימוש עבור כל חוט. זה
כרגע מיושם רק עבור הקצה האחורי של i386 ו-x86_64 עם GNU/Linux.

כאשר קוד קומפילד עם -fsplit-מחסנית קוד שיחות הידור ללא -fsplit-מחסנית, שם
ייתכן שלא יהיה הרבה שטח מחסנית זמין להפעלת הקוד האחרון. אם קומפילציה של הכל
קוד, כולל קוד ספריה, עם -fsplit-מחסנית זה לא אופציה, אז המקשר יכול
תקן את השיחות האלה כך שהקוד יודר ללא -fsplit-מחסנית תמיד יש גדול
לַעֲרוֹם. תמיכה לכך מיושמת במקשר הזהב במהדורת GNU binutils
2.21 ואילך.

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

אַזהָרָה: מה היא -בורח-קו תחתון switch גורם ל-GCC ליצור קוד שאינו
בינארי תואם לקוד שנוצר ללא המתג הזה. השתמש בו כדי להתאים את א
ממשק בינארי של יישום שאינו ברירת מחדל. לא כל היעדים מספקים תמיכה מלאה
עבור המתג הזה.

-ftls-model=מודל
שנה את מודל האחסון המקומי של חוט לשימוש. ה מודל הטיעון צריך להיות אחד מהם
"גלובלי-דינמי", "מקומי-דינמי", "ראשוני-מנהל" או "מנהל מקומי".

ברירת המחדל ללא -fpic הוא "initial-exec"; עם -fpic ברירת המחדל היא
"גלובלי-דינמי".

-fvisibility=ברירת מחדל|פנימי|מוסתר|מוגן
הגדר את ברירת המחדל של נראות סמל תמונת ELF לאפשרות שצוינה --- כל הסמלים יהיו
להיות מסומן עם זה אלא אם כן נדחק בתוך הקוד. שימוש בתכונה זו יכול מאוד
לשפר משמעותית את זמני הקישור והטעינה של ספריות אובייקטים משותפות, לייצר יותר
קוד אופטימלי, לספק ייצוא ממשק API כמעט מושלם ולמנוע התנגשויות סמלים. זה
בְּתוֹקֶף מומלץ להשתמש בזה בכל אובייקט משותף שתפיץ.

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

הסבר טוב על היתרונות המוצעים על ידי הבטחת סמלי ELF בעלי הערך הנכון
הנראות ניתנת על ידי "איך לכתוב ספריות משותפות" מאת אולריך דרפר (שיכול להיות
נמצא בhttp://people.redhat.com/~drepper/>) --- עם זאת נעשה פתרון מעולה
אפשרי על ידי אפשרות זו לסמן דברים מוסתרים כאשר ברירת המחדל היא ציבורית היא לעשות
ברירת המחדל מוסתרת וסימון דברים ציבוריים. זוהי הנורמה עם DLL של Windows ו
עם -נראות = מוסתרת ו-"__attribute__ ((visibility("default"))" במקום
"__declspec(dllexport)" אתה מקבל סמנטיקה כמעט זהה עם תחביר זהה.
זהו ברכה גדולה למי שעובד עם פרויקטים חוצי פלטפורמה.

לאלו שמוסיפים תמיכת נראות לקוד קיים, ייתכן שתמצאו #פרגמה GCC
ראות בשימוש. זה עובד בכך שאתה מצרף את ההצהרות שברצונך לקבוע
נראות עבור עם (לדוגמה) #פרגמה GCC ראות push (מוסתר) ו #פרגמה GCC
ראות פופ. זכור שיש לראות את נראות הסמלים as חלק of מה היא
API ממשק חוזה ולכן כל הקוד החדש צריך תמיד לציין את הנראות כאשר הוא
אינו ברירת המחדל; כלומר, הצהרות רק לשימוש בתוך ה-DSO המקומי צריך תמיד
להיות מסומן במפורש כמו מוסתר כדי למנוע תקורה עקיפה PLT --- מה שהופך את זה
ברור בשפע גם מסייע לקריאה ותיעוד עצמי של הקוד. ציין זאת
עקב דרישות מפרט ISO C++, מפעיל חדש ומחיקת מפעיל חייבים
תמיד תהיה ברירת מחדל.

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

חיצוני הצהרות אינן מושפעות מ -נראות, אז הרבה קוד יכול להיות
הידור מחדש עם -נראות = מוסתרת ללא שינויים. עם זאת, המשמעות היא זאת
קורא ל חיצוני פונקציות ללא חשיפה מפורשת ישתמשו ב-PLT, אז זה יותר
יעיל לשימוש __תְכוּנָה ((רְאוּת)) ו / או #פרגמה GCC ראות לספר ל
מהדר אשר חיצוני יש להתייחס להצהרות כאל מוסתרות.

שים לב כי -נראות אכן משפיע על ישויות קישור מעורפלות של C++. זה אומר שעבור
לדוגמה, מחלקה חריגה שתושק בין DSOs חייבת להיות במפורש
מסומן עם נראות ברירת מחדל כך שה סוג_מידע צמתים יאוחדו בין ה
DSOs.

סקירה כללית של טכניקות אלה, היתרונות שלהן ואופן השימוש בהן נמצאת ב
<http://gcc.gnu.org/wiki/Visibility>.

-פניקט-נדיפות-שדות
יש להשתמש באפשרות זו אם יש גישה לשדות סיביות נדיפים (או מבנה אחר
שדות, למרות שהמהדר בדרך כלל מכבד את הטיפוסים האלה בכל מקרה) צריך להשתמש בסינגל
גישה של רוחב סוג השדה, מיושר ליישור טבעי במידת האפשר.
לדוגמה, מטרות עם אוגרים היקפיים ממופי זיכרון עשויים לדרוש את כל אלה
גישה ברוחב של 16 סיביות; עם הדגל הזה המשתמש יכול להכריז על כל הסיביות ההיקפיות-
שדות כ"קצר חסר סימן" (בהנחה שהקצר הוא 16 סיביות במטרות אלו) כדי לאלץ את GCC
להשתמש בגישה של 16 סיביות במקום, אולי, בגישה יעילה יותר של 32 סיביות.

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

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

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

הסביבה

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

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

שפה
LC_CTYPE
LC_MESSAGES
LC_ALL
משתני סביבה אלה שולטים באופן שבו GCC משתמש במידע לוקליזציה
מה שמאפשר ל-GCC לעבוד עם מוסכמות לאומיות שונות. GCC בודק את המקום
קטגוריות LC_CTYPE ו LC_MESSAGES אם הוא הוגדר לעשות זאת. המקום האלה
ניתן להגדיר קטגוריות לכל ערך שנתמך על ידי ההתקנה שלך. ערך טיפוסי הוא
en_GB.UTF-8 לאנגלית בבריטניה מקודדת ב-UTF-8.

אל האני LC_CTYPE משתנה סביבה מציין סיווג תווים. GCC משתמש בזה כדי
לקבוע את גבולות התווים במחרוזת; זה נחוץ עבור כמה multibyte
קידודים המכילים מרכאות ותווי בריחה שאחרת היו מתפרשים
כקצה מיתר או בריחה.

אל האני LC_MESSAGES משתנה סביבה מציין את השפה לשימוש באבחון
הודעות.

אם LC_ALL משתנה סביבה מוגדר, הוא עוקף את הערך של LC_CTYPE ו
LC_MESSAGES; אחרת, LC_CTYPE ו LC_MESSAGES ברירת המחדל לערך של שפה
משתנה הסביבה. אם אף אחד מהמשתנים האלה לא מוגדר, GCC כברירת מחדל למסורתי
C התנהגות אנגלית.

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

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

GCC_EXEC_PREFIX
If GCC_EXEC_PREFIX מוגדר, הוא מציין קידומת לשימוש בשמות של
תוכניות משנה המופעלות על ידי המהדר. לא מוסיפים לוכסן כאשר קידומת זו משולבת
עם שם של תת-תוכנית, אבל אתה יכול לציין קידומת שמסתיימת בקו נטוי if
אתה רוצה.

If GCC_EXEC_PREFIX לא מוגדר, GCC ינסה למצוא קידומת מתאימה ל
השתמש בהתבסס על שם הנתיב איתו הוא הופעל.

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

ערך ברירת המחדל של GCC_EXEC_PREFIX is prefix/lib/gcc/ איפה קידומת הוא הקידומת ל
המהדר המותקן. במקרים רבים קידומת הוא הערך של "קידומת" כשהרצת את
להגדיר תַסרִיט.

קידומות אחרות שצוינו עם -B לקבל עדיפות על קידומת זו.

קידומת זו משמשת גם למציאת קבצים כגון crt0.o המשמשים לקישור.

בנוסף, הקידומת משמשת בצורה יוצאת דופן במציאת הספריות לחיפוש
עבור קבצי כותרות. לכל אחת מהספריות הסטנדרטיות שהשם שלהן מתחיל בדרך כלל
עם /usr/local/lib/gcc (ליתר דיוק, עם הערך של GCC_INCLUDE_DIR), מנסה GCC
החלפת ההתחלה בקידומת שצוינה כדי לייצר ספרייה חלופית
שֵׁם. לפיכך, עם -Bfoo/, GCC יחפש פו בר איפה זה יחפש בדרך כלל
/usr/local/lib/bar. ספריות חלופיות אלו נבדקות תחילה; הסטנדרט
מדריכים מגיעים בהמשך. אם ספרייה רגילה מתחילה עם המוגדר קידומת אז
את הערך של קידומת מוחלף על ידי GCC_EXEC_PREFIX כאשר מחפשים קבצי כותרות.

COMPILER_PATH
הערך של COMPILER_PATH היא רשימה מופרדת בנקודתיים של ספריות, בדומה ל נתיב.
GCC מנסה את הספריות שצוינו כך בעת חיפוש אחר תוכניות משנה, אם היא לא מצליחה
מצא את תוכניות המשנה באמצעות GCC_EXEC_PREFIX.

LIBRARY_PATH
הערך של LIBRARY_PATH היא רשימה מופרדת בנקודתיים של ספריות, בדומה ל נתיב.
כאשר מוגדר כקומפיילר מקורי, GCC מנסה את הספריות שצוינו כך מתי
מחפש קבצי קישור מיוחדים, אם הוא לא יכול למצוא אותם באמצעות GCC_EXEC_PREFIX.
קישור באמצעות GCC משתמש גם בספריות אלו בעת חיפוש ספריות רגילות
עבור -l אפשרות (אבל ספריות צוינו עם -L תבוא ראשון).

שפה
משתנה זה משמש להעברת מידע מקומי לקומפיילר. דרך אחת שבה
מידע זה משמש כדי לקבוע את ערכת התווים שישמש כאשר תו
מילוליות, מילוליות מחרוזות והערות מנותחות ב-C ו-C++. כאשר המהדר הוא
מוגדר לאפשר תווים מרובי-בתים, הערכים הבאים עבור שפה יש לו
מוּכָּר:

C-JIS
זיהוי דמויות JIS.

C-SJIS
זיהוי דמויות SJIS.

C-EUCJP
זיהוי תווי EUCJP.

If שפה אינו מוגדר, או אם יש לו ערך אחר, אז המהדר ישתמש
mblen ו-mbtowc כפי שהוגדרו על ידי מקום ברירת המחדל לזיהוי ולתרגם של multibyte
תווים.

כמה משתני סביבות נוספים משפיעים על התנהגות המעבד המקדים.

CPATH
C_INCLUDE_PATH
CPLUS_INCLUDE_PATH
OBJC_INCLUDE_PATH
הערך של כל משתנה הוא רשימה של ספריות מופרדות על ידי תו מיוחד, הרבה
כמו נתיב, שבו לחפש קבצי כותרות. הדמות המיוחדת,
"PATH_SEPARATOR", תלוי ביעד ונקבע בזמן בניית GCC. עבור מיקרוסופט
יעדים מבוססי Windows זה נקודה-פסיק, וכמעט עבור כל שאר המטרות זה א
המעי הגס.

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

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

בכל המשתנים הללו, אלמנט ריק מורה למהדר לחפש את הזרם שלו
ספריית עבודה. אלמנטים ריקים יכולים להופיע בתחילת או בסופו של נתיב. ל
למשל, אם הערך של CPATH הוא ":/special/include", שיש לו אותה השפעה כמו
-אני. -אני/מיוחד/כולל.

DEPENDENCIES_OUTPUT
אם משתנה זה מוגדר, הערך שלו מציין כיצד להפיק תלות עבור Make based
על קבצי הכותרות שאינם מערכת המעובדים על ידי המהדר. קבצי כותרות מערכת הם
התעלמו בפלט התלות.

הערך של DEPENDENCIES_OUTPUT יכול להיות רק שם קובץ, ובמקרה זה הכללים Make
נכתבים לקובץ הזה, מנחשים את שם היעד משם קובץ המקור. או ה
ערך יכול לקבל את הצורה פילה יעד, ובמקרה זה הכללים נכתבים לתיק פילה
באמצעות יעד כשם היעד.

במילים אחרות, משתנה סביבה זה שווה ערך לשילוב האפשרויות -ממ
ו -MF, עם אופציונלי -MT להחליף גם.

SUNPRO_DEPENDENCIES
משתנה זה זהה ל DEPENDENCIES_OUTPUT (ראה לעיל), מלבד המערכת ההיא
לא מתעלמים מקובצי כותרת, כך שזה מרמז -M ולא -ממ. אולם, ה
התלות בקובץ הקלט הראשי נשמטת.

השתמש ב-arm-linux-gnueabihf-gcc-4.7 באינטרנט באמצעות שירותי onworks.net