sh4-linux-gnu-g++ - מקוון בענן

תָכְנִית:

שֵׁם

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

תַקצִיר

gcc [-c|-S|-E] [-std=תֶקֶן]
[-g] [-עמוד] [-Oרָמָה]
[-Wלהזהיר...] [-Wpedantic]
[-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. is -fno-foo. מדריך זה מתעד רק אחד מאלה
שתי צורות, כל אחת מהן אינה ברירת המחדל.

אפשרויות

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

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

C שפה אפשרויות
-אנסי -std=תֶקֶן -fgnu89-inline -מידע נוסף שם הקובץ
-פונקציות-פרמטר-חסר-פרמטר-variadic -fno-asm -fno-builtin -fno-builtin-פונקציה
-אירוח -עומד בפני עצמו -fopenacc -fopenmp -fopenmp-simd -fms-הרחבות
-fplan9-הרחבות -טריגרפים -מָסוֹרתִי -מסורתי-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 -fsized-deallocation -fstats
-ftemplate-backtrace-limit=n -ftemplate-depth=n -fno-threadsafe-statics
-פיוז-cxa-atexit -fno-חלש -nostdinc++ -fvisibility-inlines-hidden
-fvtable-verify=[std|preinit|אף לא אחד] -fvtv-ספירות -fvtv-debug -fvisibility-ms-compat
-פקס-מספרי-מילוליים -וואבי=n -תג וואבי -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 -fno-local-ivars
-fivar-visibility=[ציבורי|מוּגָן|פְּרָטִי|חבילה] -freplace-objc-classes
-fzero-link -gen-decls -Wassign-יירט -אין פרוטוקול -ובורר
-Wstrict-selector-match -בורר-מוצהר

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

אזהרה אפשרויות
-fsyntax-בלבד -fmax-errors=n -Wpedantic -פדנטיות-טעויות -w אקסטרה - קיר
-כתובת -Waggregate-return -אופטימיזציות של לולאת שוק -גבולות המלחמה
-Warray-bounds=n -Wbool-השוואה -אין תכונות -מובנה-מקרו-מוגדר מחדש
-Wc90-c99-compat -Wc99-c11-compat -Wc++-compat -Wc++11-compat -Wc++14-compat
-יישור Wcast -Wcast-qual -Wchar-מנויים -קשקש -הערה
- נתמך בתנאי -המרה -אי-התאמה של כיסוי -Wdate-time
-Wdelete-לא שלם -Wno-cpp -לא הוצא משימוש -הצהרות-לא-מוות
-Wno-designated-init -Wdisabled-אופטימיזציה -לא-מושלכים-מוקדמות
-Wno-discarded-array-qualifiers -Wno-div-by-XNUMX - קידום כפול -גוף רטוב
-וונום-השוו -תוויות Wno-endif -שגיאה -שגיאה=* -שגיאות חמורות -Wfloat-שווה
- -Wformat=2 -Wno-format-contains-nul -Wno-format-extra-args
-Wformat-לא מילולי -Wformat-אבטחה -חתימות Wformat -Wformat-y2k
-Wframe-larger than=לן -ללא-חפץ-לא-ערמה -Wjump-misses-init
- מוקדמות מנוצלות -סוגי מצביע תואמי Win - מרומז
-הצהרה-פונקציונלית -מוכר -וויניט-עצמי -Winline
-Wno-int-conversion -Wno-int-to-pointer-cast -Wno-invalid-offsetof -Winvalid-pch
-Wlarer- than=לן -אופטימיזציות של Wunsafe-loop -Wlogical-op -הגיוני-לא-סוגריים
-ולונג-ארוך -מיין -אולי-לא אתחול -Wmemset-transposed-args -חסר-פלטה
-חסרי-שדה-initializers -חסרים-include-dirs -Wno-multichar -Wnonnull
-Wnormalized=[אף לא אחד|id|NFC|nfkc]
-ודר -ללא הצפה -Wopenmp-simd -מיתרים באורך רוח -ארוז
-Wpacked-bitfield-compat -Wpadded -סוגריים -Wpedantic-ms-format
-Wno-pedantic-ms-format -Wpointer-arith -אין-מצביע ל-int-cast -חסר-מבטל
-Wno-return-local-addr -סוג חזרה -נקודת רצף -וצל -Wno-shadow-ivar
-Wshift-ספירת-שלילי -Wshift-count-overflow -Wsign-השוואה -המרת סימן
-המרה ציפה -Wsizeof-pointer-memaccess -גודל-מערך-טיעון
-מגן Wstack -Wstack-usage=לן -Wstrict-aliasing -Wstrict-aliasing=n
-Wstrict-הצפה -Wstrict-overflow=n -Wsuggest-attribute=[טהור|const|אין דרך חזרה|פוּרמָט]
-סוגי Wsuggest-סופי -Wsuggest-סופי-שיטות -הצעת-עקיפה
-תכונה חסרת-פורמט -מתג -Wswitch-default -סוויצ'-אנום -Wswitch-bool
-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 -fsanitize=סגנון -הסניטציה-להתאושש
-fsanitize-recover=סגנון -fasan-shadow-offset=מספר
-fsanitize-undefined-trap-on-error -fcheck-pointer-bounds -fchkp-check-incomplete-type
-fchkp-לשדה הראשון-יש גבולות משלו -fchkp-צר-גבולות
-fchkp-צר-לפנימי-מערך -fchkp-אופטימיזציה -fchkp-use-fast-string-functions
-fchkp-use-nochk-string-functions -FCHKP-USE-STATIC-HAUNDS
-fchkp-use-static-const-bounds -fchkp-treat-zero-dynamic-size-as-infinity
-fchkp-check-read -fchkp-check-read -פצ'ק-צ'ק-וריט -fchkp-store-bounds
-fchkp-מכשיר-שיחות -fchkp-מכשיר-מסומן-בלבד -fchkp-use-wrappers
-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-כינוי -fdump-tree-ch -fdump-tree-ssa[-n] -fdump-tree-pre[-n]
-fdump-tree-ccp[-n] -fdump-tree-dce[-n] -fdump-tree-gimple[-גלם] -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-vtable-verify -fdump-tree-vrp[-n] -fdump-tree-storeccp[-n]
-fdump-final-insns=פילה -fcompare-debug[=בוחר] -fcompare-debug-second
-פלימינאט-גמד2-דופים -fno-eliminate-unused-debug-types
סמלים-feliminate-unused-debug-symbols -femit-class-debug-always -ניתן להפגין-סוג-לעבור
-ניתן להפגין-סוג-לעבור=רשימת טווחים -fdebug-types-section -fmem-report-wpa -fmem-דוח
-fpre-ipa-mem-report -fpost-ipa-mem-report -fprofile-arcs -fopt-info
-fopt-info-אפשרויות[=פילה] -פרנדום-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+ -gz[=סוג] -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-profile
-fauto-profile[=נתיב] -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 -fdevirtualize-ספקולטיבית
-fdevirtualize-at-ltrans -fdse -פחד-הטבעה -פיפא-סרה -זול-אופטימיזציות
-ffat-lto-objects -מהיר-מתמטיקה -סופית-מתמטיקה-בלבד -ffloat-store
-fexcess-precision=סגנון -לפנים-להפיץ -ffp-contract=סגנון -פפונקציה-סעיפים
-fgcse -fgcse-after-reload -fgcse-las -fgcse-lm -זהות-fgraphite -fgcse-sm
-fhoist-סמוך-עומסים -fif-המרה -fif-conversion2 -findirect-inlining
-finline-פונקציות -finline-functions-שנקרא פעם אחת -finline-limit=n
-finline-קטנות-פונקציות -fipa-cp -fipa-cp-clone -fipa-cp-alignment -פיפא-pta
-fipa-profile -פיפא-טהור-קונסט -פיפא-התייחסות -fipa-icf -fira-algorithm=אַלגוֹרִיתְם
-fira-region=באזור -פירה-הרמה-לחץ -פירה-לולאה-לחץ -fno-ira-share-save-slots
-fno-ira-share-spill-slots -fira-verbose=n -נתיבות-שגויות-התייחסות
-תכונת-נתיבים-מתבודדים-שגויים -fivopts -fkeep-inline-functions
-fkeep-static-consts -התכווצות-טווח-פליוו -פלופ-בלוק -פלופ-מחלף
-פלופ-רצועה-שלי -פלופ-להתגלגל-וגם -floop-nest-optimize -פלופ-מקביל-הכל
-flra-remat -flto -flto-compression-level -flto-partition=ALG -flto-דוח
-flto-report-wpa -fmerge-all-constants -fmerge-constants -fmodulo-sched
-fmodulo-sched-allow-regmoves -fmove-loop-invariants -fno-branch-count-reg
-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-אחיות-שיחות
-fpartial-inlining -fpeel-לולאות -fpredictive-commoning -fprefetch-loop-arrays
-fprofile-report -fprofile-תיקון -fprofile-dir=נתיב -fprofile-generate
-fprofile-generate=נתיב -fprofile-שימוש -fprofile-use=נתיב -fprofile-values
-fprofile-סדר מחדש-פונקציות -תדמיתי-מתמטיקה -חופשי -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-fusion -fschedule-insns -fschedule-insns2 -fsection-עוגנים
-סלקטיבי-תזמון -fsellective-scheduling2 -fsel-sched-pipelining
-fsel-sched-pipelining-outer-loops -פסמנטי-אינטרפוזיציה -להכווץ-לעטוף
-fsignaling-nans -דיוק-קבוע-יחיד -fsplit-ivs-in-unroller
-fsplit-wide-types -fssa-phiopt -מגן מחסנית -fstack-protector-all
-fstack-protector-חזק -fstack-protector-explicit -fstdarg-opt -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-loop-vectorize
-ftree-parallize-לולאות=n -ftree-pre -ftree-partial-pre -ftree-pta -ftree-reassoc
-כיור-ftree -ftree-slsr -ftree-sra -ftree-switch-conversion -ftree-זנב-מיזוג
-ftree-ter -ftree-vectorize -ftree-vrp -כיף-בכל פעם -funroll-all-loops
-funroll-לולאות -אופטימיזציות של לולאת funsafe -אופטימיזציות-funsafe-math
-לולאות funswitch -פיפא-רה -fvariable-expansion-in-unroller -fvect-cost-model -fvpt
-FWeb. -התוכנית שלמה -fwpa -תוסף-מקשר-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 אוֹפְּצִיָה -no-integrated-cpp

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

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

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

מכונה תלוי אפשרויות
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=מסורתי
-mfix-cortex-a53-835769 -mno-fix-cortex-a53-835769 -mfix-cortex-a53-843419
-mno-fix-cortex-a53-843419 -מרץ=שם -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-רג

קשת אפשרויות -מחליף-מעביר -mcpu=מעבד -mA6 -mARC600 -mA7 -mARC700 -mdpfp
-mdpfp-compact -mdpfp-מהיר -mno-dpfp-lrsr -מה -mno-mpy -mmul32x16 -mmul64 -מנורם
-mspfp -mspfp-compact -mspfp-מהיר -msimd -msoft-float -mswap -mcrc -mdsp-packa -mdvbf
-מלוק -mmac-d16 -mmac-24 -mrtsc -mswape -טלפוניה -מקסי -הגדלה -מנוט-יישר
-מרקלינוקס -marclinux_prof -mepilogue-cfi -מלונג-שיחות -מבינוני-שיחות -msdata
-mucb-mcount -mvolatile-cache -ממאיר-קריאה -mauto-modify-reg -מבביט-חור הצצה -mno-brcc
-mcase-vector-pcrel -mcompact-casesi -mno-cond-exec -mearly-cbranchsi -mexpand-adddi
-עומסים מודפסים -mlra -mlra-priority-none -mlra-priority-compact mlra-עדיפות-
לא קומפקטי -mno-millicode -mmixed-code -mq-class -mRcq -mRcw -msize-level=רָמָה
-mtune=מעבד -multcost=NUM -munalign-prob-threshold=הסתברות

זרוע אפשרויות -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
-mfloat-abi=שם -mfp16-format=שם -מ-אגודל-עבודה -mno-thumb-interwork -mcpu=שם
-מרץ=שם -mfpu=שם -mtune=שם -mprint-tune-info -mstructure-size-boundary=n
-אם-על-חזרה -מלונג-שיחות -שיחות ארוכות -בסיס תמונה אחת
-mno-single-pic-base -mpic-register=רג -mnop-fun-dllimport -שם פונקציה-mpoke
-אגודל -מרם -mtpcs-frame -mtpcs-leaf-frame -mcaller-סופר-אינטרוורקינג
-mcallee-סופר-אינטרוורקינג -mtp=שם -mtls-dialect=נִיב -mword-relocations
-mfix-cortex-m3-ldrd -גישה מנוהלת -מנאון-עבור-64 סיביות -mslow-flash-data
-masm-תחביר-מאוחד -מגביל-זה

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

שחור אפשרויות -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 -מיי -מיי-עם-לא מדויק
-מיי-תואם -mfp-trap-mode=מצב -mfp-rounding-mode=מצב -mtrap-precision=מצב
-mbuild-קבועים -mcpu=סוג מעבד -mtune=סוג מעבד -mbwx -ממקס -mfix -mcix
-mfloat-vax -mfloat-ieee -מפורש-רילוקים -msmall-data -הגדלה-נתונים -msmall-text
-טקסט גדול -זיכרון-השהייה=זמן

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 אפשרויות -להירגע -מ"ה -גברת -מנ -mexr -mno-exr -מנטה32 -ממאיר-300

HPPA אפשרויות -מרץ=סוג אדריכלות -mdisable-fpregs -mdisable-indexing
-שיחות בלתי ישירות -מגז -מגנו-לד -mhp-ld -mfixed-range=רישום-טווח
-mjump-in-delay -mlinker-opt -מלונג-שיחות -מלונג-load-store -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 -סטָטִי
-חוטים

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

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
-mbig-endian -מעט-אנדיאן -mxl-סדר מחדש -mxl-mode-דגם אפליקציה

MIPS אפשרויות -ה -EB -מרץ=קשת -mtune=קשת -מיפס1 -מיפס2 -מיפס3 -מיפס4
-מיפס32 -mips32r2 -mips32r3 -mips32r5 -mips32r6 -מיפס64 -mips64r2 -mips64r3
-mips64r5 -mips64r6 -מיפס16 -mno-mips16 -mflip-mips16 -מינטרלינק-דחוס
-mno-interlink-compressed -minterlink-mips16 -mno-interlink-mips16 -מאבי=אבי
-מאביקלים -מנו-אביקל -mshared -mno-משותף -mplt -mno-plt -mxgot -mno-xgot
-mgp32 -mgp64 -mfp32 -mfpxx -mfp64 -mhard-float -msoft-float -mno-float
ציפה אחת -mdouble-float -modd-spreg -mno-odd-spreg -mabs=מצב -מנן=הַצפָּנָה
-mdsp -mno-dsp -mdspr2 -mno-dspr2 -ממקו -mmno-mcu -מבע -מנו-אווה -מווירט -mno-virt
-mxpa -mno-xpa -micromips -mno-micromips -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-rm7000 -mno-fix-rm7000
-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 -מסתלב

מוקסי אפשרויות -מב -מל -mmul.x -mno-crt0

MSP430 אפשרויות -מסים -masm-hex -mmcu= -mcpu= -להגדיל -msmall -להירגע -mhwmult= -מינרט

NDS32 אפשרויות -mbig-endian -מעט-אנדיאן -mreduced-regs -mfull-regs -מקמוב -mno-cmov
-perf-ext -mno-perf-ext -mv3push -mno-v3push -m16bit -mno-16bit -misr-vector-size=NUM
-mcache-block-size=NUM -מרץ=קשת -mcmodel=מודל קוד -מקטור-דטור -להירגע

ניוס II אפשרויות -G NUM -mgpopt=אוֹפְּצִיָה -mgpopt -mno-gpopt -מל -מב -mno-bypass-cache
-mbypass-cache -mno-cache-volatile -mcache-נדיף -mno-fast-sw-div -mfast-sw-div
-מהו-מול -מנו-הוו-מול -מהוו-מולקס -mno-hw-mulx -mno-hw-div -mhw-div -מנהג-insn=N
-mno-custom-insn -mcustom-fpu-cfg=שם -מחל -msmallc -msys-crt0=שם -msys-lib=שם

Nvidia PTX אפשרויות -מ 32 -מ 64 -עיקרון

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 -m64bit-כפילים -m32bit-כפילים

RS/6000 ו PowerPC אפשרויות -mcpu=סוג מעבד -mtune=סוג מעבד -mcmodel=מודל קוד
-mpowerpc64 -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 -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-עקיף -mpower8-fusion -mno-mpower8-fusion
-mpower8-וקטור -mno-power8-וקטור -mcrypto -mno-crypto -mdirect-move -mno-direct-move
-mquad-memory -mno-quad-memory -mquad-memory-atomic -mno-quad-memory-atomic
-mcompat-align-parm -mno-compat-align-parm -mupper-regs-df -mno-upper-regs-df
-mupper-regs-sf -mno-upper-regs-sf -מופר-רגס -mno-upper-regs

RX אפשרויות -m64bit-כפילים -m32bit-כפילים -fpu -nofpu -mcpu= -mbig-endian-data
-mlittle-endian-data -msmall-data -מסים -מנו-סים -mas100-תחביר -mno-as100-תחביר
-להירגע -mmax-constant-size= -mint-register= -mpid -mno-warn-multiple-fast-interrupts
-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 -mhotpatch=חצאי מילים,חצאי מילים

ציון אפשרויות -מב -מל -מןהולופ -מולס -ממק -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-סמלים
-מטומי-מודל=דגם אטומי -brranch-cost=NUM -mzdcbranch -mno-zdcbranch
-mcbranch-force-delay-slot -מfused-madd -mno-fused-madd -mfsca -mno-fsca -mfsrra
-מנו-פסרה -mpretend-cmove -mtas

Solaris 2 אפשרויות -mclear-hwcap -mno-clear-hwcap -טקסט-מימפור -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 -מצב-muser -mno-user-mode -mv8plus -mno-v8plus -mvis
-mno-vis -mvis2 -mno-vis2 -mvis3 -mno-vis3 -mcbcond -mno-cbcond -mfmaf -mno-fmaf
-mpopc -mno-popc -mfix-at697f -mfix-ut699

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=CPU -מ 32 -מ 64 -mbig-endian -מעט-אנדיאן -mcmodel=מודל קוד

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 -mv850e3v5 -מלופ -להירגע -מלונג-קפיצות -msoft-float -mhard-float -mgcc-abi
-mrh850-abi -מביג-מתג

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

ויזיום אפשרויות -mdebug -מסים -mfpu -mno-fpu -mhard-float -msoft-float -mcpu=סוג מעבד
-mtune=סוג מעבד -msv-mode -מצב-muser

VMS אפשרויות -mvms-return-codes -mdebug-main=קידומת -mmalloc64 -mpointer-size=גודל

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

x86 אפשרויות -mtune=סוג מעבד -מרץ=סוג מעבד -mtune-ctrl=רשימת תכונות
-mdump-tune-features -mno-default -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 -mavx512f -mavx512pf -mavx512er
-mavx512cd -משה -מייס -mpclmul -mfsgsbase -mrdrnd -mf16c -mfma -mprefetchwt1
-mclflushopt -mxsavec -mxsaves -msse4a -m3dnow -mpopcnt -מאבם -מבמי -mtbm -mfma4 -mxop
-mlzcnt -mbmi2 -mfxsr -mxsave -mxsaveopt -mrtm -mlwp -mmpx -ממווייטקס -חוטים
-mno-align-stringops -מינליין-כל-stringops -מינליין-stringops-דינמית
-mstringop-strategy=ALG -mmemcpy-strategy=אסטרטגיה -mmemset-strategy=אסטרטגיה
-מפוש-ארגס -צבור-יוצא-ארגים -m128bit-long-double -m96bit-long-double
-מלונג-כפול-64 -מלונג-כפול-80 -מלונג-כפול-128 -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 -מ 16 -mlarge-data-threshold=NUM
-msse2avx -מפנטרי -mrecord-mcount -mnop-mcount -m8bit-idiv
-mavx256-split-unaligned-load -mavx256-split-unaligned-store -malign-data=סוג
-mstack-protector-guard=שומר

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

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-רג -תוקן-רג חריגות - חריגים ללא שיחות
-fdelete-dead-exceptions -שולחנות רוח כיף -פא-סינכרוני-פריק-שולחנות -fno-gnu-unique
-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=מודל
-fstack-reuse=reuse_level -ftrapv -fwrapv -fbounds-check
-fvisibility=[ברירת מחדל|פנימי|מוסתר|מוּגָן] -פניקט-נדיפות-שדות
-fsync-libcalls

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

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

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

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

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

- עזרה
הדפס (על הפלט הסטנדרטי) תיאור של אפשרויות שורת הפקודה המובנות על ידי
gcc. אם -v האפשרות מצוינת גם אז - עזרה מועבר גם לשונות
תהליכים שהופעלו על ידי gcc, כדי שהם יוכלו להציג את אפשרויות שורת הפקודה שהם
לְקַבֵּל. אם ה אקסטרה צוינה גם האפשרות (לפני ה - עזרה אוֹפְּצִיָה),
אז גם אפשרויות שורת הפקודה שאין להן תיעוד משויך
מוצג.

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

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

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

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

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

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 is
gdb --ארגס cc1 ....

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

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

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

-fada-spec-parent=יחידה
בשיתוף עם -fdump-ada-spec[-רָזֶה] למעלה, צור מפרט 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++. זה מטפל .c, .h ו .i קבצים כ
קבצי מקור C++ במקום קבצי מקור C אלא אם כן -x משמש. גם תוכנית זו שימושית
בעת קומפילציה מראש של קובץ כותרת 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 ללא תשלום. ל
כי, -Wpedantic נדרש בנוסף ל -אנסי.

המאקרו "__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, כמו השמטת ה-
מונח אמצעי של ביטוי "?:". מצד שני, כאשר ניב גנו של תקן
מוגדר, כל התכונות הנתמכות על ידי המהדר מופעלות, גם כאשר אלו
תכונות משנות את המשמעות של תקן הבסיס. כתוצאה מכך, כמה קפדנית התאמה
תוכניות עלולות להידחות. התקן המסוים משמש על ידי -Wpedantic לזהות
אילו תכונות הן הרחבות של GNU בהינתן גרסה זו של התקן. לדוגמה
-std=gnu90 -Wpedantic מזהיר לגבי סגנון C++ // הערות, תוך כדי -std=gnu99 -Wpedantic
לא.

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

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

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

c99
c9x
iso9899:1999
iso9899:199x
ISO C99. תקן זה נתמך באופן מלא, מודולו באגים ו
בעיות של נקודה צפה (בעיקר אך לא לגמרי קשורות לתכונות C99 אופציונליות
מהנספחים ו' ו-ז'). לִרְאוֹתhttp://gcc.gnu.org/c99status.html> לעוד
מֵידָע. השמות c9x ו iso9899:199x מיושנים.

c11
c1x
iso9899:2011
ISO C11, עדכון 2011 של תקן ISO C. תקן זה הוא מהותי
תמיכה מלאה, באגים במודולו, בעיות בנקודה צפה (בעיקר אבל לא לגמרי
המתייחסים לתכונות C11 אופציונליות מהנספחים F ו-G) והנספחים האופציונליים K
(ממשקי בדיקת גבולות) ו-L (יכולת ניתוח). השם c1x הוצא משימוש.

gnu90
gnu89
ניב GNU של ISO C90 (כולל כמה תכונות של C99).

gnu99
gnu9x
ניב GNU של ISO C99. השם gnu9x הוצא משימוש.

gnu11
gnu1x
ניב GNU של ISO C11. זוהי ברירת המחדל עבור קוד C. השם gnu1x is
הוצא משימוש.

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

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

11 +
c ++ 0x
תקן ISO C++ לשנת 2011 בתוספת תיקונים. השם c ++ 0x הוצא משימוש.

gnu++11
gnu++0x
ניב גנו של 11. std = c ++. השם gnu++0x הוצא משימוש.

14 +
c++1y
תקן ISO C++ לשנת 2014 בתוספת תיקונים. השם c++1y הוצא משימוש.

gnu++14
gnu++1y
ניב גנו של 14. std = c ++. השם gnu++1y הוצא משימוש.

c++1z
הגרסה הבאה של תקן ISO C++, מתוכננת באופן טנטטיבי לשנת 2017. תמיכה
הוא מאוד ניסיוני, וכמעט בוודאות ישתנה בדרכים לא תואמות ב
מהדורות עתידיות.

gnu++1z
ניב גנו של -std = c ++ 1z. התמיכה היא מאוד ניסיונית, והיא תהיה כמעט
בהחלט להשתנות בדרכים לא תואמות במהדורות עתידיות.

-fgnu89-inline
האפשרות -fgnu89-inline אומר ל-GCC להשתמש בסמנטיקה המסורתית של GNU עבור "inline"
מתפקד במצב C99.

שימוש באפשרות זו שווה ערך להוספת תכונת הפונקציה "gnu_inline".
לכל הפונקציות המוטבעות.

האפשרות -fno-gnu89-inline אומר במפורש ל-GCC להשתמש בסמנטיקה של C99 עבור
"inline" במצב C99 או gnu99 (כלומר, הוא מציין את התנהגות ברירת המחדל). זֶה
האפשרות אינה נתמכת ב -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-מתארח.

-fopenacc
אפשר טיפול בהנחיות OpenACC "#pragma acc" ב-C/C++ ו-"!$acc" ב-Fortran.
מתי -fopenacc מצוין, המהדר מייצר קוד מואץ על פי ה
ממשק תכנות יישומים של OpenACC v2.0http://www.openacc.org/>. אפשרות זו
מרמז -phthread, ולכן הוא נתמך רק על יעדים שיש להם תמיכה עבור
-phthread.

שים לב שזו תכונה ניסיונית, לא שלמה ונתונה לשינויים בעתיד
גרסאות של GCC. לִרְאוֹתhttps://gcc.gnu.org/wiki/OpenACCלמידע נוסף.

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

-fopenmp-simd
אפשר טיפול בהנחיות SIMD של OpenMP עם "#pragma omp" ב-C/C++ ו-"!$omp" ב-
פורטרן. מתעלמים מהנחיות אחרות של OpenMP.

-fcilkplus
אפשר את השימוש בתכונות הרחבת השפה של Cilk Plus עבור C/C++. כאשר האפשרות
-fcilkplus מוגדר, אפשר את השימוש בתכונות ההרחבה של Cilk Plus Language
עבור C/C++. היישום הנוכחי עוקב אחר גירסת ABI 1.2. זה
תכונה ניסיונית שמלאה רק בחלקה, ושהממשק שלה עשוי להשתנות
בגרסאות עתידיות של GCC כאשר המפרט הרשמי משתנה. נכון לעכשיו, הכל
תכונות אך "_Cilk_for" יושמו.

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

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

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

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

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

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

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

שים לב שהאפשרות הזו כבויה עבור כל היעדים למעט יעדי x86 באמצעות ms-abi.

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

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

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

-מָסוֹרתִי
-מסורתי-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. ברירת המחדל היא גרסה 0.

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

גרסה 1 היא הגרסה של C++ ABI שהופיעה לראשונה ב-G++ 3.2.

גרסה 2 היא הגרסה של C++ ABI שהופיעה לראשונה ב-G++ 3.4, והייתה
ברירת מחדל דרך G++ 4.9.

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

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

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

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

גרסה 7, שהופיעה לראשונה ב-G++ 4.8, שמתייחסת ל-nullptr_t כאל סוג מובנה
ומתקן את ה-mangling של lambdas בהיקף ארגומנט ברירת המחדל.

גרסה 8, שהופיעה לראשונה ב-G++ 4.9, מתקנת את התנהגות ההחלפה של
סוגי פונקציות עם מאפיינים של function-cv.

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

-fabi-compat-version=n
על יעדים התומכים בכינויים חזקים, G++ פועל סביב פגיעה בשינויים על ידי יצירה
כינוי עם השם המעורב הנכון בעת ​​הגדרת סמל עם שגוי
שם מעוות. מתג זה מציין באיזו גרסת ABI להשתמש עבור הכינוי.

עם -fabi-version=0 (ברירת המחדל), ברירת המחדל היא 2. אם גרסת ABI אחרת היא
נבחר במפורש, ברירת המחדל היא 0.

גרסת התאימות נקבעת גם על ידי -וואבי=n.

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

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

-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++ המוער. עם זאת, ב-ISO C++ a
פונקציית friend שאינה מוצהרת בהיקף מקיף ניתן למצוא רק באמצעות
חיפוש תלוי טיעונים. ברירת המחדל של GCC היא ההתנהגות הסטנדרטית.

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

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

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

-fextern-tls-init
-fno-extern-tls-init
תקני C++11 ו-OpenMP מאפשרים למשתנים "thread_local" ו-"threadprivate"
יש אתחול דינמי (זמן ריצה). כדי לתמוך בכך, כל שימוש במשתנה כזה
עובר פונקציית עטיפה שמבצעת כל אתחול הכרחי. כאשר
השימוש וההגדרה של המשתנה נמצאים באותה יחידת תרגום, תקורה זו יכולה
יש לבצע אופטימיזציה משם, אבל כאשר השימוש הוא ביחידת תרגום אחרת יש
תקורה משמעותית גם אם המשתנה לא באמת צריך דינמיקה
אִתחוּל. אם המתכנת יכול להיות בטוח שאין שימוש במשתנה ב-non-
הגדרת TU צריכה להפעיל אתחול דינמי (או בגלל שהמשתנה הוא
אתחול סטטי, או שיבוצע שימוש במשתנה ב-TU המגדיר
לפני כל שימוש ב-TU אחר), הם יכולים למנוע את התקורה הזו עם
-fno-extern-tls-init אוֹפְּצִיָה.

במטרות התומכות בכינויי סמלים, ברירת המחדל היא -fextern-tls-init. על מטרות
שאינם תומכים בכינויי סמלים, ברירת המחדל היא -fno-extern-tls-init.

-ffor-scope
-fno-for-scope
If -ffor-scope מצוין, היקף המשתנים המוצהרים ב-a עבור-init-statement
מוגבל ללולאת "for" עצמה, כפי שצוין בתקן 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-הרחבות
השבת אזהרות Wpedantic לגבי מבנים המשמשים ב-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
כאשר הודעת שגיאה מתייחסת להתמחות של תבנית פונקציה, המהדר
בדרך כלל מדפיס את החתימה של התבנית ואחריה את הארגומנטים של התבנית ו
כל סוג defs או שמות טיפוס בחתימה (למשל "void f(T) [עם T = int]" במקום זאת
מאשר "void f(int)") כדי שיהיה ברור באיזו תבנית מדובר. כאשר טעות
ההודעה מתייחסת להתמחות של תבנית מחלקה, המהדר משמיט כל
ארגומנטים של תבנית התואמים לארגומנטים של תבנית ברירת המחדל עבור אותה תבנית. אם
כל אחת מההתנהגויות הללו מקשה על הבנת הודעת השגיאה במקום
קל יותר, אתה יכול להשתמש -fno-pretty-templates כדי להשבית אותם.

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

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

-fsized-deallocation
אפשר את ההצהרות הגלובליות המובנות

אופרטור void delete (void *, std::size_t) noexcept;
אופרטור void delete[] (void *, std::size_t) noexcept;

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

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

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

-ftemplate-backtrace-limit=n
הגדר את המספר המרבי של הערות ליצירת תבנית עבור אזהרה או שגיאה בודדת
ל n. ערך ברירת המחדל הוא 10.

-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 להגדיר טיפוסים עם אותו שם בצורה שונה.

-fvtable-verify=[std|preinit|אף לא אחד]
הפעל (או כבה, אם אתה משתמש -fvtable-verify=ללא) תכונת האבטחה שמאמתת ב
זמן ריצה, עבור כל שיחה וירטואלית, כי מצביע ה-vtable שדרכו מתבצעת השיחה
made תקף לסוג האובייקט, ולא הושחת או הוחלף.
אם מזוהה מצביע vtable לא חוקי בזמן הריצה, מדווחת שגיאה ו
ביצוע התוכנית מופסק באופן מיידי.

אפשרות זו גורמת לבניית מבני נתונים בזמן ריצה בעת הפעלת התוכנית, שהם
משמש לאימות מצביעי vtable. האפשרויות std ו preinit לשלוט ב-
תזמון מתי נבנים מבני נתונים אלה. בשני המקרים מבני הנתונים הם
נבנה לפני שהביצוע מגיע ל"ראשי". באמצעות -fvtable-verify=std גורם לנתונים
מבנים שייבנו לאחר טעינה ואותחול של ספריות משותפות.
-fvtable-verify=preinit גורם להם להיבנות לפני שספריות משותפות היו
נטען ואותחל.

אם אפשרות זו מופיעה מספר פעמים בשורת הפקודה עם ערכים שונים
נָקוּב, אף לא אחד מקבל את העדיפות הגבוהה ביותר על פני שניהם std ו preinit; preinit לוקח
עדיפות על פני std.

-fvtv-debug
כאשר משתמשים בו יחד עם -fvtable-verify=std or -fvtable-verify=preinit, גורם ל
ניפוי באגים של פונקציות זמן הריצה עבור תכונת אימות vtable
שקוראים לו. הדגל הזה גם גורם למהדר לרשום מידע לגבי איזה vtable
מצביעים שהוא מוצא עבור כל מחלקה. מידע זה נכתב לקובץ בשם
vtv_set_ptr_data.log בספרייה הנקראת על ידי משתנה הסביבה VTV_LOGS_DIR
אם זה מוגדר או ספריית העבודה הנוכחית אחרת.

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

-fvtv-ספירות
זהו דגל ניפוי באגים. בשימוש בשילוב עם -fvtable-verify=std or
-fvtable-verify=preinit, זה גורם למהדר לעקוב אחר המספר הכולל של
שיחות וירטואליות שהוא נתקל בו ומספר האימותים שהוא מוסיף. זה גם
סופר את מספר הקריאות לפונקציות מסוימות של ספריית זמן ריצה שהוא מוסיף ו
רושם מידע זה עבור כל יחידת הידור. המהדר כותב את המידע הזה
לקובץ בשם vtv_count_data.log בספרייה הנקראת על ידי משתנה הסביבה
VTV_LOGS_DIR אם זה מוגדר או ספריית העבודה הנוכחית אחרת. זה גם
סופר את הגודל של ערכות המצביעים vtable עבור כל מחלקה, וכותב מידע זה
ל vtv_class_set_sizes.log באותה ספרייה.

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

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

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

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

-וואבי (C, Objective-C, C++ ו-Objective-C++ בלבד)
כאשר מפורש -fabi-version=n בשימוש, גורם ל-G++ להתריע כאשר הוא יוצר
קוד שככל הנראה אינו תואם ל-C++ ABI ניטרלי לספק. מאז G++ עכשיו
ברירת מחדל ל -fabi-version=0, -וואבי אין השפעה אלא אם כן גרסת ABI ישנה יותר כן
נבחר (עם -fabi-version=n) או נבחרה גרסת תאימות ישנה יותר (עם
-וואבי=n or -fabi-compat-version=n).

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

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

-וואבי ניתן להשתמש גם עם מספר גרסה מפורש כדי להתריע על תאימות
עם מסוים -גרסת פאבי רמה, למשל -וואבי=2 להתריע על שינויים ביחס ל
-fabi-version=2. ציון מספר גרסה גם קובע -fabi-compat-version=n.

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

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

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

זה תוקן ב -fabi-version=3.

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

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

* "__attribute ((const))" ו-"noreturn" עונו כסממני סוג, וכן
"decltype" של הצהרה פשוטה היה מקופל.

בעיות התרסקות אלה תוקנו ב -fabi-version=5.

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

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

בעיות אלו תוקנו ב -fabi-version=6.

* למבדות בהיקף ארגומנט ברירת המחדל טופלו בצורה שגויה, וה-ABI השתנה
הרסנית של "nullptr_t".

בעיות אלו תוקנו ב -fabi-version=7.

* כאשר משבשים סוג פונקציה עם function-cv-qualifiers, ה-un-qualified
סוג הפונקציה טופל באופן שגוי כמועמד להחלפה.

זה תוקן ב -fabi-version=8.

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

* עבור SysV/x86-64, איגודים עם חברים "כפולים ארוכים" מועברים בזיכרון כ
המצוין ב-psABI. לדוגמה:

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

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

-תג וואבי (C++ ו-Objective-C++ בלבד)
אזהרה כאשר נעשה שימוש בסוג עם תג ABI בהקשר שאין בו תג ABI.
לִרְאוֹת C + + תכונות למידע נוסף על תגי ABI.

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

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

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

#define __STDC_FORMAT_MACROS
#לִכלוֹל
#לִכלוֹל

int main () {
int64_t i64 = 123;
printf("My int64: %"PRId64"\n", i64);
}

במקרה זה, "PRId64" מטופל כאסימון עיבוד מקדים נפרד.

אזהרה זו מופעלת כברירת מחדל.

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

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

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

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

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

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

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

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

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

-פקס-מספרי-מילוליים (C++ ו-Objective-C++ בלבד)
קבל סיומות מספרים מילוליים דמיוניים, נקודות קבועות או מוגדרות במכונה כ-GNU
הרחבות. כאשר אפשרות זו כבויה, הסיומות הללו מטופלות כ-C++11 משתמש-
הגדירו סיומות מספריות מילוליות. זה מופעל כברירת מחדל עבור כל הדיאלקטים שלפני C++11
וכל הדיאלקטים של גנו: 98. std = c ++, -std=gnu++98, -std=gnu++11, -std=gnu++14. זֶה
האפשרות כבויה כברירת מחדל עבור ISO C++11 ואילך (11. std = c ++,...).

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

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

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

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

* תבקש מ-"operator=" להחזיר הפניה ל*זה.

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

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

* לעולם אל תעמיס יתר על המידה "&&", "||", או ",".

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

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

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

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

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

אפשרויות שליטה 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, ולא על אלה
בירושה ממעמדות-על. באחריות זמן הריצה של Objective-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("...")" ללא קשר לאפשרויות שורת הפקודה.

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

-fivar-visibility=[ציבורי|מוּגָן|פְּרָטִי|חבילה]
הגדר את הנראות של משתנה המופע המוגדר כברירת מחדל לאפשרות שצוינה כך שהמופע הזה
משתנים שהוכרזו מחוץ לתחום של כל הוראות שינוי גישה ברירת המחדל ל-
הנראות שצוינה.

-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 המתארת ​​את המבנה הגדול ביותר שמועבר לפי ערך, אם בכלל.

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

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

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

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

-fdiagnostics-color[=כאשר]
-fno-אבחון-צבע
השתמש בצבע באבחון. כאשר is לעולם לא, תמיד, או המכונית. ברירת המחדל תלויה כיצד
המהדר הוגדר, זה יכול להיות כל אחד מהדברים לעיל כאשר אפשרויות או גם
לעולם לא if GCC_COLORS משתנה סביבה אינו קיים בסביבה, ו המכונית
אחרת. המכונית פירושו להשתמש בצבע רק כאשר השגיאה הסטנדרטית היא מסוף. ה
צורות -fdiagnostics-color ו -fno-אבחון-צבע הם כינויים עבור
-fdiagnostics-color=תמיד ו -fdiagnostics-color=אף פעם, בהתאמה.

הצבעים מוגדרים על ידי משתנה הסביבה GCC_COLORS. הערך שלו הוא נקודתיים-
רשימה מופרדת של יכולות ו-Select Graphic Rendition (SGR) משנה מחרוזות. SGR
הפקודות מתפרשות על ידי אמולטור הטרמינל או המסוף. (ראה את הסעיף ב
התיעוד של מסוף הטקסט שלך עבור ערכים מותרים ומשמעויותיהם כ
תכונות תו.) ערכי המחרוזת המשנה הללו הם מספרים שלמים בייצוג עשרוני
וניתן לשרשר אותו עם נקודה-פסיק. ערכים נפוצים לשרשור כוללים 1 ל
נוֹעָז, 4 עבור קו תחתון, 5 למצמוץ, 7 עבור הפוך, 39 עבור צבע קדמי ברירת מחדל, 30
ל 37 עבור צבעי קדמה, 90 ל 97 עבור צבעי קדמה של מצב 16 צבעים, 38; 5; 0 ל
38; 5; 255 עבור צבעי קדמה של 88 צבעים ו-256 צבעים, 49 לרקע ברירת מחדל
צֶבַע, 40 ל 47 עבור צבעי רקע, 100 ל 107 עבור צבעי רקע במצב 16 צבעים,
ו 48; 5; 0 ל 48; 5; 255 עבור צבעי רקע של 88 צבעים ו-256 צבעים.

ברירת המחדל GCC_COLORS is

error=01;31:warning=01;35:note=01;36:caret=01;32:locus=01:quote=01

איפה 01; 31 הוא אדום מודגש, 01; 35 הוא מגנטה מודגש, 01; 36 הוא ציאן מודגש, 01; 32 הוא נועז
ירוק ו 01 הוא נועז. הגדרה GCC_COLORS למחרוזת הריקה משבית צבעים.
היכולות הנתמכות הן כדלקמן.

"שגיאה="
מחרוזת משנה SGR לשגיאה: סמנים.

"אזהרה="
מחרוזת משנה SGR לאזהרה: סמנים.

"הערה="
מחרוזת משנה SGR עבור הערה: סמנים.

"caret="
מחרוזת משנה SGR עבור קו קרט.

"locus="
מחרוזת משנה SGR למידע על מיקום, קובץ: שורה or file:line:column וכו '

"ציטוט="
מחרוזת משנה SGR למידע המודפס בתוך ציטוטים.

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

-fno-diagnostics-show-caret
כברירת מחדל, כל אבחון שנפלט כולל את שורת המקור המקורית וסימן '^'
מציין את העמודה. אפשרות זו מדחיקה מידע זה. שורת המקור היא
קטוע ל n תווים, אם ה -fmessage-length=n ניתנת אפשרות. כאשר הפלט
נעשה למסוף, הרוחב מוגבל לרוחב שניתן על ידי ה עמודים
משתנה סביבה או, אם לא מוגדר, לרוחב הטרמינל.

אפשרויות ל בקש 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 ++ ניב אפשרויות.

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

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

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

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

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

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

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

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

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

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

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

-כתובת -Warray-bounds=1 (רק עם -O2) -Wc++11-compat -Wc++14-compat
-Wchar-מנויים -וונום-השוו (ב-C/ObjC; זה מופעל כברירת מחדל ב-C++)
-מוכר (C ו-Objective-C בלבד) -הצהרה-פונקציונלית (C ו
Objective-C בלבד) -הערה - -מיין (רק עבור C/ObjC אלא אם כן
-עומד בפני עצמו) -אולי-לא אתחול -חסר-פלטה (רק עבור C/ObjC) -Wnonnull
-Wopenmp-simd -סוגריים -סימן 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 * רדיוס * רדיוס;
}

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

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

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

-Wformat=1
-
אפשרות - שווה -Wformat=1, ו -ללא פורמט שווה
-Wformat=0. מאז - גם בודק ארגומנטים של פורמט null עבור כמה
פונקציות, - גם מרמז -Wnonnull. כמה היבטים של רמת פורמט זו
ניתן לבטל את הבדיקה על ידי האפשרויות: -Wno-format-contains-nul,
-Wno-format-extra-args, ו -אין-פורמט-אפס-אורך. - מופעל על ידי
- קיר.

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

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

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

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

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

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

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

-חתימות Wformat
If - מצוין, גם הזהיר אם מחרוזת הפורמט דורשת סימן לא חתום
טיעון והטיעון חתום ולהיפך.

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

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

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

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

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

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

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

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

-מוכר (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 -Wpedantic.

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

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++.

-Wno-return-local-addr
אל תזהיר על החזרת מצביע (או ב-C++, הפניה) למשתנה שהולך
מחוץ לטווח לאחר שהפונקציה חוזרת.

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

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

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

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

-Wshift-count-overflow
אזהרה אם ספירת משמרות >= רוחב הסוג. אזהרה זו מופעלת כברירת מחדל.

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

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

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

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

מתג ((int) (a == 4))
{
...
}

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

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

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

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

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

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

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

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

-Warray-bounds=1
זו רמת האזהרה של -גבולות המלחמה והוא מופעל על ידי - קיר; שלבים גבוהים
אינם, ויש לבקשם במפורש.

-Warray-bounds=2
רמת אזהרה זו מזהירה גם על גישה מחוץ לתחום עבור מערכים בסוף
מבנה ועבור מערכים אליהם ניתן לגשת באמצעות מצביעים. רמת אזהרה זו עשויה לתת א
מספר גדול יותר של תוצאות חיוביות שגויות ומושבת כברירת מחדל.

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

int n = 5;
...
if ((n > 1) == 2) { ... }

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

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

-Wno-discarded-array-qualifiers (C ו-Objective-C בלבד)
אל תזהיר אם קיימים מוקדי סוג במערכים שהם יעדי מצביע
מוּשׁלָך. בדרך כלל, המהדר מזהיר אם משתנה "const int (*)[]" מועבר אל
פונקציה שלוקחת פרמטר "int (*)[]". ניתן להשתמש באפשרות זו כדי לדכא
אזהרה כזו.

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

-Wno-int-conversion (C ו-Objective-C בלבד)
אל תזהיר על המרות לא תואמות של מספר שלם למצביע ומצביע למספר שלם.
אזהרה זו נוגעת להמרות מרומזות; להמרות מפורשות האזהרות
-Wno-int-to-pointer-cast ו -אין-מצביע ל-int-cast עשוי להיות בשימוש.

-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 עשה זאת
מספיק הקשר כדי למנוע אזהרה במקרים אלה.

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

* להצהרת "switch" יש אופרנד מסוג "long".

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

-וונדף
אזהרה אם מזהה לא מוגדר מוערך בהנחיית "#if".

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

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

-Wno-shadow-ivar (מטרה-C בלבד)
אין להזהיר בכל פעם שמשתנה מקומי מצל משתנה מופע ב-Objective-C
שִׁיטָה.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-Wc99-c11-compat (C ו-Objective-C בלבד)
הזהר לגבי תכונות שאינן קיימות ב-ISO C99, אך קיימות ב-ISO C11. לדוגמה,
התריעו על שימוש במבנים ובאיגודים אנונימיים, מוקדמות מסוג "_Atomic",
מפרט מחלקת האחסון "_Thread_local", מפרט "_Alignas", אופרטור "Alignof",
מילת מפתח "_Generic", וכן הלאה. אפשרות זו אינה תלויה במצב הסטנדרטים.
אזהרות מושבתות בביטוי שאחרי "__extension__".

-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. אזהרה זו
מדליק -מצמצם והוא מופעל על ידי - קיר.

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

-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" או "vfork". אזהרה זו היא
מופעל גם על ידי אקסטרה.

- נתמך בתנאי (C++ ו-Objective-C++ בלבד)
אזהרה על מבנים הנתמכים על תנאי (C++11 [intro.defs]).

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

אופרטור void מחק (void *) noexcept;
אופרטור void delete[] (void *) noexcept;

ללא הגדרה של פונקציית ההקצאה בגודל המתאימה

אופרטור void delete (void *, std::size_t) noexcept;
אופרטור void delete[] (void *, std::size_t) noexcept;

או להפך. מופעל על ידי אקסטרה יחד עם -fsized-deallocation.

-Wsizeof-pointer-memaccess
התריע על פרמטרי אורך חשודים לפונקציות מסוימות המובנות במחרוזת וזיכרון
אם הטיעון משתמש ב-"sizeof". אזהרה זו מזהירה למשל לגבי "memset (ptr, 0, sizeof
(ptr));" אם "ptr" אינו מערך, אלא מצביע, ומציע תיקון אפשרי, או
על "memcpy (&foo, ptr, sizeof (&foo));". אזהרה זו מופעלת על ידי - קיר.

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

-Wmemset-transposed-args
אזהרה מפני קריאות חשודות לפונקציה המובנית "ממסט", אם הארגומנט השני הוא
לא אפס והארגומנט השלישי הוא אפס. זה מזהיר למשל@ לגבי "memset (buf, sizeof
buf, 0)" שבו ככל הנראה התכוונה "ממסט (buf, 0, sizeof buf)" במקום זאת.
אבחון נפלט רק אם הארגומנט השלישי הוא אפס מילולי. אם זה חלק
ביטוי שמקופל לאפס, גבס של אפס לסוג כלשהו וכו', זה הרבה פחות
סביר להניח שהמשתמש החליף בטעות את הטיעונים ולא נשלחת אזהרה.
אזהרה זו מופעלת על ידי - קיר.

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

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

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

int a;
...
if (!a > 1) { ... }

אפשר לדכא את האזהרה על ידי עטיפה של ה-LHS בסוגריים:

if ((!a) > 1) { ... }

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

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

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

ב-C++ אפשרות זו אינה מזהירה גם על האתחול הריק { }, למשל:

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

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

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

- מנורמל[=<אף לא אחד|id|NFC|nfkc>]
ב-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=אין or
-לא מנורמל. עליך לעשות זאת רק אם אתה משתמש בנורמליזציה אחרת
סכמה (כמו "D"), כי אחרת אתה יכול בקלות ליצור באגים שהם פשוטו כמשמעו
בלתי אפשרי לראות.

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

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

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

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

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

-Wopenmp-simd
אזהרה אם מודל עלות הווקטורייזר עוקף את ההנחיה OpenMP או Cilk Plus simd
מוגדר על ידי המשתמש. ה -fsimd-cost-model=unlimited ניתן להשתמש באפשרות כדי להרגיע את העלות
מודל.

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

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

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

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

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

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

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

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

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

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

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

-ולונג-ארוך
אזהרה אם נעשה שימוש בסוג "ארוך ארוך". זה מופעל על ידי אחד מהם -Wpedantic or
-מסורתי במצבי ISO C90 ו-C++98. כדי לבלום את הודעות האזהרה, השתמש
-לא ארוך-ארוך.

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

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

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

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

-Wvla
אזהרה אם נעשה שימוש במערך אורך משתנה בקוד. -Wno-vla מונע את -Wpedantic
אזהרה על מערך האורך המשתנה.

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

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

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

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

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

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

אפשרות זו משתמעת מ -Wpedantic, וניתן לנטרל באמצעות
-לא-אורך יתר-מיתרים.

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

-Wno-designated-init (C ו-Objective-C בלבד)
דחק אזהרות כאשר נעשה שימוש באתחול מיקום לאתחול מבנה
סומן בתכונה "designated_init".

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

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

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

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

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

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

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

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

-gpubnames
צור קטעי .debug_pubnames ו-.debug_pubtypes ננסיים.

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

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

-fdebug-types-section
בעת שימוש ב-DWARF גרסה 4 ומעלה, ניתן להכניס את הסוג DIEs לעצמם
הקטע ".debug_types" במקום להפוך אותם לחלק מקטע ".debug_info". זה
יעיל יותר להכניס אותם לקטעי comdat נפרדים מכיוון שהמקשר יכול אז
להסיר כפילויות. אבל עדיין לא כל צרכני DWARF תומכים בקטעי ".debug_types".
ובחלק מהאובייקטים ".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 (אם זה נתמך). הערך של
גרסה יכול להיות 2, 3, 4 או 5; גרסת ברירת המחדל עבור רוב המטרות היא 4. DWARF
גרסה 5 היא ניסיונית בלבד.

שים לב שעם 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 סטנדרטית מאוחרת יותר מזו שנבחרה עם
-גמד-גרסה.

-gz[=סוג]
הפק קטעי ניפוי באגים דחוסים בפורמט DWARF, אם זה נתמך. אם סוג is
לא ניתן, סוג ברירת המחדל תלוי ביכולות של ההרכב והמקשר
מְשׁוּמָשׁ. סוג עשוי להיות אחד מהם אף לא אחד (אל תדחס קטעי ניפוי באגים), zlib (השתמש ב- zlib
דחיסה בפורמט ELF gABI), או zlib-gnu (השתמש בדחיסת zlib ב-GNU המסורתי
פוּרמָט). אם המקשר אינו תומך בכתיבת קטעי ניפוי באגים דחוסים, האפשרות
נדחה. אחרת, אם ההרכב אינו תומך בהם, -gz הוא בשקט
התעלמו בעת הפקת קבצי אובייקט.

-gvms
הפק מידע איתור באגים בפורמט ניפוי באגים Alpha/VMS (אם זה נתמך). זֶה
הוא הפורמט שבו משתמש DEBUG במערכות Alpha/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.

-fsanitize=כתובת
הפעל את AddressSanitizer, גלאי שגיאות זיכרון מהיר. הוראות גישה לזיכרון הן
מכשיר לאיתור באגים מחוץ לתחום ובאגים לאחר שימוש ללא תשלום. לִרְאוֹת
<https://github.com/google/sanitizers/wiki/AddressSanitizer> לפרטים נוספים. ה
ניתן להשפיע על התנהגות בזמן ריצה באמצעות ASAN_OPTIONS משתנה הסביבה. מתי
מוגדר ל-"help=1", האפשרויות הזמינות מוצגות בעת ההפעלה של המכשיר
תכנית. לִרְאוֹת
<https://github.com/google/sanitizers/wiki/AddressSanitizerFlags#run-time-flags> עבור א
רשימה של אפשרויות נתמכות.

-fsanitize=כתובת הקרנל
הפעל את AddressSanitizer עבור ליבת לינוקס. לִרְאוֹתhttps://github.com/google/kasan/wiki>
לקבלת פרטים נוספים.

-fsanitize=חוט
הפעל את ThreadSanitizer, גלאי מירוץ נתונים מהיר. הוראות גישה לזיכרון הן
מכשיר לזיהוי באגים במירוץ נתונים. לִרְאוֹת
<https://github.com/google/sanitizers/wiki#threadsanitizer> לפרטים נוספים. הריצה-
ניתן להשפיע על התנהגות הזמן באמצעות TSAN_OPTIONS משתנה הסביבה; לִרְאוֹת
<https://github.com/google/sanitizers/wiki/ThreadSanitizerFlags> לרשימה של
אפשרויות נתמכות.

-fsanitize=דליפה
אפשר LeakSanitizer, גלאי דליפות זיכרון. אפשרות זו חשובה רק לקישור של
קובצי הפעלה ואם אף אחד מהם -fsanitize=כתובת ולא -fsanitize=חוט משמש. בתוך זה
במקרה שבו קובץ ההפעלה מקושר לספרייה שעוקפת את "malloc" ואחרות
פונקציות מקצה. לִרְאוֹת
<https://github.com/google/sanitizers/wiki/AddressSanitizerLeakSanitizer> לעוד
פרטים. ניתן להשפיע על התנהגות זמן הריצה באמצעות ה LSAN_OPTIONS סביבה
משתנה

-fsanitize=לא מוגדר
אפשר את UndefinedBehaviorSanitizer, גלאי התנהגות לא מוגדר מהיר. שׁוֹנִים
חישובים מוקנים כדי לזהות התנהגות לא מוגדרת בזמן ריצה. נוֹכְחִי
אפשרויות המשנה הן:

-fsanitize=shift
אפשרות זו מאפשרת לבדוק שהתוצאה של פעולת משמרת אינה
לא מוגדר. שימו לב שמה בדיוק נחשב לא מוגדר שונה מעט
בין C ל-C++, וכן בין ISO C90 ל-C99 וכו'.

-fsanitize=מספר שלם-חלק-באפס
זיהוי חלוקה של מספרים שלמים באפס וכן חלוקה של "INT_MIN / -1".

-fsanitize=לא ניתן להגיע
עם אפשרות זו, המהדר הופך את הקריאה "__builtin_unreachable" ל-a
שיחת הודעת אבחון במקום זאת. כשמגיעים לשיחה "__builtin_unreachable",
ההתנהגות אינה מוגדרת.

-fsanitize=vla-bound
אפשרות זו מורה למהדר לבדוק שהגודל של אורך משתנה
המערך חיובי.

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

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

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

חתום char a = SCHAR_MAX;
a ++;

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

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

-fsanitize=גודל אובייקט
אפשרות זו מאפשרת מכשור של הפניות זיכרון באמצעות
הפונקציה "__builtin_object_size". גישות מצביעים שונות מחוץ לתחום הן
זוהה.

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

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

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

-fsanitize=מחזירה-nonnull-תכונה
אפשרות זו מאפשרת מכשור של הצהרות החזרה בפונקציות המסומנות ב
תכונת הפונקציה "returns_nonnull", לזיהוי החזרה של ערכי null מכאלה
פונקציות.

-fsanitize=bool
אפשרות זו מאפשרת מכשור של עומסים מ-bool. אם ערך שונה מ-0/1
נטען, מונפקת שגיאת זמן ריצה.

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

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

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

-fno-sanitize=הכל
אפשרות זו משביתה את כל חומרי החיטוי שהופעלו בעבר. -fsanitize=הכל לא
מותר, מכיוון שלא ניתן להשתמש בחומרי חיטוי מסוימים יחד.

-fasan-shadow-offset=מספר
אפשרות זו מאלצת את GCC להשתמש בהיסט צל מותאם אישית בבדיקות AddressSnitizer. זה
שימושי להתנסות בפריסות שונות של זיכרון צל ב-Kernel
AddressSnitizer.

-הסניטציה-להתאושש[=בוחר]
-fsanitize-recover= שולט במצב שחזור שגיאות עבור חומרי חיטוי המוזכרים בפסיקים-
רשימה מופרדת של בוחר. הפעלת אפשרות זו עבור רכיב חיטוי גורם לכך
נסה להמשיך להפעיל את התוכנית כאילו לא קרתה שגיאה. זה אומר מרובה
ניתן לדווח על שגיאות בזמן ריצה בהפעלת תוכנית אחת, ואת קוד היציאה של ה-
התוכנית עשויה להצביע על הצלחה גם כאשר שגיאות דווחו. ה
-fno-sanitize-recover= ניתן להשתמש באפשרות כדי לשנות התנהגות זו: רק הראשונה
שגיאה שזוהתה מדווחת והתוכנית יוצאת עם קוד יציאה שאינו אפס.

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

תחביר ללא מפורש בוחר הפרמטר הוצא משימוש. זה שווה ערך ל

-fsanitize-recover=undefined,float-cast-overflow,float-חלק באפס

באופן דומה -fno-sanitize-recover שווה

-fno-sanitize-recover=undefined,float-cast-overflow,float-חלק באפס

-fsanitize-undefined-trap-on-error
השמיים -fsanitize-undefined-trap-on-error option מורה למהדר לדווח
התנהגות לא מוגדרת באמצעות "__builtin_trap" ולא בשגרת ספריית "libubsan".
היתרון בכך הוא שאין צורך בספריית "libubsan" ואינה מקושרת
ב, אז זה שמיש אפילו בסביבות עצמאיות.

-fcheck-pointer-bounds
אפשר מכשור בודק Pointer Bounds. כל התייחסות לזיכרון היא מכשירנית
עם בדיקות של המצביע המשמש לגישה לזיכרון מול גבולות הקשורים לכך
מַצבִּיעַ.

נכון לעכשיו יש רק יישום עבור Intel MPX זמין, ולכן x86 target ו
-mmpx נדרשים כדי להפעיל תכונה זו. מכשור מבוסס MPX דורש א
ספריית זמן ריצה כדי לאפשר MPX בחומרה ולטפל באותות הפרת גבולות. על ידי
ברירת מחדל מתי -fcheck-pointer-bounds ו -mmpx משתמשים באפשרויות לקישור תוכנית, ה
קישורי מנהלי התקן GCC נגד libmpx ספריית זמן ריצה ו libmpxwrappers סִפְרִיָה. זה
מעביר גם '-z bndplt' למקשר למקרה שהוא תומך באפשרות זו (שמסומנת
על תצורת libmpx). שים לב שגרסאות ישנות של קישור עשויות להתעלם מהאפשרות. זהב
מקשר אינו תומך באפשרות '-z bndplt'. ללא תמיכה ב-'-z bndplt' ב-linker הכל
קריאות לספריות דינמיות מאבדות גבולות שעברו, מה שמפחית את רמת ההגנה הכוללת. שֶׁלָה
מומלץ מאוד להשתמש במקשר עם תמיכה ב-'-z bndplt'. במקרה שמקשר כזה אינו
זמין, מומלץ להשתמש בו תמיד -static-libmpxwrappers להגנה טובה יותר
רמה או שימוש -סטָטִי להימנע לחלוטין מקריאות חיצוניות לספריות דינמיות. MPX-
מכשור מבוסס עשוי לשמש לניפוי באגים וגם עשוי להיכלל בייצור
קוד להגברת אבטחת התוכנית. בהתאם לשימוש, ייתכן שיש לך שונה
דרישות עבור ספריית זמן הריצה. הגרסה הנוכחית של ספריית זמן הריצה MPX
מכוון יותר לשימוש ככלי איתור באגים. שימוש בספריית זמן ריצה MPX מרמז
-פתיל. ראה גם -static-libmpx. ניתן להשפיע על התנהגות ספריית זמן הריצה
באמצעות שונות CHKP_RT_* משתני סביבה. לִרְאוֹת
<https://gcc.gnu.org/wiki/Intel%20MPX%20support%20in%20the%20GCC%20compiler> לעוד
פרטים.

מכשור שנוצר עשוי להיות נשלט על ידי שונים -fchkp-* אפשרויות ולפי ה
תכונת השדה "bnd_variable_size" ו-"bnd_legacy" ו-"bnd_instrument"
תכונות פונקציה. GCC מספק גם מספר פונקציות מובנות לשליטה
בודק גבולות המצביע.

-fchkp-check-incomplete-type
צור בדיקות גבולות מצביע עבור משתנים עם סוג לא שלם. מופעל על ידי
ברירת המחדל.

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

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

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

-fchkp-אופטימיזציה
מאפשר אופטימיזציות של בודק Pointer Bounds. מופעל כברירת מחדל בעת אופטימיזציה
רמות -O, -O2, -O3.

-fchkp-use-fast-string-functions
מאפשר שימוש בגרסאות *_nobnd של פונקציות מחרוזת (לא העתקת גבולות) על ידי Pointer
בודק גבולות. מושבת כברירת מחדל.

-fchkp-use-nochk-string-functions
מאפשר שימוש בגרסאות *_nochk של פונקציות מחרוזת (לא בדיקת גבולות) על ידי Pointer
בודק גבולות. מושבת כברירת מחדל.

-FCHKP-USE-STATIC-HAUNDS
אפשר ל-Pointer Bounds Checker ליצור גבולות סטטיים המכילים גבולות סטטיים
משתנים. מופעל כברירת מחדל.

-fchkp-use-static-const-bounds
השתמש בגבולות מאתחלים סטטית עבור גבולות קבועים במקום ליצור אותם כל אחד
הזמן שהם נדרשים. כברירת מחדל מופעל כאשר -FCHKP-USE-STATIC-HAUNDS מאופשר.

-fchkp-treat-zero-dynamic-size-as-infinity
עם אפשרות זו, אובייקטים עם סוג לא שלם שגודלם שהושג באופן דינמי הוא אפס
מטופלים כבעלי גודל אינסופי במקום זאת על ידי בודק Pointer Bounds. אפשרות זו
עשוי להיות מועיל אם תוכנית מקושרת עם ספרייה חסר מידע על גודל עבור חלק
סמלים. מושבת כברירת מחדל.

-fchkp-check-read
מורה ל-Pointer Bounds Checker ליצור בדיקות עבור כל גישת הקריאה לזיכרון.
מופעלת כברירת מחדל.

-פצ'ק-צ'ק-וריט
מורה ל-Pointer Bounds Checker ליצור בדיקות עבור כל גישת הכתיבה לזיכרון.
מופעלת כברירת מחדל.

-fchkp-store-bounds
מורה ל-Pointer Bounds Checker ליצור מאגרי גבולות עבור כתיבת מצביע.
מופעלת כברירת מחדל.

-fchkp-מכשיר-שיחות
מורה ל-Pointer Bounds Checker להעביר את גבולות המצביע לשיחות. מופעל כברירת מחדל.

-fchkp-מכשיר-מסומן-בלבד
מורה ל-Pointer Bounds Checker למכשיר רק פונקציות המסומנות ב-
מאפיין "bnd_instrument". מושבת כברירת מחדל.

-fchkp-use-wrappers
מאפשר ל-Pointer Bounds Checker להחליף שיחות לפונקציות מובנות בקריאות אל
פונקציות עטיפה. מתי -fchkp-use-wrappers משמש לקישור תוכנית, מנהל ההתקן של GCC
קישור אוטומטי נגד libmpxwrappers. ראה גם -static-libmpxwrappers. מופעל
כברירת מחדל.

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

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

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

-fprofile-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)" מחזיר אמת רק עבור 10 הראשונים
קריאות.

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

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

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

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

-ניתן-איפא-לעבור
אפשר אישור IPA לעבור. לעבור הוא שם המעבר. אם אותו מעבר הוא סטטי
מופעל במהדר מספר פעמים, לשם המעבר יש לצרף א
מספר רציף החל מ-1.

-ניתן-rtl-לעבור
-ניתן-rtl-לעבור=רשימת טווחים
אפשר מעבר RTL לעבור. לראות -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-לעבור
-fdump-rtl-לעבור=שם הקובץ
אומר לבצע dumps לניפוי באגים במהלך הקומפילציה בזמנים שצוינו על ידי אותיות. זֶה
משמש לאיתור באגים במעברים מבוססי RTL של המהדר. שמות הקבצים לרוב
מההשלכות מתבצעות על ידי הוספת מספר מעבר ומילה ל- שם dump, וה
קבצים נוצרים בספרייה של קובץ הפלט. במקרה =שם הקובץ אוֹפְּצִיָה,
ה-dump מופק בקובץ הנתון במקום קבצי ה-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-sched1
-fdump-rtl-sched2
-fdump-rtl-sched1 ו -fdump-rtl-sched2 אפשר השלכה לאחר החסימה הבסיסית
תזמון עוברים.

-fdump-rtl-ree
dump אחרי סימן/ביטול הארכת אפס.

-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-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 ביאור.

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

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

-לדווח-באג
אסוף והשלך מידע על ניפוי באגים לקובץ זמני אם ICE במהדר C/C++
התרחש.

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

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

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

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

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

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

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

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

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

אבני
אפשר הצגת גבולות בלוקים בסיסיים (מושבת ב-raw dumps).

גרף
עבור כל אחד מקבצי ה-dump האחרים שצוינו (-fdump-rtl-לעבור), לזרוק א
ייצוג של גרף זרימת הבקרה המתאים לצפייה עם GraphViz to
file.passid.pass.dot. כל פונקציה בקובץ מודפסת יפה כתת-גרף,
כך ש-GraphViz יוכל לעבד את כולם בעלילה אחת.

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

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

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

uid אפשר הצגת המזהה הייחודי ("DECL_UID") עבור כל משתנה.

מִלוּלִי
אפשר הצגת dump העץ עבור כל הצהרה.

eh אפשר הצגת מספר אזור ה-EH המחזיק כל הצהרה.

scev
אפשר הצגת פרטי ניתוח אבולוציה סקלרית.

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

החטיא
אפשר הצגת פרטי אופטימיזציה שהוחמצו (זמין רק במעברים מסוימים).

הערות
אפשר מידע אופטימיזציה מפורט אחר (זמין רק במעברים מסוימים).

=שם הקובץ
במקום קובץ dump אוטומטי בשם, פלט לשם הקובץ הנתון. הקובץ
שמות stdout ו סטדרר מטופלים במיוחד ונחשבים כבר פתוחים
זרמים סטנדרטיים. לדוגמה,

gcc -O2 -ftree-vectorize -fdump-tree-vect-blocks=foo.dump
-fdump-tree-pre=stderr file.c

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

את כל הפעל את כל האפשרויות, מלבד חי, רָזֶה, מִלוּלִי ו לינו.

optall
הפעל את כל אפשרויות האופטימיזציה, כלומר, אופטימיזציה, החטיא, ו הערות.

השלכות העצים הבאות אפשריות:

מְקוֹרִי
לזרוק לפני כל אופטימיזציה מבוססת עץ, כדי file.original.

אופטימיזציה
לזרוק אחרי הכל עץ מבוסס אופטימיזציה, כדי file.optimized.

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

cfg זרוק את גרף זרימת הבקרה של כל פונקציה לקובץ. שם הקובץ נוצר על ידי
מצרף .cfg לשם קובץ המקור.

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 לשם קובץ המקור.

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

-fopt-info
-fopt-info-אפשרויות
-fopt-info-אפשרויות=שם הקובץ
שולט על זריקות אופטימיזציה ממעברי אופטימיזציה שונים. אם ה -אפשרויות הצורה היא
בשימוש, אפשרויות היא רשימה של - מילות מפתח אפשרויות מופרדות לבחירת פרטי ה-dump ו
אופטימיזציות.

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

האפשרויות הבאות שולטות במילוליות ה-dump:

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

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

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

את כל הדפס מידע אופטימיזציה מפורט. זה כולל אופטימיזציה, החטיא, ו
הערות.

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

Ipa אפשר dumps מכל האופטימיזציות הבין-הליכים.

לולאה
אפשר dumps מכל אופטימיזציות הלולאה.

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

vec אפשר dumps מכל האופטימיזציות של וקטוריזציה.

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

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

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

שימו לב שהפלט שם הקובץ מוחלף במקרה של מספר יחידות תרגום. אם
רצוי פלט משולב ממספר יחידות תרגום, סטדרר יש להשתמש
במקום.

בדוגמה הבאה, מידע האופטימיזציה מופלט אל סטדרר:

gcc -O3 -fopt-info

דוגמה זו:

GCC -O3 -fopt -Info -missed = החמצה.

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

gcc -O2 -ftree-vectorize -fopt-info-vec-missed

מדפיס מידע על הזדמנויות אופטימיזציה שהוחמצו ממעברי וקטוריזציה
on סטדרר. שים לב ש -fopt-info-vec-missed שווה -fopt-info-missed-vec.

כדוגמה נוספת,

gcc -O3 -fopt-info-inline-optimized-missed=inline.txt

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

לבסוף, שקול:

gcc -fopt-info-vec-missed=vec.miss -fopt-info-loop-optimized=loop.opt

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

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

-מאבר-מעקב-מנתקים-טבגול
למתג -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 עצמו נבנה.)

-fno-eliminate-unused-debug-types
בדרך כלל, בעת הפקת פלט DWARF 2, GCC נמנע מיצירת פלט סמל ניפוי באגים עבור
סוגים שאינם נמצאים בשימוש בשום מקום בקובץ המקור הנערך. לפעמים זה שימושי
לאפשר ל-GCC לפלוט מידע ניפוי באגים עבור כל הסוגים המוצהרים ביחידת קומפילציה,
ללא קשר אם הם משמשים בפועל באותה יחידת הידור או לא, עבור
לדוגמה, אם, ב-debuger, אתה רוצה להטיל ערך לטיפוס שאינו בפועל
משמש בתוכנית שלך (אך מוצהר). עם זאת, לעתים קרובות יותר, זה גורם ל-
כמות משמעותית של שטח מבוזבז.

אפשרויות כי שליטה אופטימיזציה
אפשרויות אלה שולטות בסוגים שונים של אופטימיזציות.

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

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

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

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

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

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

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

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

-O מפעיל את דגלי האופטימיזציה הבאים:

-fauto-inc-dec -fbranch-count-reg -fcombine-stack-adjustments -fcompare-elim
-fcprop-registers -fdce -fdefer-pop -ענף מושהה -fdse -לפנים-להפיץ
-ניחוש-ענף-הסתברות -fif-conversion2 -fif-המרה
-finline-functions-שנקרא פעם אחת -פיפא-טהור-קונסט -fipa-profile -פיפא-התייחסות
-fmerge-constants -fmove-loop-invariants -להכווץ-לעטוף -fsplit-wide-types
-ftree-bit-ccp -ftree-ccp -fssa-phiopt -ftree-ch -ftree-copy-prop -ftree-copyrename
-ftree-dce -ftree-dominator-opts -ftree-dse -ftree-forwprop -ftree-fre -ftree-phiprop
-כיור-ftree -ftree-slsr -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 -fdevirtualize-ספקולטיבית
-זול-אופטימיזציות -fgcse -fgcse-lm -fhoist-סמוך-עומסים
-finline-קטנות-פונקציות -findirect-inlining -fipa-cp -fipa-cp-alignment -פיפא-סרה
-fipa-icf -נתיבות-שגויות-התייחסות -flra-remat -foptimize-אחיות-שיחות
-foptimize-strlen -fpartial-inlining -fpeephole2 -Freord-בלוקים
-לאחר סדר-בלוקים-ו-מחיצה -פקודת-פונקציות -frerun-cse-after-loop
-fsched-interblock -fsched-spec -fschedule-insns -fschedule-insns2 -fstrict-aliasing
-פרקט-הצפה -ftree-builtin-call-dce -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-loop-vectorize, -ftree-loop-distribute-passtrens, -ftree-slp-וקטוריזה,
-fvect-cost-model, -ftree-partial-pre ו -fipa-cp-clone אפשרויות.

-O0 צמצם את זמן ההידור וגרמו לניפוי באגים להניב את התוצאות הצפויות. זה
ברירת המחדל.

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

-אוס משבית את דגלי האופטימיזציה הבאים: -falign-פונקציות -falign-קפיצות
-falign-לולאות -falign-תוויות -Freord-בלוקים -לאחר סדר-בלוקים-ו-מחיצה
-fprefetch-loop-arrays

-אופסט
התעלם מעמידה בתקנים מחמירים. -אופסט מאפשר לכולם -O3 אופטימיזציות. זה גם
מאפשר אופטימיזציות שאינן תקפות עבור כל התוכניות התואמות לתקן. זה
מדליק -מהיר-מתמטיקה והספציפי ל-Fortran -fno-protect-parens ו -fstack-מערכי.

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

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

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

האפשרויות הבאות שולטות באופטימיזציות ספציפיות. הם מופעלים על ידי -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"
שולט אם מכונת יעד תומך בדגל זה.

הגדרת ברירת המחדל (כאשר לא מתבצע אופטימיזציה לגודל) עבור 32 סיביות GNU/Linux x86 ו-32 סיביות
יעדי דרווין x86 הוא -fomit-frame-pointer. אתה יכול להגדיר את GCC עם
--enable-frame-pointer הגדר אפשרות לשנות את ברירת המחדל.

מופעל ברמות -O, -O2, -O3, -אוס.

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

מופעל ברמות -O2, -O3, -אוס.

-foptimize-strlen
בצע אופטימיזציה של פונקציות מחרוזות C סטנדרטיות שונות (למשל "strlen", "strchr" או "strcpy") ו
עמיתיהם "_FORTIFY_SOURCE" שלהם לתוך חלופות מהירות יותר.

מופעל ברמות -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.

מופעל כברירת מחדל ב -O1 וגבוה יותר.

ברירת המחדל היא -fbranch-count-reg.

-fno-function-cse
אין לשים כתובות של פונקציות ברגיסטרים; בצע כל הוראה שקוראת א
פונקציה קבועה מכילה את כתובת הפונקציה במפורש.

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

ברירת המחדל היא -ffunction-cse

-fno-zero-initialized-in-bss
אם היעד תומך בקטע BSS, GCC כברירת מחדל מציבה משתנים שכן
אתחול לאפס לתוך BSS. זה יכול לחסוך מקום בקוד המתקבל.

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

ברירת המחדל היא -fzero-initialized-in-bss.

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

מופעל ברמות -O2, -O3, -אוס.

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

מופעל ברמות -O, -O2, -O3, -אוס.

-fcse-follow-jumps
בחיסול תת-ביטויים נפוצים (CSE), סרוק דרך הוראות קפיצה כאשר
מטרת הקפיצה אינה מושגת בשום נתיב אחר. לדוגמה, כאשר נתקל ב-CSE
הצהרת "if" עם סעיף "else", 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 מופעל, ניסיונות חיסול של תת-ביטויים נפוצים בעולם
עומסים שנהרגים רק על ידי חנויות לתוך עצמם. זה מאפשר לולאה המכילה א
רצף טעינה/חנות שישתנה לעומס מחוץ ללולאה, והעתקה/חנות בתוך
הלולאה.

מופעל כברירת מחדל כאשר -fgcse מאופשר.

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

מופעל ברמות -O, -O2, -O3, -אוס.

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

מופעל ברמות -O, -O2, -O3, -אוס.

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

מופעל על ידי -אוס.

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

עם זאת, שימו לב שבסביבות מסוימות הנחה זו אינה נכונה. להשתמש
-fno-delete-null-pointer-checks כדי להשבית אופטימיזציה זו עבור תוכניות התלויות
על ההתנהגות הזו.

יעדים מסוימים, במיוחד אלה משובצים, משביתים אפשרות זו בכל הרמות. אחרת
זה מופעל בכל הרמות: -O0, -O1, -O2, -O3, -אוס. מעברים המשתמשים במידע
מופעלים באופן עצמאי ברמות אופטימיזציה שונות.

-fdevirtualize
ניסיון להמיר שיחות לפונקציות וירטואליות לשיחות ישירות. זה נעשה גם וגם
במסגרת הליך ובין פרוצדורלי כחלק מהטבעה עקיפה
(-findirect-inlining) והתפשטות מתמדת בין פרוצדורלית (-fipa-cp). מופעל ב-
רמות -O2, -O3, -אוס.

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

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

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

מופעל ברמות -O2, -O3, -אוס.

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

מופעל עבור Alpha, AArch64 ו-x86 ברמות -O2, -O3, -אוס.

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

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

-fira-algorithm=אַלגוֹרִיתְם
השתמש באלגוריתם הצביעה שצוין עבור מקצה האוגר המשולב. ה
אַלגוֹרִיתְם טיעון יכול להיות עדיפות, המציין את צביעה העדיפות של Chow, או CB,
אשר מפרט צביעה Chaitin-Briggs. צביעה Chaitin-Briggs אינה מיושמת
עבור כל הארכיטקטורות, אבל עבור אותם יעדים שתומכים בכך, זוהי ברירת המחדל
כי זה מייצר קוד טוב יותר.

-fira-region=באזור
השתמש באזורים שצוינו עבור מקצה האוגר המשולב. ה באזור טענה
צריך להיות אחד מהבאים:

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

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

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

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

אפשרות זו מופעלת ברמה -אוס לכל המטרות.

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

אפשרות זו מופעלת ברמה -O3 עבור כמה יעדים.

-fno-ira-share-save-slots
השבת שיתוף של חריצי מחסנית המשמשים לשמירת אוגרים קשיחים המשמשים בשיחות
שיחה. כל אוגר קשיח מקבל משבצת מחסנית נפרדת, וכתוצאה מכך מחסנית פונקציות
המסגרות גדולות יותר.

-fno-ira-share-spill-slots
השבת את השיתוף של חריצי מחסנית שהוקצו עבור פסאודו-ריסטרים. כל פסאודו-רישום
שאינו מקבל אוגר קשיח מקבל משבצת מחסנית נפרדת, וכתוצאה מכך פונקציה
מסגרות ערימה גדולות יותר.

-fira-verbose=n
שליטה במילוליות של קובץ ה-dump עבור מקצה האוגר המשולב. ה
ערך ברירת המחדל הוא 5. אם הערך n גדול או שווה ל-10, פלט ה-dump נשלח
כדי stderr באמצעות אותו פורמט כמו n מינוס 10.

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

מופעל ברמות -O2, -O3, -אוס.

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

מופעל ברמות -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 שנתקע
זה מועמד להרחקה מוקדמת מהתור של כניסות שנתקעו. יש לזה
השפעה רק במהלך מעבר התזמון השני, ורק אם -fsched-stalled-insns is
מְשׁוּמָשׁ. -fno-sched-stalled-insns-dep שווה -fsched-stalled-insns-dep=0.
-fsched-stalled-insns-dep ללא ערך שווה ערך ל
-fsched-stalled-insns-dep=1.

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

-fsel-sched-pipelining-outer-loops
כאשר צינורות לולאות במהלך תזמון סלקטיבי, גם צינור לולאות חיצוניות. זֶה
לאופציה אין השפעה אלא אם כן -fsel-sched-pipelining מופעל.

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

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

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

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

מופעל ברמות -O2, -O3, -אוס.

-fcombine-stack-adjustments
עוקב אחר התאמות מחסנית (דחיפות וקפיצות) ומערימה הפניות לזיכרון ולאחר מכן מנסה
למצוא דרכים לשלב ביניהם.

מופעל כברירת מחדל ב -O1 וגבוה יותר.

-פיפא-רה
השתמש ברישומי שמירת המתקשרים להקצאה אם ​​אוגרים אלה אינם בשימוש על ידי אף אחד שנקרא
פוּנקצִיָה. במקרה כזה אין צורך לשמור ולשחזר אותם סביב שיחות.
זה אפשרי רק אם הפונקציות הנקראות הן חלק מאותה יחידת קומפילציה כמו הנוכחית
פונקציה והם מורכבים לפניה.

מופעל ברמות -O2, -O3, -אוס.

-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 וגבוה יותר.

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

-ftree-copy-prop
בצע ריבוי העתקות על עצים. מעבר זה מבטל פעולות העתקה מיותרות.
דגל זה מופעל כברירת מחדל ב -O וגבוה יותר.

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

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

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

-fipa-profile
בצע הפצת פרופיל בין-הליכים. הפונקציות נקראות רק מקור
פונקציות מסומנות כקר. גם פונקציות שבוצעו פעם אחת (כגון "קר",
"norreturn", בנאים סטטיים או הרסנים) מזוהים. פונקציות קרות ו
לולאה פחות חלקים של פונקציות שבוצעו פעם אחת לאחר מכן מותאמים לגודל. מופעל על ידי
ברירת מחדל ב -O וגבוה יותר.

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

-fipa-cp-clone
בצע שיבוט פונקציות כדי להפוך את ההתפשטות הקבועה בין פרוצדורלית לחזקה יותר. מתי
מופעל, התפשטות קבועה בין פרוצדורלית מבצעת שיבוט פונקציות כאשר
ניתן לקרוא לפונקציה גלויה חיצונית עם ארגומנטים קבועים. בגלל זה
אופטימיזציה יכולה ליצור עותקים מרובים של פונקציות, היא עשויה להגדיל באופן משמעותי
גודל קוד (ראה --param ipcp-unit-growth=ערך). דגל זה מופעל כברירת מחדל ב
-O3.

-fipa-cp-alignment
כאשר היא מופעלת, אופטימיזציה זו מפיצה יישור של פרמטרי פונקציה לתמיכה
וקטוריזציה ופעולות מחרוזות טובות יותר.

דגל זה מופעל כברירת מחדל ב -O2 ו -אוס. זה דורש את זה -fipa-cp מאופשר.

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

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

דגל זה מופעל כברירת מחדל ב -O2 ו -אוס.

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

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

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

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

-ftree-ccp
בצע ריבוי קבוע מותנה דליל (CCP) על עצים. המעבר הזה בלבד
פועל על משתנים סקלרים מקומיים ומופעל כברירת מחדל ב- -O וגבוה יותר.

-fssa-phiopt
בצע התאמת דפוסים בצמתי SSA PHI כדי לייעל את הקוד המותנה. המעבר הזה הוא
מופעל כברירת מחדל ב -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-isl כדי לאפשר את
תשתית טרנספורמציה של לולאות גרפיט.

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

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-isl ל
אפשר את תשתית הטרנספורמציה של לולאת גרפיט.

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

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-isl ל
אפשר את תשתית הטרנספורמציה של לולאת גרפיט.

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

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-isl ל
אפשר את תשתית הטרנספורמציה של לולאת גרפיט.

-זהות-fgraphite
אפשר את שינוי הזהות עבור גרפיט. עבור כל SCoP שאנו יוצרים את
ייצוג רב-הדרלי ולהפוך אותו בחזרה לגימפל. באמצעות -זהות-fgraphite
אנו יכולים לבדוק את העלויות או היתרונות של הטרנספורמציה של GIMPLE -> GRAPHITE -> GIMPLE.
כמה אופטימיזציות מינימליות מבוצעות גם על ידי מחולל הקוד ISL, כמו אינדקס
פיצול וביטול קוד מת בלולאות.

-floop-nest-optimize
הפעל את אופטימיזציית קן הלולאה מבוסס ISL. זהו מייעל קן גנרי מבוסס לולאה
על אלגוריתמי האופטימיזציה של פלוטו. הוא מחשב מבנה לולאה המותאם עבורו
נתונים-מקביליות ומקביליות. אפשרות זו היא ניסיונית.

-פלופ-להתגלגל-וגם
הפעל את ה-Urroll and Jam עבור כלי האופטימיזציה של קן הלולאה מבוסס ISL. גורם הפתיחה יכול להיות
השתנה באמצעות לולאה-נפילת-ג'אם-גודל פָּרָמֶטֶר. הממד הנפרש (ספירה
מהפנימי ביותר) ניתן לשנות באמצעות לולאה-פרוש-ריבה-עומק פָּרָמֶטֶר.
.

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

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

-ftree-coalesce-vars
ספר למעבר שם העותק (ראה -ftree-copyrename) כדי לנסות לשלב משתמש קטן-
גם משתנים מוגדרים, במקום רק זמני מהדר. זה עלול להגביל מאוד
היכולת לנפות באגים בתוכנית מותאמת שהידור עם -fno-var-tracking-assignments.
בצורה השלילה, דגל זה מונע התלכדות SSA של משתני משתמש, כולל
משובצים. אפשרות זו מופעלת כברירת מחדל.

-ftree-ter
בצע החלפת ביטוי זמנית במהלך השלב SSA->נורמלי. יחיד
זמני שימוש/הגדרה יחיד מוחלפים במיקום השימוש שלהם עם ההגדרה שלהם
ביטוי. זה מביא לקוד שאינו GIMPLE, אבל נותן למרחיבים הרבה יותר
עצים מורכבים לעבוד עליהם וכתוצאה מכך ליצור RTL טוב יותר. זה מופעל על ידי
ברירת מחדל ב -O וגבוה יותר.

-ftree-slsr
בצע הפחתת חוזק בקו ישר על עצים. זה מזהה קשורים
ביטויים הכוללים כפל ומחליפים אותם בחישובים זולים יותר
כשמתאפשר. זה מופעל כברירת מחדל ב -O וגבוה יותר.

-ftree-vectorize
בצע וקטוריזציה על עצים. דגל זה מאפשר -ftree-loop-vectorize ו
-ftree-slp-וקטוריזה אם לא צוין במפורש.

-ftree-loop-vectorize
בצע וקטוריזציה של לולאה על עצים. דגל זה מופעל כברירת מחדל ב -O3 ומתי
-ftree-vectorize מאופשר.

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

-fvect-cost-model=מודל
שנה את מודל העלות המשמש לוקטוריזציה. ה מודל הטיעון צריך להיות אחד מהם
בלתי מוגבל, דינמי or זול. עם ה בלתי מוגבל דגם נתיב הקוד הווקטורי הוא
ההנחה היא להיות רווחית בעוד עם דינמי דגם בדיקת זמן ריצה שומרת על
נתיב קוד וקטור כדי לאפשר אותו רק עבור ספירות איטרציות שסביר להניח שיבוצעו
מהר יותר מאשר בעת ביצוע הלולאה הסקלרית המקורית. ה זול הדגם משבית
וקטוריזציה של לולאות כאשר ביצוע זה יהיה עלות אוסרנית למשל בשל
נדרש בדיקות זמן ריצה עבור תלות או יישור נתונים, אך חוץ מזה שווה ל-
דינמי דֶגֶם. מודל העלות המוגדר כברירת מחדל תלוי בדגלי אופטימיזציה אחרים והוא
או דינמי or זול.

-fsimd-cost-model=מודל
שנה את מודל העלות המשמש לוקטוריזציה של לולאות המסומנות ב-OpenMP או Cilk
בנוסף הנחיית simd. ה מודל הטיעון צריך להיות אחד מהם בלתי מוגבל, דינמי, זול.
כל הערכים של מודל בעלי אותה משמעות כפי שמתוארת ב -fvect-cost-model ועל ידי
ברירת מחדל מודל עלות מוגדר עם -fvect-cost-model משמש.

-ftree-vrp
בצע ריבוי טווח ערכים על עצים. זה דומה להתפשטות המתמדת
לעבור, אבל במקום ערכים, טווחי ערכים מופצים. זה מאפשר את
אופטימיזציה להסרת בדיקות טווח מיותרות כמו בדיקות מאוגדות מערך ומצביע null
המחאות. זה מופעל כברירת מחדל ב -O2 וגבוה יותר. חיסול בדיקת מצביע אפס
נעשה רק אם -fdelete-null-pointer-checks מאופשר.

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

מופעל עבור x86 ברמות -O2, -O3.

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

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

-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.

הדבר היחיד שחשוב לזכור הוא שכדי לאפשר אופטימיזציות של זמן קישור אתה
צריך להשתמש במנהל ההתקן של GCC כדי לבצע את שלב הקישור. לאחר מכן, GCC מבצע אוטומטית
אופטימיזציה של זמן קישור אם אחד מהאובייקטים המעורבים הורכב עם ה- -flto
אפשרות שורת הפקודה. בדרך כלל עליך לציין את אפשרויות האופטימיזציה שבהן יש להשתמש
עבור אופטימיזציה בזמן קישור למרות ש-GCC מנסה להתחכם בלנחש אופטימיזציה
רמה לשימוש מהאפשרויות המשמשות בזמן ההידור אם לא תציינו אחת בקישור-
זְמַן. אתה תמיד יכול לעקוף את ההחלטה האוטומטית לבצע אופטימיזציה של זמן קישור ב
זמן קישור על ידי מעבר -fno-lto לפקודת הקישור.

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

מתי -תוסף-מקשר-fuse אינו מופעל אז, כאשר קובץ מורכב עם -flto, ה
קובץ האובייקט שנוצר גדול יותר מקובץ אובייקט רגיל מכיוון שהוא מכיל GIMPLE
bytecodes והקוד הסופי הרגיל (ראה -ffat-lto-objects. זה אומר האובייקט הזה
ניתן לקשר קבצים עם מידע LTO כקובצי אובייקט רגילים; אם -fno-lto זה עבר
על המקשר, לא מוחלות אופטימיזציות בין-הליכים. שימו לב מתי
-fno-fat-lto-objects מופעל, שלב ההידור מהיר יותר אך אינך יכול לבצע א
קישור רגיל ללא LTO עליהם.

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

gcc -c -O0 -ffat-lto-objects -flto foo.c
gcc -c -O0 -ffat-lto-objects -flto bar.c
gcc -o myprog -o3 foo.o bar.o

זה מייצר קבצי אובייקט בודדים עם קוד אסמבלר לא מותאם, אבל ה
בינארי המתקבל myprog מותאם ב -O3. אם, במקום זאת, הבינארי הסופי הוא
נוצר עם -fno-lto, לאחר מכן myprog אינו מותאם.

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

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

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

נכון לעכשיו, האפשרויות הבאות וההגדרות שלהן לקוחות מקובץ האובייקט הראשון
שציין זאת במפורש: -fPIC, -fpic, -fpie, -נפוץ, חריגות,
- חריגים ללא שיחות, -fgnu-tm וכל -m דגלי מטרה.

דגלים מסוימים המשתנים של ABI נדרשים להתאים בכל יחידות ההידור והניסיון
כדי לעקוף זאת בזמן קישור עם ערך מתנגש, מתעלמים. זה כולל
אפשרויות כגון -freg-struct-return ו -fpcc-struct-return.

אפשרויות נוספות כגון -ffp-חוזה, -fno-strict-overflow, -fwrapv, -fno-trapv or
-fno-string-aliasing מועברים לשלב הקישור ומתמזגים באופן שמרני
עבור יחידות תרגום סותרות. במיוחד -fno-strict-overflow, -fwrapv ו
-fno-trapv לקבל עדיפות ולמשל -ffp-contract=off מקבל עדיפות על פני
-ffp-contract=מהיר. אתה יכול לעקוף אותם בזמן הקישור.

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

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

תכונה נוספת של LTO היא שניתן ליישם אופטימיזציות בין-הליכים
על קבצים שנכתבו בשפות שונות:

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

אם קבצי אובייקט המכילים GIMPLE bytecode מאוחסנים בארכיון של ספרייה, נניח
libfoo.a, אפשר לחלץ ולהשתמש בהם בקישור LTO אם אתה משתמש ב-
מקשר עם תמיכה בפלאגין. כדי ליצור ספריות סטטיות המתאימות ל-LTO, השתמש gcc-ar
ו gcc-ranlib במקום ar ו ranlib; כדי להציג את הסמלים של קבצי אובייקט איתם
GIMPLE bytecode, השתמש gcc-nm. הפקודות האלה דורשות את זה ar, ranlib ו nm היה
מורכב עם תמיכה בפלאגין. בזמן הקישור, השתמש בדגל -תוסף-מקשר-fuse ל
ודא שהספרייה משתתפת בתהליך האופטימיזציה של LTO:

gcc -o myprog -O2 -flto -fuse-linker-plugin ao bo -lfoo

כאשר תוסף הקישור מופעל, המקשר מחלץ מהם את קבצי ה-GIMPLE הדרושים
libfoo.a ומעביר אותם ל-GCC הפועל כדי להפוך אותם לחלק מהמצטבר
תמונת GIMPLE למיטוב.

אם אינך משתמש בקישור עם תמיכה בפלאגין ו/או לא מפעיל את המקשר
תוסף, ואז האובייקטים בפנים libfoo.a נשלפים ומקושרים כרגיל, אבל הם
אל תשתתף בתהליך האופטימיזציה של LTO. על מנת ליצור ספרייה סטטית
מתאים גם לאופטימיזציה של LTO וגם לקישור רגיל, קומפלס את קבצי האובייקט שלו
-flto -ffat-lto-objects.

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

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

-flto-compression-level=n
אפשרות זו מציינת את רמת הדחיסה המשמשת עבור שפת ביניים כתובה
לקבצי אובייקט LTO, והוא בעל משמעות רק בשילוב עם מצב LTO (-flto).
ערכים חוקיים הם 0 (ללא דחיסה) עד 9 (דחיסה מקסימלית). ערכים מחוץ לזה
הטווח מוצמד ל-0 או 9. אם האפשרות לא ניתנת, ברירת המחדל מאוזנת
נעשה שימוש בהגדרת הדחיסה.

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

מושבת כברירת מחדל.

-flto-report-wpa
כמו -flto-דוח, אך הדפס רק עבור שלב ה-WPA של מיטוב זמן קישור.

-תוסף-מקשר-fuse
מאפשר שימוש בתוסף קישור במהלך אופטימיזציה של זמן קישור. אפשרות זו מסתמכת
על תמיכה בפלאגין ב-linker, שזמין בזהב או ב-GNU ld 2.21 או
חדש יותר.

אפשרות זו מאפשרת חילוץ של קבצי אובייקט עם קוד בתים GIMPLE מחוץ לספרייה
אַרְכִיוֹן. זה משפר את איכות האופטימיזציה על ידי חשיפת קוד נוסף לקישור-
מייעל זמן. מידע זה מפרט לאילו סמלים ניתן לגשת חיצונית
(על ידי אובייקט שאינו LTO או במהלך קישור דינמי). כתוצאה מכך שיפורים באיכות הקוד על
קבצים בינאריים (וספריות משותפות המשתמשות בחשיפה נסתרת) דומים ל
-התוכנית שלמה. לראות -flto לתיאור ההשפעה של דגל זה וכיצד לעשות זאת
תשתמש בזה.

אפשרות זו מופעלת כברירת מחדל כאשר תמיכת LTO ב-GCC מופעלת ו-GCC הייתה
מוגדר לשימוש עם קישור תומך תוספים (GNU ld 2.21 או חדש יותר או זהב).

-ffat-lto-objects
אובייקטי LTO שמנים הם קובצי אובייקט המכילים גם את שפת הביניים וגם את
קוד פריט. זה הופך אותם לשימושים גם לקישור LTO וגם לקישור רגיל. זֶה
אפשרות יעילה רק בעת קומפילציה עם -flto ומתעלמים ממנו בזמן הקישור.

-fno-fat-lto-objects משפר את זמן הקומפילציה על פני LTO רגיל, אך דורש את
שרשרת כלים מלאה כדי להיות מודע ל-LTO. זה דורש מקשר עם תמיכה בפלאגין מקשר
עבור פונקציונליות בסיסית. בנוסף, nm, ar ו ranlib צריך לתמוך במקשר
תוספים כדי לאפשר סביבת בנייה מלאה (שיכולה לבנות סטטי
ספריות וכו'). GCC מספקת את gcc-ar, gcc-nm, gcc-ranlib עטיפות להעביר את
אפשרויות נכונות לכלים אלה. עם LTO ללא שומן יש לשנות קבצי makefile לשימוש
אותם.

ברירת המחדל היא -fno-fat-lto-objects על מטרות עם תמיכה בפלאגין מקשר.

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

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

מופעל ברמות -O, -O2, -O3, -אוס.

-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=נתיב
אפשר אופטימיזציות מכוונות משוב לפרופיל, ואת האופטימיזציות הבאות אשר
הם בדרך כלל רווחיים רק עם משוב פרופיל זמין: -fענף-הסתברויות,
-fvpt, -funroll-לולאות, -fpeel-לולאות, -ftracer, -ftree-vectorize, ו ftree-loop-
הפצה-דפוסים.

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

If נתיב מצוין, GCC מסתכל על נתיב כדי למצוא את קבצי נתוני המשוב של הפרופיל.
לִרְאוֹת -fprofile-dir.

-fauto-profile
-fauto-profile=נתיב
אפשר אופטימיזציות מכוונות משוב המבוססות על דגימה, ואת האופטימיזציות הבאות
שהם בדרך כלל רווחיים רק עם משוב פרופיל זמין:
-fענף-הסתברויות, -fvpt, -funroll-לולאות, -fpeel-לולאות, -ftracer,
-ftree-vectorize, -finline-פונקציות, -fipa-cp, -fipa-cp-clone,
-fpredictive-commoning, -לולאות funswitch, -fgcse-after-reload, ו
-ftree-loop-distribute-passtrens.

נתיב הוא שם של קובץ המכיל מידע על פרופיל AutoFDO. אם מושמט, זה
ברירת מחדל ל fbdata.afdo בספרייה הנוכחית.

הפקת קובץ נתוני פרופיל AutoFDO מחייבת הפעלת התוכנית שלך עם perf
כלי עזר במערכת יעד נתמכת של GNU/Linux. למידע נוסף, ראה
<https://perf.wiki.kernel.org/>.

לְמָשָׁל

perf record -e br_inst_retired:near_taken -b -o perf.data \
-- התוכנית_שלך

ואז השתמש ב- create_gcov כלי להמרת נתוני הפרופיל הגולמיים לפורמט שיכול להיות
בשימוש על ידי GCC. עליך לספק גם את הבינארי הבלתי מופשט עבור התוכנית שלך לזה
כְּלִי. לִרְאוֹתhttps://github.com/google/autofdo>.

לְמָשָׁל

create_gcov --binary=your_program.unstripped --profile=perf.data \
--gcov=profile.afdo

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

-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-שימוש.

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

מופעל עם -fprofile-שימוש.

-fvpt
אם משלבים עם -fprofile-arcs, אפשרות זו מורה למהדר להוסיף לו קוד
לאסוף מידע על ערכי ביטויים.

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

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

מופעל כברירת מחדל עם -funroll-לולאות ו -fpeel-לולאות.

-fschedule-fusion
מבצע מעבר תלוי מטרה על זרם ההוראות כדי לתזמן הוראות
מאותו סוג יחד כי מכונת היעד יכולה לבצע אותם בצורה יעילה יותר אם הם
צמודים זה לזה בזרימת ההוראות.

מופעל ברמות -O2, -O3, -אוס.

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

-fstack-protector-all
כמו -מגן מחסנית אלא שכל הפונקציות מוגנות.

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

-fstack-protector-explicit
כמו -מגן מחסנית אלא רק מגן על הפונקציות שיש להן
מאפיין "מחסנית_הגנה".

-fstdarg-opt
מטב את הפרולוג של פונקציות ארגומנטים וריאדיות ביחס לשימוש באלו
ארגומנטים.

הערה: באובונטו 14.10 ובגירסאות מאוחרות יותר, -fstack-protector-חזק מופעל על ידי
ברירת מחדל עבור C, C++, ObjC, ObjC++, אם אף אחד מהם -fno-מחסנית-מגן, -נוסטדליב, ולא
-עומד בפני עצמו נמצאים.

-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 של העץ מחשיב ל-inliner. זה רק משפיע
פונקציות שהוכרזו בשורה ושיטות מיושמות בהצהרת מחלקה (C++).
ערך ברירת המחדל הוא 400.

max-inline-insns-auto
כאשר אתה משתמש ב -finline-פונקציות (כלול ב -O3), הרבה פונקציות שיעשו זאת
אחרת לא ייחשבו להטמעה על ידי המהדר נחקרים. ל
הפונקציות הללו, מגבלה שונה (מגבילה יותר) בהשוואה לפונקציות
ניתן להחיל את המוצהר מוטבע. ערך ברירת המחדל הוא 40.

inline-min-speedup
כאשר שיפור הביצועים המשוער של זמן הריצה של המתקשר + המתקשר חורג מזה
threshold (בקדמה), הפונקציה יכולה להיות מוטבעת ללא קשר להגבלה על
--param max-inline-insns-סינגל ו --param max-inline-insns-auto.

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

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

יחידות גדולות
המגבלה המציינת יחידת תרגום גדולה. צמיחה הנגרמת משילוב של יחידות
גדול מהגבול הזה מוגבל על ידי --param גידול יחידה מוטבע. ליחידות קטנות
זה עשוי להיות צמוד מדי. לדוגמה, שקול יחידה המורכבת מפונקציה A
זה מוטבע ו-B שרק קורא ל-A שלוש פעמים. אם B קטן ביחס ל-A,
הגידול ביחידה הוא 300\% ובכל זאת שיבוץ כזה שפוי מאוד. לגדולים מאוד
יחידות המורכבות מפונקציות קטנות שאינן ניתנות לשורה, לעומת זאת, הצמיחה הכוללת של היחידה
יש צורך ב-limit כדי למנוע התפוצצות אקספוננציאלית של גודל הקוד. כך לקטנים יותר
יחידות, הגודל גדל ל --param יחידות גדולות לפני החלת --param
גידול יחידה מוטבע. ברירת המחדל היא 10000.

גידול יחידה מוטבע
מציין את הצמיחה הכוללת המקסימלית של יחידת הקומפילציה הנגרמת על ידי inlining. ה
ערך ברירת המחדל הוא 20 המגביל את צמיחת היחידה לפי 1.2 מהגודל המקורי. קַר
פונקציות (או מסומנות קר באמצעות תכונה או על ידי משוב פרופיל) אינן
נלקח בחשבון בגודל היחידה.

ipcp-unit-growth
מציין את הצמיחה הכוללת המקסימלית של יחידת ההידור הנגרמת על ידי תהליכים בין-פרוצדורליים
התפשטות מתמדת. ערך ברירת המחדל הוא 10 המגביל את צמיחת היחידה ל-1.1
פעמים מהגודל המקורי.

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

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

max-inline-insns-רקורסיבי
מקסימום-קו-קו-אינס-רקורסבי-אוטו
מציין את המספר המרבי של הוראות עותק לא מקוון של קובץ עצמי
פונקציה רקורסיבית מוטבעת יכולה לצמוח לתוך על ידי ביצוע משולב רקורסיבי.

--param max-inline-insns-רקורסיבי חל על פונקציות שהוכרזו ב-inline. ל
פונקציות לא מוכרזות בשורה, הטבעה רקורסיבית מתרחשת רק כאשר
-finline-פונקציות (כלול ב -O3) מופעל; --param max-inline-insns-
רקורסיבי-אוטומטי חל במקום זאת. ערך ברירת המחדל הוא 450.

מקסימום-inline-רקורסיבי-עומק
max-inline-recursive-depth-auto
מציין את עומק הרקורסיה המקסימלי המשמש להטמעה רקורסיבית.

--param מקסימום-inline-רקורסיבי-עומק חל על פונקציות שהוכרזו ב-inline. ל
פונקציות לא מוכרזות בשורה, הטבעה רקורסיבית מתרחשת רק כאשר
-finline-פונקציות (כלול ב -O3) מופעל; --param max-inline-recursive-
עומק אוטומטי חל במקום זאת. ערך ברירת המחדל הוא 8.

min-inline-recursive-probability
הטבעה רקורסיבית רווחית רק לתפקוד שיש לו רקורסיה עמוקה
ממוצע ויכול לפגוע בתפקוד בעל עומק רקורסיה קטן על ידי הגדלת ה-
גודל פרולוג או מורכבות של גוף הפונקציה למייעל אחרים.

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

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

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

comdat-שיתוף-הסתברות
ההסתברות (באחוזים) שפונקציית C++ מוטבעת עם נראות comdat היא
משותף על פני מספר יחידות אוסף. ערך ברירת המחדל הוא 20.

profile-func-internal-id
פרמטר כדי לקבוע אם להשתמש במזהה פנימי של פונקציה במסד הנתונים של הפרופיל
הבט מעלה. אם הערך הוא 0, המהדר משתמש במזהה שמבוסס על פונקציה
שם assembler ושם קובץ, מה שהופך את נתוני הפרופיל הישנים לסובלניים יותר למקור
שינויים כגון סידור מחדש של פונקציות וכו'. ערך ברירת המחדל הוא 0.

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

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

מקסימום זמני פתיחה
המספר המרבי של פתיחת לולאה בודדת.

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

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

מקסימום-פיל-ענפים
המספר המרבי של ענפים על השביל החם דרך הרצף המקולף.

מקסימום-מקולפים-לגמרי-insns
המספר המרבי של אינסנס של לולאה מקולף לחלוטין.

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

מקסימום-לגמרי-קלוף-לולאה-עומק-קן
העומק המרבי של קן לולאה המתאים לקילוף מלא.

max-unswitch-insns
המספר המרבי של אינסנס של לולאה לא משתנה.

רמה מקסימלית של ביטול מתג
המספר המרבי של סניפים ללא מיתוג בלולאה אחת.

לא יקר
העלות המינימלית של ביטוי יקר בתנועה בלתי משתנה של הלולאה.

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

iv-max-considered-uses
האופטימיזציות של משתני האינדוקציה מוותרות על לולאות המכילות יותר אינדוקציה
שימושים משתנים.

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

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

vect-max-version-for-alias-checks
המספר המרבי של בדיקות זמן ריצה שניתן לבצע בעת ביצוע לולאה
גרסאות עבור כינוי ב-Vectorizer.

vect-max-peeling-for-alignment
המספר המרבי של קילופי לולאות כדי לשפר את יישור הגישה לוקטורייזר. ערך
-1 פירושו 'ללא גבול'.

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

hot-bb-count-ws-permille
ספירת פרופיל בלוקים בסיסית נחשבת חמה אם היא תורמת לנתון
פרמילג' (כלומר 0...1000) של כל הביצוע הצדודית.

hot-bb-frequency-fraction
בחר חלק מתדירות בלוק הכניסה של ביצוע בלוק בסיסי
פונקציה בהינתן בלוק בסיסי צריך להיחשב חם.

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

מובנית-צפוי-הסתברות
שליטה בהסתברות של הביטוי בעל הערך שצוין. זֶה
פרמטר לוקח אחוז (כלומר 0 ... 100) כקלט. הסתברות ברירת המחדל
של 90 מתקבל באופן אמפירי.

יישור-סף
בחר חלק מהתדירות המקסימלית של ביצועים של בלוק בסיסי ב-a
פונקציה ליישור הבלוק הבסיסי.

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 (ה
ברירת מחדל) משבית תוספי אזור.

max-sched-insn-conflict-delay
עיכוב הסכסוך המקסימלי עבור אינסנס שייחשב לתנועה ספקולטיבית.
ערך ברירת המחדל הוא 3.

sched-spec-prob-cutoff
ההסתברות המינימלית להצלחת ספקולציות (באחוזים), כך שהספקולציות
insns מתוכננים. ערך ברירת המחדל הוא 40.

sched-spec-state-edge-prob-cutoff
ההסתברות המינימלית שצריכה להיות לקצה כדי שהמתזמן ישמור את מצבו
מעבר לזה. ערך ברירת המחדל הוא 10.

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.

max-combine-ins
המספר המרבי של הוראות שמשלב RTL מנסה לשלב. ברירת המחדל
הערך הוא 2 ב -אוג ו-4 אחרת.

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

ssp-buffer-size
הגודל המינימלי של מאגרים (כלומר מערכים) שמקבלים הגנת מחסנית
מתי -fstack-הגנה משמש.

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

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

max-jump-thread-dplication-stmts
המספר המרבי של הצהרות המותר בבלוק שיש לשכפל כאשר
קפיצות השחלה.

max-fields-for-field-sensitive
מספר מרבי של שדות במבנה שטופל באופן רגיש לשדה במהלך
ניתוח מצביע. ברירת המחדל היא אפס עבור -O0 ו -O1, ו 100 עבור -אוס, -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.

scccvn-max-alias-queries-per-access
המספר המרבי של שאילתות alias-oracle שאנו מבצעים בעת חיפוש יתירות
עבור מטענים וחנויות. אם מגבלה זו נפגעת החיפוש מבוטל והטעינה או
החנות אינה נחשבת מיותרת. מספר השאילתות הוא אלגוריתמי
מוגבל למספר החנויות בכל הנתיבים מהטעינה ועד כניסת הפונקציה.
ברירת המחדל של המספר המקסימלי של שאילתות הוא 1000.

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

ira-max-conflict-table-size
למרות ש-IRA משתמש באלגוריתם מתוחכם כדי לדחוס את טבלת הקונפליקט, ה-
הטבלה עדיין יכולה לדרוש כמויות מוגזמות של זיכרון עבור פונקציות ענק. אם ה
טבלת התנגשות עבור פונקציה יכולה להיות יותר מהגודל ב-MB שניתן על ידי זה
פרמטר, מקצה האוגר משתמש במקום זאת ב- מהיר יותר, פשוט יותר ונמוך יותר
אלגוריתם איכותי שאינו דורש בניית טבלת התנגשות פסאודו-רישום.
ערך ברירת המחדל של הפרמטר הוא 2000.

ira-loop-reserved-regs
ניתן להשתמש ב-IRA כדי להעריך לחץ רישום מדויק יותר בלולאות לקבלת החלטות
כדי להזיז אינוריאנטים של לולאה (ראה -O3). מספר הרשמים הזמינים שמורים עבור
כמה מטרות אחרות ניתנות על ידי פרמטר זה. ערך ברירת המחדל של ה-
הפרמטר הוא 2, שהוא המספר המינימלי של רגיסטרים הדרושים לטיפוס
הוראות. ערך זה הוא הטוב ביותר שנמצא מניסויים רבים.

lra-heritance-ebb-probability-cutoff
LRA מנסה לעשות שימוש חוזר בערכים שנטענו מחדש ברגיסטרים בתוספות עוקבות. זֶה
אופטימיזציה נקראת ירושה. EBB משמש כאזור לעשות זאת
אופטימיזציה. הפרמטר מגדיר הסתברות מינימלית לנפילה דרך קצה ב
האחוז המשמש להוספת BB לירושת EBB ב-LRA. ערך ברירת המחדל של ה-
הפרמטר הוא 40. הערך נבחר מתוך ריצות רבות של SPEC2000 ב-x86-64.

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 פעמים
גודל פרמטר המצביע המקורי.

sra-max-scalarization-size-Ospeed
sra-max-scalarization-size-Osize
שני אישורי ההפחתה הסקלרית של אגרגטים (SRA ו-IPA-SRA) שואפים להחליף
חלקים סקלרים של אגרגטים עם שימושים במשתנים סקלרים בלתי תלויים. אלה
פרמטרים שולטים בגודל המקסימלי, ביחידות אחסון, של המצטבר שהוא
נחשב להחלפה בעת קומפילציה עבור מהירות (sra-max-scalarization-size-
אוספפיד) או גודל (sra-max-scalarization-size-Osize) בהתאמה.

tm-max-aggregate-size
בעת יצירת עותקים של משתנים מקומיים בטרנזקציה, פרמטר זה
מציין את הגודל בבייטים שלאחריו נשמרים משתנים עם הרישום
מתפקד בניגוד לשמירה/שחזור של צמדי רצף קוד. אפשרות זו בלבד
חל בעת השימוש -fgnu-tm.

graphite-max-nb-scop-params
כדי להימנע מהשפעות אקספוננציאליות בטרנספורמציה של לולאת גרפיט, המספר של
פרמטרים בחלק בקרה סטטית (SCoP) מוגבלים. ערך ברירת המחדל הוא 10
פרמטרים. משתנה שערכו אינו ידוע בזמן ההידור ומוגדר
מחוץ ל-SCoP הוא פרמטר של ה-SCoP.

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

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

לולאה-נפילת-ג'אם-גודל
ציין את גורם הפתיחה עבור ה -פלופ-להתגלגל-וגם אוֹפְּצִיָה. ערך ברירת המחדל
הוא 4.

לולאה-פרוש-ריבה-עומק
ציין את הממד שיש לפרוס (ספירה מהלולאה הפנימית ביותר) עבור ה-
-פלופ-להתגלגל-וגם. ערך ברירת המחדל הוא 2.

ipa-cp-value-list-size
IPA-CP מנסה לעקוב אחר כל הערכים והסוגים האפשריים שהועברו לפונקציה
פרמטר על מנת להפיץ אותם ולבצע דה וירטואליזציה. ipa-cp-value-
גודל רשימה הוא המספר המרבי של ערכים וסוגים שהוא מאחסן לכל רשמי אחד
פרמטר של פונקציה.

ipa-cp-eval-threshold
IPA-CP מחשבת את הניקוד שלה של שיבוט יוריסטיות רווחיות ומבצעת
אותן הזדמנויות שיבוט עם ציונים שעולים ipa-cp-eval-threshold.

ipa-cp-recursion-penalty
אחוז עונש שהפונקציות הרקורסיביות יקבלו כשהן יוערכו
לשיבוט.

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

ipa-max-agg-items
IPA-CP מסוגל גם להפיץ מספר ערכים סקלרים שהועברו ב-an
לְקַבֵּץ. ipa-max-agg-items שולט במספר המרבי של ערכים כאלה לכל אחד
פָּרָמֶטֶר.

ipa-cp-loop-hint-bonus
כאשר IPA-CP קובע כי מועמד שיבוט יעשה את המספר של
איטרציות של לולאה ידועה, זה מוסיף בונוס של ipa-cp-loop-hint-bonus אל ה
ציון הרווחיות של המועמד.

ipa-cp-array-index-hint-bonus
כאשר IPA-CP קובע שמועמד לשיבוט יעשה את האינדקס של מערך
גישה ידועה, זה מוסיף בונוס של ipa-cp-array-index-hint-bonus אל ה
ציון הרווחיות של המועמד.

ipa-max-aa-steps
במהלך הניתוח של גופי הפונקציה, IPA-CP משתמש בניתוח כינוי על מנת לעשות זאת
עקוב אחר ערכים שעליהם הצביעו פרמטרי פונקציה. כדי לא לבזבז יותר מדי זמן
מנתח פונקציות ענקיות, הוא מוותר ומחשיב את כל הזיכרון שהושג אחריו
בחינה ipa-max-aa-steps הצהרות שמשנות את הזיכרון.

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

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

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

תזמון-לחץ-אלגוריתם
בחר בין שני ההטמעות הזמינות של -fsched-לחץ. אלגוריתם 1
הוא היישום המקורי והסבירות הגבוהה יותר למנוע הוראות מ
מסודר מחדש. אלגוריתם 2 תוכנן להיות פשרה בין
גישה שמרנית יחסית שננקטה על ידי אלגוריתם 1 ותוקפנית למדי
גישה שננקטה על ידי מתזמן ברירת המחדל. זה מסתמך יותר על כך שיש א
קובץ רישום רגיל ושיעורי לחץ אוגר מדויקים. לִרְאוֹת חיפה-שד.ג
במקורות GCC לפרטים נוספים.

בחירת ברירת המחדל תלויה ביעד.

max-slsr-cand-scan
הגדר את המספר המרבי של מועמדים קיימים שייקח בחשבון בעת ​​חיפוש א
בסיס למועמד חדש להפחתת חוזק בקו ישר.

אסאן-גלובלים
אפשר זיהוי הצפת מאגר עבור אובייקטים גלובליים. סוג זה של הגנה הוא
מופעל כברירת מחדל אם אתה משתמש -fsanitize=כתובת אוֹפְּצִיָה. כדי להשבית גלובלי
שימוש בהגנה על חפצים --param asan-globals=0.

אסאן-מחסנית
אפשר זיהוי גלישת מאגר עבור אובייקטי מחסנית. סוג זה של הגנה הוא
מופעל כברירת מחדל בעת השימוש-fsanitize=כתובת. כדי להשבית את השימוש בהגנה על מחסנית
--param asan-stack=0 אוֹפְּצִיָה.

אסאן-מכשיר-קורא
אפשר זיהוי גלישת מאגר לקריאות זיכרון. סוג זה של הגנה הוא
מופעל כברירת מחדל בעת השימוש -fsanitize=כתובת. כדי להשבית את קריאות הזיכרון
שימוש בהגנה --param asan-instrument-reads = 0.

אסאן-מכשיר-כותב
אפשר זיהוי גלישת מאגר עבור כתיבת זיכרון. סוג זה של הגנה הוא
מופעל כברירת מחדל בעת השימוש -fsanitize=כתובת. כדי לבטל את הכתיבה בזיכרון
שימוש בהגנה --param asan-instrument-writes=0 אוֹפְּצִיָה.

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

asan-שימוש-אחרי-החזרה
אפשר זיהוי של שימוש לאחר החזרה. סוג זה של הגנה מופעל על ידי
ברירת מחדל בעת השימוש -fsanitize=כתובת אוֹפְּצִיָה. כדי לבטל שימוש לאחר החזרה
שימוש באיתור --param asan-use-after-return=0.

אסאן-מכשור-עם-סף-קריאה
אם מספר הגישות לזיכרון בפונקציה המותקנת במכשיר גדול או שווה ל
מספר זה, השתמש בהתקשרות חוזרת במקום בהמחאות מוטבעות. למשל כדי להשבית קוד מוטבע
להשתמש --param asan-instrumentation-with-call-threshold=0.

chkp-max-ctor-size
בנאים סטטיים שנוצרו על ידי Pointer Bounds Checker עשויים להיות גדולים מאוד ו
להגדיל משמעותית את זמן ההידור ברמת האופטימיזציה -O1 וגבוה יותר. זֶה
פרמטר הוא מספר מקסימלי של הצהרות בבנאי יחיד שנוצר.
ערך ברירת המחדל הוא 5000.

max-fsm-thread-path-insns
מספר מקסימלי של הוראות להעתקה בעת שכפול בלוקים במצב סופי
נתיב חוט קפיצה אוטומטי. ברירת המחדל היא 100.

מקסימום-fsm-thread-thread
מספר מקסימלי של בלוקים בסיסיים בנתיב קפיצה של אוטומט במצב סופי. ה
ברירת המחדל היא 10.

max-fsm-thread-paths
מספר מרבי של נתיבי חוט קפיצה חדשים ליצירה עבור אוטומט מצב סופי.
ברירת המחדל היא 50.

אפשרויות שליטה מה היא Preprocessor
אפשרויות אלה שולטות במעבד הקדם C, המופעל על כל קובץ מקור C לפני המציאות
הַהדָרָה.

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

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

-Xpreprocessor אוֹפְּצִיָה
לעבור אוֹפְּצִיָה כאופציה למעבד הקדם. אתה יכול להשתמש בזה כדי לספק מערכת-
אפשרויות קדם-מעבד ספציפיות ש-GCC לא מזהה.

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

-no-integrated-cpp
בצע עיבוד מקדים כמעבר נפרד לפני הידור. כברירת מחדל, GCC פועל
עיבוד מקדים כחלק משולב של אסימון קלט וניתוח. אם אפשרות זו
מסופק, קצה השפה המתאים (cc1, cc1plus, או cc1obj עבור C, C++,
ו-Objective-C, בהתאמה) מופעל במקום פעמיים, פעם אחת לעיבוד מקדים בלבד
ופעם אחת עבור הידור בפועל של הקלט המעובד מראש. אפשרות זו עשויה להיות שימושית
בשיתוף עם -B or -עֲטִיפָה אפשרויות לציון מעבד מקדים חלופי או
לבצע עיבוד נוסף של מקור התוכנית בין עיבוד מקדים רגיל לבין
הַהדָרָה.

-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
קבל שמות תווים אוניברסליים במזהים. אפשרות זו מופעלת כברירת מחדל
עבור C99 (וגרסאות מאוחרות יותר בתקן C) ו-C++.

-fno-canonical-system-headers
בעת עיבוד מקדים, אל תקצר נתיבי כותרת של המערכת באמצעות קנוניזציה.

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

שים לב ש"-ftrack-macro-expansion=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 אם נעשה שימוש באחת מהאפשרויות הללו, המקשר אינו מופעל, ושמות קבצי האובייקט
לא צריך לשמש כטיעונים.

-fuse-ld=bfd
השתמש bfd מקשר במקום מקשר ברירת המחדל.

-fuse-ld=זהב
השתמש זהב מקשר במקום מקשר ברירת המחדל.

-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
אל תשתמש בספריות המערכת הסטנדרטיות בעת הקישור. רק הספריות שאתה מציין
מועברים למקשר, ואפשרויות המציינות קישור של ספריות המערכת, כגון
as -static-libgcc or -shared-libgcc, מתעלמים מהם. נעשה שימוש בקבצי האתחול הסטנדרטיים
בדרך כלל, אלא אם כן -nostartfiles משמש.

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

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

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

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

ברוב המקרים, אתה צריך libgcc.a גם כאשר אתה רוצה להימנע מספריות סטנדרטיות אחרות.
במילים אחרות, כשאתה מציין -נוסטדליב or -nodefaultlibs אתה צריך בדרך כלל
לפרט -lgcc גם כן. זה מבטיח שאין לך אזכורים לא פתורים
תתי שגרות פנימיות של ספריית GCC. (דוגמה לתתי שגרה פנימית כזו היא
"__main", משמש כדי להבטיח שנקראים בנאים C++.)

-פַּאִי
הפקת עמדה עצמאית לביצוע על יעדים התומכים בה. לצפוי
תוצאות, עליך לציין גם את אותה קבוצת אפשרויות המשמשת להידור (-fpie,
-fPIE, או אפשרויות משנה של מודל) כאשר אתה מציין אפשרות קישור זו.

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

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

-s הסר את כל מידע על טבלת הסמלים והעברת המיקום מקובץ ההפעלה.

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

-מְשׁוּתָף
צור אובייקט משותף שאותו ניתן לקשר עם אובייקטים אחרים ליצירת
בר הפעלה. לא כל המערכות תומכות באפשרות זו. לתוצאות צפויות, אתה חייב
ציין גם את אותה קבוצת אפשרויות המשמשת להידור (-fpic, -fPIC, או דגם
suboptions) כאשר אתה מציין אפשרות קישור זו.[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 by
בְּרִירַת מֶחדָל. זה מאפשר לחריגים להתפשט דרך ספריות משותפות כאלה, בלי
עלויות רילוקיישן בזמן טעינת הספרייה.

עם זאת, אם ספרייה או קובץ הפעלה ראשי אמורים לזרוק או לתפוס חריגים, אתה
חייב לקשר אותו באמצעות מנהל ההתקן G++ או GCJ, בהתאם לשפות המשמשות ב-
תוכנית, או באמצעות האפשרות -shared-libgcc, כך שהוא מקושר עם המשותף
libgcc.

-סטטי-ליבאסן
כאשר -fsanitize=כתובת האפשרות משמשת לקישור תוכנית, מנהל ההתקן של GCC
קישור אוטומטי נגד libasan. אם libasan זמין כספרייה משותפת, ו
מה היא -סטָטִי האפשרות אינה בשימוש, אז זה מקשר לגרסה המשותפת של libasan.
השמיים -סטטי-ליבאסן אפשרות מפנה את מנהל ההתקן של GCC לקישור libasan באופן סטטי, בלי
בהכרח קישור סטטי של ספריות אחרות.

-סטטי-ליבטסן
כאשר -fsanitize=חוט האפשרות משמשת לקישור תוכנית, מנהל ההתקן של GCC
קישור אוטומטי נגד ליבצאן. אם ליבצאן זמין כספרייה משותפת, ו
מה היא -סטָטִי האפשרות אינה בשימוש, אז זה מקשר לגרסה המשותפת של ליבצאן.
השמיים -סטטי-ליבטסן אפשרות מפנה את מנהל ההתקן של GCC לקישור ליבצאן באופן סטטי, בלי
בהכרח קישור סטטי של ספריות אחרות.

-סטטי-ליבלסן
כאשר -fsanitize=דליפה האפשרות משמשת לקישור תוכנית, מנהל ההתקן של GCC
קישור אוטומטי נגד ליבלסאן. אם ליבלסאן זמין כספרייה משותפת, ו
מה היא -סטָטִי האפשרות אינה בשימוש, אז זה מקשר לגרסה המשותפת של ליבלסאן.
השמיים -סטטי-ליבלסן אפשרות מפנה את מנהל ההתקן של GCC לקישור ליבלסאן באופן סטטי, בלי
בהכרח קישור סטטי של ספריות אחרות.

-סטטי-libubsan
כאשר -fsanitize=לא מוגדר האפשרות משמשת לקישור תוכנית, מנהל ההתקן של GCC
קישור אוטומטי נגד ליבובסן. אם ליבובסן זמין כספרייה משותפת,
ו -סטָטִי האפשרות אינה בשימוש, אז זה מקשר לגרסה המשותפת של
ליבובסן. ה -סטטי-libubsan אפשרות מפנה את מנהל ההתקן של GCC לקישור ליבובסן
באופן סטטי, מבלי לקשר בהכרח ספריות אחרות באופן סטטי.

-static-libmpx
כאשר -fcheck-pointer גבולות ו -mmpx משתמשים באפשרויות לקישור תוכנית, ה-GCC
מנהל ההתקן מקשר אוטומטית נגד libmpx. אם libmpx זמין כמשותף
הספרייה, וה -סטָטִי האפשרות אינה בשימוש, אז זה מקשר נגד המשותף
גרסה של libmpx. ה -static-libmpx אפשרות מפנה את מנהל ההתקן של GCC לקישור libmpx
באופן סטטי, מבלי לקשר בהכרח ספריות אחרות באופן סטטי.

-static-libmpxwrappers
כאשר -fcheck-pointer גבולות ו -mmpx משתמשים באפשרויות לקישור תוכנית ללא
גם באמצעות -fno-chkp-use-wrappers, מנהל ההתקן של GCC מקשר אוטומטית נגד
libmpxwrappers. אם libmpxwrappers זמין כספרייה משותפת, וה- -סטָטִי
האפשרות אינה בשימוש, אז זה מקשר לגרסה המשותפת של libmpxwrappers. ה
-static-libmpxwrappers אפשרות מפנה את מנהל ההתקן של GCC לקישור libmpxwrappers
באופן סטטי, מבלי לקשר בהכרח ספריות אחרות באופן סטטי.

-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 מספר פעמים עם סמלים שונים כדי לאלץ טעינה
מודולי ספרייה נוספים.

-z מילות מפתח
-z מועבר ישירות למקשר יחד עם מילת המפתח מילות מפתח. עיין בסעיף
בתיעוד של המקשר שלך עבור ערכים מותרים ומשמעויותיהם.

אפשרויות ל מַדרִיך חיפוש
אפשרויות אלה מציינות ספריות לחיפוש קובצי כותרות, ספריות וחלקים
של המהדר:

-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 עדיין עובד, אבל היבט הספרייה לא.

--no-sysroot-suffix
עבור יעדים מסוימים, מתווספת סיומת לספריית השורש שצוינה עם --sysroot,
בהתאם לאפשרויות האחרות בהן נעשה שימוש, כך שכותרות עשויות להימצא למשל ב
dir/suffix/usr/include במקום dir/usr/include. אפשרות זו מבטלת את התוספת
של סיומת כזו.

-אני- אפשרות זו הוצאה משימוש. בבקשה תשתמש -אני מצטט במקום זאת עבור -I ספריות לפני
מה היא -אני- ולהסיר את -אני- אוֹפְּצִיָה. כל ספריות שאתה מציין איתן -I אפשרויות לפני
מה היא -אני- מחפשים רק את המקרה של "#include"קוֹבֶץ""; הם לא
חיפש את "#includeקובץ>".

אם צוינו ספריות נוספות עם -I אפשרויות לאחר ה -אני- אפשרות, אלה
מחפשים את כל הנחיות "#include" בספריות. (בדרך כלל את כל -I
מדריכים משמשים בדרך זו.)

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

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

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

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

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

AAArch64 אפשרויות

אפשרויות אלה מוגדרות עבור יישומי AArch64:

-מאבי=שם
צור קוד עבור מודל הנתונים שצוין. ערכים מותרים הם ilp32 עבור SysV-
כמו מודל נתונים שבו int, long int ומצביע הם 32 סיביות, ו lp64 עבור דמוי SysV
מודל נתונים שבו int הוא 32 סיביות, אבל long int ומצביע הם 64 סיביות.

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

-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
משתנים.

-mfix-cortex-a53-835769
-mno-fix-cortex-a53-835769
הפעל או השבת את הדרך לעקיפת הבעיה עבור ARM Cortex-A53 שגיאה מספר 835769.
כולל הכנסת הוראת NOP בין הוראות זיכרון למספר שלם של 64 סיביות
להכפיל-צבור הוראות.

-mfix-cortex-a53-843419
-mno-fix-cortex-a53-843419
הפעל או השבת את הדרך לעקיפת הבעיה עבור ARM Cortex-A53 שגיאה מספר 843419.
עקיפת הבעיה מתבצעת בזמן הקישור וזה יעבור רק את הדגל המתאים
למקשר.

-מרץ=שם
ציין את השם של ארכיטקטורת היעד, אופציונלי עם סיומת אחת או יותר
משנה תכונות. לאפשרות זו יש את הטופס -מרץ=קשת{+[לא]תכונה}*, איפה ה
רק ערך מותר עבור קשת is armv8-a. הערכים המותרים עבור תכונה יש לו
המתועד בסעיף המשנה להלן.

כאשר צוינו תכונה מתנגשת, התכונה הכי ימנית משמשת.

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

איפה -מרץ מצוין ללא אחד מהם -mtune or -mcpu כמו כן מצויין, ה
הקוד מכוון לביצועים טובים במגוון מעבדי יעד המיישמים את
ארכיטקטורת יעד.

-mtune=שם
ציין את שם מעבד היעד שעבורו GCC צריך לכוון את הביצועים שלו
הקוד. הערכים המותרים עבור אפשרות זו הם: גנרית, קליפת המוח-a53, קליפת המוח-a57,
קליפת המוח-a72, exynos-m1, Thunderx, xgene1.

בנוסף, אפשרות זו יכולה לציין ש-GCC צריך לכוון את הביצועים של הקוד
למערכת גדולה.LITTLE. הערכים המותרים עבור אפשרות זו הם:
cortex-a57.cortex-a53, cortex-a72.cortex-a53.

איפה אף אחד מ -mtune=, -mcpu= or -מרץ= מצוינים, הקוד מכוון לביצוע
היטב על פני מגוון מעבדי יעד.

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

-mcpu=שם
ציין את שם מעבד היעד, עם סיומת אופציונלית על ידי תכונה אחת או יותר
משנה. לאפשרות זו יש את הטופס -mcpu=מעבד{+[לא]תכונה}*, כאשר המותר
ערכים עבור מעבד זהים לאלו הזמינים עבור -mtune.

הערכים המותרים עבור תכונה מתועדים בסעיף המשנה שלהלן.

כאשר צוינו תכונה מתנגשת, התכונה הכי ימנית משמשת.

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

-מרץ ו -mcpu משנה תכונות

משנה תכונות בשימוש עם -מרץ ו -mcpu יכול להיות אחד מהבאים:

CRC אפשר הרחבת CRC.

קריפטו
אפשר הרחבת Crypto. זה מרמז שמתקדם SIMD מופעל.

fp אפשר הוראות נקודה צפה.

סימד
אפשר הוראות SIMD מתקדמות. זה מרמז על הוראות נקודה צפה
מופעל. זוהי ברירת המחדל עבור כל הערכים האפשריים הנוכחיים עבור אפשרויות -מרץ ו
-mcpu=.

אדפטיבה הִתגַלוּת אפשרויות

אלה -m אפשרויות מוגדרות עבור Adapteva Epiphany:

-mhalf-reg-file
אל תקצה שום רשם בטווח "r32"..."r63". זה מאפשר לרוץ על הקוד
גרסאות חומרה חסרות רגיסטרים אלה.

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

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

-mcmove
אפשר יצירת מהלכים מותנים.

-mnops=NUM
פולט NUM NOPs לפני כל הוראה אחרת שנוצרה.

-mno-soft-cmpsf
להשוואת נקודה צפה ברמת דיוק בודדת, שלח הוראה ובדיקה "fsub".
הדגלים. זה מהיר יותר מהשוואת תוכנה, אבל יכול לקבל תוצאות שגויות
בנוכחות NaNs, או כאשר משווים בין שני מספרים קטנים שונים כך
ההפרש שלהם מחושב כאפס. ברירת המחדל היא -msoft-cmpsf, אשר שימושים
השוואת תוכנה איטית יותר אך תואמת IEEE.

-mstack-offset=NUM
הגדר את ההיסט בין החלק העליון של הערימה לבין מצביע הערימה. למשל, ערך של 8
פירושו שמונה בתים בטווח "sp+0...sp+7" יכולים לשמש על ידי פונקציות עלים
ללא הקצאת מחסנית. ערכים מלבד 8 or 16 לא נבדקו ולא סביר שיעשו זאת
עֲבוֹדָה. שימו לב גם שאופציה זו משנה את ה-ABI; הידור תוכנית עם א
קיזוז מחסנית שונה מזה שהספריות הולדרו איתו בדרך כלל לא
עֲבוֹדָה. אפשרות זו יכולה להיות שימושית אם ברצונך להעריך אם היסט מחסנית שונה
ייתן לך קוד טוב יותר, אבל למעשה להשתמש בהיסט מחסנית שונה לבנייה
תוכניות עבודה, מומלץ להגדיר את שרשרת הכלים עם המתאים
--with-stack-offset=NUM אוֹפְּצִיָה.

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

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

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

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

קשת אפשרויות

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

-מחליף-מעביר
צור הוראות הנתמכות על ידי מעביר חבית. זוהי ברירת המחדל אלא אם כן
-mcpu=ARC601 הוא בתוקף.

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

ARC600
קומפילציה עבור ARC600. כינויים: -mA6, -mARC600.

ARC601
קומפילציה עבור ARC601. כינוי: -mARC601.

ARC700
קומפילציה עבור ARC700. כינויים: -mA7, -mARC700. זוהי ברירת המחדל כאשר היא מוגדרת
עם --with-cpu=arc700.

-mdpfp
-mdpfp-compact
FPX: צור הוראות FPX Double Precision, מכווננות למימוש הקומפקטי.

-mdpfp-מהיר
FPX: צור הוראות FPX Double Precision, מכווננות ליישום מהיר.

-mno-dpfp-lrsr
השבת את הוראות LR ו-SR משימוש באוגרי aux של הרחבות FPX.

-מה
צור הוראות חשבון מורחבות. כרגע רק "divaw", "adds", "subs",
ו-"sat16" נתמכים. זה תמיד מופעל עבור -mcpu=ARC700.

-mno-mpy
אל תיצור הוראות mpy עבור ARC700.

-mmul32x16
צור 32x16 סיביות כפל והוראות mac.

-mmul64
צור הוראות mul64 ו-mulu64. תקף רק עבור -mcpu=ARC600.

-מנורם
צור הוראה נורמלית. זוהי ברירת המחדל אם -mcpu=ARC700 הוא בתוקף.

-mspfp
-mspfp-compact
FPX: צור הוראות FPX דיוק יחיד, מכווננות למימוש הקומפקטי.

-mspfp-מהיר
FPX: צור הוראות FPX דיוק יחיד, מכווננות ליישום מהיר.

-msimd
אפשר יצירת הוראות ARC SIMD באמצעות מובנים ספציפיים ליעד. תקף בלבד
ל -mcpu=ARC700.

-msoft-float
אפשרות זו התעלמה; הוא מסופק למטרות תאימות בלבד. תוֹכנָה
קוד נקודה צפה נפלט כברירת מחדל, וברירת מחדל זו יכולה לעקוף על ידי FPX
אפשרויות; mspfp, mspfp-compact, או mspfp-מהיר עבור דיוק יחיד, ו mdpfp, mdpfp-
קומפקטי, או mdpfp-מהיר לדיוק כפול.

-mswap
צור הוראות החלפה.

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

-mdsp-packa
הועבר ל-assembler כדי לאפשר את הרחבות DSP Pack A. מגדיר גם את
סמל קדם-מעבד "__Xdsp_packa".

-mdvbf
הועבר להרכב כדי לאפשר את הרחבה הכפולה של פרפר ויטרבי. גַם
מגדיר את סמל הפרה-מעבד "__Xdvbf".

-מלוק
הועבר להרכב כדי לאפשר את ההרחבה Locked Load/Store Conditional.
מגדיר גם את סמל המעבד "__Xlock".

-mmac-d16
הועבר להרכב. מגדיר גם את סמל הפרה-מעבד "__Xxmac_d16".

-mmac-24
הועבר להרכב. מגדיר גם את סמל הפרה-מעבד "__Xxmac_24".

-mrtsc
הועבר ל-assembler כדי לאפשר את ההרחבה של 64-bit Time-Stamp Counter
הוראה. מגדיר גם את סמל הפרה-מעבד "__Xrtsc".

-mswape
הועבר ל-assembler כדי לאפשר את הוראת ההרחבה להזמנת בתים.
מגדיר גם את סמל הפרה-מעבד "__Xswape".

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

-מקסי
הועבר ל-assembler כדי לאפשר את הרחבת XY Memory. מגדיר גם את
סמל קדם-מעבד "__Xxy".

האפשרויות הבאות קובעות את אופן ההערה של קוד ההרכבה:

-הגדלה
הערה הוראות assembler עם כתובות משוערות.

-מנוט-יישר
הסבר אילו שיקולי יישור מובילים להחלטה לקבל הוראה
קצר או ארוך.

האפשרויות הבאות מועברות למקשר:

-מרקלינוקס
הועבר אל המקשר, כדי לציין שימוש באמולציית "arclinux". אפשרות זו
מופעל כברירת מחדל בשרשרות כלים שנבנו עבור "arc-linux-uclibc" ו
"arceb-linux-uclibc" מטרות כאשר לא מתבקש לעשות פרופיל.

-marclinux_prof
הועבר למקשר, כדי לציין שימוש באמולציית "arclinux_prof". זֶה
האפשרות מופעלת כברירת מחדל בשרשרות כלים שנבנו עבור "arc-linux-uclibc" ו
"arceb-linux-uclibc" מטרות כאשר מתבקש יצירת פרופיל.

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

-mepilogue-cfi
אפשר יצירת מידע על מסגרת שיחה עבור אפילוגים.

-mno-epilogue-cfi
השבת יצירת מידע על מסגרת שיחה עבור אפילוגים.

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

-מבינוני-שיחות
אל תשתמש בטווח כתובת של פחות מ-25 סיביות עבור שיחות, שהוא ההיסט הזמין
להוראת סניף וקישור ללא תנאי. ביצוע מותנה של פונקציה
שיחות מדוכאות, כדי לאפשר שימוש בטווח של 25 סיביות, במקום בטווח של 21 סיביות
עם ענף וקישור מותנה. זוהי ברירת המחדל עבור שרשראות כלים שנבנו עבורם
מטרות "arc-linux-uclibc" ו-"arceb-linux-uclibc".

-mno-sdata
אל תיצור הפניות sdata. זוהי ברירת המחדל עבור שרשראות כלים שנבנו עבורם
מטרות "arc-linux-uclibc" ו-"arceb-linux-uclibc".

-mucb-mcount
מכשיר עם שיחות mcount כפי שמשמש בקוד UCB. כלומר, בצע את הספירה אצל הנקרא,
לא המתקשר. כברירת מחדל, מכשור ARC סופר אצל המתקשר.

-mvolatile-cache
השתמש בגישה רגילה לזיכרון במטמון עבור הפניות נדיפות. זוהי ברירת המחדל.

-mno-volatile-cache
אפשר עקיפת מטמון עבור הפניות נדיפות.

האפשרויות הבאות מכוונן את יצירת הקוד:

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

-mauto-modify-reg
אפשר את השימוש ב-pre/post modify עם עקירת רישום.

-מבביט-חור הצצה
הפעל Bbit peephole2.

-mno-brcc
אפשרות זו משביתה מעבר ספציפי ליעד arc_reorg ליצור "BRcc"
הוראות. אין לו השפעה על יצירת "BRcc" המונע על ידי מעבר המשלב.

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

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

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

-mearly-cbranchsi
אפשר שימוש בטעינה מחדש של דפוס cbranchsi.

-mexpand-adddi
הרחב את "adddi3" ו-"subdi3" בזמן יצירת rtl ל-"add.f", "adc" וכו'.

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

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

-mlra-priority-none
אל תציין כל עדיפות עבור אוגרי יעד.

-mlra-priority-compact
ציין עדיפות רישום יעד עבור r0..r3 / r12..r15.

-mlra-priority-noncompact
הפחת את עדיפות רישום היעד עבור r0..r3 / r12..r15.

-mno-millicode
בעת אופטימיזציה לגודל (באמצעות -אוס), פרולוגים ואפילוגים שיש לשמור או
לשחזר מספר רב של רישומים מתקצרים לעתים קרובות על ידי שימוש בהתקשרות מיוחדת
פונקציה ב-libgcc; זה מכונה א מיליקוד שִׂיחָה. כפי שהשיחות האלה יכולות להופיע
בעיות ביצועים ו/או לגרום לבעיות קישור בעת קישור בצורה לא סטנדרטית,
אפשרות זו ניתנת לביטול יצירת שיחות מיליקוד.

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

-mq-class
אפשר חלופות הוראות 'q'. זוהי ברירת המחדל עבור -אוס.

-mRcq
אפשר טיפול באילוצי Rcq - רוב יצירת הקוד הקצר תלוי בזה. זה
ברירת המחדל.

-mRcw
אפשר טיפול באילוצי Rcw - ccfsm condexec תלוי בעיקר בזה. זה
ברירת המחדל.

-msize-level=רָמָה
כוונן עדין אופטימיזציה של גודל בכל הנוגע לאורכי הוראות ויישור. ה
ערכים מוכרים עבור רָמָה הם:

0 אין אופטימיזציה של גודל. רמה זו הוצאה משימוש ומטופלת כמו 1.

1 הוראות קצרות משמשות באופן אופורטוניסטי.

2 בנוסף, יישור של לולאות ושל קוד לאחר שחרור מחסומים.

3 בנוסף, יישור נתונים אופציונלי נמחק, והאפשרות Os מאופשר.

זה כברירת מחדל ל 3 מתי -אוס בתוקף. אחרת, ההתנהגות כשזה לא
סט שווה לרמה 1.

-mtune=מעבד
הגדר פרמטרים של תזמון הוראות עבור מעבד, עוקף כל המשתמע מ -mcpu=.

ערכים נתמכים עבור מעבד יש לו

ARC600
כוון למעבד ARC600.

ARC601
כוון למעבד ARC601.

ARC700
כוון למעבד ARC700 עם בלוק מכפיל סטנדרטי.

ARC700-xmac
כוון למעבד ARC700 עם בלוק XMAC.

ARC725D
כוונן עבור מעבד ARC725D.

ARC750D
כוונן עבור מעבד ARC750D.

-multcost=NUM
עלות להניח עבור הוראה להכפל, עם 4 להיות שווה להוראה רגילה.

-munalign-prob-threshold=הסתברות
הגדר סף הסתברות לביטול יישור ענפים. כאשר מכוונים עבור ARC700 ו
אופטימיזציה למהירות, ענפים ללא חריץ השהיה מלא נפלטים
לא מיושר וארוך, אלא אם הפרופיל מצביע על כך שההסתברות לסניף
להילקח למטה הסתברות. ברירת המחדל היא (REG_BR_PROB_BASE/2), כלומר 5000.

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

-מרגונאוט
FPX מיושן.

-mbig-endian
-EB הידור קוד עבור מטרות אנדיאניות גדולות. השימוש באפשרויות אלה הוצא כעת משימוש. משתמשים
שרוצה קוד גדול, צריך להשתמש במטרות "arceb-elf32" ו-"arceb-linux-uclibc"
בעת בניית שרשרת הכלים, שעבורה big-endian הוא ברירת המחדל.

-מעט-אנדיאן
-ה הידור קוד עבור מטרות אנדיאניות קטנות. השימוש באפשרויות אלה הוצא כעת משימוש.
משתמשים המעוניינים בקוד קטן-Endian צריכים להשתמש ב-"arc-elf32" ו-"arc-linux-uclibc"
יעדים בעת בניית שרשרת הכלים, שעבורם little-endian הוא ברירת המחדל.

-mbarrel_shifter
הוחלף על ידי -מחליף-מעביר.

-mdpfp_compact
הוחלף על ידי -mdpfp-compact.

-mdpfp_מהיר
הוחלף על ידי -mdpfp-מהיר.

-mdsp_packa
הוחלף על ידי -mdsp-packa.

-mEA
הוחלף על ידי -מה.

-mmac_24
הוחלף על ידי -mmac-24.

-mmac_d16
הוחלף על ידי -mmac-d16.

-mspfp_compact
הוחלף על ידי -mspfp-compact.

-mspfp_מהיר
הוחלף על ידי -mspfp-מהיר.

-mtune=מעבד
ערכים arc600, arc601, arc700 ו arc700-xmac ל מעבד מוחלפים ב ARC600, ARC601,
ARC700 ו ARC700-xmac בהתאמה

-multcost=NUM
הוחלף על ידי -מחיר רב.

זרוע אפשרויות

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

-mfloat-abi=שם
מציין באיזה ABI של נקודה צפה להשתמש. הערכים המותרים הם: רך, softfp ו
קָשֶׁה.

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

ברירת המחדל תלויה בתצורת היעד הספציפית. שימו לב שה-hard-float
ו- ABIs soft float אינם תואמים קישורים; אתה חייב להרכיב את כל התוכנית שלך עם
אותו ABI, וקישור עם קבוצה תואמת של ספריות.

-מעט-אנדיאן
צור קוד עבור מעבד הפועל במצב little-endian. זוהי ברירת המחדל עבור
כל התצורות הסטנדרטיות.

-mbig-endian
צור קוד עבור מעבד הפועל במצב big-endian; ברירת המחדל היא קומפילציה
קוד עבור מעבד קטן אנדיאן.

-מרץ=שם
זה מציין את השם של ארכיטקטורת 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, armv7ve, armv8-a, armv8-a+crc, iwmmxt, iwmmxt2, ep9312.

-march=armv7ve היא ארכיטקטורת armv7-a עם הרחבות וירטואליזציה.

-march=armv8-a+crc מאפשר יצירת קוד עבור ארכיטקטורת ARMv8-A יחד עם
הרחבות CRC32 האופציונליות.

-צעדה = יליד גורם למהדר לזהות אוטומטית את הארכיטקטורה של ה-build
מַחשֵׁב. נכון לעכשיו, תכונה זו נתמכת רק ב-GNU/Linux, ולא בכולם
ארכיטקטורות מוכרות. אם הזיהוי האוטומטי לא מצליח לאפשרות אין
השפעה.

-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,
קליפת המוח-a12, קליפת המוח-a15, קליפת המוח-a53, קליפת המוח-a57, קליפת המוח-a72, cortex-r4, cortex-r4f,
cortex-r5, cortex-r7, קורטקס-m7, קורטקס-m4, קורטקס-m3, קורטקס-m1, קורטקס-m0,
cortex-m0plus, cortex-m1.small-multiply, cortex-m0.small-multiply,
cortex-m0plus.small-multiply, exynos-m1, marvell-pj4, xscale, iwmmxt, iwmmxt2, ep9312,
fa526, fa626, fa606te, fa626te, fmp626, fa726te, xgene1.

בנוסף, אפשרות זו יכולה לציין ש-GCC צריך לכוון את הביצועים של הקוד
למערכת גדולה.LITTLE. השמות המותרים הם: cortex-a15.cortex-a7,
cortex-a57.cortex-a53, cortex-a72.cortex-a53.

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

-mtune=native גורם למהדר לזהות אוטומטית את ה-CPU של מחשב ה-build. בְּ
קיים, תכונה זו נתמכת רק ב-GNU/Linux, ולא כל הארכיטקטורות
מוּכָּר. אם הזיהוי האוטומטי לא מצליח לאפשרות אין השפעה.

-mcpu=שם
זה מציין את השם של מעבד ARM היעד. GCC משתמש בשם זה כדי לגזור את
שם ארכיטקטורת ARM היעד (כאילו צוין על ידי -מרץ) ומעבד ARM
סוג שעבורו יש לכוונן לביצועים (כאילו צוין על ידי -mtune). איפה האפשרות הזו
משמש בשילוב עם -מרץ or -mtune, אפשרויות אלו עדיפות על פני ה
חלק מתאים של אפשרות זו.

השמות המותרים עבור אפשרות זו זהים לאלו עבור -mtune.

-mcpu=גנרי-קשת מותר גם הוא, והוא שווה ערך ל -מרץ=קשת
-mtune=גנרי-קשת. לראות -mtune לקבלת מידע נוסף.

-mcpu = יליד גורם למהדר לזהות אוטומטית את ה-CPU של מחשב ה-build. בְּ
קיים, תכונה זו נתמכת רק ב-GNU/Linux, ולא כל הארכיטקטורות
מוּכָּר. אם הזיהוי האוטומטי לא מצליח לאפשרות אין השפעה.

-mfpu=שם
זה מציין באיזו חומרת נקודה צפה (או אמולציית חומרה) זמינה
המטרה. השמות המותרים הם: vfp, vfpv3, vfpv3-fp16, vfpv3-d16, VFPV3-D16-FP16,
vfpv3xd, vfpv3xd-fp16, נאון, neon-fp16, vfpv4, vfpv4-d16, fpv4-sp-d16, ניאון-vfpv4,
fpv5-d16, fpv5-sp-d16, fp-armv8, neon-fp-armv8, ו קריפטו-ניאון-fp-armv8.

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 מגה-בייט
טווח של הגרסה מבוססת היסט של הוראת שיחות תת שגרתיות.

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

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

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

-mpic-register=רג
ציין את האוגר שישמש עבור כתובת PIC. למקרה בסיס PIC סטנדרטי, ה
ברירת המחדל היא כל אוגר מתאים שנקבע על ידי המהדר. עבור מקרה בסיס PIC יחיד,
ברירת המחדל היא R9 אם היעד מבוסס על EABI או שבדיקת מחסנית מופעלת, אחרת
ברירת המחדל היא R10.

-mpic-data-הוא-טקסט-יחסי
נניח שכל קטע נתונים הוא יחסי לקטע טקסט בזמן הטעינה. לָכֵן,
הוא מאפשר להתייחס לנתונים באמצעות פעולות ביחס למחשב. אפשרות זו מופעלת כברירת מחדל
עבור יעדים שאינם VxWorks RTP.

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

-mslow-flash-data
נניח שטעינת הנתונים מ-Flash איטית יותר מאשר שליפת הוראות. לכן מילולית
העומס ממוזער לביצועים טובים יותר. אפשרות זו נתמכת רק כאשר
קומפילציה עבור ARMv7 M-profile וכבוי כברירת מחדל.

-masm-תחביר-מאוחד
נניח ש-inline assembler משתמש בתחביר asm מאוחד. ברירת המחדל כבויה כרגע
מה שמרמז על תחביר מחולק. כרגע אפשרות זו זמינה רק עבור Thumb1 ו-
אין השפעה על מצב ARM ו-Thumb2. עם זאת, זה עשוי להשתנות במהדורות עתידיות של
GCC. יש להתייחס לתחביר מחולק שהוצא משימוש.

-מגביל-זה
מגביל יצירת בלוקים של IT כדי להתאים לכללים של ARMv8. בלוקים של IT יכולים
מכילים רק פקודה בודדת של 16 סיביות מתוך קבוצה נבחרת של הוראות. זֶה
האפשרות מופעלת כברירת מחדל עבור מצב ARMv8 Thumb.

-mprint-tune-info
הדפס מידע כוונון CPU כהערה בקובץ assembler. זוהי אפשרות בשימוש
רק לבדיקת רגרסיה של המהדר ולא מיועד לשימוש רגיל ב
קומפילציה קוד. אפשרות זו מושבתת כברירת מחדל.

AVR אפשרויות

אפשרויות אלה מוגדרות עבור יישומי 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{}= "ata5272", "ata6616c", "attiny13", "attiny13a",
"attiny2313", "attiny2313a", "attiny24", "attiny24a", "attiny25", "attiny261",
"attiny261a", "attiny43u", "attiny4313", "attiny44", "attiny44a", "attiny441",
"attiny45", "attiny461", "attiny461a", "attiny48", "attiny828", "attiny84",
"attiny84a", "attiny841", "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{}= "ata5505", "ata6617c", "ata664251",
"atmega16u2", "atmega32u2", "atmega8u2", "attiny1634", "attiny167", "at90usb162",
"at90usb82".

"avr4"
מכשירים "משופרים" עם עד 8@tie{}KiB של זיכרון תוכניות. מקו@tie{}= "ata6285",
"ata6286", "ata6289", "ata6612c", "atmega48", "atmega48a", "atmega48p",
"atmega48pa", "atmega8", "atmega8a", "atmega8hva", "atmega8515", "atmega8535",
"atmega88", "atmega88a", "atmega88p", "atmega88pa", "at90pwm1", "at90pwm2",
"at90pwm2b", "at90pwm3", "at90pwm3b", "at90pwm81".

"avr5"
מכשירים "משופרים" עם 16@tie{}KiB עד 64@tie{}KiB של זיכרון תוכנית.
מקו@tie{}= "ata5702m322", "ata5782", "ata5790", "ata5790n", "ata5795", "ata5831",
"ata6613c", "ata6614q", "atmega16", "atmega16a", "atmega16hva", "atmega16hva2",
"atmega16hvb", "atmega16hvbrevb", "atmega16m1", "atmega16u4", "atmega161",
"atmega162", "atmega163", "atmega164a", "atmega164p", "atmega164pa", "atmega165",
"atmega165a", "atmega165p", "atmega165pa", "atmega168", "atmega168a",
"atmega168p", "atmega168pa", "atmega169", "atmega169a", "atmega169p",
"atmega169pa", "atmega32", "atmega32a", "atmega32c1", "atmega32hvb",
"atmega32hvbrevb", "atmega32m1", "atmega32u4", "atmega32u6", "atmega323",
"atmega324a", "atmega324p", "atmega324pa", "atmega325", "atmega325a",
"atmega325p", "atmega325pa", "atmega3250", "atmega3250a", "atmega3250p",
"atmega3250pa", "atmega328", "atmega328p", "atmega329", "atmega329a",
"atmega329p", "atmega329pa", "atmega3290", "atmega3290a", "atmega3290p",
"atmega3290pa", "atmega406", "atmega64", "atmega64a", "atmega64c1", "atmega64hve",
"atmega64hve2", "atmega64m1", "atmega64rfr2", "atmega640", "atmega644",
"atmega644a", "atmega644p", "atmega644pa", "atmega644rfr2", "atmega645",
"atmega645a", "atmega645p", "atmega6450", "atmega6450a", "atmega6450p",
"atmega649", "atmega649a", "atmega649p", "atmega6490", "atmega6490a",
"atmega6490p", "at90can32", "at90can64", "at90pwm161", "at90pwm216", "at90pwm316",
"at90scr100", "at90usb646", "at90usb647", "at94k", "m3000".

"avr51"
מכשירים "משופרים" עם 128@tie{}KiB של זיכרון תוכניות. מקו@tie{}= "atmega128",
"atmega128a", "atmega128rfa1", "atmega128rfr2", "atmega1280", "atmega1281",
"atmega1284", "atmega1284p", "atmega1284rfr2", "at90can128", "at90usb1286",
"at90usb1287".

"avr6"
מכשירים "משופרים" עם מחשב של 3 בתים, כלומר עם יותר מ-128@tie{}KiB של תוכנית
זיכרון. מקו@tie{}= "atmega256rfr2", "atmega2560", "atmega2561", "atmega2564rfr2".

"avrxmega2"
מכשירי "XMEGA" עם יותר מ-8@tie{}KiB ועד 64@tie{}KiB של זיכרון תוכנית.
מקו@tie{}= "atxmega16a4", "atxmega16a4u", "atxmega16c4", "atxmega16d4",
"atxmega16e5", "atxmega32a4", "atxmega32a4u", "atxmega32c3", "atxmega32c4",
"atxmega32d3", "atxmega32d4", "atxmega32e5", "atxmega8e5".

"avrxmega4"
מכשירי "XMEGA" עם יותר מ-64@tie{}KiB ועד 128@tie{}KiB של תוכנית
זיכרון. מקו@tie{}= "atxmega64a3", "atxmega64a3u", "atxmega64a4u", "atxmega64b1",
"atxmega64b3", "atxmega64c3", "atxmega64d3", "atxmega64d4".

"avrxmega5"
מכשירי "XMEGA" עם יותר מ-64@tie{}KiB ועד 128@tie{}KiB של תוכנית
זיכרון ויותר מ-64@tie{}KiB של זיכרון RAM. מקו@tie{}= "atxmega64a1",
"atxmega64a1u".

"avrxmega6"
התקני "XMEGA" עם יותר מ-128@tie{}KiB של זיכרון תוכניות. מקו@tie{}=
"atxmega128a3", "atxmega128a3u", "atxmega128b1", "atxmega128b3", "atxmega128c3",
"atxmega128d3", "atxmega128d4", "atxmega192a3", "atxmega192a3u", "atxmega192c3",
"atxmega192d3", "atxmega256a3", "atxmega256a3b", "atxmega256a3bu",
"atxmega256a3u", "atxmega256c3", "atxmega256d3", "atxmega384c3", "atxmega384d3".

"avrxmega7"
התקני "XMEGA" עם יותר מ-128@tie{}KiB של זיכרון תוכניות ויותר מ
64@tie{}KiB של זיכרון RAM. מקו@tie{}= "atxmega128a1", "atxmega128a1u", "atxmega128a4u".

"avrtiny"
"TINY" התקני ליבה זעירים עם 512@tie{}B עד 4@tie{}KiB של זיכרון תוכנית.
מקו@tie{}= "attiny10", "attiny20", "attiny4", "attiny40", "attiny5", "attiny9".

"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, אך היא מביאה לקטן יותר
גודל קוד.

-mn-flash=NUM
נניח שלזיכרון הפלאש יש גודל של NUM פעמים 64@tie{}KiB.

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

-להירגע
נסה להחליף "CALL" בהתאמה. הוראת "JMP" על ידי ה"RCALL" הקצר יותר. "RJMP"
הוראה אם ​​רלוונטית. הגדרה -להירגע רק מוסיף את --mlink-להירגע אפשרות
שורת הפקודה של assembler ו- --לְהִרָגַע אפשרות לשורת הפקודה של המקשר.

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

יש להפעיל את ההרגעה אם יש צורך בסתמי קישור, ראה סעיף על "EIND" ו
בדלי קישור למטה.

-מרמוו
נניח שהמכשיר תומך בהוראות קריאה-שינוי-כתיבה "XCH", "LAC", "LAS"
ו-"LAT".

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

אפשרות זו משמשת באופן פנימי על ידי המהדר כדי לבחור ולבנות עבורם multilibs
ארכיטקטורות "avr2" ו-"avr25". ארכיטקטורות אלו מערבבות מכשירים עם ובלי
"SPH". לכל הגדרה מלבד -mmcu=avr2 or -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{}הסיביות התחתונות של מצביע המחסנית.

-nodevicelib
אל תקשר מול הספרייה הספציפית למכשיר של AVR-LibC "libdev.a".

-Waddr-space-convert
התריע על המרות בין מרחבי כתובות במקרה שבו הכתובת המתקבלת
הרווח אינו כלול במרחב הכתובות הנכנסות.

"EIND" ומכשירים עם יותר מ-128 קי בייט של פלאש

המצביעים ביישום הם ברוחב של 16@tie{}סיביות. הכתובת של פונקציה או תווית
מיוצג ככתובת מילה כך שקפיצות ושיחות עקיפות יכולות למקד לכל קוד
כתובת בטווח של 64@tie{}מילים קי.

על מנת לאפשר קפיצה עקיפה למכשירים עם יותר מ-128@tie{}Ki bytes של
שטח זיכרון תוכנית, קיים אוגר פונקציות מיוחד בשם "EIND" המשמש כ
החלק המשמעותי ביותר של כתובת היעד כאשר הוראות "EICALL" או "EIJMP".
מְשׁוּמָשׁ.

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

* המהדר אף פעם לא מגדיר "EIND".

* המהדר משתמש ב-"EIND" באופן מרומז בהוראות "EICALL"/"EIJMP" או עשוי לקרוא
"EIND" ישירות על מנת לחקות קריאה/קפיצה עקיפה באמצעות "RET"
הוראה.

* המהדר מניח ש"EIND" לעולם לא משתנה במהלך קוד האתחול או במהלך
יישום. בפרט, "EIND" אינו נשמר/שוחזר בתפקוד או בפסיקה
פרולוג/אפילוג שגרתי שירות.

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

* יש להפעיל את הרפיית המקשר כדי שהמקשר יפיק את הסטאבים בצורה נכונה
בכל המצבים. ראה את אפשרות המהדר -להירגע ואפשרות הקישור --לְהִרָגַע.
ישנם מקרים פינתיים בהם המקשר אמור ליצור בדלים אך מבטל
ללא הרפיה וללא הודעת שגיאה מועילה.

* סקריפט המקשר המוגדר כברירת מחדל מסודר לקוד עם "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" מוגדר בסקריפט המקשר.

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

-
(קיצור ל ליצור תלים) ככה:

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=מקו אוֹפְּצִיָה. ערכים אפשריים הם:

2, 25, 3, 31, 35, 4, 5, 51, 6

ל מקו="avr2", "avr25", "avr3", "avr31", "avr35", "avr4", "avr5", "avr51", "avr6",

בהתאמה ו

100, 102, 104, 105, 106, 107

ל מקו="avrtiny", "avrxmega2", "avrxmega4", "avrxmega5", "avrxmega6", "avrxmega7",
בהתאמה. אם מקו מציין מכשיר, מאקרו מובנה זה מוגדר בהתאם. ל
לדוגמה, עם -mmcu=atmega8 המאקרו מוגדר ל-4.

"__AVR_מכשיר__"
הגדרת -mmcu=מכשיר מגדיר מאקרו מובנה זה המשקף את שם המכשיר. ל
דוגמא, -mmcu=atmega8 מגדיר את המאקרו המובנה "__AVR_ATmega8__", -mmcu=attiny261a
מגדיר "__AVR_ATtiny261A__", וכו'.

שמות פקודות המאקרו המובנות עוקבים אחר הסכימה "__AVR_מכשיר__" איפה מכשיר האם ה
שם המכשיר כמו ממדריך למשתמש של הרסיבר. ההבדל בין מכשיר במובנה
מאקרו ו מכשיר in -mmcu=מכשיר הוא שהאחרון הוא תמיד באותיות קטנות.

If מכשיר אינו מכשיר אלא רק ארכיטקטורת ליבה כמו avr51, המאקרו הזה לא
מוּגדָר.

"__AVR_DEVICE_NAME__"
הגדרת -mmcu=מכשיר מגדיר מאקרו מובנה זה לשם המכשיר. לדוגמה,
עם -mmcu=atmega8 המאקרו מוגדר ל-"atmega8".

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 של זיכרון תוכנית.

"__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__"
מאקרו זה משקף את -מנו-מפריע אפשרות שורת פקודה.

"__AVR_ERRATA_SKIP__"
"__AVR_ERRATA_SKIP_JMP_CALL__"
לחלק מהתקני רסיבר (AT90S8515, ATmega103) אסור לדלג על הוראות של 32 סיביות בגלל
תקלה בחומרה. הוראות הדילוג הן "SBRS", "SBRC", "SBIS", "SBIC" ו-"CPSE".
המאקרו השני מוגדר רק אם "__AVR_HAVE_JMP_CALL__" מוגדר גם כן.

"__AVR_ISA_RMW__"
למכשיר יש הוראות קריאה-שינוי-כתיבה (XCH, LAC, LAS ו-LAT).

"__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
מעבד. כל הדרכים לעקיפת הבעיה הזמינות עבור עדכון הסיליקון הממוקד מופעלות.
If סירטוויזיון is אף לא אחד, לא מופעלות דרכים לעקיפת הבעיה. אם סירטוויזיון is כל, כל
דרכים לעקיפת הבעיה עבור המעבד הממוקד מופעלות. המאקרו "__SILICON_REVISION__".
מוגדר לשתי ספרות הקסדצימליות המייצגות את המספרים הגדולים והקטנים ב-
עדכון סיליקון. אם סירטוויזיון is אף לא אחד, ה-"__SILICON_REVISION__" אינו מוגדר.
If סירטוויזיון is כל, ה-"__SILICON_REVISION__" מוגדר כ-0xffff. אם זה
אופציונלי סירטוויזיון אינו בשימוש, GCC מניח את גרסת הסיליקון הידועה האחרונה של
מעבד Blackfin ממוקד.

GCC מגדיר מאקרו קדם-מעבד עבור הנתון שצוין מעבד. בשביל ה bfin-elf שרשרת כלים,
אפשרות זו גורמת ל-BSP החומרה שסופק על ידי libgloss להיות מקושר ב-if -מסים is
לא ניתן.

ללא אפשרות זו, bf532 משמש כמעבד כברירת מחדל.

שים לב שתמיכה עבור bf561 אינו שלם. ל bf561, רק המאקרו הקדם-מעבד הוא
מוּגדָר.

-מסים
מציין שהתוכנית תופעל בסימולטור. זה גורם לסימולטור
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 -מקורב, ה
נעשה שימוש במודל תכנות של יישום יחיד/דו-ליבת. בדגם זה, העיקרי
הפונקציה של Core B צריכה להיות בשם "coreb_main".

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

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

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

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

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

C6X אפשרויות

-מרץ=שם
זה מציין את השם של ארכיטקטורת היעד. GCC משתמש בשם זה כדי לקבוע
איזה סוג של הוראות הוא יכול לפלוט בעת יצירת קוד הרכבה. מוּתָר
השמות הם: c62x, c64x, c64x+, c67x, c67x+, c674x.

-mbig-endian
צור קוד עבור יעד גדול.

-מעט-אנדיאן
צור קוד עבור יעד קטן. זוהי ברירת המחדל.

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

-msdata = ברירת מחדל
שים נתונים גלובליים וסטטיים קטנים בקטע ".neardata", שאליו מצביעים
רשום "B14". שים נתונים גלובליים וסטטיים קטנים לא מאותחלים בקטע ".bss",
שנמצא בסמוך לקטע ".neardata". הכנס נתונים קטנים לקריאה בלבד לתוך
קטע ".rodata". הקטעים המקבילים המשמשים עבור פיסות נתונים גדולות הם
".fardata", ".far" ו-".const".

-msdata=הכל
שים את כל הנתונים, לא רק אובייקטים קטנים, בקטעים השמורים לנתונים קטנים, ו
השתמש בכתובת ביחס לרשום "B14" כדי לגשת אליהם.

-msdata=אין
אל תעשה שימוש בקטעים השמורים לנתונים קטנים, והשתמש בכתובות מוחלטות כדי
לגשת לכל הנתונים. שים את כל הנתונים הגלובאליים והסטטיים המאתחלים ב-".fardata"
מקטע, וכל הנתונים הלא מאומתים בקטע ".far". שים את כל הנתונים הקבועים לתוך
הקטע ".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.

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

-sim2
כמו -סים, אבל העבר אפשרויות קישור לאיתור נתונים מאתחלים ב-0x40000000 ואפס-
נתונים מאתחלים ב-0x80000000.

CR16 אפשרויות

אפשרויות אלו מוגדרות במיוחד עבור יציאות CR16.

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

-mcr16cplus
-mcr16c
צור קוד עבור ארכיטקטורת CR16C או CR16C+. ארכיטקטורת CR16C+ היא ברירת מחדל.

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

-מנטה32
בחר סוג מספר שלם ברוחב של 32 סיביות.

-mbit-ops
יוצר הוראות "sbit"/"cbit" עבור מניפולציות של סיביות.

-mdata-model=מודל
בחר מודל נתונים. הבחירות עבור מודל יש לו ליד, רחוק or בינוני. בינוני הוא ברירת מחדל.
עם זאת, רחוק אינו תקף עם -mcr16c, מכיוון שארכיטקטורת CR16C אינה תומכת ב
מודל נתונים רחוק.

דרווין אפשרויות

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

FSF GCC על דרווין אינו יוצר קבצי אובייקט "שמנים"; זה יוצר קובץ אובייקט עבור
ארכיטקטורה יחידה ש-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
אפשרויות ונסרקות בסדר משמאל לימין.

ספריית פריימים היא ספרייה עם מסגרות בתוכה. מסגרת היא א
ספרייה עם א כותרות ו / או ראש פרטי מדריך הכלול ישירות בו כי
נגמר ב .מִסגֶרֶת. שם המסגרת הוא השם של ספרייה זו למעט
מה היא .מִסגֶרֶת. כותרות המשויכות למסגרת נמצאות באחת מהשתיים הללו
ספריות, עם כותרות חיפוש ראשון. תת-מסגרת היא מסגרת
ספרייה שנמצאת בתוך מסגרת מובילות מַדרִיך. כולל מסגרת משנה
כותרות יכולות להופיע רק בכותרת של מסגרת המכילה את תת המסגרת, או
בכותרת משנה של מסגרת אחים. שתי מסגרות משנה הן אחים אם הן מתרחשות ב-
אותה מסגרת. תת-מסגרת לא צריך להיות שם זהה לזה של מסגרת; א
ניתנת אזהרה אם זה מופר. נכון לעכשיו, תת-מסגרת לא יכולה להיות
מסגרות משנה; בעתיד, המנגנון עשוי להיות מורחב כדי לתמוך בכך. ה
ניתן למצוא מסגרות סטנדרטיות ב / System / Library / Frameworks ו
/ Library / Frameworks. דוגמה ל-include נראית כמו "#include ",
איפה מסגרת מציין את שם המסגרת ו header.h נמצא באזור
ראש פרטי or כותרות במדריך.

-iframeworkdir
כמו -F אלא שהספרייה מטופלת כאל ספריית מערכת. ההבדל העיקרי
בין זה -iframework ו -F האם זה עם -iframework המהדר לא מזהיר
אודות מבנים הכלולים בתוך קבצי כותרות שנמצאו באמצעות dir. אפשרות זו תקפה
רק למשפחת השפות C.

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

-מלא
פלט מידע ניפוי באגים עבור כל הסמלים והסוגים.

-mmacosx-version-min=גרסה
הגרסה המוקדמת ביותר של MacOS X שעליה ירוץ קובץ ההפעלה הזה היא גרסה. אופייני
ערכים של גרסה כוללים את 10.1, 10.2 ו-10.3.9.

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

-מקרנל
אפשר מצב פיתוח ליבה. ה -מקרנל ערכות אפשרויות -סטָטִי, -fno-נפוץ,
-fno-use-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)"
הוא 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 הפעלה
אפשרות זו מציינת את הפעלה שיטען את קובץ הפלט של build
צָמוּד. ראה גבר ld(1) למידע נוסף.

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

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

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

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

-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.

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 מופעלת. זה לא יוצר חדש
מנות; זה רק מוסיף NOPs לקיימים.

-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. יש להשתמש במתג זה עם -גברת.

-mexr
אוגרים מורחבים מאוחסנים על מחסנית לפני ביצוע הפונקציה עם צג
תְכוּנָה. אפשרות ברירת המחדל היא -mexr. אפשרות זו תקפה רק עבור יעדי H8S.

-mno-exr
אוגרים מורחבים אינם מאוחסנים בערימה לפני ביצוע הפונקציה עם המוניטור
תְכוּנָה. אפשרות ברירת המחדל היא -mno-exr. אפשרות זו תקפה רק עבור יעדי H8S.

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

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
אל תיצור (או תעשה) קוד אסמבלר עבור מידע ניפוי מספרי שורה של DWARF 2.
זה עשוי להיות שימושי כאשר לא משתמשים ב-GNU assembler.

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

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

-mtls-size=tls-גודל
ציין גודל סיביות של קיזוז TLS מיידי. ערכים חוקיים הם 14, 22 ו-64.

-mtune=סוג מעבד
כוונן את תזמון ההוראות עבור מעבד מסוים, ערכים חוקיים הם איטניום,
איטניום1, מרסד, איטניום2, ו מקינלי.

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

LM32 אפשרויות

אלה -m אפשרויות מוגדרות עבור ארכיטקטורת LatticeMico32:

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

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=אין
השבת את השימוש באזור הנתונים הקטן. משתנים מוכנסים לאחד מ-".data", ".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 51ag 51cn 51em 51je 51jf 51jg 51jm 51mm 51qe 51qm
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
התייחס תמיד לשדות סיביות בגודל "int".

-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".

-מביטופים
מאפשר את הוראות פעולת הסיביות --- בדיקת סיביות ("btstm"), הגדר ("bsetm"), נקה
("bclrm"), הפוך ("bnotm"), ו-test-and-set ("tas").

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

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

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

-חוזר על עצמו
מאפשר את ההוראות "חזרה" ו"חזרה", המשמשות ללולאה נמוכה.

-גברת גורם לכל המשתנים להיכנס כברירת מחדל לקטע ". זעיר". שימו לב שיש א
מגבלה של 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 is
קוד תאימות. ערכים לדוגמה הם 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" ביחס ל-GP.

-mxl-כפיל-גבוה
השתמש בהוראות כפל גבוה עבור חלק גבוה של כפל 32x32.

-mxl-float-convert
השתמש בהוראות המרת נקודה צפה בחומרה.

-mxl-float-sqrt
השתמש בהוראת שורש נקודה צפה בחומרה.

-mbig-endian
צור קוד עבור יעד גדול.

-מעט-אנדיאן
צור קוד עבור יעד קטן.

-mxl-סדר מחדש
השתמש בהוראות לסדר מחדש (החלפה וטעינה/חנות הפוכה של בתים).

-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, MIPS32R3, MIPS32R5, MIPS32R6, mips64, MIPS64R2, MIPS64R3, MIPS64R5
ו MIPS64R6. שמות המעבדים הם: 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, 34kn, 74kc, 74KF2_1, 74KF1_1, 74KF3_2, 1004kc, 1004KF2_1, 1004KF1_1,
loongson2e, longson2f, longson3a, M4K, M14K, m14kc, m14ke, m14kec, אוקטאון, אוקטאון+,
אוקטאון2, אוקטאון3, אוריון, p5600, r2000, r3000, r3900, r4000, r4400, r4600, r4650,
r4700, r6000, r8000, rm7000, rm9000, r10000, r12000, r14000, r16000, sb1, sr71000,
vr4100, vr4111, vr4120, vr4130, vr4300, vr5000, vr5400, vr5500, xlr ו xlp. ה
ערך מיוחד מ-abi בוחר את הארכיטקטורה התואמת ביותר עבור ה-ABI הנבחר
(זה, mips1 עבור 32 סיביות ABI ו mips3 עבור ABI של 64 סיביות).

שרשרת הכלים המקורית של Linux/GNU תומכת גם היא בערך יליד, שבוחר את הטוב ביותר
אפשרות ארכיטקטורה עבור המעבד המארח. -צעדה = יליד אין השפעה אם 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 הוא הערך באותיות רישיות של "_MIPS_ARCH". לדוגמה,
-March=r2000 מגדיר את "_MIPS_ARCH" ל-"r2000" ומגדיר את המאקרו "_MIPS_ARCH_R2000".

שימו לב שהמאקרו "_MIPS_ARCH" משתמש בשמות המעבדים שצוינו למעלה. באחר
מילים, יש לו את הקידומת המלאה ואינו מקצר 000 as k. במקרה של מ-
אבי, המאקרו שם את הארכיטקטורה שנפתרה (או "mips1" או "mips3"). זה שמות
ארכיטקטורת ברירת המחדל כאשר לא -מרץ ניתנת אפשרות.

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

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

-mtune מגדיר את פקודות המאקרו "_MIPS_TUNE" ו-"_MIPS_TUNE_פו", אשר עובדים באותו
דרך כמו ה -מרץ אלה שתוארו לעיל.

-מיפס1
שווה ערך ל -march=mips1.

-מיפס2
שווה ערך ל -march=mips2.

-מיפס3
שווה ערך ל -march=mips3.

-מיפס4
שווה ערך ל -march=mips4.

-מיפס32
שווה ערך ל -march=mips32.

-mips32r3
שווה ערך ל -march=mips32r3.

-mips32r5
שווה ערך ל -march=mips32r5.

-mips32r6
שווה ערך ל -march=mips32r6.

-מיפס64
שווה ערך ל -march=mips64.

-mips64r2
שווה ערך ל -march=mips64r2.

-mips64r3
שווה ערך ל -march=mips64r3.

-mips64r5
שווה ערך ל -march=mips64r5.

-mips64r6
שווה ערך ל -march=mips64r6.

-מיפס16
-mno-mips16
צור (אל תיצור) קוד MIPS16. אם GCC מכוון ל-MIPS32 או MIPS64
ארכיטקטורה, הוא עושה שימוש ב-MIPS16e ASE.

ניתן לשלוט בהפקת קוד MIPS16 גם על בסיס פונקציה באמצעות
תכונות "mips16" ו-"nomips16".

-mflip-mips16
צור קוד MIPS16 על פונקציות מתחלפות. אפשרות זו ניתנת עבור רגרסיה
בדיקה של יצירת קוד מעורב MIPS16/לא MIPS16, ואינה מיועדת לרגיל
להשתמש בהידור קוד משתמש.

-מינטרלינק-דחוס
-mno-interlink-compressed
דרוש (לא דורש) שקוד המשתמש ב-MIPS ISA הסטנדרטי (לא דחוס) יהיה קישור-
תואם לקוד MIPS16 ו-microMIPS, ולהיפך.

לדוגמה, קוד המשתמש בקידוד ISA הסטנדרטי אינו יכול לקפוץ ישירות ל-MIPS16 או
קוד microMIPS; הוא חייב להשתמש בשיחה או בקפיצה עקיפה. -מינטרלינק-דחוס
לכן משבית קפיצות ישירות אלא אם כן GCC יודע שמטרת הקפיצה אינה
דָחוּס.

-minterlink-mips16
-mno-interlink-mips16
כינויים של -מינטרלינק-דחוס ו -mno-interlink-compressed. האפשרויות הללו
קודמים ל-microMIPS ASE ונשמרים עבור תאימות לאחור.

-מאבי=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, MIPS32R3 ו-MIPS32R5.

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

שתי גרסאות נוספות של o32 ABI נתמכות כדי לאפשר מעבר מ
אוגרים של 32 סיביות עד 64 סיביות. אלו הם FPXX (-mfpxx) ו-FP64A (-mfp64
-mno-odd-spreg). ההרחבה FPXX מחייבת שכל הקוד חייב לפעול כהלכה
בעת הפעלה באמצעות אוגרים של 32 סיביות או 64 סיביות. ניתן לקשר את הקוד עם אחד מהם
FP32 או FP64, אבל לא שניהם. הרחבה FP64A דומה להרחבה FP64 אבל
אוסר על שימוש ברגיסטרים עם מספרים אי-זוגיים בעלי דיוק בודד. זה יכול לשמש ב
בשילוב עם מצב "FRE" של FPUs במעבדי MIPS32R5 ומאפשר גם FP32
וקוד FP64A לקישור והפעלה באותו תהליך מבלי לשנות מצבי FPU.

-מאביקלים
-מנו-אביקל
צור (אל תיצור) קוד שמתאים לאובייקטים דינמיים בסגנון 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 סיביות.

-mfpxx
אל תניח את הרוחב של אוגרי נקודה צפה.

-mhard-float
השתמש בהוראות מעבד שותף בנקודה צפה.

-msoft-float
אל תשתמש בהוראות מעבד שותף בנקודה צפה. יישם נקודה צפה
חישובים באמצעות שיחות ספרייה במקום.

-mno-float
שווה ערך ל -msoft-float, אך בנוסף טוענת שהתוכנית הולכת
אינו מבצע שום פעולות נקודה צפה. אפשרות זו נתמכת כעת
רק על ידי כמה תצורות MIPS ממתכת חשופה, שבהן הוא עשוי לבחור סט מיוחד של
ספריות חסרות כל תמיכה בנקודה צפה (כולל, למשל, ה-floating-
פורמטים של נקודה "printf"). אם קוד קומפילד עם -mno-float מכיל בטעות
פעולות של נקודה צפה, היא צפויה לסבול מכשל בזמן קישור או ריצה.

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

-mdouble-float
נניח שהמעבד המשנה בנקודה צפה תומך בפעולות דיוק כפול. זֶה
הוא ברירת המחדל.

-modd-spreg
-mno-odd-spreg
אפשר את השימוש באוגרי נקודה צפה עם מספר אי-זוגי עם דיוק יחיד עבור ה-o32
ABI. זוהי ברירת המחדל עבור מעבדים שידוע כי הם תומכים בריסטרים אלה.
בעת שימוש ב-o32 FPXX ABI, -mno-odd-spreg מוגדר כברירת מחדל.

-מאבס = 2008
-mabs=מורשת
אפשרויות אלה שולטות בטיפול ב-Non-a-number המיוחד (NaN) IEEE 754
נתוני נקודה צפה עם ה-"abs.fmt" ו"שלילה.fmt" הוראות מכונה.

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

השמיים -מאבס = 2008 אפשרות בוחרת בטיפול IEEE 754-2008. במקרה זה אלה
הוראות נחשבות לא אריתמטיות ולכן פועלות כהלכה בכולן
מקרים, כולל במיוחד כאשר אופרנד הקלט הוא NaN. הוראות אלו
לכן משמשים תמיד עבור הפעולות המתאימות.

-mnan=2008
-מנאן=מורשת
אפשרויות אלה שולטות בקידוד של ה-Non-a-number (NaN) המיוחד IEEE 754
נתוני נקודה צפה.

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

השמיים -mnan=2008 אפשרות בוחרת בקידוד IEEE 754-2008. במקרה זה qNaNs הם
מסומן בכך שהחלק הראשון של השדה המשמעותי הנגרר שלהם הוא 1, ואילו sNaNs
מסומנים בכך שהסיבית הראשונה של שדה המובהקות הנגרר שלהם היא 0.

ברירת המחדל היא -מנאן=מורשת אלא אם הוגדרה תצורה של GCC עם --with-nan=2008.

-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 מרמז -לקוי-רווק.

-micromips
-mno-micromips
צור (אל תיצור) קוד microMIPS.

ניתן לשלוט בהפקת קוד MicroMIPS על בסיס פונקציה באמצעות
תכונות "micromips" ו-"nomicromips".

-ממץ
-מנו-מט
השתמש (אל תשתמש) בהוראות MT Multithreading.

-ממקו
-mno-mcu
השתמש (אל תשתמש) בהוראות MIPS MCU ASE.

-מבע
-מנו-אווה
השתמש (אל תשתמש) בהוראות MIPS Enhanced Virtual Addressing.

-מווירט
-mno-virt
השתמש (אל תשתמש) בהוראות הספציפיות של יישום הווירטואליזציה של MIPS.

-mxpa
-mno-xpa
השתמש (אל תשתמש) בהוראות MIPS eXtended Physical Address (XPA).

-מלונג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". לדוגמה, אם הקוד הוא חלק מספריה שעשוי לשמש באתחול
מוניטור, תוכניות הקוראות לשגרות אתחול מוניטור מעבירות ערך לא ידוע ב-$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" עבור מהלכי בלוק לא טריוויאליים. ברירת המחדל היא
-mno-memcpy, המאפשר ל-GCC להטמיע את רוב העותקים בגודל קבוע.

-מלונג-שיחות
-שיחות ארוכות
השבת (אל תבטל) את השימוש בהוראה "jal". קריאה לפונקציות באמצעות "jal"
הוא יעיל יותר אך מחייב את המתקשר והמתקשר להיות באותו 256 מגה בייט
מגזר.

לאפשרות זו אין השפעה על קוד abicalls. ברירת המחדל היא -שיחות ארוכות.

-מאד
-מנון-משוגע
אפשר (השבת) שימוש בהוראות "mad", "madu" ו-"mul", כפי שסופקו על ידי
R4650 ISA.

-מימד
-מנו-אימד
אפשר (השבת) שימוש בהוראות ה-"madd" ו-"msub". ברירת המחדל היא
-מימד על ארכיטקטורות שתומכות ב-"madd" ו-"msub" למעט ה-74k
ארכיטקטורה שבה נמצא כי היא מייצרת קוד איטי יותר.

-מfused-madd
-mno-fused-madd
אפשר (השבת) שימוש בהוראות הכפלה-צבירה של נקודה צפה, כאשר הן
פנויים. ברירת המחדל היא -מfused-madd.

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

-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-rm7000
-mno-fix-rm7000
עקיפת RM7000 "dmult"/"dmultu" errata. הדרכים לעקיפת הבעיה מיושמות על ידי
המאסף ולא על ידי GCC.

-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" או "__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, אך ניתן לעקוף את ברירת המחדל על ידי הגדרה
GCC עם --עם-synci.

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

-mrelax-pic-calls
-mno-relax-pic-calls
נסה להפוך שיחות PIC הנשלחות בדרך כלל באמצעות 25$ לרשום לשיחות ישירות.
זה אפשרי רק אם המקשר יכול לפתור את היעד בזמן הקישור ואם
היעד נמצא בטווח לשיחה ישירה.

-mrelax-pic-calls הוא ברירת המחדל אם GCC הוגדר להשתמש ב-assembler ו-a
מקשר שתומכים בהוראת הרכבה ".reloc" ו -מפורש-רילוקים הוא ב
השפעה. עם -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__".

מוקסי אפשרויות

-מב
צור קוד גדול. זוהי ברירת המחדל עבור מוקסי-*-* תצורות.

-מל
צור קוד קטן-אנדיאן.

-mmul.x
צור הוראות mul.x ו-umul.x. זוהי ברירת המחדל עבור moxiebox-*-*
תצורות.

-mno-crt0
אין לקשר בקובץ אובייקט האתחול בזמן ריצה C.

MSP430 אפשרויות

אפשרויות אלה מוגדרות עבור MSP430:

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

-mmcu=
בחר את ה-MCU למיקוד. זה משמש ליצירת סמל C preprocessor המבוסס על
שם ה-MCU, שהומר לאותיות רישיות ותוקן מראש ואחרי __. זאת בתורו
משמש את msp430.h קובץ כותרת לבחירת כותרת משלימה ספציפית ל-MCU
קובץ.

האפשרות גם מגדירה את ה-ISA לשימוש. אם שם ה-MCU הוא כזה שמוכר רק לו
תמכו ב-430 ISA אז זה נבחר, אחרת ה-430X ISA נבחר. א
שם MCU גנרי של msp430 ניתן להשתמש גם לבחירת ה-430 ISA. באופן דומה ה
גנרית msp430x שם MCU בוחר את ISA 430X.

בנוסף מתווסף סקריפט מקשר ספציפי ל-MCU לשורת הפקודה המקשר. ה
שם התסריט הוא השם של ה-MCU עם .ld מצורף. כך מפרט -mmcu=xxx on
מה היא gcc שורת הפקודה מגדירה את סמל המעבד C "__XXX__" וגורמת לקישור
כדי לחפש סקריפט שנקרא xxx.ld.

אפשרות זו מועברת גם לאסמבלר.

-mcpu=
מציין את ה-ISA לשימוש. הערכים המקובלים הם msp430, msp430x ו msp430xv2. זֶה
האפשרות הוצאה משימוש. ה -mmcu= יש להשתמש באפשרות כדי לבחור את ה-ISA.

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

-להגדיל
השתמש בכתובת בדגם גדול (מצביעים של 20 סיביות, 32 סיביות "size_t").

-msmall
השתמש בכתובת של מודל קטן (מצביעים של 16 סיביות, 16 סיביות "size_t").

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

mhwmult=
מתאר את סוג כפל החומרה הנתמך על ידי היעד. הערכים המקובלים הם
אף לא אחד ללא חומרה להכפיל, 16bit עבור הכפל המקורי של 16 סיביות בלבד נתמך
על ידי MCUs מוקדם. 32bit עבור הכפל של 16/32 סיביות נתמך על ידי MCUs מאוחר יותר ו f5series
להכפלה של 16/32 סיביות הנתמכת על ידי MCUs מסדרת F5. ערך של המכונית גם יכול להיות
נָתוּן. זה אומר ל-GCC להסיק את התמיכה בכפל החומרה בהתבסס על שם ה-MCU
המסופק על ידי -ממקו אוֹפְּצִיָה. אם לא -ממקו אז תצוין אפשרות 32bit חומרה
מניחים תמיכה בכפל. המכונית היא הגדרת ברירת המחדל.

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

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

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

NDS32 אפשרויות

אפשרויות אלה מוגדרות עבור יישומי NDS32:

-mbig-endian
צור קוד במצב big-endian.

-מעט-אנדיאן
צור קוד במצב little-endian.

-mreduced-regs
השתמש באוגרים מופחתים להקצאת פנקס.

-mfull-regs
השתמש ברשימות מלאות להקצאת רישום.

-מקמוב
צור הוראות מעבר מותנה.

-mno-cmov
אל תיצור הוראות תנועה מותנות.

-perf-ext
צור הוראות להרחבת ביצועים.

-mno-perf-ext
אל תיצור הוראות להרחבת ביצועים.

-mv3push
צור הוראות v3 push25/pop25.

-mno-v3push
אל תיצור הוראות v3 push25/pop25.

-m16-bit
צור הוראות של 16 סיביות.

-mno-16-bit
אל תיצור הוראות של 16 סיביות.

-misr-vector-size=NUM
ציין את הגודל של כל וקטור פסיקה, שעליו להיות 4 או 16.

-mcache-block-size=NUM
ציין את הגודל של כל בלוק מטמון, שעליו להיות בחזקת 2 בין 4 ל-512.

-מרץ=קשת
ציין את השם של ארכיטקטורת היעד.

-mcmodel=מודל קוד
הגדר את מודל הקוד לאחד מ

קטן
כל הנתונים וקטעי הנתונים לקריאה בלבד חייבים להיות בשטח כתובות של 512KB.
קטע הטקסט חייב להיות בשטח כתובות של 16MB.

בינוני
קטע הנתונים חייב להיות בטווח של 512KB בעוד שקטע הנתונים לקריאה בלבד יכול להיות
בתוך שטח כתובות של 4GB. קטע הטקסט צריך להיות עדיין בטווח של 16MB
מרחב התייחסות.

גָדוֹל
כל מקטעי הטקסט והנתונים יכולים להיות בשטח כתובות של 4GB.

-מקטור-דטור
אפשר תכונת בנאי/הרס.

-להירגע
מדריך קישור להרגעת הוראות.

ניוס II אפשרויות

אלו הן האפשרויות שהוגדרו עבור מעבד Altera Nios II.

-G NUM
שים אובייקטים גלובליים וסטטיים פחות או שווה ל NUM בתים לתוך הנתונים הקטנים או
קטעי BSS במקום הנתונים הרגילים או קטעי BSS. ערך ברירת המחדל של NUM is
8.

-mgpopt=אוֹפְּצִיָה
-mgpopt
-mno-gpopt
צור (אל תיצור) גישה יחסית ל-GP. הבאים אוֹפְּצִיָה שמות הם
מוּכָּר:

אף לא אחד
אל תיצור גישה ל-GP.

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

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

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

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

-mgpopt שווה -mgpopt=מקומי, ו -mno-gpopt שווה -mgpopt=none.

ברירת המחדל היא -mgpopt אלא מתי -fpic or -fPIC מצוין כדי ליצור מיקום-
קוד עצמאי. שים לב שה-Nios II ABI אינו מאפשר גישה ל-GP מ
ספריות משותפות.

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

-מל
-מב
צור קוד little-endian (ברירת מחדל) או big-endian (ניסיוני), בהתאמה.

-mbypass-cache
-mno-bypass-cache
כפה על כל הוראות הטעינה והאחסון לעקוף תמיד את המטמון באמצעות גרסאות קלט/פלט של
ההוראות. ברירת המחדל היא לא לעקוף את המטמון.

-mno-cache-volatile
-mcache-נדיף
גישה לזיכרון נדיף עוקפת את המטמון באמצעות גרסאות ה-I/O של הטעינה והאחסון
הוראות. ברירת המחדל היא לא לעקוף את המטמון.

-mno-fast-sw-div
-mfast-sw-div
אל תשתמש בחלוקה מהירה מבוססת טבלה עבור מספרים קטנים. ברירת המחדל היא להשתמש במהיר
לחלק ב -O3 ומעל.

-מנו-הוו-מול
-מהו-מול
-mno-hw-mulx
-מהוו-מולקס
-mno-hw-div
-mhw-div
אפשר או השבת את פליטת "mul", "mulx" ו-"div" של משפחת הוראות על ידי
מַהְדֵר. ברירת המחדל היא לפלוט "mul" ולא לפלוט "div" ו-"mulx".

-מנהג-insn=N
-mno-custom-insn
כל אחד -מנהג-insn=N האפשרות מאפשרת שימוש בהוראה מותאמת אישית עם קידוד N מתי
יצירת קוד שמשתמש insn. לדוגמה, -mcustom-fadds=253 מייצר מותאם אישית
הוראה 253 לפעולות הוספה של נקודה צפה עם דיוק יחיד במקום ה-
התנהגות ברירת מחדל של שימוש בשיחת ספרייה.

הערכים הבאים של insn נתמכים. למעט כפי שצוין אחרת, נקודה צפה
הפעולות צפויות להיות מיושמות עם סמנטיקה רגילה של IEEE 754 ו
תואמים ישירות לאופרטורים C או לפונקציות המובנות המקבילות של GCC.

נקודה צפה בעלת דיוק יחיד:

אופנות, fsubs, fdivs, fmuls
פעולות חשבון בינאריות.

fnegs
שלילה לא נורית.

fabss
ערך מוחלט לא נורמלי.

fcmpeqs, fcmpges, fcmpgts, fcmples, fcmplts, fcmpnes
פעולות השוואה.

fmins, fmaxs
מינימום ומקסימום נקודה צפה. הוראות אלו נוצרות רק אם
-סופית-מתמטיקה-בלבד מוגדר.

fsqrts
פעולת שורש ריבועי לא נעשית.

fcoss, פסין, ftans, פתאנים, fexps, מלקות
פונקציות טריגונומטריות ואקספוננציאליות בנקודה צפה. הוראות אלו הן
נוצר רק אם -אופטימיזציות-funsafe-math מצוין גם.

נקודה צפה בעלת דיוק כפול:

פאדד, fsubd, fdivd, פמולד
פעולות חשבון בינאריות.

fnegd
שלילה לא נורית.

fabsd
ערך מוחלט לא נורמלי.

fcmpeqd, fcmpged, fcmpgtd, fcmpled, fcmpltd, fcmpned
פעולות השוואה.

fmind, fmaxd
מינימום ומקסימום דיוק כפול. הוראות אלו נוצרות רק אם
-סופית-מתמטיקה-בלבד מוגדר.

fsqrtd
פעולת שורש ריבועי לא נעשית.

fcosd, fsind, ftand, fatand, fexpd, מלקות
פונקציות טריגונומטריות ואקספוננציאליות עם דיוק כפול. הוראות אלו הן
נוצר רק אם -אופטימיזציות-funsafe-math מצוין גם.

המרות:

textsd
המרה מדיוק יחיד לדיוק כפול.

ftruncds
המרה מדיוק כפול לדיוק יחיד.

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

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

floatis, צף, צף, floatud
המרה מסוגי מספרים שלמים בסימן או ללא סימן לסוגי נקודה צפה.

כמו כן, כל הוראות ההעברה שלהלן עבור רושמים פנימיים X ו-Y
יש לספק כדי להשתמש בכל אחת מהוראות הנקודה הצפה בעלת הדיוק הכפול.
הוראות מותאמות אישית הנוטלות שני אופרנדים מקור כפולים מצפים לראשון
אופרנד ברגיסטר 64 סיביות X. האופרנד השני (או רק אופרנד של unary
פעולה) ניתנת להוראת החשבון המותאמת אישית עם הכי פחות משמעותי
חצי בפנקס המקורות src1 והחצי הכי משמעותי ב src2. תחפושת
הוראה שמחזירה תוצאה בעלת דיוק כפול מחזירה את ה-32 המשמעותי ביותר
סיביות באוגר היעד והחצי השני באוגר של 32 סיביות Y. GCC
מייצר אוטומטית את רצפי הקוד הדרושים כדי לכתוב אוגר X ו/או לקרוא
רשום Y כאשר נעשה שימוש בהוראות נקודה צפה בעלת דיוק כפול.

fwrx
לכתוב src1 לתוך המחצית הפחות משמעותית של X ו src2 לתוך המשמעותי ביותר
חצי מ-X.

חבל
לכתוב src1 לתוך Y.

frdxhi, frdxlo
קרא את החצי המשמעותי ביותר או הפחות (בהתאמה) של X ואחסן אותו dest.

frdy
קרא את הערך של Y ואחסן אותו dest.

שים לב שאתה יכול להשיג יותר שליטה מקומית על הדור של Nios II מותאם אישית
הוראות באמצעות ה-"target("custom-insn=N")" ו-"target("לא-מותאם אישית-insn")"
תכונות פונקציה או פרגמות.

-mcustom-fpu-cfg=שם
אפשרות זו מאפשרת קבוצה מוגדרת מראש בשם של קידודי הוראות מותאמים אישית (ראה
-מנהג-insn מֵעַל). נכון לעכשיו, הקבוצות הבאות מוגדרות:

-mcustom-fpu-cfg=60-1 שווה ל: -mcustom-fmuls=252 -mcustom-fadds=253
-mcustom-fsubs=254 -דיוק-קבוע-יחיד

-mcustom-fpu-cfg=60-2 שווה ל: -mcustom-fmuls=252 -mcustom-fadds=253
-mcustom-fsubs=254 -mcustom-fdivs=255 -דיוק-קבוע-יחיד

-mcustom-fpu-cfg=72-3 שווה ל: -mcustom-floatus=243 -mcustom-fixsi=244
-mcustom-floatis=245 -mcustom-fcmpgts=246 -mcustom-fcmples=249 -mcustom-fcmpeqs=250
-mcustom-fcmpnes=251 -mcustom-fmuls=252 -mcustom-fadds=253 -mcustom-fsubs=254
-mcustom-fdivs=255 -דיוק-קבוע-יחיד

מטלות הדרכה מותאמות אישית שניתנו על ידי אדם -מנהג-insn= לעקוף אפשרויות
אלה שניתנו על ידי -mcustom-fpu-cfg=, ללא קשר לסדר האפשרויות ב-
שורת הפקודה.

שים לב שאתה יכול להשיג יותר שליטה מקומית על בחירת תצורת FPU על ידי
באמצעות ה-"target("custom-fpu-cfg=שֵׁם")" תכונת פונקציה או פרגמה.

אלה נוספים -m אפשרויות זמינות עבור יעדה Altera Nios II ELF (מתכת חשופה):

-מחל
קישור עם HAL BSP. זה מדכא את הקישור עם אתחול זמן הריצה C שסופק על ידי GCC
וקוד סיום, והוא משמש בדרך כלל בשילוב עם -msys-crt0= לפרט
המיקום של קוד האתחול החלופי שסופק על ידי HAL BSP.

-msmallc
קישור לגרסה מוגבלת של ספריית C, -לקטנה, במקום Newlib.

-msys-crt0=קובץ התחלה
קובץ התחלה הוא שם הקובץ של קובץ ההתחלה (crt0) לשימוש בעת הקישור. אפשרות זו
שימושי רק בשילוב עם -מחל.

-msys-lib=systemlib
systemlib הוא שם הספרייה של הספרייה המספקת קריאות מערכת ברמה נמוכה
נדרש על ידי ספריית C, למשל "קרא" ו"כתוב". אופציה זו משמשת בדרך כלל
קישור עם ספרייה שסופקה על ידי HAL BSP.

Nvidia PTX אפשרויות

אפשרויות אלה מוגדרות עבור Nvidia PTX:

-מ 32
-מ 64
צור קוד עבור 32 סיביות או 64 סיביות ABI.

-עיקרון
קישור בקוד לגרעין __ראשי. זה מיועד לעצמאי במקום להורדה
ביצוע.

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.

-m64bit-כפילים
-m32bit-כפילים
הפוך את סוג הנתונים "כפול" להיות 64 סיביות (-m64bit-כפילים) או 32 סיביות (-m32bit-כפילים)
במידה. ברירת המחדל היא -m32bit-כפילים.

יבמ RS/6000 ו PowerPC אפשרויות

אלה -m אפשרויות מוגדרות עבור IBM RS/6000 ו-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.
ציון ה- -mcpu=cpu_type עוקף את המפרט של אפשרויות אלה. אָנוּ
ממליץ לך להשתמש ב -mcpu=cpu_type אפשרות במקום האפשרויות המפורטות למעלה.

מפרט -mpowerpc-gpopt מאפשר ל-GCC להשתמש בארכיטקטורת PowerPC האופציונלית
הוראות בקבוצת המטרה הכללית, כולל שורש ריבועי של נקודה צפה.
מפרט -mpowerpc-gfxopt מאפשר ל-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.

-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,
e5500, e6500, EC603E, G3, G4, G5, עֲנָק, power3, power4, power5, power5+, power6,
כוח 6x, power7, power8, מחשב כוח, powerpc64, powerpc64le, ו rs64.

-mcpu=powerpc, -mcpu=powerpc64, ו -mcpu=powerpc64le ציין PowerPC טהור של 32 סיביות
(כל אחד אנדיאן), 64 סיביות גדול אנדיאן PowerPC ו-64 סיביות אנדיאן קטן PowerPC
סוגי מכונות ארכיטקטורה, עם מודל מעבד גנרי מתאים
מטרות תזמון.

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

השמיים -mcpu אפשרויות מאפשרות או משביתות באופן אוטומטי את האפשרויות הבאות:

-maltivec -mfprnd -mhard-float -mmfcrf -מרובה -mpopcntb -mpopcntd -mpowerpc64
-mpowerpc-gpopt -mpowerpc-gfxopt ציפה אחת -mdouble-float -msimple-fpu -mstring
-ממולהוו -mdlmzb -mmfpgpr -mvsx -mcrypto -mdirect-move -mpower8-fusion
-mpower8-וקטור -mquad-memory -mquad-memory-atomic

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

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

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

מתי -maltivec משמש, במקום -maltivec=le or -maltivec=להיות, סדר האלמנטים
עבור מאפיינים פנימיים של Altivec כגון "vec_splat", "vec_extract" ו-"vec_insert"
סדר רכיבי מערך התואם את הקצה של המטרה. כלומר אלמנט
אפס מזהה את האלמנט השמאלי ביותר באוגר וקטור בעת מיקוד ל- big-endian
פלטפורמה, ומזהה את האלמנט הימני ביותר באוגר וקטור בעת מיקוד ל-a
פלטפורמה קטנה-אנדיאנית.

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

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

-maltivec=le
צור הוראות Altivec באמצעות סדר האלמנטים הקטנים, ללא קשר לשאלה אם
המטרה היא גדולה או קטנה. זוהי ברירת המחדל כאשר ממקדים מעט-
פלטפורמת אנדיאנית. כרגע מתעלמים מהאפשרות הזו בעת מיקוד ל-Big-Endian
פלטפורמה.

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

-mvrsave
-mno-vrsave
צור הוראות VRSAVE בעת הפקת קוד AltiVec.

-mgen-cell-microcode
צור הוראות מיקרוקוד של תא.

-mwarn-cell-microcode
אזהרה כאשר נפלטת הוראת מיקרוקוד של תא. דוגמה למיקרוקוד של תא
ההוראה היא שינוי משתנה.

-msecure-plt
צור קוד שמאפשר ld ו ld.so לבנות איתם קובצי הפעלה וספריות משותפות
קטעי ".plt" ו-".got" שאינם ניתנים להפעלה. זוהי אפשרות PowerPC 32 סיביות SYSV ABI.

-mbss-plt
צור קוד שמשתמש בקטע BSS ".plt" ש ld.so ממלא ודורש ".plt"
וקטעי ".got" שניתנים לכתיבה וגם להפעלה. זהו PowerPC 32 סיביות
אפשרות SYSV ABI.

-מיזל
-mno-isel
מתג זה מאפשר או משבית את יצירת הוראות ISEL.

-מיזל=כן לא
מתג זה הוצא משימוש. להשתמש -מיזל ו -mno-isel במקום.

-mspe
-מנו-ספ
מתג זה מאפשר או משבית את יצירת הוראות SPE simd.

-פגוע
-מוצמדים
מתג זה מאפשר או משבית את היצירה של PAIRED הוראות simd.

-mspe=כן לא
אפשרות זו הוצאה משימוש. להשתמש -mspe ו -מנו-ספ במקום.

-mvsx
-mno-vsx
צור קוד שמשתמש (לא משתמש) בהוראות וקטור/סקלר (VSX), וגם
לאפשר שימוש בפונקציות מובנות המאפשרות גישה ישירה יותר ל-VSX
סט הוראות.

-mcrypto
-mno-crypto
אפשר את השימוש (השבת) בפונקציות המובנות המאפשרות גישה ישירה ל-
הוראות הצפנה שנוספו בגרסה 2.07 של PowerPC ISA.

-mdirect-move
-mno-direct-move
צור קוד שמשתמש (לא משתמש) בהוראות להעברת נתונים בין
רגיסטרים למטרות כלליות והרגיסטרים הוקטורים/סקלרים (VSX) שנוספו
גרסה 2.07 של PowerPC ISA.

-mpower8-fusion
-mno-power8-fusion
צור קוד ששומר (לא שומר) כמה פעולות שלמים צמודות כך שה
ניתן למזג הוראות יחד במעבדי power8 ואילך.

-mpower8-וקטור
-mno-power8-וקטור
צור קוד שמשתמש (לא משתמש) בהוראות הווקטור והסקלריות שהיו
נוסף בגרסה 2.07 של PowerPC ISA. אפשר גם שימוש בפונקציות מובנות
המאפשרים גישה ישירה יותר להוראות הווקטוריות.

-mquad-memory
-mno-quad-memory
צור קוד שמשתמש (לא משתמש) בהוראות הזיכרון הלא-אטומיות של ארבע מילים.
השמיים -mquad-memory האפשרות דורשת שימוש במצב 64 סיביות.

-mquad-memory-atomic
-mno-quad-memory-atomic
צור קוד שמשתמש (לא משתמש) בהוראות הזיכרון של ארבע מילים האטומיות. ה
-mquad-memory-atomic האפשרות דורשת שימוש במצב 64 סיביות.

-mupper-regs-df
-mno-upper-regs-df
צור קוד שמשתמש (לא משתמש) בהוראות הדיוק הכפול הסקלרי ש
למקד את כל 64 הרגיסטרים בערכת הנקודה הצפה הווקטורית/סקלרית שהיו
נוסף בגרסה 2.06 של PowerPC ISA. -mupper-regs-df מופעל כברירת מחדל אם
אתה משתמש בכל אחד מה -mcpu=power7, -mcpu=power8, או -mvsx אפשרויות.

-mupper-regs-sf
-mno-upper-regs-sf
צור קוד שמשתמש (לא משתמש) בהוראות הדיוק הסקלריות הבודדות שבהן
למקד את כל 64 הרגיסטרים בערכת הנקודה הצפה הווקטורית/סקלרית שהיו
נוסף בגרסה 2.07 של PowerPC ISA. -mupper-regs-sf מופעל כברירת מחדל אם
אתה משתמש באחת מהן -mcpu=power8 or -mpower8-וקטור אפשרויות.

-מופר-רגס
-mno-upper-regs
צור קוד שמשתמש (לא משתמש) בהוראות הסקלריות המכוונות לכל 64
רגיסטרים בערכת הנקודה הצפה הווקטורית/סקלרית, בהתאם לדגם של
המכונה.

אם -mno-upper-regs בשימוש, היא מכבה את שניהם -mupper-regs-sf ו
-mupper-regs-df אפשרויות.

-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,
בזמן -מאיקס 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 (שווה ערך ל
ציפה אחת -msimple-fpu), dp_lite (שווה ערך ל -mdouble-float -msimple-fpu),
sp_full (שווה ערך ל ציפה אחת,) ו 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 נעשה שימוש במהלך התזמון השני
לַעֲבוֹר. הטיעון תכנית לוקח אחד מהערכים הבאים:

לא אל תכניס NOPs.

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

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

מספר
הכנס NOPs כדי לאלץ insns תלויים יקרים לקבוצות נפרדות. לְהַכנִיס מספר
NOPs לאלץ insn לקבוצה חדשה.

-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, elfv1,
elfv2.

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

-מאבי=לא-ספ
השבת את הרחבות ABI של Book-E SPE עבור ה-ABI הנוכחי.

-mabi=ibmlongdouble
שנה את ה-ABI הנוכחי לשימוש ב-IBM עם דיוק ארוך כפול מורחב. זה PowerPC
אפשרות SYSV ABI של 32 סיביות.

-mabi=ieeelongdouble
שנה את ה-ABI הנוכחי לשימוש ב-IEEE דיוק ארוך כפול מורחב. זה PowerPC
אפשרות 32-bit Linux ABI.

-mabi=elfv1
שנה את ה-ABI הנוכחי לשימוש ב-ELFv1 ABI. זהו ברירת המחדל של ABI עבור big-endian
PowerPC 64 סיביות לינוקס. לעקוף את ברירת המחדל של ABI נדרשת תמיכת מערכת מיוחדת ו
צפוי להיכשל בדרכים מרהיבות.

-mabi=elfv2
שנה את ה-ABI הנוכחי לשימוש ב-ELFv2 ABI. זהו ברירת המחדל של ABI עבור מעט-
endian PowerPC 64 סיביות לינוקס. לעקוף את ברירת המחדל של 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 בתים, לא
פונקציית האתחול EABI נקראת מ-"main", וה- -msdata אפשרות משתמשת בלבד
"r13" כדי להצביע על אזור נתונים קטן יחיד. ה -מאבי האפשרות מופעלת כברירת מחדל אם אתה
הגדיר את GCC באמצעות אחד מה- powerpc*-*-eabi* אפשרויות.

-msdata=eabi
על מערכת V.4 ומערכות PowerPC משובצות, שים את "קונסט" גלובליות קטן מאותחל ו
נתונים סטטיים בסעיף ".sdata2", שאליו מצביע הרשום "r2". לשים קטן
נתונים גלובליים וסטטיים מאתחלים שאינם "const" בסעיף ".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 משובצות, שים את כל הנתונים הגלובאליים והסטטיים המאתחלים ב-".data"
מקטע, וכל הנתונים הלא מאומתים בקטע ".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" עם רילוקיישן המציין את הפונקציה
טַעֲנָה. ההעברה מאפשרת למקשר לשייך באופן מהימן את קריאת הפונקציה
הוראות הגדרת ארגומנטים עבור אופטימיזציה של TLS, אשר בתורה מאפשרת ל-GCC להשתפר
לתזמן את הרצף.

-phthread
מוסיף תמיכה בריבוי השחלות עם חוטים סִפְרִיָה. אפשרות זו מגדירה דגלים עבור
גם הפרהמעבד וגם המקשר.

-mrecip
-mno-recip
אפשרות זו מאפשרת שימוש באומדן ההדדיות ובאומדן שורש ריבועי הדדי
הוראות עם שלבים נוספים של ניוטון-ראפסון להגברת הדיוק במקום
ביצוע חלוקה או שורש ריבועי וחלוקה עבור ארגומנטים של נקודה צפה. אתה צריך להשתמש
מה היא -מהיר-מתמטיקה אפשרות בעת השימוש -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,
-mcpu=power7 or -mcpu=power8 בוחר אוטומטית -mrecip-דיוק. הכפול-
הוראות אומדן שורש ריבועי מדויק אינן נוצרות כברירת מחדל ב-low-
מכונות מדויקות, שכן הן אינן מספקות אומדן שמתכנס לאחר שלוש
צעדים.

-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-עקיף אפשרות היא ברירת המחדל.

-mcompat-align-parm
-mno-compat-align-parm
צור (אל תיצור) קוד כדי להעביר פרמטרים של מבנה עם יישור מקסימלי
של 64 סיביות, לתאימות עם גרסאות ישנות יותר של GCC.

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

השמיים -mno-compat-align-parm אפשרות היא ברירת המחדל.

RX אפשרויות

אפשרויות שורת הפקודה האלה מוגדרות עבור יעדי RX:

-m64bit-כפילים
-m32bit-כפילים
הפוך את סוג הנתונים "כפול" להיות 64 סיביות (-m64bit-כפילים) או 32 סיביות (-m32bit-כפילים)
במידה. ברירת המחדל היא -m32bit-כפילים. הערות חומרת נקודה צפה RX עובדת רק
על ערכי 32 סיביות, וזו הסיבה שברירת המחדל היא -m32bit-כפילים.

-fpu
-nofpu
מאפשר (-fpu) או משבית (-nofpu) השימוש בחומרת נקודה צפה RX. ה
ברירת המחדל מופעלת עבור סדרת RX600 ומושבתת עבור סדרת RX200.

הוראות נקודה צפה נוצרות רק עבור ערכי נקודה צפה של 32 סיביות,
עם זאת, כך שחומרת ה-FPU אינה משמשת לכפולות אם -m64bit-כפילים האפשרות היא
מְשׁוּמָשׁ.

הערות אם -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 מצוינים בשורת הפקודה.

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

-mno-warn-multiple-fast-interrupts
-mwarn-מרוב-מהיר-מפריע
מונע מ-GCC להוציא הודעת אזהרה אם הוא מוצא יותר מפסיקה מהירה אחת
מטפל כאשר הוא עורך קובץ. ברירת המחדל היא להוציא אזהרה עבור כל תוספת
נמצא מטפל בפסיקה מהירה, מכיוון שה-RX תומך רק בפסיקה אחת כזו.

הערה: אפשרות שורת הפקודה הגנרית של 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 מוגדר, ה-
המהדר יוצר הוראות חומרה בנקודה צפה עשרונית. זוהי ברירת המחדל
ל -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, z196, zEC12, ו z13. בעת יצירת קוד באמצעות ההוראות
זמין ב-z/Architecture, ברירת המחדל היא -מרץ=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=גודל ערימה
אם אפשרויות אלה מסופקות, הקצה האחורי של S/390 פולט הוראות נוספות ב-
פרולוג פונקציות שמפעיל מלכודת אם גודל הערימה הוא מחסנית בתים מעל
גודל ערימה (זכור שהערימה ב-S/390 גדלה כלפי מטה). אם ה מחסנית
האפשרות מושמטת את החזקה הקטן ביותר של 2 גדול מגודל המסגרת של הקומפילציה
הפונקציה נבחרת. אפשרויות אלה מיועדות לשמש כדי לסייע באיתור באגים
בעיות הצפה. הקוד הנפלט בנוסף גורם רק מעט תקורה ו
לפיכך ניתן להשתמש גם במערכות דמויות ייצור ללא ביצועים טובים יותר
הַשׁפָּלָה. הערכים הנתונים צריכים להיות בחזקות מדויקות של 2 ו גודל ערימה צריך להיות
גדול מ מחסנית מבלי לחרוג מ-64k. על מנת להיות יעיל התוספת
קוד עושה את ההנחה שהמחסנית מתחילה בכתובת מיושרת לערך
ניתנו על ידי גודל ערימה. ה מחסנית ניתן להשתמש באפשרות רק בשילוב עם
גודל ערימה.

-mhotpatch=מילים מקדימות,פוסט חצאי מילים
אם האפשרות hotpatch מופעלת, נוצר פרולוג פונקציה "hot-patching" עבור
כל הפונקציות ביחידת ההידור. תווית הפונקציה מוצמדת לנתון
מספר הוראות NOP של שני בתים (מילים מקדימות, מקסימום 1000000). לאחר
תווית, 2 * פוסט חצאי מילים בתים מתווספים, תוך שימוש בהוראות כמו NOP הגדולות ביותר
הארכיטקטורה מאפשרת (מקסימום 1000000).

אם שני הארגומנטים הם אפס, Hotpatching מושבת.

ניתן לעקוף אפשרות זו עבור פונקציות בודדות עם התכונה "hotpatch".

ציון אפשרויות

אפשרויות אלה מוגדרות עבור יישומי ציון:

-מב
הידור קוד עבור מצב גדול. זוהי ברירת המחדל.

-מל
הידור קוד עבור מצב 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.

-m4-100
צור קוד עבור SH4-100.

-m4-100-nofpu
צור קוד עבור SH4-100 בצורה כזו שלא נעשה שימוש ביחידת הנקודה הצפה.

-m4-100-סינגל
צור קוד עבור SH4-100 בהנחה שיחידת הנקודה הצפה נמצאת במצב דיוק יחיד
כברירת מחדל.

-m4-100-יחיד בלבד
צור קוד עבור SH4-100 בצורה כזו שאין נקודה צפה בעלת דיוק כפול
נעשה שימוש בפעולות.

-m4-200
צור קוד עבור SH4-200.

-m4-200-nofpu
צור קוד עבור SH4-200 ללא בצורה כזו שיחידת הנקודה הצפה אינה
מְשׁוּמָשׁ.

-m4-200-סינגל
צור קוד עבור SH4-200 בהנחה שיחידת הנקודה הצפה נמצאת במצב דיוק יחיד
כברירת מחדל.

-m4-200-יחיד בלבד
צור קוד עבור SH4-200 בצורה כזו שאין נקודה צפה בעלת דיוק כפול
נעשה שימוש בפעולות.

-m4-300
צור קוד עבור SH4-300.

-m4-300-nofpu
צור קוד עבור SH4-300 ללא בצורה כזו שיחידת הנקודה הצפה אינה
מְשׁוּמָשׁ.

-m4-300-סינגל
צור קוד עבור SH4-300 בצורה כזו שאין נקודה צפה בעלת דיוק כפול
נעשה שימוש בפעולות.

-m4-300-יחיד בלבד
צור קוד עבור SH4-300 בצורה כזו שאין נקודה צפה בעלת דיוק כפול
נעשה שימוש בפעולות.

-m4-340
צור קוד עבור SH4-340 (ללא MMU, ללא FPU).

-m4-500
צור קוד עבור SH4-500 (ללא FPU). עובר -isa=sh4-nofpu להרכבה.

-m4a-nofpu
צור קוד עבור SH4al-dsp, או עבור SH4a בצורה כזו שהנקודה הצפה
היחידה אינה בשימוש.

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

-m4a-סינגל
צור קוד עבור SH4a בהנחה שיחידת הנקודה הצפה היא ברמת דיוק יחידה
מצב כברירת מחדל.

-m4a
צור קוד עבור SH4a.

-m4al
כמו -m4a-nofpu, אלא שזה עובר במרומז -dsp להרכבה. GCC
לא מייצר הוראות DSP כרגע.

-m5-32media
צור קוד 32 סיביות עבור SHmedia.

-m5-32media-nofpu
צור קוד 32 סיביות עבור SHmedia בצורה כזו שיחידת הנקודה הצפה אינה
מְשׁוּמָשׁ.

-m5-64media
צור קוד 64 סיביות עבור SHmedia.

-m5-64media-nofpu
צור קוד 64 סיביות עבור SHmedia בצורה כזו שיחידת הנקודה הצפה אינה
מְשׁוּמָשׁ.

-m5-קומפקטי
צור קוד עבור SHcompact.

-m5-compact-nofpu
צור קוד עבור SHcompact בצורה כזו שלא נעשה שימוש ביחידת הנקודה הצפה.

-מב הידור קוד עבור המעבד במצב big-endian.

-מל הידור קוד עבור המעבד במצב little-endian.

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

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

- mbigtable
השתמש בקיזוזים של 32 סיביות בטבלאות "בורר". ברירת המחדל היא להשתמש בהיסטים של 16 סיביות.

-מביטופים
אפשר את השימוש בהוראות מניפולציה של סיביות ב-SH2A.

-mfmovd
אפשר את השימוש בהוראה "fmovd". חשבון -מדליין עבור אילוצי יישור.

-mrenesas
ציית למוסכמות השיחות שהוגדרו על ידי Renesas.

-mno-renesas
ציית למוסכמות השיחות שהוגדרו עבור GCC לפני אמנות Renesas
היו זמינים. אפשרות זו היא ברירת המחדל עבור כל היעדים של שרשרת הכלים של SH.

-mnomacsave
סמן את רישום ה-"MAC" כ-Call-clobbered, גם אם -mrenesas נתון.

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

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

-הגדלה
גודל ההוראה ומיקום ההנחיה בקוד ההרכבה.

-mpadstruct
אפשרות זו הוצאה משימוש. זה מרפד מבנים לכפולה של 4 בתים, כלומר
אינו תואם את SH ABI.

-מטומי-מודל=מודל
מגדיר את המודל של פעולות אטומיות ופרמטרים נוספים כמופרד בפסיק
רשימה. לפרטים על הפונקציות המובנות האטומיות ראה __אָטוֹמִי מובנה. ה
הדגמים והפרמטרים הבאים נתמכים:

אף לא אחד
השבת רצפים אטומיים שנוצרו על ידי מהדר ופלוט קריאות ספרייה עבור atomic
פעולות. זוהי ברירת המחדל אם היעד אינו "sh*-*-linux*".

רך-גוסה
צור רצפים אטומיים של תוכנת gUSA תואמי GNU/Linux עבור המבנה האטומי-
בפונקציות. הרצפים האטומיים שנוצרו דורשים תמיכה נוספת מה-
קוד טיפול בפסיקה/חריגה של המערכת ומתאימים רק ל-SH3* ו
מערכות SH4* חד ליבות. אפשרות זו מופעלת כברירת מחדל כאשר היעד הוא
"sh*-*-linux*" ו-SH3* או SH4*. כאשר היעד הוא SH4A, אפשרות זו גם
מנצל חלקית את הוראות החומרה האטומיות "movli.l" ו-"movco.l" ל
ליצור קוד יעיל יותר, אלא אם כן קַפְּדָנִי מוגדר.

soft-tcb
צור רצפי תוכנה אטומיים המשתמשים במשתנה בבקרת החוטים
לַחסוֹם. זוהי וריאציה של רצפי gUSA שניתן להשתמש בהם גם ב-SH1*
ומטרות SH2*. הרצפים האטומיים שנוצרו דורשים תמיכה נוספת מ
קוד הטיפול בפסיקה/חריגה של המערכת ומתאימים רק עבור
מערכות ליבה אחת. בעת שימוש בדגם זה, ה gbr-offset= פרמטר חייב להיות
מצוין גם כן.

רך-imask
צור רצפי תוכנה אטומיים המשביתים באופן זמני פסיקות על ידי הגדרה
"SR.IMASK = 1111". מודל זה פועל רק כאשר התוכנית פועלת במצב מיוחס
ומתאים רק למערכות ליבה אחת. תמיכה נוספת מה
אין צורך בקוד טיפול בפסיקה/חריגה של המערכת. הדגם הזה הוא
מופעל כברירת מחדל כאשר היעד הוא "sh*-*-linux*" ו-SH1* או SH2*.

hard-llcs
צור רצפים אטומיים של חומרה באמצעות ההוראות "movli.l" ו-"movco.l".
רק. זה זמין רק ב-SH4A ומתאים למערכות מרובות ליבות.
מכיוון שהוראות החומרה תומכות רק במשתנים אטומיים של 32 סיביות, גישה ל-8
או משתנים של 16 סיביות מחוקים עם גישה של 32 סיביות. קוד מורכב עם זה
האפשרות תואמת גם לפסיקה/חריגה של מודל אטומי תוכנה אחרת
טיפול במערכות אם מבוצעות על מערכת SH4A. תמיכה נוספת מה
קוד טיפול בפסיקה/חריגה של המערכת אינו נדרש עבור דגם זה.

gbr-offset=
פרמטר זה מציין את ההיסט בבתים של המשתנה בבקרת החוטים
מבנה בלוקים שאמור לשמש את הרצפים האטומיים שנוצרו כאשר
soft-tcb הדגם נבחר. עבור דגמים אחרים מתעלמים מפרמטר זה.
הערך שצוין חייב להיות כפולה שלמה של ארבע ובטווח 0-1020.

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

-mtas
צור את ה-opcode "tas.b" עבור "__atomic_test_and_set". שימו לב כי בהתאם ל
תצורת חומרה ותוכנה מסוימת זה יכול לפגום בביצועים הכוללים
עקב שטפי קו המטמון של האופרנד המשתמעים מהפקודה "tas.b". עַל
מעבדי SH4A מרובי ליבות יש להשתמש בהוראה "tas.b" בזהירות מכיוון שהיא
יכול לגרום לפגיעה בנתונים עבור תצורות מטמון מסוימות.

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

-מצב מוסר
-mno-usermode
אל תאפשר (תאפשר) למהדר שיוצר קוד מצב מיוחס. מפרט
-מצב מוסר גם מרמז -mno-inline-ic_invalidate אם הקוד המוטבע לא יעבוד
במצב משתמש. -מצב מוסר הוא ברירת המחדל כאשר היעד הוא "sh*-*-linux*". אם ה
היעד הוא SH1* או SH2* -מצב מוסר אין השפעה, מכיוון שאין מצב משתמש.

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

-כתובת-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. יש לזה את
השפעה לא מכוונת של הפיכת זה לא בטוח לתזמן הוראות אלו לפני א
להסניף, או להניף אותם מתוך לולאה. לדוגמה, "__do_global_ctors", חלק מ
libgcc שמריץ בנאים בעת הפעלת התוכנית, קורא לפונקציות ברשימה שהיא
תחום ב-1. עם ה -mpt-תוקן אפשרות, ה"ptabs" נעשה לפני הבדיקה
נגד -1. זה אומר שכל הבנאים פועלים קצת יותר מהר, אבל כאשר
לולאה מגיעה לסוף הרשימה, התוכנית קורסת בגלל ש-"ptabs" טוען -1 לתוך a
מאגר יעדים.

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

-mzdcbranch
-mno-zdcbranch
נניח (אל תניח) כי אפס תזוזה מותנית הוראות ענף "bt" ו
"bf" מהירים. אם -mzdcbranch מצוין, המהדר מעדיף תזוזה אפסית
רצפי קוד ענפים. זה מופעל כברירת מחדל בעת יצירת קוד עבור SH4 ו
SH4A. ניתן להשבית אותו במפורש על ידי ציון -mno-zdcbranch.

-mcbranch-force-delay-slot
כפה על השימוש בחריצי השהיה עבור ענפים מותנים, מה שדוחס את חריץ ההשהיה
עם "לא" אם לא ניתן למצוא הוראה מתאימה. כברירת מחדל אפשרות זו היא
נָכֶה. ניתן להפעיל אותו כדי לעקוף באגי חומרה כפי שנמצאו במקור
SH7055.

-מfused-madd
-mno-fused-madd
צור קוד שמשתמש (אינו משתמש) בנקודה הצפה כפולה וצבירה
הוראות. הוראות אלה נוצרות כברירת מחדל אם חומרה נקודה צפה
משמש. התלוי במכונה -מfused-madd האפשרות ממופה כעת למכונה-
עצמאי -ffp-contract=מהיר אפשרות ו -mno-fused-madd ממופה ל
-ffp-contract=off.

-mfsca
-mno-fsca
אפשר או לא לאפשר למהדר לפלוט את הוראת "fsca" עבור סינוס וקוסינוס
קירובים. האפשרות -mfsca יש להשתמש בשילוב עם
-אופטימיזציות-funsafe-math. זה מופעל כברירת מחדל בעת יצירת קוד עבור SH4A.
שימוש -mno-fsca משבית את קירובי הסינוס והקוסינוס גם אם
-אופטימיזציות-funsafe-math הוא בתוקף.

-mfsrra
-מנו-פסרה
אפשר או לא לאפשר למהדר לפלוט את הוראת "fsrra" עבור ריבוע הדדי
קירובי שורש. האפשרות -mfsrra יש להשתמש בשילוב עם
-אופטימיזציות-funsafe-math ו -סופית-מתמטיקה-בלבד. זה מופעל כברירת מחדל כאשר
יצירת קוד עבור SH4A. באמצעות -מנו-פסרה משבית שורש ריבועי הדדי
קירובים גם אם -אופטימיזציות-funsafe-math ו -סופית-מתמטיקה-בלבד נמצאים ב
השפעה.

-mpretend-cmove
העדיפו ענפים מותנים באפס תזוזה להוראת תנועה מותנית
דפוסים. זה יכול לגרום לקוד מהיר יותר במעבד SH4.

Solaris 2 אפשרויות

אלה -m אפשרויות נתמכות על Solaris 2:

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

-טקסט-מימפור
-טקסט-מימפור, בשימוש בנוסף ל -מְשׁוּתָף, אומר למהדר לא לעבור -z טֶקסט ל
המקשר בעת קישור אובייקט משותף. באמצעות אפשרות זו, תוכל לקשר מיקום-
קוד תלוי לאובייקט משותף.

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

-מצב-muser
-mno-user-mode
אל תיצור קוד שיכול לפעול רק במצב מפקח. זה רלוונטי רק עבור
הוראת "casa" שנפלטה עבור מעבד LEON3. זוהי ברירת המחדל.

-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, לאון, leon3, LEON3V7, ספרקליט, f930, f934, sparclite86x, ספרקל,
tsc701, v9, ultrasparc, ultrasparc3, ניאגרה, ניאגרה 2, ניאגרה 3 ו ניאגרה 4.

רשתות הכלים המקוריות של Solaris ו-GNU/Linux תומכות גם הן בערך יליד, אשר בוחר
אפשרות הארכיטקטורה הטובה ביותר עבור המעבד המארח. -mcpu = יליד אין לו השפעה אם
GCC לא מזהה את המעבד.

פרמטרים של תזמון הוראות ברירת מחדל משמשים עבור ערכים הבוחרים ב-
ארכיטקטורה ולא יישום. אלו הם v7, v8, ספרקליט, ספרקל, v9.

להלן רשימה של כל ארכיטקטורה נתמכת והיישומים הנתמכים שלה.

ברוש v7, leon3v7

V8 SupersParc, Hypersparc, ליאון, ליאון

ספרקליט
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, לאון, leon3, LEON3V7, 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.

-mcbcond
-mno-cbcond
עם -mcbcond, GCC מייצר קוד שמנצל את ההשוואה והסניף
הוראות, כפי שהוגדרו ב- Sparc Architecture 2011. ברירת המחדל היא -mcbcond מתי
מיקוד למעבד התומך בהוראות כאלה, כגון niagara-4 ואילך.

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

-mfix-ut699
אפשר את הדרכים המתועדות לעקיפת הבעיה עבור שגיאת הנקודה הצפה ומטמון הנתונים
לבטל שגיאות של מעבד UT699.

אלה -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
כבוד לעומסים ומאגרים של הזיכרון שאליו ניגשים. עם -munsafe-dma
אתה חייב להשתמש במילת המפתח "נדיפה" כדי להגן על גישה לזיכרון, אבל זה יכול להוביל
קוד לא יעיל במקומות שבהם ידוע שהזיכרון אינו משתנה. במקום לסמן
הזיכרון כמו נדיף, אתה יכול להשתמש -msafe-dma להגיד למהדר לטפל ב-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:

-mcmodel=small
צור קוד עבור הדגם הקטן. המרחק לשיחות ישירות מוגבל ל-500M
לכל כיוון. הכתובות היחסיות למחשב הן 32 סיביות. תמיכה בכתובות מוחלטות
טווח הכתובות המלא.

-mcmodel=גדול
צור קוד עבור הדגם הגדול. אין הגבלה על מרחק שיחה, PC-
כתובות יחסיות, או כתובות מוחלטות.

-mcpu=שם
בוחר את סוג המעבד למיקוד. כרגע הסוג הנתמך היחיד הוא tilegx.

-מ 32
-מ 64
צור קוד עבור סביבת 32 סיביות או 64 סיביות. סביבת 32 סיביות מגדירה int,
ארוך, ומצביע ל-32 סיביות. סביבת 64 סיביות מגדירה את int ל-32 סיביות וארוך ו
מצביע ל-64 סיביות.

-mbig-endian
-מעט-אנדיאן
צור קוד במצב אנדיאן גדול/קטן, בהתאמה.

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.

-mv850e3v5
ציין שמעבד היעד הוא V850E3V5. הקבוע הקדם-מעבד
"__v850e3v5__" מוגדר אם נעשה שימוש באפשרות זו.

-mv850e2v4
ציין שמעבד היעד הוא V850E3V5. זהו כינוי ל-
-mv850e3v5 אוֹפְּצִיָה.

-mv850e2v3
ציין שמעבד היעד הוא V850E2V3. הקבוע הקדם-מעבד
"__v850e2v3__" מוגדר אם נעשה שימוש באפשרות זו.

-mv850e2
ציין שמעבד היעד הוא ה-V850E2. הקבוע הקדם-מעבד
"__v850e2__" מוגדר אם נעשה שימוש באפשרות זו.

-mv850e1
ציין שמעבד היעד הוא ה-V850E1. הקבועים הקדם-מעבדים
"__v850e1__" ו-"__v850e__" מוגדרים אם נעשה שימוש באפשרות זו.

-mv850es
ציין שמעבד היעד הוא ה-V850ES. זהו כינוי ל- -mv850e1
אוֹפְּצִיָה.

-mv850e
ציין שמעבד היעד הוא ה-V850E. הקבוע הקדם-מעבד "__v850e__"
מוגדר אם נעשה שימוש באפשרות זו.

אם גם לא -mv850 ולא -mv850e ולא -mv850e1 ולא -mv850e2 ולא -mv850e2v3 ולא -mv850e3v5
מוגדרים ואז נבחר מעבד יעד ברירת מחדל והרלוונטי __v850*__
קבוע קדם-מעבד מוגדר.

הקבועים הקדם-מעבדים "__v850" ו-"__v851__" מוגדרים תמיד, ללא קשר ל
איזו גרסת מעבד היא היעד.

-mdisable-call
-mno-disable-call
אפשרות זו מדכאת את היצירה של הוראת "CALLT" עבור v850e, v850e1,
הטעמים v850e2, v850e2v3 ו-v850e3v5 של ארכיטקטורת v850.

אפשרות זו מופעלת כברירת מחדל כאשר ה-RH850 ABI נמצא בשימוש (ראה -mrh850-abi,) ו
מושבת כברירת מחדל כאשר GCC ABI נמצא בשימוש. אם מתבצעות הוראות "CALLT".
נוצר אז הסמל C preprocessor "__V850_CALLT__" מוגדר.

-להירגע
-מנו-להירגע
להעביר הלאה (או לא להעביר הלאה) את -להירגע אפשרות שורת הפקודה ל-assembler.

-מלונג-קפיצות
-קפיצות-לאורך
השבת (או הפעל מחדש) את יצירת הוראות הקפיצה היחסיות למחשב.

-msoft-float
-mhard-float
השבת (או הפעל מחדש) את הפקת הוראות חומרה לנקודה צפה. זֶה
אפשרות משמעותית רק כאשר ארכיטקטורת היעד היא V850E2V3 או גבוה יותר. אם
נוצרות הוראות נקודה צפה בחומרה ולאחר מכן מקדם המעבד C
הסמל "__FPU_OK__" מוגדר, אחרת הסמל "__NO_FPU__" מוגדר.

-מלופ
מאפשר שימוש בהוראה e3v5 LOOP. השימוש בהוראה זו אינו
מופעל כברירת מחדל כאשר ארכיטקטורת e3v5 נבחרת מכיוון שהשימוש בה עדיין
נִסיוֹנִי.

-mrh850-abi
-מג'ש
מאפשר תמיכה בגרסת RH850 של V850 ABI. זוהי ברירת המחדל. עם
בגרסה זו של ABI חלים הכללים הבאים:

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

* מבנים ואיגודים גדולים (בגודל של יותר מ-8 בתים) עוברים לפי ערך.

* פונקציות מיושרות לגבולות 16 סיביות.

* -m8byte-align אפשרות שורת הפקודה נתמכת.

* -mdisable-call אפשרות שורת הפקודה מופעלת כברירת מחדל. ה
-mno-disable-call אפשרות שורת הפקודה אינה נתמכת.

כאשר גרסה זו של ה-ABI מופעלת, סמל ה-C preprocessor "__V850_RH850_ABI__"
מוגדר.

-mgcc-abi
מאפשר תמיכה בגרסת GCC הישנה של V850 ABI. עם גרסה זו של ABI
הכללים הבאים חלים:

* מבנים ואיגודים בגודל מספר שלם מוחזרים ברישום "r10".

* מבנים ואיגודים גדולים (בגודל של יותר מ-8 בתים) מועברים בהתייחסות.

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

* -m8byte-align אפשרות שורת הפקודה אינה נתמכת.

* -mdisable-call אפשרות שורת הפקודה נתמכת אך אינה מופעלת כברירת מחדל.

כאשר גרסה זו של ה-ABI מופעלת, הסמל C preprocessor "__V850_GCC_ABI__"
מוגדר.

-m8byte-align
-mno-8byte-align
מאפשר תמיכה בסוגים "כפולים" ו"ארוכים ארוכים" להתיישר על גבולות של 8 בתים.
ברירת המחדל היא להגביל את היישור של כל האובייקטים ל-4 בתים לכל היותר. מתי
-m8byte-align הוא למעשה הסמל C preprocessor "__V850_8BYTE_ALIGN__" הוא
מוּגדָר.

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

-mapp-regs
אפשרות זו גורמת לשימוש ב-r2 ו-r5 בקוד שנוצר על ידי המהדר. זֶה
ההגדרה היא ברירת המחדל.

-mno-app-regs
אפשרות זו גורמת להתייחסות ל-r2 ו-r5 כאל אוגרים קבועים.

VAX אפשרויות

אלה -m אפשרויות מוגדרות עבור VAX:

-מוניקס
אל תוציא הוראות קפיצה מסוימות ("aobleq" וכן הלאה) מה-Unix assembler
שכן ה-VAX לא יכול להתמודד עם טווחים ארוכים.

-מגנו
פלט את הוראות הקפיצה האלה, בהנחה שהאסמבלר של GNU נמצא
מְשׁוּמָשׁ.

-מג קוד פלט עבור מספרי נקודה צפה בפורמט G במקום בפורמט D.

ויזיום אפשרויות

-mdebug
תוכנית שמבצעת קלט/פלט של קבצים ומיועדת לפעול על יעד MCM צריכה להיות
מקושר לאפשרות זו. זה גורם לקישור בין הספריות libc.a ו-libdebug.a.
התוכנית צריכה להיות מופעלת על היעד תחת שליטה של ​​איתור באגים מרחוק של GDB
בָּדָל.

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

-mfpu
-mhard-float
צור קוד המכיל הוראות נקודה צפה. זוהי ברירת המחדל.

-mno-fpu
-msoft-float
צור קוד המכיל קריאות לספרייה עבור נקודה צפה.

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

-mcpu=cpu_type
הגדר את ערכת ההוראות, ערכת הרישום ותזמון ההוראות עבור
סוג מכונה cpu_type. ערכים נתמכים עבור cpu_type יש לו מלמ"ק, gr5 ו gr6.

מלמ"ק הוא מילה נרדפת של gr5 נוכח עבור תאימות לאחור.

כברירת מחדל (אלא אם הוגדר אחרת), GCC יוצר קוד עבור גרסת GR5 של
ארכיטקטורת Visium.

עם -mcpu=gr6, GCC מייצר קוד עבור גרסת GR6 של ארכיטקטורת Visium.
ההבדל היחיד מקוד GR5 הוא שהמהדר יפיק מהלך בלוק
הוראות.

-mtune=cpu_type
הגדר את פרמטרי תזמון ההוראות עבור סוג המכונה cpu_type, אבל לא להגדיר
ערכת ההוראות או הרשמה קבעה את האפשרות -mcpu=cpu_type היה.

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

-מצב-muser
צור קוד עבור מצב המשתמש, שבו הגישה לכמה אוגרים כלליים היא
אסור: ב-GR5, לא ניתן לגשת לרישומים r24 עד r31 במצב זה; על
GR6, רק אוגרים r29 עד r31 מושפעים.

VMS אפשרויות

אלה -m אפשרויות מוגדרות עבור יישומי VMS:

-mvms-return-codes
החזר קודי תנאי VMS מ-"main". ברירת המחדל היא החזרת מצב בסגנון POSIX
(למשל שגיאה) קודי.

-mdebug-main=קידומת
סמן את השגרה הראשונה ששמה מתחיל בה קידומת כשגרה העיקרית עבור
מנפה.

-mmalloc64
ברירת מחדל לשגרות הקצאת זיכרון של 64 סיביות.

-mpointer-size=גודל
הגדר את גודל ברירת המחדל של מצביעים. אפשרויות אפשריות עבור גודל יש לו 32 or קצר עבור 32 ביט
מצביעים, 64 or ארוך עבור מצביעי 64 סיביות, ו לא לתמיכה במצביעי 32 סיביות בלבד.
האפשרות המאוחרת יותר משביתה את "פרגמה pointer_size".

VxWorks אפשרויות

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

-mrtp
GCC יכול ליצור קוד הן עבור ליבות VxWorks והן עבור תהליכים בזמן אמת (RTP). זֶה
אופציה עוברת מהראשון לאחר. זה גם מגדיר את המאקרו הקדם-מעבד
"__RTP__".

-לא סטטי
קשר קובץ RTP נגד ספריות משותפות ולא ספריות סטטיות. ה
אפשרויות -סטָטִי ו -מְשׁוּתָף יכול לשמש גם עבור RTPs; -סטָטִי הוא ברירת המחדל.

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

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

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

x86 אפשרויות

אלה -m אפשרויות מוגדרות עבור משפחת x86 של מחשבים.

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

הבחירות עבור סוג מעבד הם:

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

i386
מעבד Intel i386 מקורי.

i486
מעבד Intel i486. (אין תזמון מיושם עבור השבב הזה.)

i586
פנטיום
מעבד Intel Pentium ללא תמיכה ב-MMX.

פנטיום-mmx
Intel Pentium MMX CPU, מבוסס על ליבת Pentium עם תמיכה בערכת הוראות MMX.

pentiumpro
מעבד Intel Pentium Pro.

i686
בעת שימוש עם -מרץ, נעשה שימוש בערכת ההוראות Pentium Pro, כך שהקוד פועל
על כל השבבים המשפחתיים של i686. בשימוש עם -mtune, יש לזה אותה משמעות כמו
גנרית.

פנטיום2
Intel Pentium II CPU, מבוסס על ליבת Pentium Pro עם תמיכה בערכת הוראות MMX.

פנטיום3
פנטיום 3m
מעבד Intel Pentium III, מבוסס על ליבת Pentium Pro עם ערכת הוראות MMX ו-SSE
תומכים.

פנטיום-מ
Intel Pentium M; גרסת הספק נמוך של מעבד Intel Pentium III עם MMX, SSE ו-SSE2
תמיכה בערכת הוראות. בשימוש על ידי מחברות Centrino.

פנטיום4
פנטיום 4m
Intel Pentium 4 CPU עם תמיכה בערכת הוראות MMX, SSE ו-SSE2.

פרסקוט
גרסה משופרת של מעבד Intel Pentium 4 עם הוראות MMX, SSE, SSE2 ו-SSE3
להגדיר תמיכה.

נוקונה
גרסה משופרת של Intel Pentium 4 CPU עם הרחבות של 64 סיביות, MMX, SSE, SSE2 ו
תמיכה בערכת הוראות SSE3.

2
Intel Core 2 CPU עם הרחבות של 64 סיביות, MMX, SSE, SSE2, SSE3 ו-SSSE3
תמיכה בערכת הוראות.

נחלם
מעבד Intel Nehalem עם הרחבות של 64 סיביות, MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1,
תמיכה בערכת הוראות SSE4.2 ו-POPCNT.

ווסטמיר
Intel Westmere CPU עם הרחבות של 64 סיביות, MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1,
תמיכה בערכת הוראות SSE4.2, POPCNT, AES ו-PCLMUL.

גשר סנדי
Intel Sandy Bridge CPU עם הרחבות של 64 סיביות, MMX, SSE, SSE2, SSE3, SSSE3,
תמיכה בערכת הוראות SSE4.1, SSE4.2, POPCNT, AVX, AES ו-PCLMUL.

ivybridge
Intel Ivy Bridge CPU עם הרחבות של 64 סיביות, MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1,
סט הוראות SSE4.2, POPCNT, AVX, AES, PCLMUL, FSGSBASE, RDRND ו-F16C
תומכים.

haswell
Intel Haswell CPU עם הרחבות של 64 סיביות, MOVBE, MMX, SSE, SSE2, SSE3, SSSE3,
SSE4.1, SSE4.2, POPCNT, AVX, AVX2, AES, PCLMUL, FSGSBASE, RDRND, FMA, BMI, BMI2
ותמיכה בערכת הוראות F16C.

Broadwell
Intel Broadwell CPU עם הרחבות של 64 סיביות, MOVBE, MMX, SSE, SSE2, SSE3, SSSE3,
SSE4.1, SSE4.2, POPCNT, AVX, AVX2, AES, PCLMUL, FSGSBASE, RDRND, FMA, BMI, BMI2,
תמיכה בערכת הוראות F16C, RDSEED, ADCX ו-PREFETCHW.

בונל
Intel Bonnell CPU עם הרחבות של 64 סיביות, MOVBE, MMX, SSE, SSE2, SSE3 ו-SSSE3
תמיכה בערכת הוראות.

סילברמונט
Intel Silvermont CPU עם הרחבות של 64 סיביות, MOVBE, MMX, SSE, SSE2, SSE3, SSSE3,
תמיכה בערכת הוראות SSE4.1, SSE4.2, POPCNT, AES, PCLMUL ו-RDRND.

knl מעבד הנחיתה של Intel Knight עם הרחבות של 64 סיביות, MOVBE, MMX, SSE, SSE2, SSE3,
SSSE3, SSE4.1, SSE4.2, POPCNT, AVX, AVX2, AES, PCLMUL, FSGSBASE, RDRND, FMA, BMI,
BMI2, F16C, RDSEED, ADCX, PREFETCHW, AVX512F, AVX512PF, AVX512ER ו-AVX512CD
תמיכה בערכת הוראות.

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
אופטרון
64
athlon-fx
מעבדים המבוססים על ליבת AMD K8 עם תמיכה בערכת הוראות x86-64, כולל
מעבדי AMD Opteron, Athlon 64 ו-Athlon 64 FX. (זה מחליף את MMX,
SSE, SSE2, 3DNow!, 3DNow משופר! והרחבות של ערכת הוראות של 64 סיביות.)

k8-sse3
opteron-sse3
athlon64-sse3
גרסאות משופרות של ליבות AMD K8 עם תמיכה בערכת הוראות 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, FMA4, AVX, XOP, LWP, AES, PCL_MUL, CX16, MMX, SSE,
SSE2, SSE3, SSE4A, SSSE3, SSE4.1, SSE4.2, ABM וערכת הוראות של 64 סיביות
הרחבות.)

bdver3
מעבדי AMD Family 15h מבוססי ליבה עם תמיכה בערכת הוראות x86-64. (זֶה
ערכות-על BMI, TBM, F16C, FMA, FMA4, FSGSBASE, AVX, XOP, LWP, AES, PCL_MUL, CX16,
MMX, SSE, SSE2, SSE3, SSE4A, SSSE3, SSE4.1, SSE4.2, ABM וערכת הוראות של 64 סיביות
הרחבות.

bdver4
מעבדי AMD Family 15h מבוססי ליבה עם תמיכה בערכת הוראות x86-64. (זֶה
ערכות-על BMI, BMI2, TBM, F16C, FMA, FMA4, FSGSBASE, AVX, AVX2, XOP, LWP, AES,
PCL_MUL, CX16, MOVBE, 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 סיביות
הרחבות.)

btver2
מעבדים המבוססים על ליבות AMD Family 16h עם תמיכה בערכת הוראות x86-64. זֶה
כולל MOVBE, F16C, BMI, AVX, PCL_MUL, AES, SSE4.2, SSE4.1, CX16, ABM, SSE4A,
הרחבות SSSE3, SSE3, SSE2, SSE, MMX ו-64 סיביות.

winchip-c6
IDT WinChip C6 CPU, מטופל באותו אופן כמו i486 עם ערכת הוראות MMX נוספת
תומכים.

winchip2
IDT WinChip 2 CPU, מטופל באותו אופן כמו i486 עם MMX נוספים ו-3DNow!
תמיכה בערכת הוראות.

c3 VIA C3 CPU עם MMX ו-3DNow! תמיכה בערכת הוראות. (אין תזמון
מיושם עבור השבב הזה.)

c3-2
מעבד VIA C3-2 (Nehemiah/C5XL) עם תמיכה בערכת הוראות MMX ו-SSE. (לא
תזמון מיושם עבור שבב זה.)

גאוד
מעבד משובץ AMD Geode עם MMX ו-3DNow! תמיכה בערכת הוראות.

-mtune=סוג מעבד
כוון ל סוג מעבד כל מה שיש לקוד שנוצר, מלבד ה-ABI
וערכת ההוראות הזמינות. תוך כדי בחירת ספציפי סוג מעבד לוחות זמנים
דברים המתאימים לשבב המסוים הזה, המהדר לא מייצר שום קוד
שאינו יכול לפעול בסוג המחשב המוגדר כברירת מחדל אלא אם כן אתה משתמש ב-a -מרץ=סוג מעבד אוֹפְּצִיָה.
לדוגמה, אם GCC מוגדר עבור i686-pc-linux-gnu אז -mtune=pentium4 מייצר
קוד שמכוון ל-Pentium 4 אך עדיין פועל על מכונות i686.

הבחירות עבור סוג מעבד זהים ל -מרץ. בנוסף, -mtune תומך 2
אפשרויות נוספות עבור סוג מעבד:

גנרית
הפק קוד מותאם למעבדי IA32/AMD64/EM64T הנפוצים ביותר. אם אתה
לדעת את ה-CPU שעליו יפעל הקוד שלך, אז עליך להשתמש בקוד המתאים
-mtune or -מרץ אפשרות במקום -mtune=גנרי. אבל, אם אתה לא יודע
בדיוק מה יהיה למשתמשי ה-CPU של האפליקציה שלך, אז אתה צריך להשתמש בזה
אוֹפְּצִיָה.

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

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

אינטל
הפק קוד מותאם למעבדי אינטל העדכניים ביותר, שהם Haswell
ו-Silvermont עבור גרסה זו של GCC. אם אתה יודע את המעבד שבו הקוד שלך
ירוץ, אז אתה צריך להשתמש במתאים -mtune or -מרץ אפשרות במקום
-mtune=intel. אבל, אם אתה רוצה, היישום שלך מבצע ביצועים טובים יותר בשני Haswell
וסילברמונט, אז אתה צריך להשתמש באפשרות זו.

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

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

-mcpu=סוג מעבד
מילה נרדפת שהוצאה משימוש עבור -mtune.

-mfpmath=יחידה
צור אריתמטיקה של נקודה צפה עבור היחידה שנבחרה יחידה. הבחירות עבור יחידה הם:

387 השתמש במעבד המשנה הסטנדרטי של 387 נקודות צפה הקיים ברוב השבבים
וחיקוי אחרת. קוד הידור עם אפשרות זו פועל כמעט בכל מקום.
התוצאות הזמניות מחושבות בדיוק של 80 סיביות במקום בדיוק
מוגדר לפי הסוג, וכתוצאה מכך תוצאות מעט שונות בהשוואה לרוב
צ'יפס אחרים. לִרְאוֹת -ffloat-store לתיאור מפורט יותר.

זוהי בחירת ברירת המחדל עבור יעדי x86-32.

ESS השתמש בהוראות נקודה צפה סקלריות הקיימות בערכת ההוראות של SSE. זֶה
ערכת ההוראות נתמכת על ידי פנטיום III ושבבים חדשים יותר, ובקו AMD
של Athlon-4, Athlon XP ו-Athlon MP שבבי. הגרסה הקודמת של ה-SSE
ערכת ההוראות תומכת רק בחשבון בעל דיוק יחיד, ולכן הכפול ו
אריתמטיקה עם דיוק מורחב עדיין נעשים באמצעות 387. גרסה מאוחרת יותר, קיימת
רק בשבבי Pentium 4 ו-AMD x86-64, תומך גם באריתמטיקה בעלת דיוק כפול.

עבור מהדר x86-32, עליך להשתמש -מרץ=סוג מעבד, -msse or -msse2 עובר ל
אפשר הרחבות SSE והפוך את האפשרות הזו ליעילה. עבור מהדר x86-64,
הרחבות אלו מופעלות כברירת מחדל.

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

זוהי בחירת ברירת המחדל עבור מהדר x86-64.

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

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

-mieee-fp
-mno-ieee-fp
שליטה אם המהדר משתמש בהשוואות IEEE של נקודה צפה או לא. אלה
לטפל נכון במקרה בו תוצאת ההשוואה אינה מסודרת.

-msoft-float
צור פלט המכיל קריאות לספרייה עבור נקודה צפה.

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

במכונות בהן פונקציה מחזירה תוצאות נקודה צפה באוגר 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. ציין אפשרות זו כדי להימנע מיצירת הוראות אלו. אפשרות זו היא
ברירת מחדל ב-OpenBSD ו-NetBSD. אפשרות זו נדחפת כאשר -מרץ מעיד על כך
למעבד היעד יש תמיד FPU ולכן ההוראה אינה זקוקה לאמולציה.
הוראות אלה אינן נוצרות אלא אם כן אתה משתמש גם ב-
-אופטימיזציות-funsafe-math מתג.

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

ב-x86-64, -ממאיר-כפול מופעל כברירת מחדל.

אַזהָרָה: אם אתה משתמש ב- -ממאיר-כפול מתג, מבנים המכילים את הסוגים לעיל
מיושרים בצורה שונה ממפרטי הממשק הבינארי של היישום שפורסמו
עבור ה-x86-32 ואינם תואמים בינאריים למבנים בקוד שהידור ללא
המתג הזה.

-m96bit-long-double
-m128bit-long-double
מתגים אלה שולטים בגודל של סוג "כפול ארוך". יישום ה-x86-32 הבינארי
ממשק מציין את הגודל להיות 96 סיביות, אז -m96bit-long-double הוא ברירת המחדל ב
מצב 32 סיביות.

ארכיטקטורות מודרניות (פנטיום וחדשות יותר) מעדיפות "כפול ארוך" להיות מיושר ל-8-
או גבול של 16 בתים. במערכים או במבנים התואמים את ABI, זה לא
אפשרי. כל כך מפרט -m128bit-long-double מיישר את "כפול ארוך" ל-16 בתים
גבול על ידי ריפוד ה"כפול הארוך" באפס נוסף של 32 סיביות.

במהדר x86-64, -m128bit-long-double הוא ברירת המחדל כ-ABI שלו
מציין ש"כפול ארוך" מיושר על גבול של 16 בתים.

שימו לב שאף אחת מהאפשרויות הללו לא מאפשרת דיוק נוסף על תקן x87
של 80 סיביות עבור "כפול ארוך".

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

-מלונג-כפול-64
-מלונג-כפול-80
-מלונג-כפול-128
מתגים אלה שולטים בגודל של סוג "כפול ארוך". גודל של 64 סיביות עושה את
סוג "כפול ארוך" שווה ערך לסוג "כפול". זוהי ברירת המחדל עבור 32 סיביות
ספריית Bionic C. גודל של 128 סיביות הופך את הסוג "כפול ארוך" לשווה ל-
סוג "__float128". זוהי ברירת המחדל עבור ספריית 64 סיביות Bionic C.

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

-malign-data=סוג
שליטה כיצד GCC מיישר משתנים. ערכים נתמכים עבור סוג יש לו compat השימושים גדלו
תואם ערך יישור משתמש ב-GCC 4.8 ואילך, אבי משתמש בערך יישור כ
שצוין על ידי psABI, ו cacheline משתמש בערך יישור מוגבר כדי להתאים את
גודל שורת המטמון. compat הוא ברירת המחדל.

-mlarge-data-threshold=סף
מתי -mcmodel = בינוני מצוין, אובייקטי נתונים גדולים מ- סף ממוקמים ב
מדור הנתונים הגדולים. ערך זה חייב להיות זהה בכל האובייקטים המקושרים אליהם
הבינארי, וברירת המחדל היא 65535.

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

אתה יכול לציין שפונקציה בודדת תיקרא עם רצף הקריאה הזה עם
תכונת הפונקציה "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
יישר מחדש את הערימה בכניסה. ב-x86, ה -mstackrealign אפשרות יוצרת an
פרולוג ואפילוג חלופי שמיישרים מחדש את ערימת זמן הריצה במידת הצורך. זֶה
תומך בערבוב קודים מדור קודם השומרים על יישור מחסנית של 4 בתים עם קודים מודרניים
שמור על יישור מחסנית של 16 בתים עבור תאימות SSE. ראה גם את התכונה
"force_align_arg_pointer", ישים לפונקציות בודדות.

-mreferred-stack-boundary=NUM
נסה לשמור על גבול הערימה מיושר ל-2 מורם ל NUM גבול בתים. אם
-גבול-מחסנית לא צוין, ברירת המחדל היא 4 (16 בתים או 128 סיביות).

אַזהָרָה: בעת יצירת קוד עבור ארכיטקטורת x86-64 עם הרחבות SSE
נָכֶה, -mreferred-stack-boundary=3 ניתן להשתמש כדי לשמור את גבול הערימה מיושר
לגבול 8 בתים. מכיוון ש-x86-64 ABI דורש יישור מחסנית של 16 בתים, זהו ABI
אינו תואם ומיועד לשימוש בסביבה מבוקרת שבה נמצא שטח מחסנית
מגבלה חשובה. אפשרות זו מובילה לקוד שגוי כאשר פונקציות מורכבות עם 16
יישור מחסנית בתים (כגון פונקציות מספריה סטנדרטית) נקראים עם
מחסנית לא מיושרת. במקרה זה, הוראות SSE עלולות להוביל לגישה שגויה לזיכרון
מלכודות. בנוסף, ארגומנטים משתנים מטופלים בצורה שגויה עבור 16 בתים מיושרים
אובייקטים (כולל x87 long double ו-__int128), מה שמוביל לתוצאות שגויות. אתה חייב
לבנות את כל המודולים עם -mreferred-stack-boundary=3, כולל כל ספריות. זֶה
כולל את ספריות המערכת ומודולי ההפעלה.

-mincoming-stack-boundary=NUM
נניח שהמחסנית הנכנסת מיושרת ל-2 שהועלתה ל NUM גבול בתים. אם
-גבול-מחסנית-mincoming לא צוין, זה שצוין על ידי
-גבול-מחסנית משמש.

ב-Pentium ו-Pentium Pro, ערכי "כפול" ו"כפול ארוך" צריכים להיות מיושרים ל-
גבול של 8 בתים (ראה -ממאיר-כפול) או סובלים מביצועים משמעותיים בזמן ריצה
עונשים. ב-Pentium III, סוג הנתונים של הזרמת SIMD Extension (SSE) "__m128" עשוי
אינו פועל כראוי אם הוא אינו מיושר ל-16 בתים.

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

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

-מממקס
-msse
-msse2
-msse3
-mssse3
-msse4
-msse4a
-msse4.1
-msse4.2
-mavx
-mavx2
-mavx512f
-mavx512pf
-mavx512er
-mavx512cd
-משה
-מייס
-mpclmul
-מקלפוסופט
-mfsgsbase
-mrdrnd
-mf16c
-mfma
-mfma4
-mno-fma4
-mprefetchwt1
-mxop
-mlwp
-m3dnow
-mpopcnt
-מאבם
-מבמי
-mbmi2
-mlzcnt
-mfxsr
-mxsave
-mxsaveopt
-mxsavec
-mxsaves
-mrtm
-mtbm
-mmpx
-ממווייטקס
מתגים אלו מאפשרים שימוש בהוראות ב-MMX, SSE, SSE2, SSE3, SSSE3,
SSE4.1, AVX, AVX2, AVX512F, AVX512PF, AVX512ER, AVX512CD, SHA, AES, PCLMUL, FSGSBASE,
RDRND, F16C, FMA, SSE4A, FMA4, XOP, LWP, ABM, BMI, BMI2, FXSR, XSAVE, XSAVEOPT, LZCNT,
RTM, MPX, MWAITX או 3DNow! ערכות הוראות מורחבות. לכל אחד יש תואם -מנו-
אפשרות להשבית את השימוש בהוראות אלה.

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

ליצור הוראות SSE/SSE2 באופן אוטומטי מקוד נקודה צפה (בניגוד
להוראות 387), ראה -mfpmath = sse.

GCC מדכא הוראות SSEx כאשר -mavx משמש. במקום זאת, הוא מייצר AVX חדש
הוראות או שקילות AVX עבור כל הוראות ה-SSEx בעת הצורך.

אפשרויות אלה מאפשרות ל-GCC להשתמש בהוראות המורחבות הללו בקוד שנוצר, אפילו
לְלֹא -mfpmath = sse. יישומים שמבצעים זיהוי CPU בזמן ריצה חייבים לבצע קומפילציה
קבצים נפרדים עבור כל ארכיטקטורה נתמכת, תוך שימוש בדגלים המתאימים. ב
במיוחד, הקובץ המכיל את קוד זיהוי ה-CPU צריך להיות הידור ללא
אפשרויות אלה.

-mdump-tune-features
אפשרות זו מורה ל-GCC לזרוק את השמות של תכונות כוונון הביצועים של x86 ו
הגדרות ברירת מחדל. ניתן להשתמש בשמות ב -mtune-ctrl=רשימת תכונות.

-mtune-ctrl=רשימת תכונות
אפשרות זו משמשת לשליטה עדינה בתכונות יצירת קוד x86.
רשימת תכונות היא רשימה מופרדת בפסיקים של תכונה שמות. ראה גם
-mdump-tune-features. כאשר צוין, ה תכונה מופעל אם אין להקדים
עם ^, אחרת, הוא כבוי. -mtune-ctrl=רשימת תכונות מיועד לשימוש
על ידי מפתחי GCC. השימוש בו עלול להוביל לנתיבי קוד שאינם מכוסים בבדיקה ויכולים
עלול לגרום ל-ICEs מהדר או לשגיאות זמן ריצה.

-mno-default
אפשרות זו מורה ל-GCC לבטל את כל התכונות הניתנות לשינוי. ראה גם
-mtune-ctrl=רשימת תכונות ו -mdump-tune-features.

-mcld
אפשרות זו מורה ל-GCC לפלוט הוראת "cld" בפרולוג הפונקציות
המשתמשים בהוראות מחרוזת. הוראות מחרוזת תלויות בדגל ה-DF לבחירה
בין מצב הגדלה אוטומטית או הפחתה אוטומטית. בעוד ה-ABI מציין את דגל ה-DF ל
יש לנקות בהזנת פונקציה, חלק ממערכות ההפעלה מפרות מפרט זה בכך שלא
ניקוי דגל DF בשולחי החריג שלהם. המטפל חריג יכול להיות
מופעל עם סט דגל DF, מה שמוביל למצב כיוון שגוי בעת מחרוזת
נעשה שימוש בהוראות. ניתן להפעיל אפשרות זו כברירת מחדל ביעדי x32 של 86 סיביות על ידי
הגדרת GCC עם ה --enable-cld אפשרות להגדיר. דור של "cld"
ניתן לדכא הוראות באמצעות ה -mno-cld אפשרות מהדר במקרה זה.

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

-mrefer-avx128
אפשרות זו מורה ל-GCC להשתמש בהוראות 128-bit AVX במקום 256-bit AVX
הוראות ב-Vectorizer האוטומטי.

-mcx16
אפשרות זו מאפשרת ל-GCC ליצור הוראות "CMPXCHG16B". "CMPXCHG16B" מאפשר
עבור פעולות אטומיות על סוגי נתונים כפולים של ארבע מילים (או oword) של 128 סיביות. זה
שימושי עבור מונים ברזולוציה גבוהה שניתן לעדכן על ידי מספר מעבדים (או
ליבות). הוראה זו נוצרת כחלק מפונקציות מובנות אטומיות: ראה
__סינכרון מובנה or __אָטוֹמִי מובנה לקבלת פרטים.

-משף
אפשרות זו מאפשרת יצירת הוראות "SAHF" בקוד 64 סיביות. מוקדם של אינטל
מעבדי פנטיום 4 עם תמיכה של אינטל 64, לפני הצגת שלב פנטיום 4 G1
בדצמבר 2005, חסרו הוראות "LAHF" ו-"SAHF" הנתמכות על ידי
AMD64. אלו הן הוראות טעינה ואחסון, בהתאמה, עבור דגלי סטטוס מסוימים.
במצב 64 סיביות, ההוראה "SAHF" משמשת לאופטימיזציה של "fmod", "drem" ו
"שארית" פונקציות מובנות; לִרְאוֹת אחר מובנה לקבלת פרטים.

-ממוב
אפשרות זו מאפשרת שימוש בהוראה "movbe" ליישום "__builtin_bswap32"
ו-"__builtin_bswap64".

-mcrc32
אפשרות זו מאפשרת פונקציות מובנות "__builtin_ia32_crc32qi",
"__builtin_ia32_crc32hi", "__builtin_ia32_crc32si" ו-"__builtin_ia32_crc32di" ל
צור את הוראת המכונה "crc32".

-mrecip
אפשרות זו מאפשרת שימוש בהוראות "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
אפשר את הקירוב עבור חלוקה וקטורית.

מ"ר
אפשר את הקירוב לשורש ריבועי סקלרי.

vec-sqrt
אפשר את הקירוב לשורש ריבועי וקטורי.

אז, למשל, -mrecip=all,!sqrt מאפשר את כל הקירוב ההדדיים,
חוץ מהשורש הריבועי.

-mveclibabi=סוג
מציין את סוג ABI לשימוש עבור וקטוריזציה פנימית באמצעות ספרייה חיצונית.
ערכים נתמכים עבור סוג יש לו svml עבור ספריית המתמטיקה הווקטורית הקצרה של אינטל ו acml
עבור ספריית הליבה המתמטית של AMD. כדי להשתמש באפשרות זו, שניהם -ftree-vectorize ו
-אופטימיזציות-funsafe-math חייבים להיות מופעלים, ו-SVML או ACML ABI תואם
יש לציין את הספרייה בזמן הקישור.

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 is
בשימוש, ו-"__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 משמש.

-מאבי=שם
צור קוד עבור מוסכמות השיחות שצוינה. ערכים מותרים הם sysv ל
ה-ABI המשמש ב-GNU/Linux ומערכות אחרות, ו ms עבור Microsoft ABI. ה
ברירת המחדל היא להשתמש ב-Microsoft ABI כאשר ממקדים ל-Microsoft Windows ול-SysV ABI
בכל שאר המערכות. אתה יכול לשלוט בהתנהגות זו עבור פונקציות ספציפיות על ידי שימוש
תכונות הפונקציה "ms_abi" ו-"sysv_abi".

-mtls-dialect=סוג
צור קוד כדי לגשת לאחסון מקומי באמצעות גנו or gnu2 מוסכמות. גנו
הוא ברירת המחדל השמרנית; gnu2 הוא יעיל יותר, אבל הוא עשוי להוסיף קומפיל-והפעלה-
דרישות זמן שלא ניתן לעמוד בהן בכל המערכות.

-מפוש-ארגס
-mno-push-args
השתמש בפעולות PUSH כדי לאחסן פרמטרים יוצאים. שיטה זו קצרה יותר ובדרך כלל
מהירה באותה מידה כמו שיטה המשתמשת בפעולות SUB/MOV והיא מופעלת כברירת מחדל. בחלק
מקרים השבתת אותו עשויה לשפר את הביצועים בגלל תזמון משופר ומופחת
תלות.

-צבור-יוצא-ארגים
אם מופעל, כמות השטח המקסימלית הנדרשת עבור ארגומנטים יוצאים מחושבת
פרולוג הפונקציה. זה מהיר יותר ברוב המעבדים המודרניים בגלל מופחת
תלות, תזמון משופר ושימוש מופחת בערימה כאשר הערימה המועדפת
הגבול אינו שווה ל-2. החיסרון הוא עלייה בולטת בגודל הקוד. זֶה
מתג מרמז -mno-push-args.

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

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

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

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

-mstringop-strategy=ALG
לעקוף את היוריסטית ההחלטה הפנימית עבור האלגוריתם המסוים לשימוש
פעולות מחרוזות מוטבעות. הערכים המותרים עבור ALG הם:

rep_byte
rep_4 בייט
rep_8 בייט
הרחב באמצעות הקידומת "rep" i386 בגודל שצוין.

byte_loop
לולאה
unrolled_loop
הרחב ללולאה מוטבעת.

libcall
השתמש תמיד בשיחת ספרייה.

-mmemcpy-strategy=אסטרטגיה
עוקף את היוריסטית ההחלטה הפנימית כדי להחליט אם "__builtin_memcpy" צריך להיות
מוטבע ואיזה אלגוריתם מוטבע להשתמש כאשר הגודל הצפוי של פעולת ההעתקה
ידוע. אסטרטגיה היא רשימה המופרדת בפסיקים של ALG:גודל מקסימלי:dest_align שלישיות. ALG
מוגדר ב -אסטרטגיה-mstringop, גודל מקסימלי מציין את גודל הבתים המקסימלי שאיתו
אלגוריתם מוטבע ALG מותר. עבור השלישייה האחרונה, ה גודל מקסימלי חייב להיות "-1". ה
גודל מקסימלי יש לציין את השלשות ברשימה בסדר עולה. ה
גודל בתים מינימלי עבור ALG הוא 0 עבור השלישייה הראשונה ו"גודל מקסימלי + 1" של
הטווח הקודם.

-mmemset-strategy=אסטרטגיה
האפשרות דומה ל -mmemcpy-strategy= אלא שזה כדי לשלוט
הרחבה "__builtin_memset".

-momit-leaf-frame-pointer
אל תשמור את מצביע המסגרת בפנקס עבור פונקציות עלים. זה נמנע את
הוראות לשמירה, הגדרה ושחזור של מצביעי מסגרת ועושה רישום נוסף
זמין בפונקציות עלים. האפשרות -fomit-leaf-frame-pointer מסיר את המסגרת
מצביע עבור פונקציות עלים, מה שעשוי להקשות על ניפוי באגים.

-mtls-direct-seg-refs
-mno-tls-direct-seg-refs
שולט אם ניתן לגשת למשתני TLS עם היסטים מקטע TLS
לרשום (%gs עבור 32 סיביות, %fs עבור 64 סיביות), או אם מצביע בסיס השרשור חייב להיות
הוסיף. אם זה תקף או לא תלוי במערכת ההפעלה, והאם היא
ממפה את הקטע כך שיכסה את כל אזור ה-TLS.

עבור מערכות המשתמשות בספריית GNU C, ברירת המחדל מופעלת.

-msse2avx
-mno-sse2avx
ציין שהאסמבלר צריך לקודד הוראות SSE עם קידומת VEX. האפשרות
-mavx מפעיל את זה כברירת מחדל.

-מפנטרי
-מנו-פנטרי
אם הפרופיל פעיל (-עמוד), שים את שיחת מונה הפרופיל לפני הפרולוג.
הערה: בארכיטקטורות x86 התכונה "ms_hook_prologue" אינה אפשרית ב-
רגע עבור -מפנטרי ו -עמוד.

-mrecord-mcount
-mno-record-mcount
אם הפרופיל פעיל (-עמוד), צור קטע __mcount_loc המכיל מצביעים
לכל שיחת פרופיל. זה שימושי לתיקון ויציאה אוטומטית של שיחות.

-mnop-mcount
-מנו-נופ-ממונה
אם הפרופיל פעיל (-עמוד), צור את הקריאות לפונקציות הפרופיל כ-nops.
זה שימושי כאשר יש לתקן אותם מאוחר יותר באופן דינמי. זה כנראה רק
שימושי יחד עם -mrecord-mcount.

-mskip-rax-setup
-mno-skip-rax-setup
בעת יצירת קוד עבור ארכיטקטורת x86-64 עם הרחבות SSE מושבתות,
-דילוג-rax-setup ניתן להשתמש כדי לדלג על הגדרת אוגר RAX כאשר אין משתנה
ארגומנטים שהועברו ברגיסטרים וקטורים.

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

-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 לא מיושר עומס ואחסון.

-mstack-protector-guard=שומר
צור קוד הגנה מחסנית באמצעות Canary at שומר. מיקומים נתמכים הם גלוֹבָּלִי
לקנרית עולמית או Tls עבור קנרית לכל חוט בבלוק TLS (ברירת המחדל). זֶה
לאופציה יש השפעה רק כאשר -מגן מחסנית or -fstack-protector-all מוגדר.

אלה -m מתגים נתמכים בנוסף לאמור לעיל במעבדי x86-64 ב-64 סיביות
סביבות.

-מ 32
-מ 64
-mx32
-מ 16
צור קוד עבור סביבת 16 סיביות, 32 סיביות או 64 סיביות. ה -מ 32 הגדרות אפשרויות "int",
"ארוך", ומצביע מקליד ל-32 סיביות, ומייצר קוד שרץ על כל מערכת i386.

השמיים -מ 64 אפשרות מגדירה "int" ל-32 סיביות ו-"long" וסוגי מצביע ל-64 סיביות, ו
יוצר קוד עבור ארכיטקטורת x86-64. עבור דרווין רק את -מ 64 אפשרות גם
מכבה את -fno-pic ו -מדינמית-ללא-תמונה אפשרויות.

השמיים -mx32 אפשרות מגדירה "int", "long" וסוגי מצביע ל-32 סיביות, ומפיקה קוד
עבור ארכיטקטורת x86-64.

השמיים -מ 16 אפשרות זהה ל -מ 32, מלבד זה הוא מוציא את ה-".code16gcc"
הוראת assembly בתחילת הפלט assembly כך שהבינארי יוכל לפעול
במצב 16 סיביות.

-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.

x86 Windows אפשרויות

אפשרויות נוספות אלו זמינות עבור יעדי Microsoft Windows:

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

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

-mnop-fun-dllimport
אפשרות זו זמינה עבור יעדי Cygwin ו-MinGW. הוא מציין כי
יש להתעלם מתכונת "dllimport".

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

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

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

-mwindows
אפשרות זו זמינה עבור יעדי Cygwin ו-MinGW. זה מציין ש-GUI
יש ליצור יישום על ידי הוראה למקשר להגדיר את כותרת PE
סוג תת מערכת כראוי.

-fno-set-stack-ניתן להפעלה
אפשרות זו זמינה עבור יעדי MinGW. זה מציין שדגל ההפעלה עבור
המחסנית המשמשת את הפונקציות המקוננות לא מוגדרת. זה הכרחי להפעלת קבצים בינאריים
במצב ליבה של Microsoft Windows, כמו שם ה-User32 API, המשמש להגדרה
הרשאות הפעלה, אינו זמין.

-fwritable-relocated-rdata
אפשרות זו זמינה עבור יעדי MinGW ו-Cygwin. זה מציין שהעברה-
נתונים בקטע לקריאה בלבד מוכנסים למקטע .data. זה הכרחי למבוגרים
זמני ריצה לא תומכים בשינוי של קטעי rdata עבור פסאודו-relocation.

-mpe-aligned-commons
אפשרות זו זמינה עבור יעדי Cygwin ו-MinGW. זה מציין שה-GNU
הרחבה לפורמט הקובץ PE המאפשר יישור נכון של משתני COMMON
יש להשתמש בעת יצירת קוד. זה מופעל כברירת מחדל אם GCC מזהה ש-
רכיב מטרה שנמצא במהלך ההגדרה תומך בתכונה.

ראה גם תחת x86 אפשרויות עבור אפשרויות סטנדרטיות.

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

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

zSeries אפשרויות

אלה מפורטים למטה

אפשרויות ל קופונים דור אמנות
אפשרויות אלו שאינן תלויות במכונה שולטות במוסכמות הממשק המשמשות בקוד
דוֹר.

לרובם יש צורות חיוביות ושליליות כאחד; הצורה השלילית של -ffoo. is
-fno-foo. בטבלה למטה, רק אחד מהטפסים מופיע --- זה שאינו ה-
בְּרִירַת מֶחדָל. אתה יכול להבין את הטופס האחר על ידי הסרה לא- או הוספתו.

-fbounds-check
עבור ממשקי קצה שתומכים בזה, צור קוד נוסף כדי לבדוק מה נהגו המדדים
מערכי גישה נמצאים בטווח המוצהר. זה נתמך כרגע רק על ידי
ממשקי קצה של Java ו-Fortran, כאשר אפשרות זו מוגדרת כברירת מחדל כ-true ו-false
בהתאמה.

-fstack-reuse=רמת שימוש חוזר
אפשרות זו שולטת בשימוש חוזר בחלל מחסנית עבור משתנים מקומיים/אוטומטיים המוצהרים על ידי המשתמש ו
מהדר שנוצר זמני. reuse_level יכול להיות את כל, named_vars, או אף לא אחד. את כל
מאפשר שימוש חוזר במחסנית עבור כל המשתנים המקומיים והזמניים, named_vars מאפשר
שימוש חוזר רק עבור משתנים מקומיים המוגדרים על ידי המשתמש עם שמות, ו אף לא אחד משבית שימוש חוזר במחסנית
לַחֲלוּטִין. ערך ברירת המחדל הוא את כל. האפשרות נחוצה כאשר התוכנית מתארכת
משך החיים של משתנה מקומי בהיקף או מהדר שנוצר זמני מעבר ל-
נקודת הסיום המוגדרת על ידי השפה. מתי מסתיים חייו של משתנה, ואם ה
חיים משתנים בזיכרון, למהדר המייעל יש את החופש לעשות שימוש חוזר בערימה שלו
מרחב עם משתנים מקומיים זמניים אחרים או בעלי היקף שהטווח החי שלהם לא
חופפים איתו. קוד מדור קודם המאריך את תוחלת החיים המקומית עשוי לשבור את
אופטימיזציה לשימוש חוזר מחסנית.

לדוגמה,

int * p;
{
int local1;

p = &local1;
local1 = 10;
....
}
{
int local2;
local2 = 20;
...
}

if (*p == 10) // שימוש מחוץ לטווח של local1
{

}

דוגמא נוספת:

מבנה א
{
A(int k) : i(k), j(k) { }
int i;
int j;
};

A *ap;

void foo(const A& ar)
{
ap = &ar;
}

void bar()
{
פו(A(10)); // משך החיים של אובייקט זמני מסתיים כאשר foo חוזר

{
A a(20);
....
}
ap->i+= 10; // הפניות לאפליקציה מחוץ לטווח הטמפ' שהמרחב שלה
// נעשה שימוש חוזר עם א. מה הערך של ap->i?
}

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

-ftrapv
אפשרות זו יוצרת מלכודות עבור גלישה חתומה בחיבור, חיסור,
פעולות כפל.

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

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

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

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

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

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

-fno-gnu-unique
במערכות עם GNU assembler וספריית C לאחרונה, המהדר C++ משתמש ב-
"STB_GNU_UNIQUE" מחייב כדי לוודא שהגדרות של תבנית נתונים סטטיים חברים
ומשתנים מקומיים סטטיים בפונקציות מוטבעות הם ייחודיים אפילו בנוכחות
"RTLD_LOCAL"; זה הכרחי כדי למנוע בעיות עם ספרייה המשמשת שניים שונים
תוספים "RTLD_LOCAL" בהתאם להגדרה באחד מהם ולכן
חולק על השני לגבי עקידת הסמל. אבל זה גורם
"dlclose" שיש להתעלם ממנו עבור DSOs מושפעים; אם התוכנית שלך מסתמכת על אתחול מחדש
של DSO באמצעות "dlclose" ו-"dlopen", אתה יכול להשתמש -fno-gnu-unique.

-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" להיות "short unsigned int" במקום
ברירת המחדל עבור היעד. אפשרות זו שימושית לבניית תוכניות לרוץ בהן
יַיִן.

אַזהָרָה: מה היא -fshort-wchar switch גורם ל-GCC ליצור קוד שאינו בינארי
תואם לקוד שנוצר ללא המתג הזה. השתמש בו כדי להתאים לא-
ממשק בינארי של יישום ברירת המחדל.

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

-fno-ident
התעלם מההנחיה "#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. ל-x86 אין מגבלה כזו.)

קוד בלתי תלוי במיקום דורש תמיכה מיוחדת, ולכן עובד רק על
מכונות מסוימות. עבור ה-x86, 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);

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

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

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

-finstrument-functions-exclude-file-list=פילה,פילה, ...
הגדר את רשימת הפונקציות שאינן נכללות במכשור (ראה את התיאור
of -finstrument-פונקציות). אם הקובץ שמכיל הגדרת פונקציה תואם
עם אחד מ פילה, אז הפונקציה הזו אינה מכשירה. ההתאמה מתבצעת ב
מחרוזות משנה: אם ה פילה פרמטר הוא מחרוזת משנה של שם הקובץ, הוא נחשב ל
להיות התאמה.

לדוגמה:

-finstrument-functions-exclude-file-list=/bits/stl,include/sys

אינו כולל כל פונקציה מוטבעת המוגדרת בקבצים ששמות הנתיבים שלהם מכילים /bits/stl or
כוללים/sys.

אם, מסיבה כלשהי, אתה רוצה לכלול מכתב , באחד מ SYM, כתוב ,. לדוגמה,
-finstrument-functions-exclude-file-list=',,tmp' (שים לב לציטוט היחיד שמסביב
האפשרות).

-finstrument-functions-exclude-function-list=SYM,SYM, ...
זה דומה ל -finstrument-functions-exclude-file-list, אך אפשרות זו מגדירה את ה
רשימה של שמות פונקציות שיש להוציא מהמכשיר. שם הפונקציה שצריך להיות
מותאם הוא השם הגלוי למשתמש, כגון "וקטור blah(const vector &)", לא
השם המעוות הפנימי (למשל, "_Z4blahRSt6vectorIiSaIiEE"). ההתאמה מתבצעת ב
מחרוזות משנה: אם ה SYM פרמטר הוא מחרוזת משנה של שם הפונקציה, הוא נחשב
להיות התאמה. עבור מזהים מורחבים C99 ו-C++, יש לתת את שם הפונקציה
ב-UTF-8, לא משתמש בשמות תווים אוניברסליים.

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

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

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

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

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

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

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

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

-fstack-limit-register=רג
-fstack-limit-symbol=SYM
-fno-stack-limit
צור קוד כדי להבטיח שגם המחסנית לא תגדל מעבר לערך מסוים
הערך של פנקס או כתובת של סמל. אם נדרשת ערימה גדולה יותר, א
האות מורם בזמן הריצה. עבור רוב המטרות, האות מורם לפני הערימה
חוצה את הגבול, כך שאפשר לתפוס את האות בלי לקחת מיוחד
אמצעי זהירות.

למשל, אם המחסנית מתחילה בכתובת מוחלטת 0x80000000 וגדל כלפי מטה,
אתה יכול להשתמש בדגלים -fstack-limit-symbol=__stack_limit ו
-Wl,--defsym,__stack_limit=0x7ffe0000 לאכוף מגבלת מחסנית של 128KB. ציין זאת
זה עשוי לעבוד רק עם מקשר GNU.

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

כאשר קוד קומפילד עם -fsplit-מחסנית קוד שיחות הידור ללא -fsplit-מחסנית, שם
ייתכן שלא יהיה הרבה שטח מחסנית זמין להפעלת הקוד האחרון. אם קומפילציה של הכל
קוד, כולל קוד ספריה, עם -fsplit-מחסנית זה לא אופציה, אז המקשר יכול
תקן את השיחות האלה כך שהקוד יודר ללא -fsplit-מחסנית תמיד יש גדול
לַעֲרוֹם. תמיכה לכך מיושמת במקשר הזהב במהדורת GNU binutils
2.21 ואילך.

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

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

-ftls-model=מודל
שנה את מודל האחסון המקומי של חוט לשימוש. ה מודל הטיעון צריך להיות אחד מהם
גלובלי-דינמי, מקומי-דינמי, initial-exec or local-exec. שימו לב שהבחירה היא
כפוף לאופטימיזציה: המהדר עשוי להשתמש במודל יעיל יותר עבור סמלים שלא
גלוי מחוץ ליחידת התרגום, או אם -fpic לא מופיע בשורת הפקודה.

ברירת המחדל ללא -fpic is initial-exec; עם -fpic ברירת המחדל היא גלובלי-דינמי.

-fvisibility=[ברירת מחדל|פנימי|מוסתר|מוּגָן]
הגדר את ברירת המחדל של נראות סמל תמונת ELF לאפשרות שצוינה --- כל הסמלים הם
מסומן עם זה אלא אם כן נדחק בתוך הקוד. שימוש בתכונה זו יכול מאוד
לשפר משמעותית את זמני הקישור והטעינה של ספריות אובייקטים משותפות, לייצר יותר
קוד אופטימלי, לספק ייצוא ממשק API כמעט מושלם ולמנוע התנגשויות סמלים. זה
בְּתוֹקֶף מומלץ להשתמש בזה בכל אובייקט משותף שתפיץ.

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

הסבר טוב על היתרונות המוצעים על ידי הבטחת סמלי ELF בעלי הערך הנכון
הנראות ניתנת על ידי "איך לכתוב ספריות משותפות" מאת אולריך דרפר (שיכול להיות
נמצא בhttp://www.akkadia.org/drepper/>) --- עם זאת נעשה פתרון מעולה
אפשרי על ידי אפשרות זו לסמן דברים מוסתרים כאשר ברירת המחדל היא ציבורית היא לעשות
ברירת המחדל מוסתרת וסימון דברים ציבוריים. זו הנורמה עם קובצי DLL ב-Windows ו-
עם -נראות = מוסתרת ו-"__attribute__ ((visibility("default"))" במקום
"__declspec(dllexport)" אתה מקבל סמנטיקה כמעט זהה עם תחביר זהה.
זהו ברכה גדולה למי שעובד עם פרויקטים חוצי פלטפורמה.

לאלו שמוסיפים תמיכת נראות לקוד קיים, ייתכן שתמצאו את "#pragma GCC
נראות" של השימוש. זה עובד בכך שאתה מצרף את ההצהרות שברצונך להגדיר
נראות עבור עם (לדוגמה) "#pragma GCC visibility push(hidden)" ו-"#pragma
פופ נראות של GCC". זכור שיש לראות את נראות הסמלים as חלק of
מה היא API ממשק חוזה ולכן כל הקוד החדש צריך תמיד לציין את הנראות מתי
זה לא ברירת המחדל; כלומר, הצהרות רק לשימוש בתוך ה-DSO המקומי צריך
תמיד להיות מסומן באופן מפורש כמו מוסתר כדי למנוע עקיפה PLT
תקורה --- הפיכת זה בבירור מסייעת גם לקריאה ולתיעוד עצמי
של הקוד. שימו לב שבשל דרישות מפרט ISO C++, "מפעיל חדש" ו
"מחיקת מפעיל" חייבת להיות תמיד ברירת מחדל.

שים לב לכך שכותרות מחוץ לפרויקט שלך, בפרט כותרות מערכת ו
כותרות מכל ספרייה אחרת שבה אתה משתמש, אולי לא מצפים להידור איתן
נראות מלבד ברירת המחדל. ייתכן שיהיה עליך לומר במפורש "#pragma GCC
visibility push(ברירת מחדל)" לפני הכללת כותרות כאלה.

הצהרות "חיצוניות" אינן מושפעות מ -נראות, אז הרבה קוד יכול להיות
הידור מחדש עם -נראות = מוסתרת ללא שינויים. עם זאת, המשמעות היא זאת
קריאות לפונקציות "חיצוניות" ללא חשיפה מפורשת משתמשות ב-PLT, אז זה יותר
יעיל להשתמש ב-"__attribute ((visibility))" ו/או "#pragma GCC visibility" כדי לדעת
המהדר אשר יש להתייחס להצהרות "חיצוניות" כאל מוסתרות.

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

סקירה כללית של טכניקות אלה, היתרונות שלהן ואופן השימוש בהן נמצאת ב
<http://gcc.gnu.org/wiki/Visibility>.

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

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

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

הערה: עקב הגבלות של מודל הזיכרון C/C++11, גישה לכתיבה אינה מותרת
לגעת באיברים שאינם בשדה סיביות. לכן מומלץ להגדיר את כל החלקים של
סוג השדה כחברי שדה סיביות.

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

-fsync-libcalls
אפשרות זו שולטת אם מופע כלשהו מחוץ לקו של משפחת "__sync" של
ניתן להשתמש בפונקציות כדי ליישם את משפחת הפונקציות "__atomic" של C++11.

ערך ברירת המחדל של אפשרות זו מופעל, ובכך הצורה השימושית היחידה של האפשרות
is -fno-sync-libcalls. אפשרות זו משמשת ביישום של ליבאטומי
ספריית זמן ריצה.

הסביבה

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

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

השתמש ב-sh4-linux-gnu-g++ באינטרנט באמצעות שירותי onworks.net