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

תָכְנִית:

שֵׁם

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-פונקציה
-אירוח -עומד בפני עצמו -fopenmp -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 -fstats
-ftemplate-backtrace-limit=n -ftemplate-depth=n -fno-threadsafe-statics
-פיוז-cxa-atexit -fno-חלש -nostdinc++ -fno-default-inline
-fvisibility-inlines-hidden -fvisibility-ms-compat -פקס-מספרי-מילוליים -וואבי
-Wconversion-null -וקטור-דטור-פרטיות -Wdelete-non-virtual-dtor -סיומת וליטרלי
-מצמצם -לא חוץ מזה -Wnon-Virtual-dtor -הסדר -Weffc++ -Wstrict-null-sentinel
-לא-לא-חבר-תבנית -קאסט בסגנון וולד -עמוס-וירטואלי -Wno-pmf-המרות
-Wsign-promo

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

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

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

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

Debugging אפשרויות
-dאותיות -מפרט dump -מכונת dump -גרסת dump -fsanitize=סגנון -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-עץ-דש בוץ[-n]
-fdump-tree-dom[-n] -fdump-tree-dse[-n] -fdump-tree-phiprop[-n] -fdump-tree-phiopt[-n]
-fdump-tree-forwprop[-n] -fdump-tree-copyrename[-n] -fdump-tree-nrv -fdump-tree-vect
-fdump-עץ-כיור -fdump-tree-sra[-n] -fdump-tree-forwprop[-n] -fdump-tree-fre[-n]
-fdump-tree-vrp[-n] -ftree-vectorizer-verbose=n -fdump-tree-storeccp[-n]
-fdump-final-insns=פילה -fcompare-debug[=בוחר] -fcompare-debug-second
-פלימינאט-גמד2-דופים -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+ -fno-merge-debug-strings
-fno-dwarf2-cfi-asm -fdebug-prefix-map=זקן=חדש -femit-struct-debug-baseonly
-מיט-סטרוק-דבוק מופחת -femit-struct-debug-detailed[=מפרט-רשימת] -p -עמוד
-print-file-name=ספריה -print-libgcc-file-name -הדפס-מספר ספריות
-print-multi-lib -print-multi-os-directory -print-prog-name=התוכנית
-print-search-dirs -Q -print-sysroot -print-sysroot-headers-suffix -חיסכון-טמפ'
-save-temps=cwd -save-temps=obj -time[=פילה]

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

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

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

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

מַדרִיך אפשרויות
-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 -מרץ=שם -mcpu=שם
-mtune=שם

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

זרוע אפשרויות -mapcs-frame -mno-apcs-frame -מאבי=שם -mapcs-stack-check
-mno-apcs-stack-check -mapcs-float -mno-apcs-float -mapcs-reenrant
-mno-apcs-reenrant -msched-prolog -mno-sched-פרולוג -מעט-אנדיאן -mbig-endian
-mwords-little-endian -mfloat-abi=שם -mfp16-format=שם -מ-אגודל-עבודה
-mno-thumb-interwork -mcpu=שם -מרץ=שם -mfpu=שם -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 סיביות -מגביל-זה

AVR אפשרויות -mmcu=מקו -צבור-ארגס -brranch-cost=עלות -mcall-פרולוגים -מנטה8
-מנו-מפריע -להירגע -mstrict-X -mtiny-stack -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-Big-Switch -mno-disable-fpregs -mno-disable-indexing
-מנו-מהיר-שיחות עקיפות -מנו-גז -mno-jump-in-delay -mno-long-load-store
-mno-portable-time -מנו-רך-צף -mno-space-regs -msoft-float -mpa-risc-1-0
-mpa-risc-1-1 -mpa-risc-2-0 -זמן ריצה נייד -mschedule=סוג מעבד -mspace-regs
-msio -mwsio -munix=unix-std -nolibdld -סטָטִי -חוטים

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

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

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

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

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

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

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

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

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

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

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

RS/6000 ו PowerPC אפשרויות -mcpu=סוג מעבד -mtune=סוג מעבד -mcmodel=מודל קוד
-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

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 -mcbranchdi
-מקמפקדי -מfused-madd -mno-fused-madd -mfsca -mno-fsca -mfsrra -מנו-פסרה
-mpretend-cmove -mtas

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

SPARC אפשרויות -mcpu=סוג מעבד -mtune=סוג מעבד -mcmodel=מודל קוד -זיכרון-מודל=מ-
מודל -מ 32 -מ 64 -mapp-regs -mno-app-regs -mfaster-structs -mno-faster-structs
-mflat -מנו-שטוח -mfpu -mno-fpu -mhard-float -msoft-float -mhard-quad-float
-msoft-quad-float -mstack-bias -mno-stack-bias -מונaligned-כפילים
-mno-unaligned-doubles -מצב-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=מעבד -מ 32 -מ 64 -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 אפשרויות -מג -מגנו -מוניקס

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

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

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

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

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

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

קופונים דור אפשרויות
-fcall-sved-רג -fcall-used-רג -תוקן-רג חריגות - חריגים ללא שיחות
-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 -נראות
-פניקט-נדיפות-שדות -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 המכיל גוף יחידת ספרייה (תת-תוכנית או גוף חבילה).
קבצים כאלה נקראים גם גופים.

פילה.d
קובץ קוד מקור D.

פילה.di
קובץ קוד ממשק D.

פילה.dd
קובץ קוד תיעוד D.

פילה.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
עדה
d
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. שימו לב שתקן זה עדיין אינו נתמך במלואו; לִרְאוֹת
<http://gcc.gnu.org/c99status.html> למידע נוסף. השמות c9x ו
iso9899:199x מיושנים.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-fabi-version=n
השתמש בגרסה n של C++ ABI. ברירת המחדל היא גרסה 2.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-fextern-tls-init
-fno-extern-tls-init
תקני C++11 ו-OpenMP מאפשרים thread_local ו חוט פרטי משתנים שיש
אתחול דינמי (זמן ריצה). כדי לתמוך בכך, כל שימוש במשתנה כזה הולך
באמצעות פונקציית עטיפה המבצעת כל אתחול הכרחי. כאשר השימוש
והגדרת המשתנה נמצאים באותה יחידת תרגום, תקורה זו יכולה להיות
מותאם משם, אבל כאשר השימוש הוא ביחידת תרגום אחרת יש
תקורה משמעותית גם אם המשתנה לא באמת צריך דינמיקה
אִתחוּל. אם המתכנת יכול להיות בטוח שאין שימוש במשתנה ב-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
מוגבל ל ל לולאה עצמה, כפי שצוין בתקן 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++ (- ו טיפוסי). אם לא
השתמש בחלקים אלה של השפה, אתה יכול לחסוך קצת מקום על ידי שימוש בדגל זה. הערה
הטיפול בחריגים משתמש באותו מידע, אבל G++ מייצר אותו לפי הצורך. ה
- עדיין ניתן להשתמש באופרטור לקאסטים שאינם דורשים סוג זמן ריצה
מידע, כלומר השלכה ל-"void *" או למחלקות בסיס חד-משמעיות.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

union U { int i: 4096; };

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

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

מבנה A {};

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

struct C: public B, public A {};

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

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

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

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

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

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

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

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

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

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

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

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

-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++1y. זֶה
האפשרות כבויה כברירת מחדל עבור ISO C++11 ואילך (11. std = c ++,...).

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

ב* ב;
b->f();

לא מצליח להדר.

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

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

אפשרויות שליטה 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("...")" ללא קשר לאפשרויות שורת הפקודה.

-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 דמויות. ה
ברירת המחדל היא 72 תווים עבור g ++ ו-0 עבור שאר הקצוות הקדמיים הנתמכים על ידי
GCC. אם n הוא אפס, אז לא מתבצעת גלישת שורה; כל הודעת שגיאה מופיעה ב-a
שורה בודדת.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-
-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-לא מילולי.)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void foo(bar) { }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-gvms
הפק מידע איתור באגים בפורמט ניפוי באגים 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, גלאי שגיאות זיכרון מהיר. הוראות גישה לזיכרון
יהיה מכשיר כדי לזהות באגים מחוץ לתחום ובאגים לאחר שימוש ללא תשלום. לִרְאוֹת
<http://code.google.com/p/address-sanitizer/> לפרטים נוספים.

-fsanitize=חוט
הפעל את ThreadSanitizer, גלאי מירוץ נתונים מהיר. הוראות גישה לזיכרון יהיו
מכשיר לזיהוי באגים במירוץ נתונים. לִרְאוֹת
<http://code.google.com/p/data-race-test/wiki/ThreadSanitizer> לפרטים נוספים.

-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()" מחזיר אמת תמיד אלא אם הגבול העליון מוגדר על ידי אפשרות זו. ל
לדוגמה, עם -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-regmove
dump לאחר מעבר המהלך של הרישום.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

לדוגמה,

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

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

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

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

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

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

gcc -O3 -fopt-info

שים לב כי -fopt-info-vec-missed מתנהג כמו -fopt-info-missed-vec.

כדוגמה נוספת, שקול

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

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

-ftree-vectorizer-verbose=n
אפשרות זו הוצאה משימוש והיא מיושמת במונחים של -fopt-info. בבקשה תשתמש
-fopt-info-סוג טופס במקום, איפה סוג היא אחת מאפשרויות ה-opt-info התקפות. זה
מדפיס מידע אופטימיזציה נוסף. ל n=0 אין מידע אבחוני
דיווח. אם n=1 הווקטורייזר מדווח על כל לולאה שעברה וקטור, והסך הכל
מספר לולאות שעברו וקטור. אם n=2 הווקטורייזר מדווח על מיקומים אשר
לא ניתן היה להוקטור והסיבות לכך. לכל רמות מילוליות גבוהות יותר הכל
מידע הניתוח והטרנספורמציה מהווקטורייזר מדווח.

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

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

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

-fsched-verbose=n
ביעדים המשתמשים בתזמון הוראות, אפשרות זו שולטת בכמות
איתור באגים פלט המתזמן מדפיס. מידע זה נכתב בשגיאת תקן,
אלא אם כן -fdump-rtl-sched1 or -fdump-rtl-sched2 מצוין, ובמקרה זה הוא פלט
לקובץ רישום המזבלה הרגיל, .sched1 or .sched2 בהתאמה. אולם עבור n
גדול מתשע, הפלט מודפס תמיד לפי שגיאת תקן.

בעד n גדול מאפס, -אשר-ורבוז מוציא את אותו מידע כמו
-fdump-rtl-sched1 ו -fdump-rtl-sched2. פורום n גדול מאחד, הוא גם פלט בסיסי
הסתברויות חסימה, מידע מפורט על רשימה מוכנה ומידע על יחידה/מתקן. ל n
יותר משניים, הוא כולל RTL בנקודת ביטול, זרימת בקרה ומידע על אזורים. ו
ל n מעל ארבע, -אשר-ורבוז כולל גם מידע על תלות.

-חיסכון-טמפ'
-save-temps=cwd
אחסן את קבצי הביניים ה"זמניים" הרגילים לצמיתות; למקם אותם בזרם
ספרייה ושם אותם על סמך קובץ המקור. לפיכך, קומפילציה foo.c עם -c
-חיסכון-טמפ' מייצר קבצים foo.i ו foo.s, בנוסף ל foo.o. זה יוצר א
מעובד מראש foo.i קובץ הפלט למרות שהמהדר משתמש כעת בדרך כלל ב-an
מעבד קדם משולב.

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

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

gcc -save-temps -o outdir1/foo.o indir1/foo.c&
gcc -save-temps -o outdir2/foo.o indir2/foo.c&

עלול לגרום ל foo.i ו foo.o נכתב בו זמנית על ידי שני המהדרים.

-save-temps=obj
אחסן את קבצי הביניים ה"זמניים" הרגילים לצמיתות. אם ה -o נעשה שימוש באפשרות,
הקבצים הזמניים מבוססים על קובץ האובייקט. אם ה -o האפשרות אינה בשימוש, ה
-save-temps=obj מתג מתנהג כמו -חיסכון-טמפ'.

לדוגמה:

gcc -save-temps=obj -c foo.c
gcc -save-temps=obj -c bar.c -o dir/xbar.o
gcc -save-temps=obj foobar.c -o dir2/yfoobar

יוצר foo.i, foo.s, dir/xbar.i, dir/xbar.s, dir2/yfoobar.i, dir2/yfoobar.s, ו
dir2/yfoobar.o.

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

ללא מפרט של קובץ פלט, הפלט נראה כך:

# cc1 0.12 0.01
# כ-0.00 0.01

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

עם המפרט של קובץ פלט, הפלט מצורף לקובץ בעל השם,
וזה נראה כך:

0.12 0.01 cc1
0.00 0.01 as

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

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

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

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

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

-מאבר-מעקב-מנתקים-טבגול
למתג -fvar-tracking-assignments, באותו אופן ש -gtoggle toggles -g.

-print-file-name=ספריה
הדפס את השם המוחלט המלא של קובץ הספרייה ספריה זה ישמש מתי
קישור --- ואל תעשה שום דבר אחר. עם אפשרות זו, GCC אינו מבצע קומפילציה או קישור
כל דבר; זה רק מדפיס את שם הקובץ.

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

-print-multi-lib
הדפס את המיפוי משמות ספריות multilib למתגי מהדר המאפשרים אותם.
שם הספרייה מופרד מהמתגים על ידי ;, וכל מתג מתחיל ב-an
@ במקום ה -, ללא רווחים בין מתגים מרובים. זה אמור
עיבוד קליפות קל.

-print-multi-os-directory
הדפס את הנתיב לספריות מערכת ההפעלה עבור ה-multilib שנבחר, יחסית לחלק lib
ספריית משנה. אם קיימות ספריות מערכת ההפעלה ב- lib ספריית משנה וללא multilibs
משמשים, זה בדרך כלל פשוט ., אם קיימות ספריות מערכת הפעלה ב סיומת libs אח
ספריות זה מדפיס למשל ../lib64, ../ lib or ../lib32, או אם ספריות מערכת ההפעלה כן
נוכח ב lib/subdir ספריות משנה שהוא מדפיס למשל amd64, sparcv9 or Ev6.

-print-multiarch
הדפס את הנתיב לספריות מערכת ההפעלה עבור ה-multiarch שנבחר, יחסית לכמה lib
ספריית משנה.

-print-prog-name=התוכנית
כמו -שם קובץ הדפסה, אך מחפש תוכנית כגון cpp.

-print-libgcc-file-name
כמו -print-file-name=libgcc.a.

זה שימושי כאשר אתה משתמש -נוסטדליב or -nodefaultlibs אבל אתה כן רוצה לקשר עם
libgcc.a. אתה יכול לעשות:

gcc -nostdlib ... `gcc -print-libgcc-file-name`

-print-search-dirs
הדפס את השם של ספריית ההתקנה המוגדרת ורשימת תוכניות ו
ספריות ספריות gcc מחפש --- ואל תעשה שום דבר אחר.

זה שימושי כאשר gcc מדפיס את הודעת השגיאה התקנה בְּעָיָה, לא יכול Exec
cpp0: לא כזה פילה or בספרייה. כדי לפתור את זה אתה צריך לשים cpp0 ו
רכיבי מהדר אחרים איפה gcc מצפה למצוא אותם, או שאתה יכול להגדיר את
משתנה הסביבה GCC_EXEC_PREFIX לספרייה שבה התקנת אותם. אל תעשה
לשכוח את הנגרר /.

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

-print-sysroot-headers-suffix
הדפס את הסיומת שנוספה לבסיס המטרה בעת חיפוש כותרות, או תן
שגיאה אם ​​המהדר לא מוגדר עם סיומת כזו --- ואל תעשה כלום
Other.

-מכונת dump
הדפס את מכונת היעד של המהדר (לדוגמה, i686-pc-linux-gnu)---ואל תעשה
עוד משהו.

-גרסת dump
הדפס את גרסת המהדר (לדוגמה, 3.0) --- ואל תעשה שום דבר אחר.

-מפרט dump
הדפס את המפרט המובנה של המהדר --- ואל תעשה שום דבר אחר. (זה משמש כאשר
GCC עצמו נבנה.)

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

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

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

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

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

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

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

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

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

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

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

-fauto-inc-dec -fcompare-elim -fcprop-registers -fdce -fdefer-pop -ענף מושהה
-fdse -ניחוש-ענף-הסתברות -fif-conversion2 -fif-המרה -פיפא-טהור-קונסט
-fipa-profile -פיפא-התייחסות -fmerge-constants -fsplit-wide-types -ftree-bit-ccp
-ftree-builtin-call-dce -ftree-ccp -ftree-ch -ftree-copyrename -ftree-dce
-ftree-dominator-opts -ftree-dse -ftree-forwprop -ftree-fre -ftree-phiprop -ftree-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 -זול-אופטימיזציות -fgcse
-fgcse-lm -fhoist-סמוך-עומסים -finline-קטנות-פונקציות -findirect-inlining
-פיפא-סרה -foptimize-אחיות-שיחות -fpartial-inlining -fpeephole2 -פרגmove
-Freord-בלוקים -פקודת-פונקציות -frerun-cse-after-loop -fsched-interblock
-fsched-spec -fschedule-insns -fschedule-insns2 -fstrict-aliasing -פרקט-הצפה
-ftree-switch-conversion -ftree-זנב-מיזוג -ftree-pre -ftree-vrp

נא לשים לב לאזהרה למטה -fgcse על פנייה -O2 על תוכניות המשתמשות ב-computed
גוטוס.

הערה: באובונטו 8.10 ובגירסאות מאוחרות יותר, -D_FORTIFY_SOURCE=2 מוגדר כברירת מחדל, והוא
מופעל מתי -O מוגדר ל-2 ומעלה. זה מאפשר זמן קומפילציה נוסף ו
בדיקת זמן ריצה עבור מספר פונקציות libc. כדי להשבית, ציין או
-U_FORTIFY_SOURCE or -D_FORTIFY_SOURCE=0.

-O3 בצע אופטימיזציה עוד יותר. -O3 מפעיל את כל האופטימיזציות שצוינו על ידי -O2 וגם נדלק
מה היא -finline-פונקציות, -לולאות funswitch, -fpredictive-commoning, -fgcse-after-reload,
-ftree-vectorize, -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-default-inline
אל תהפוך פונקציות איברים לשורה כברירת מחדל רק בגלל שהן מוגדרות בפנים
היקף המחלקה (C++ בלבד). אחרת, כאשר אתה מציין -O, פונקציות איברים מוגדרות
בתוך היקף המחלקה מורכבים בשורה כברירת מחדל; כלומר, אין צורך להוסיף מוטבע
לפני שם הפונקציה איבר.

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

נכים ברמות -O, -O2, -O3, -אוס.

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

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

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

ברירת המחדל היא -ffp-contract=מהיר.

-fomit-frame-pointer
אל תשמור את מצביע המסגרת בפנקס עבור פונקציות שאינן זקוקות לכזו. זֶה
נמנע מההוראות לשמירה, הגדרה ושחזור של מצביעי מסגרת; זה גם עושה an
רישום נוסף זמין בפונקציות רבות. It גם עושה ניפוי בלתי אפשרי on
כמה מכונה.

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

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

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

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

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

-fno-inline
אין להרחיב שום פונקציה בשורה מלבד אלו המסומנות ב-"always_inline"
תְכוּנָה. זוהי ברירת המחדל כאשר לא מתבצע אופטימיזציה.

ניתן לפטור פונקציות בודדות מהטבעה על ידי סימוןן ב-"noinline"
תכונה.

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

מופעל ברמה -O2.

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

מופעל ברמה -O2.

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

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

מופעל ברמה -O3.

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

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

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

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

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

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

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

Inlining נשלט למעשה על ידי מספר פרמטרים, אשר ניתן לפרט
בנפרד על ידי שימוש --param שם=ערך. ה -finline-limit=n אופציות קובע חלק מ
פרמטרים אלה כדלקמן:

max-inline-insns-סינגל
מוגדר n/ 2.

max-inline-insns-auto
מוגדר n/ 2.

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

הערה: אולי אין ערך לזה -finline-limit מה שגורם להתנהגות ברירת מחדל.

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

-fno-keep-inline-dllexport
זוהי גרסה עדינה יותר של -fkeep-inline-functions, אשר חל רק על
פונקציות המוצהרות באמצעות התכונה "dllexport" או declspec

-fkeep-inline-functions
ב-C, פולט פונקציות "סטטיות" המוכרזות "מוטבעות" בקובץ האובייקט, גם אם
הפונקציה הוטבעה בכל המתקשרים שלה. מתג זה אינו משפיע
פונקציות באמצעות סיומת "Extern inline" ב-GNU C90. ב-C++, פולט כל דבר
פונקציות מוטבעות בקובץ האובייקט.

-fkeep-static-consts
פליט משתנים שהוכרזו "קונסט סטטי" כאשר האופטימיזציה לא מופעלת, גם אם
אין התייחסות למשתנים.

GCC מאפשר אפשרות זו כברירת מחדל. אם אתה רוצה להכריח את המהדר לבדוק אם א
המשתנה מופנה, ללא קשר לשאלה אם אופטימיזציה מופעלת או לא, השתמש
מה היא -fno-keep-static-consts אוֹפְּצִיָה.

-fmerge-constants
ניסיון למזג קבועים זהים (קבועי מחרוזת וקבועי נקודה צפה)
על פני יחידות הידור.

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

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

-fmerge-all-constants
נסה למזג קבועים זהים ומשתנים זהים.

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

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

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

-fno-branch-count-reg
אל תשתמש בהוראות "הפחתה והענף" בפנקס ספירה, אלא במקום זאת
ליצור רצף של הוראות שמפחיתות רגיסטר, להשוות אותו מולו
אפס, ואז הסתעף על סמך התוצאה. אפשרות זו היא בעלת משמעות רק ב
ארכיטקטורות התומכות בהוראות כאלה, הכוללות x86, PowerPC, IA-64 ו
S / 390.

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

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

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

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

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

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

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

-fmudflap -fmudflapth -fmudflapir
עבור חזיתות התומכות בו (C ו-C++), מכשיר כל מצביע/מערך מסוכן
פעולות ייחוס, חלק מפונקציות מחרוזת/ערימה של ספרייה סטנדרטית ועוד כמה פעולות אחרות
מבנים הקשורים למבחני טווח/תוקף. מודולים כל כך מכשור צריכים להיות
חסין מפני הצפת חיץ, שימוש בערימה לא חוקית וכמה מחלקות אחרות של C/C++
שגיאות תכנות. המכשור מסתמך על ספריית זמן ריצה נפרדת
(libmudflap), המקושר לתוכנית if -fmudflap ניתן בזמן הקישור. לָרוּץ-
התנהגות הזמן של התוכנית המכשור נשלטת על ידי MUDFLAP_OPTIONS
משתנה הסביבה. ראה "env MUDFLAP_OPTIONS=-help a.out" לאפשרויות שלו.

השתמש -fmudflapth במקום -fmudflap לקמפל ולקשר אם התוכנית שלך מרובת
מוּשׁחָל. להשתמש -fmudflapir, בנוסף -fmudflap or -fmudflapth, אם
מכשור צריך להתעלם מקריאת מצביע. זה מייצר פחות מכשור (ו
לכן ביצוע מהיר יותר) ועדיין מספק הגנה מסוימת מפני זיכרון מוחלט
משחית כתיבה, אך מאפשרת קריאת נתונים בטעות להתפשט בתוך תוכנית.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

הערות -פרגmove ו -foptimize-register-move הם אותה אופטימיזציה.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-fno-sched-interblock
אל תזמן הוראות על פני בלוקים בסיסיים. זה מופעל בדרך כלל כברירת מחדל
בעת תזמון לפני הקצאת רישום, כלומר עם -fschedule-insns או -O2 or
גבוה.

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

-fsched-לחץ
אפשר תזמון insn רגיש ללחץ של אוגר לפני הקצאת אוגר. זֶה
הגיוני רק כאשר תזמון לפני הקצאת רישום מופעלת, כלומר עם
-fschedule-insns או -O2 או גבוה יותר. שימוש באפשרות זו יכול לשפר את ההפקה
קוד ולהקטין את גודלו על ידי מניעת עליית לחץ האוגר מעל המספר
של רישומים קשיחים זמינים והזליגה לאחר מכן בהקצאת פנקס.

-fsched-spec-load
אפשר תנועה ספקולטיבית של כמה הוראות עומס. זה הגיוני רק מתי
תזמון לפני הקצאת רישום, כלומר עם -fschedule-insns או -O2 או גבוה יותר.

-fsched-spec-עומס-מסוכן
אפשר תנועה ספקולטיבית של הוראות עומס נוספות. זה הגיוני רק מתי
תזמון לפני הקצאת רישום, כלומר עם -fschedule-insns או -O2 או גבוה יותר.

-fsched-stalled-insns
-fsched-stalled-insns=n
הגדר כמה אינסנס (אם בכלל) ניתן להעביר בטרם עת מהתור של תקועים
נכנס לרשימת המוכנים במהלך מעבר התזמון השני. -fno-sched-stalled-insns
פירושו שאף תוספות לא מועברות בטרם עת, -fsched-stalled-insns=0 פירושו שאין
הגבלה על כמה כניסות בתור ניתן להעביר בטרם עת. -fsched-stalled-insns
ללא ערך שווה ערך ל -fsched-stalled-insns=1.

-fsched-stalled-insns-dep
-fsched-stalled-insns-dep=n
הגדירו כמה קבוצות (מחזורים) אינסנ נבדקות עבור תלות ב- insn שנתקע
זה מועמד להרחקה מוקדמת מהתור של כניסות שנתקעו. יש לזה
השפעה רק במהלך מעבר התזמון השני, ורק אם -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 מופעל.

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

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

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

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

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

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

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

-ftree-reassoc
בצע שיוך מחדש על עצים. דגל זה מופעל כברירת מחדל ב -O וגבוה יותר.

-ftree-pre
בצע ביטול יתירות חלקית (PRE) על עצים. דגל זה מופעל על ידי
ברירת מחדל ב -O2 ו -O3.

-ftree-partial-pre
הפוך את ביטול יתירות חלקית (PRE) לאגרסיבי יותר. דגל זה מופעל על ידי
ברירת מחדל ב -O3.

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

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

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

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

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

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

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

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

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

-ftree-dce
בצע ביטול קוד מת (DCE) על עצים. דגל זה מופעל כברירת מחדל ב -O
וגבוה יותר.

-ftree-builtin-call-dce
בצע ביטול קוד מת מותנה (DCE) עבור קריאות לפונקציות מובנות
עשוי להגדיר "שגיאה" אך חוץ מתופעות לוואי. דגל זה מופעל כברירת מחדל
at -O2 ומעלה אם -אוס לא מצוין גם.

-ftree-dominator-opts
בצע מגוון של ניקויים סקלרים פשוטים (הפצה קבועה/העתקה, יתירות
חיסול, התפשטות טווח ופישוט ביטוי) מבוסס על דומינטור
מעבר עצים. זה מבצע גם השחלת קפיצות (כדי להפחית קפיצות לקפיצות). זֶה
דגל מופעל כברירת מחדל ב -O וגבוה יותר.

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

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

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

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

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

DO J = 1, M
DO I = 1, N
A(J, I) = A(J, I) * C
אנדו
אנדו

מחלף לולאה הופך את הלולאה כאילו היא נכתבה:

DO I = 1, N
DO J = 1, M
A(J, I) = A(J, I) * C
אנדו
אנדו

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

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

DO I = 1, N
A(I) = A(I) + C
אנדו

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

DO II = 1, N, 51
DO I = II, min (II + 50, N)
A(I) = A(I) + C
אנדו
אנדו

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

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

DO I = 1, N
DO J = 1, M
A (j, i) = b (i) + c (j)
אנדו
אנדו

חסימת לולאה הופכת את הלולאה כאילו היא נכתבה:

DO II = 1, N, 51
DO JJ = 1, M, 51
DO I = II, min (II + 50, N)
DO J = JJ, min (JJ + 50, M)
A (j, i) = b (i) + c (j)
אנדו
אנדו
אנדו
אנדו

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-fpartial-inlining
חלקים מוטבעים של פונקציות. אפשרות זו משפיעה רק כאשר הטבעת עצמה היא
מופעל על ידי -finline-פונקציות or -finline-קטנות-פונקציות אפשרויות.

מופעל ברמה -O2.

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

אפשרות זו מופעלת ברמה -O3.

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

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

נכה ברמה -אוס.

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

-חור הצצה מופעל כברירת מחדל. -fpeephole2 מופעל ברמות -O2, -O3, -אוס.

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

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

ברירת המחדל היא -ניחוש-ענף-הסתברות ברמות -O, -O2, -O3, -אוס.

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

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

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

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

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

כמו כן, משוב על הפרופיל חייב להיות זמין כדי להפוך אפשרות זו לאפקטיבית. לִרְאוֹת
-fprofile-arcs לקבלת פרטים.

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

-fstrict-aliasing
אפשר למהדר להניח את כללי הכינוי המחמירים ביותר החלים על השפה
הולקט. עבור C (ו++C), זה מפעיל אופטימיזציות המבוססות על סוג של
ביטויים. בפרט, מניחים כי חפץ מסוג אחד לעולם לא יתגורר ב-
כתובת זהה לאובייקט מסוג אחר, אלא אם הסוגים כמעט זהים.
לדוגמה, "int unsigned" יכול לכינוי "int", אך לא "void*" או "double". א
סוג התווים יכול לכנות כל סוג אחר.

שימו לב במיוחד לקוד כזה:

union a_union {
int i;
כפול ד;
};

int f() {
איגוד א_איגוד ט;
td = 3.0;
החזר טי;
}

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

int f() {
איגוד א_איגוד ט;
int* ip;
td = 3.0;
ip = &t.i;
החזר *ip;
}

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

int f() {
כפול d = 3.0;
return ((union a_union *) &d)->i;
}

השמיים -fstrict-aliasing האפשרות מופעלת ברמות -O2, -O3, -אוס.

-פרקט-הצפה
אפשר למהדר להניח כללי גלישה קפדניים בחתימה, בהתאם לשפה
הולקט. עבור C (ו-C++) זה אומר שהצפת כאשר עושים חשבון עם
המספרים החתומים אינם מוגדרים, מה שאומר שהמהדר עשוי להניח שלא
לִקְרוֹת. זה מאפשר אופטימיזציות שונות. לדוגמה, המהדר מניח זאת
ביטוי כמו "i + 10 > i" נכון תמיד לסימן "i". הנחה זו היא
תקף רק אם גלישה חתומה אינה מוגדרת, שכן הביטוי הוא שקר אם "i + 10"
עולה על גדותיו בעת שימוש בחשבון משלים שניים. כאשר אפשרות זו בתוקף כל
נסה לקבוע אם יש לכתוב פעולה על גלישת מספרים חתומים
בזהירות כדי לא לכלול למעשה הצפת יתר.

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

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

השמיים -פרקט-הצפה האפשרות מופעלת ברמות -O2, -O3, -אוס.

-falign-פונקציות
-falign-functions=n
יישר את תחילת הפונקציות לעוצמה הבאה של שניים הגדול מ n, דילוג עד n
בתים. לדוגמה, -falign-functions=32 מיישר פונקציות ל-32 הבתים הבאים
גבול, אבל -falign-functions=24 מתיישר לגבול הבא של 32 בתים רק אם זה
ניתן לעשות על ידי דילוג על 23 בתים או פחות.

-fno-align-functions ו -falign-functions=1 מקבילים ומתכוונים שמתפקדים
אינם מיושרים.

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

If n לא צוין או שהוא אפס, השתמש בברירת מחדל תלוית מכונה.

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

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

-fno-align-labels ו -falign-labels=1 שוות ערך ומשמעותם שהתוויות אינן
מיושר.

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

If n לא צוין או שהוא אפס, השתמש בברירת מחדל תלוית מכונה שסביר מאוד
להיות 1, כלומר אין יישור.

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

-falign-לולאות
-falign-loops=n
יישר לולאות לגבול של עוצמה של שניים, דילוג עד n בתים כמו -falign-פונקציות.
אם הלולאות מבוצעות פעמים רבות, זה מפצה על כל ביצוע של הדמה
פעולות.

-fno-align-לולאות ו -falign-loops=1 שוות ערך ומתכוון שלולאות לא
מיושר.

If n לא צוין או שהוא אפס, השתמש בברירת מחדל תלוית מכונה.

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

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

-fno-align-jumps ו -falign-jumps=1 שוות ערך ומתכוון שלולאות לא
מיושר.

If n לא צוין או שהוא אפס, השתמש בברירת מחדל תלוית מכונה.

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

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

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

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

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

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

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

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

אין להשתמש באפשרות זו בשילוב עם "-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.

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

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

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

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

gcc -c -O0 -flto foo.c
gcc -c -O0 -flto bar.c
gcc -o myprog -flto -O3 foo.o bar.o

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

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

ישנם כמה דגלי יצירת קוד שנשמרו על ידי GCC בעת יצירת קודי בתים, כמו
יש להשתמש בהם בשלב הקישור האחרון. נכון לעכשיו, האפשרויות הבאות
נשמרים בקבצי bytecode של GIMPLE: -fPIC, -נפוץ וכל -m דגלי מטרה.

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

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

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

gcc -c -flto foo.c
g++ -c -flto bar.cc
gfortran -c -flto baz.f90
g++ -o myprog -flto -O3 foo.o bar.o baz.o -lgfortran

שימו לב שהקישור הסופי נעשה עם g ++ כדי לקבל את ספריות זמן הריצה של C++ ו
-לגפורטרן נוסף כדי לקבל את ספריות זמן הריצה של Fortran. באופן כללי, בעת ערבוב
שפות במצב LTO, עליך להשתמש באותם אפשרויות פקודת קישור כמו בעת ערבוב
שפות באוסף רגיל (שאיננו LTO); כל מה שאתה צריך להוסיף הוא -flto לכל
קומפיל וקשר פקודות.

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

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

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

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

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

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

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

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

אתה יכול גם לציין -flto=שרת עבודה להשתמש במצב שרת העבודה של GNU make כדי לקבוע
מספר המשרות המקבילות. זה שימושי כאשר ה-Makefile הקורא ל-GCC כבר נמצא
ביצוע במקביל. עליך להקדים את א + למתכון הפקודה בהורה
Makefile כדי שזה יעבוד. אפשרות זו כנראה עובדת רק אם MAKE הוא מתוצרת גנו.

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

-flto-partition=ALG
ציין את אלגוריתם החלוקה המשמש את כלי האופטימיזציה של זמן קישור. הערך הוא
או "1to1" כדי לציין חלוקה לשיקוף קבצי המקור המקוריים או
"מאוזן" כדי לציין חלוקה לנתחים בגודל שווה (בכל פעם שאפשר) או
"מקסימום" כדי ליצור מחיצה חדשה עבור כל סמל במידת האפשר. ציון "ללא" בתור
אלגוריתם משבית לחלוטין את החלוקה והזרימה. ערך ברירת המחדל הוא
"מְאוּזָן". בעוד ש-"1to1" יכול לשמש כפתרון עוקף לסידור קודים שונים
בעיות, המחיצה "מקסימום" מיועדת לבדיקה פנימית בלבד.

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

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

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

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

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

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

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

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

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

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

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

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

-fuse-ld=bfd
השתמש bfd מקשר במקום מקשר ברירת המחדל.

-fuse-ld=זהב
השתמש זהב מקשר במקום מקשר ברירת המחדל.

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

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

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

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

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

האפשרויות הבאות מופעלות: "-fprofile-arcs", "-fprofile-values", "-fvpt".

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

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

האפשרויות הבאות מופעלות: "-fbranch-probabilities", "-fvpt",
"-funroll-loops", "-fpeel-loops", "-ftracer", "-ftree-vectorize",
"ftree-loop-distribute-patterns"

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

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

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

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

אפשרות זו מונעת דיוק עודף לא רצוי במכונות כגון 68000 where
הרגיסטרים הצפים (של ה-68881) שומרים על דיוק רב יותר ממה ש"כפול" אמור להיות
יש. באופן דומה עבור ארכיטקטורת x86. עבור רוב התוכניות, דיוק עודף
עושה רק טוב, אבל כמה תוכניות מסתמכות על ההגדרה המדויקת של IEEE צף
נְקוּדָה. להשתמש -ffloat-store עבור תוכניות כאלה, לאחר שינוים כדי לאחסן את כולם
חישובי ביניים רלוונטיים למשתנים.

-fexcess-precision=סגנון
אפשרות זו מאפשרת שליטה נוספת על דיוק עודף במכונות בהן צפות-
לרגיסטרים של נקודות יש דיוק רב יותר מהסוגים "צפים" ו"כפולים" של IEEE וה-
המעבד אינו תומך בפעולות עיגול לסוגים אלה. כברירת מחדל,
-fexcess-precision=מהיר בתוקף; זה אומר שהפעולות מתבצעות ב
את הדיוק של הרגיסטרים ושהוא בלתי צפוי בעת עיגול לסוגים
המצוין בקוד המקור מתרחש. בעת הידור C, if
-fexcess-precision=סטנדרטי מצוין אז דיוק עודף עוקב אחר הכללים
המצוין ב-ISO C99; בפרט, גם השחקנים וגם ההקצאות גורמים לערכים להיות
מעוגלים לסוגים הסמנטיים שלהם (אילו -ffloat-store משפיע רק על מטלות).
אפשרות זו מופעלת כברירת מחדל עבור C אם אפשרות התאמה קפדנית כגון
-std=c99 משמש.

-fexcess-precision=סטנדרטי אינו מיושם עבור שפות אחרות מלבד C, ואין לו
השפעה אם -אופטימיזציות-funsafe-math or -מהיר-מתמטיקה מצוין. ב-x86, זה
גם אין השפעה אם -mfpmath = sse or -mfpmath=sse+387 צוין; בקודם
במקרה, סמנטיקה של IEEE חלה ללא דיוק יתר, ובאחרון, עיגול הוא
בלתי צפוי.

-מהיר-מתמטיקה
סטים -fno-math-errno, -אופטימיזציות-funsafe-math, -סופית-מתמטיקה-בלבד,
-fno-עגל-מתמטיקה, -fno-signaling-nans ו -fcx-טווח מוגבל.

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

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

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

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

ברירת המחדל היא -fmath-errno.

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

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

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

ברירת המחדל היא -fno-unsafe-math-optimizations.

-אסוציאטיבית-מתמטיקה
אפשר שיוך מחדש של אופרנדים בסדרות של פעולות נקודה צפה. זֶה
מפר את תקן שפת ISO C ו-C++ על ידי שינוי אולי תוצאת החישוב.
הערה: הזמנה מחדש עשויה לשנות את סימן האפס וכן להתעלם מ-NaNs ולבלום או
ליצור זרימת יתר או הצפה (ולכן לא ניתן להשתמש בו על קוד שמסתמך על עיגול
התנהגות כמו "(x + 2**52) - 2**52". עשוי גם לסדר מחדש השוואות נקודות צפה ו
לכן לא ניתן להשתמש בו כאשר נדרשות השוואות מסודרות. אפשרות זו דורשת זאת
שניהם -fno-סימן-אפסים ו -fno-מלכודת-מתמטיקה להיות בתוקף. יתר על כן, זה לא עושה
הרבה הגיון עם -חישוב-מתמטיקה. עבור Fortran האפשרות מופעלת אוטומטית כאשר
שניהם -fno-סימן-אפסים ו -fno-מלכודת-מתמטיקה בתוקף.

ברירת המחדל היא -fno-אסוציאטיבי-מתמטיקה.

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

ברירת המחדל היא -fno-הדדיות-מתמטיקה.

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

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

ברירת המחדל היא -fno-finite-מתמטיקה-בלבד.

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

ברירת המחדל היא -fsigned-אפסים.

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

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

ברירת המחדל היא -ftrapping-מתמטיקה.

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

ברירת המחדל היא -fno-עגל-מתמטיקה.

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

-fsignaling-nans
הידור קוד בהנחה ש-NANs איתות IEEE עשויים ליצור מלכודות גלויות למשתמש במהלך
פעולות נקודה צפה. הגדרת אפשרות זו משביתה אופטימיזציות שעשויות להשתנות
מספר החריגים הנראים עם איתות NaNs. אפשרות זו מרמזת
-ftrapping-מתמטיקה.

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

ברירת המחדל היא -fno-signaling-nans.

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

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

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

אפשרות זו שולטת בהגדרת ברירת המחדל של פרגמת ISO C99 "CX_LIMITED_RANGE".
עם זאת, האפשרות חלה על כל השפות.

-fcx-fortran-rules
כפל וחילוק מורכבים פועלים לפי כללי Fortran. הפחתת טווח נעשית כ
חלק מחלוקה מורכבת, אבל אין בדיקה אם התוצאה של קומפלקס
הכפל או החלוקה הם "NaN + I*NaN", תוך ניסיון להציל את המצב
במקרה הזה.

ברירת המחדל היא -fno-cx-fortran-rules.

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

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

עם -fענף-הסתברויות, GCC שם א REG_BR_PROB הערה על כל אחד JUMP_INSN ו
CALL_INSN. ניתן להשתמש בהם כדי לשפר אופטימיזציה. נכון לעכשיו, הם משמשים רק
במקום אחד: ב reorg.c., במקום לנחש לאיזה נתיב יש סבירות גבוהה לסניף
לקחת, את REG_BR_PROB ערכים משמשים כדי לקבוע בדיוק איזה נתיב נלקח יותר
לעתים קרובות.

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

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

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

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

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

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

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

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

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

-funroll-לולאות
פתח לולאות שניתן לקבוע את מספר האיטרציות שלהן בזמן ההידור או לאחר מכן
כניסה ללופ. -funroll-לולאות מרמז -frerun-cse-after-loop, -FWeb. ו
-frename-registers. זה גם מפעיל קילוף לולאה מלא (כלומר הסרה מלאה של
לולאות עם מספר קבוע קטן של איטרציות). אפשרות זו הופכת את הקוד לגדול יותר, ו
עשוי לגרום לו לרוץ מהר יותר או לא.

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

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

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

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

-fmove-loop-invariants
מאפשר את מעבר התנועה הבלתי משתנה של הלולאה במיטוב הלולאה של RTL. מופעל ברמה
-O1

-לולאות funswitch
הזז ענפים עם תנאים בלתי משתנה של לולאה מחוץ ללולאה, עם כפילויות של ה-
לולאה בשני הענפים (שונה בהתאם לתוצאה של המצב).

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

השתמש באפשרויות אלה במערכות שבהן המקשר יכול לבצע אופטימיזציות לשיפור
מקום התייחסות במרחב ההדרכה. רוב המערכות משתמשות באובייקט ELF
למעבדי פורמט ו-SPARC המריצים את Solaris 2 יש קישורים עם אופטימיזציות כאלה.
ייתכן של-AIX יהיו אופטימיזציות אלה בעתיד.

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

-fbranch-target-load-optimize
בצע אופטימיזציה של עומס רשם יעד ענף לפני השרשור של פרולוג/אפילוג.
השימוש באוגרי מטרה בדרך כלל יכול להיחשף רק במהלך טעינה מחדש, ובכך להרים
טעינה מחוץ ללולאות וביצוע תזמון בין-בלוק מצריך אופטימיזציה נפרדת
לַעֲבוֹר.

-fbranch-target-load-optimize2
בצע אופטימיזציה של עומס רשם יעד ענף לאחר השרשור של פרולוג/אפילוג.

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

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

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

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

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

לדוגמה, יישום הפונקציה הבאה "foo":

סטטי int a, b, c;
int foo (void) { return a + b + c; }

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

int foo (בטל)
{
רשום int *xr = &x;
החזר xr[&a - &x] + xr[&b - &x] + xr[&c - &x];
}

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

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

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

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

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

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

min-crossjump-ins
המספר המינימלי של הוראות שיש להתאים בסוף שני בלוקים
לפני שמבצעים עליהם קפיצות צולבות. ערך זה מתעלם במקרה
שבו כל ההוראות בבלוק שממנו מקפצים מותאמות. ה
ערך ברירת המחדל הוא 5.

max-grow-copy-bb-insns
מקדם ההרחבה המקסימלי של גודל הקוד בעת העתקת בלוקים בסיסיים במקום
קפיצה. ההרחבה היא ביחס להוראת קפיצה. ערך ברירת המחדל הוא
8.

max-goto-duplication-insns
המספר המרבי של הוראות לשכפול לבלוק שקופץ ל-a
goto מחושב. כדי להימנע מהתנהגות O(N^2) במספר מעברים, גורמים GCC
גוטוס מחושבים בשלב מוקדם בתהליך הקומפילציה, ומבטל אותם עד מאוחר
אפשרי. רק קפיצות מחושבות בסוף בלוקים בסיסיים עם לא יותר ממקסימום-
goto-duplication-inss אינם מושפעים. ערך ברירת המחדל הוא 8.

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

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

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

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

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

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

max-inline-insns-סינגל
מספר פרמטרים שולטים ב-inliner של העץ המשמש ב-GCC. מספר זה קובע את
המספר המרבי של הוראות (נספרות בייצוג הפנימי של GCC) ב-a
פונקציה יחידה שה-inliner של העץ מחשיב ל-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. ה
ערך ברירת המחדל הוא 30 מה שמגביל את צמיחת היחידה לפי 1.3 מהגודל המקורי.

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

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

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

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

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

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

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

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

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

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

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

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

min-vect-loop-bound
המספר המינימלי של איטרציות שמתחתן לולאות אינן מקובלות
-ftree-vectorize משמש. מספר האיטרציות לאחר הוקטוריזציה צריך
להיות גדול מהערך שצוין על ידי אפשרות זו כדי לאפשר וקטוריזציה. ה
ערך ברירת המחדל הוא 0.

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

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

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

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

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

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

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

יישור-סף
בחר חלק מהתדירות המקסימלית של ביצועים של בלוק בסיסי ב-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.

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

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

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

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

loop-invariant-max-bbs-in-loop
תנועה בלתי משתנה של לולאה יכולה להיות יקרה מאוד, הן בזמן הקומפילציה והן בזמן
כמות הזיכרון הדרוש לזמן קומפילציה, עם לולאות גדולות מאוד. לולאות עם עוד
בלוקים בסיסיים מאשר פרמטר זה לא יהיו אופטימיזציה של תנועה בלתי משתנה בלולאה
בוצע עליהם. ערך ברירת המחדל של הפרמטר הוא 1000 עבור -O1 ו 10000
ל -O2 ומעל.

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

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

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

min-nondebug-insn-uid
השתמש ב-uids שמתחיל בפרמטר זה עבור insns ללא באגים. הטווח מתחת ל-
הפרמטר שמור באופן בלעדי עבור רכיבי ניפוי באגים שנוצרו על ידי
-fvar-tracking-assignments, אבל תוספי ניפוי באגים עשויים לקבל UID (לא חופפים) למעלה
זה אם הטווח השמור מוצה.

ipa-sra-ptr-growth factor
IPA-SRA מחליף מצביע לצבירה בפרמטר חדש אחד או יותר בלבד
כאשר הגודל המצטבר שלהם קטן או שווה ל ipa-sra-ptr-growth factor פעמים
גודל פרמטר המצביע המקורי.

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

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

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

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

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

lto-מחיצות
ציין את המספר הרצוי של מחיצות שנוצרו במהלך הידור WHOPR. ה
מספר המחיצות צריך לעלות על מספר המעבדים המשמשים להידור. ה
ערך ברירת המחדל הוא 32.

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

cxx-max-namespaces-for-diagnostic-help
המספר המרבי של מרחבי שמות שיש להתייעץ בהם לקבלת הצעות בעת חיפוש שמות ב-C++
נכשל עבור מזהה. ברירת המחדל היא 1000.

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

max-stores-to-sink
המספר המרבי של זוגות חנויות מותנות שניתן לשקוע. הגדר ל-0 אם
או וקטוריזציה (-ftree-vectorize) או אם-המרה (-ftree-loop-if-convert)
מושבת. ברירת המחדל היא 2.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-lobjc
אתה צריך את המקרה המיוחד הזה של -l אפשרות לקישור Objective-C או
תוכנית Objective-C++.

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

-nodefaultlibs
אל תשתמש בספריות המערכת הסטנדרטיות בעת הקישור. רק הספריות שאתה מציין
מועברים למקשר, ואפשרויות המציינות קישור של ספריות המערכת, כגון
בתור "-static-libgcc" או "-shared-libgcc", מתעלמים. קבצי האתחול הסטנדרטיים הם
בשימוש רגיל, אלא אם כן -nostartfiles משמש.

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

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

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

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

ברוב המקרים, אתה צריך libgcc.a גם כאשר אתה רוצה להימנע מספריות סטנדרטיות אחרות.
במילים אחרות, כשאתה מציין -נוסטדליב or -nodefaultlibs אתה צריך בדרך כלל
לפרט -lgcc גם כן. זה מבטיח שאין לך אזכורים לא פתורים
תתי שגרות פנימיות של ספריית GCC. (דוגמה לתתי שגרה פנימית כזו היא
__רָאשִׁי, משמש כדי להבטיח שנקראים בנאים C++.)

-פַּאִי
הפקת עמדה עצמאית לביצוע על יעדים התומכים בה. לצפוי
תוצאות, עליך לציין גם את אותה קבוצת אפשרויות המשמשת להידור (-fpie,
-fPIE, או אפשרויות משנה של מודל) כאשר אתה מציין אפשרות קישור זו.

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

-s הסר את כל מידע על טבלת הסמלים והעברת המיקום מקובץ ההפעלה.

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

-מְשׁוּתָף
צור אובייקט משותף שאותו ניתן לקשר עם אובייקטים אחרים ליצירת
בר הפעלה. לא כל המערכות תומכות באפשרות זו. לתוצאות צפויות, אתה חייב
ציין גם את אותה קבוצת אפשרויות המשמשת להידור (-fpic, -fPIC, או דגם
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 לקישור ליבצאן באופן סטטי, בלי
בהכרח קישור סטטי של ספריות אחרות.

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

-סִמלִי
קשר הפניות לסמלים גלובליים בעת בניית אובייקט משותף. להזהיר על כל
הפניות לא פתורות (אלא אם כן נדנו על ידי אפשרות עורך הקישורים -Xlinker -z
-Xlinker defs). רק מערכות בודדות תומכות באפשרות זו.

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

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

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

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

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

הערה: באובונטו 8.10 ובגירסאות מאוחרות יותר, עבור LDFLAGS, האפשרות -Wl,-z,relro משמש.
כדי להשבית, השתמש -Wl,-z,norelro.

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

אפשרויות ל מַדרִיך חיפוש
אפשרויות אלה מציינות ספריות לחיפוש קובצי כותרות, ספריות וחלקים
של המהדר:

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

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

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

-אני מצטטdir
הוסף את הספרייה dir לראש רשימת הספריות שיש לחפש את הכותרת
תיקים רק למקרה של #include "פילה"; לא מחפשים אותם #include <פילה>,
אחרת ממש כמו -I.

-Ldir
הוסף ספרייה dir לרשימת הספריות שיש לחפש -l.

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

תוכנית מנהל ההדרים מפעילה אחת או יותר מתת-התוכניות cpp, cc1, as ו ld.
זה מנסה קידומת בתור קידומת לכל תוכנית שהיא מנסה להפעיל, גם עם וגם בלי
מכונה/גרסה/.

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

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

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

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

דרך נוספת לציין קידומת בדומה ל- -B הקידומת היא להשתמש בסביבה
משתנה GCC_EXEC_PREFIX.

כמו kludge מיוחד, אם הנתיב מסופק על ידי -B is [dir/]stageN/, שם N הוא מספר
בטווח 0 עד 9, אז הוא מוחלף ב [dir/]include. זה כדי לעזור באתחול-
לחגור את המהדר.

-מפרט =פילה
התַהֲלִיך פילה לאחר שהמהדר יקרא את התקן מפרט טכני קובץ, כדי לעקוף
ברירות המחדל שבהן gcc תוכנית מנהל ההתקן משתמשת בעת קביעת הבוררים לעבור
ל cc1, cc1plus, as, ldוכו' יותר מאחד -מפרט =פילה ניתן לציין ב-
שורת הפקודה, והם מעובדים לפי הסדר, משמאל לימין.

--sysroot=dir
השתמש dir בתור ספריית השורש הלוגית לכותרות וספריות. לדוגמה, אם ה
מהדר בדרך כלל מחפש כותרות ב / usr / include וספריות ב / Usr / lib, זה
במקום חיפושים dir/usr/include ו dir/usr/lib.

אם אתה משתמש גם באפשרות זו וגם ב- -isysroot אפשרות ולאחר מכן את --sysroot אוֹפְּצִיָה
חל על ספריות, אבל ה -isysroot האפשרות חלה על קבצי כותרות.

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

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

-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 סיביות
מספר שלם כפל-צבור הוראות.

-מרץ=שם
ציין את השם של ארכיטקטורת היעד, אופציונלי עם סיומת אחת או יותר
משנה תכונות. לאפשרות זו יש את הטופס -מרץ=קשת{+[לא]תכונה}*, איפה ה
רק ערך עבור קשת is armv8-a. הערכים האפשריים עבור תכונה מתועדים ב-
סעיף משנה להלן.

כאשר צוינו תכונה מתנגשת, התכונה הכי ימנית משמשת.

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

-mcpu=שם
ציין את שם מעבד היעד, עם סיומת אופציונלית על ידי תכונה אחת או יותר
משנה. לאפשרות זו יש את הטופס -mcpu=מעבד{+[לא]תכונה}*, היכן שאפשר
ערכים עבור מעבד יש לו גנרית, גָדוֹל. הערכים האפשריים עבור תכונה מתועדים ב
תת הסעיף להלן.

כאשר צוינו תכונה מתנגשת, התכונה הכי ימנית משמשת.

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

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

-מרץ ו -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.

זרוע אפשרויות

אלה -m האפשרויות מוגדרות עבור ארכיטקטורות מתקדמות RISC Machines (ARM):

-מאבי=שם
צור קוד עבור ה-ABI שצוין. הערכים המותרים הם: apcs-gnu, atpcs, aapcs,
aapcs-linux ו iwmmxt.

-mapcs-frame
צור מסגרת מחסנית התואמת את תקן ARM Procedure Call עבור כולם
פונקציות, גם אם זה לא הכרחי לחלוטין לביצוע נכון של הקוד.
מפרט -fomit-frame-pointer עם אפשרות זו גורם למסגרות המחסנית לא להיות
נוצר עבור פונקציות עלים. ברירת המחדל היא -mno-apcs-frame.

-מפות
זוהי מילה נרדפת ל -mapcs-frame.

-מ-אגודל-עבודה
צור קוד התומך בהתקשרות בין ערכות ההוראות ARM ו-Thumb.
ללא אפשרות זו, בארכיטקטורות קדם-v5, שתי ערכות ההוראות לא יכולות להיות
בשימוש אמין בתוך תוכנית אחת. ברירת המחדל היא -mno-thumb-interwork, מאז מעט
קוד גדול יותר נוצר כאשר -מ-אגודל-עבודה מצוין. בתצורות AAPCS
אפשרות זו חסרת משמעות.

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

-mfloat-abi=שם
מציין באיזה ABI של נקודה צפה להשתמש. הערכים המותרים הם: רך, softfp ו
קָשֶׁה.

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

ברירת המחדל תלויה בתצורת היעד הספציפית. שימו לב שה-hard-float
ו- ABIs soft float אינם תואמים קישורים; אתה חייב להרכיב את כל התוכנית שלך עם
אותו ABI, וקישור עם קבוצה תואמת של ספריות.

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

-mbig-endian
צור קוד עבור מעבד הפועל במצב big-endian; ברירת המחדל היא קומפילציה
קוד עבור מעבד קטן אנדיאן.

-mwords-little-endian
אפשרות זו חלה רק בעת יצירת קוד עבור מעבדים גדולים. לִיצוֹר
קוד לסדר מילים קטן-אנדיאן אבל סדר בתים גדול-אנדיאן. כלומר, בייט
סדר הטופס 32107654. הערה: יש להשתמש באפשרות זו רק אם אתה צריך
תאימות עם קוד עבור מעבדי ARM גדולים שנוצרו על ידי גרסאות של
מהדר לפני 2.8. אפשרות זו הוצאה משימוש כעת.

-מרץ=שם
זה מציין את השם של ארכיטקטורת ARM היעד. GCC משתמש בשם זה כדי
לקבוע איזה סוג של הוראות הוא יכול לפלוט בעת הפקת קוד הרכבה. זֶה
ניתן להשתמש באפשרות בשילוב עם או במקום -mcpu= אוֹפְּצִיָה. מוּתָר
השמות הם: armv2, armv2a, armv3, armv3m, armv4, armv4t, armv5, armv5t, armv5e,
armv5te, armv6, ARMV6J, armv6t2, armv6z, armv6zk, armv6-m, armv7, armv7-a, armv7-r,
armv7-m, armv7e-m armv8-a, armv8-a+crc, iwmmxt, iwmmxt2, ep9312.

-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,
קליפת המוח-a15, קליפת המוח-a53, cortex-r4, cortex-r4f, cortex-r5, cortex-r7, קורטקס-m4,
קורטקס-m3, קורטקס-m1, קורטקס-m0, cortex-m0plus, marvell-pj4, xscale, iwmmxt, iwmmxt2,
ep9312, fa526, fa626, fa606te, fa626te, fmp626, fa726te.

-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,
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 מגה-בייט
טווח של הגרסה מבוססת היסט של הוראת שיחות תת שגרתיות.

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

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

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

-mpic-register=רג
ציין את האוגר שישמש עבור כתובת PIC. למקרה בסיס PIC סטנדרטי, ה
ברירת המחדל תהיה כל אוגר מתאים שנקבע על ידי המהדר. לבסיס PIC יחיד
במקרה, ברירת המחדל היא R9 אם היעד מבוסס על EABI או שבדיקת מחסנית מופעלת,
אחרת ברירת המחדל היא R10.

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

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

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", "ata6289", "attiny13", "attiny13a",
"attiny2313", "attiny2313a", "attiny24", "attiny24a", "attiny25", "attiny261",
"attiny261a", "attiny43u", "attiny4313", "attiny44", "attiny44a", "attiny45",
"attiny461", "attiny461a", "attiny48", "attiny84", "attiny84a", "attiny85",
"attiny861", "attiny861a", "attiny87", "attiny88", "at86rf401".

"avr3"
מכשירים "קלאסיים" עם 16@tie{}KiB עד 64@tie{}KiB של זיכרון תוכניות.
מקו@tie{}= "at43usb355", "at76c711".

"avr31"
מכשירים "קלאסיים" עם 128@tie{}KiB של זיכרון תוכניות. מקו@tie{}= "atmega103",
"at43usb320".

"avr35"
מכשירים "קלאסיים" עם 16@tie{}KiB עד 64@tie{}KiB של זיכרון תוכנית ועם
הוראת "MOVW". מקו@tie{}= "ata5505", "atmega16u2", "atmega32u2",
"atmega8u2", "attiny1634", "attiny167", "at90usb162", "at90usb82".

"avr4"
מכשירים "משופרים" עם עד 8@tie{}KiB של זיכרון תוכניות. מקו@tie{}= "ata6285",
"ata6286", "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{}= "ata5790", "ata5790n", "ata5795", "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", "atmega26hvg", "atmega32", "atmega32a", "atmega32c1",
"atmega32hvb", "atmega32hvbrevb", "atmega32m1", "atmega32u4", "atmega32u6",
"atmega323", "atmega324a", "atmega324p", "atmega324pa", "atmega325", "atmega325a",
"atmega325p", "atmega3250", "atmega3250a", "atmega3250p", "atmega3250pa",
"atmega328", "atmega328p", "atmega329", "atmega329a", "atmega329p", "atmega329pa",
"atmega3290", "atmega3290a", "atmega3290p", "atmega3290pa", "atmega406",
"atmega48hvf", "atmega64", "atmega64a", "atmega64c1", "atmega64hve", "atmega64m1",
"atmega64rfa2", "atmega64rfr2", "atmega640", "atmega644", "atmega644a",
"atmega644p", "atmega644pa", "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", "atmega1280", "atmega1281", "atmega1284",
"atmega1284p", "at90can128", "at90usb1286", "at90usb1287".

"avr6"
מכשירים "משופרים" עם מחשב של 3 בתים, כלומר עם יותר מ-128@tie{}KiB של תוכנית
זיכרון. מקו@tie{}= "atmega2560", "atmega2561".

"avrxmega2"
מכשירי "XMEGA" עם יותר מ-8@tie{}KiB ועד 64@tie{}KiB של זיכרון תוכנית.
מקו@tie{}= "atmxt112sl", "atmxt224", "atmxt224e", "atmxt336s", "atxmega16a4",
"atxmega16a4u", "atxmega16c4", "atxmega16d4", "atxmega16x1", "atxmega32a4",
"atxmega32a4u", "atxmega32c4", "atxmega32d4", "atxmega32e5", "atxmega32x1".

"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{}=
"atmxt540s", "atmxt540sreva", "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".

"avr1"
ISA זה מיושם על ידי ליבת AVR המינימלית ונתמך עבור assembler בלבד.
מקו@tie{}= "attiny11", "attiny12", "attiny15", "attiny28", "at90s1200".

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

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

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

-brranch-cost=עלות
הגדר את עלויות הסניף עבור הוראות סניף מותנות ל עלות. ערכים סבירים
ל עלות הם מספרים שלמים קטנים ולא שליליים. עלות הסניף המוגדרת כברירת מחדל היא 0.

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

-מנטה8
נניח ש"int" הוא מספר שלם של 8 סיביות. זה משפיע על הגדלים של כל הסוגים: "char" הוא 1
בייט, "int" הוא 1 בייט, "long" הוא 2 בתים, ו-"long long" הוא 4 בתים. אנא
שים לב שאופציה זו אינה תואמת את תקני C, אך היא מביאה לקטן יותר
גודל קוד.

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

-להירגע
נסה להחליף "CALL" בהתאמה. הוראת "JMP" על ידי ה"RCALL" הקצר יותר. "RJMP"
הוראה אם ​​רלוונטית. הגדרת "-mrelax" רק מוסיפה את האפשרות "--relax" ל-
שורת הפקודה מקשר כאשר קוראים למקשר.

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

יש להפעיל את ההרגעה אם יש צורך בסתמי קישור, ראה סעיף על "EIND" ו
בדלי קישור למטה.

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

אפשרות זו משמשת באופן פנימי על ידי המהדר כדי לבחור ולבנות עבורם multilibs
ארכיטקטורות "avr2" ו-"avr25". ארכיטקטורות אלו מערבבות מכשירים עם ובלי
"SPH". עבור כל הגדרה שאינה "-mmcu=avr2" או "-mmcu=avr25" מנהל ההדר
יוסיף או יסיר אפשרות זו משורת הפקודה של המהדר, מכיוון ש-
מהדר אז יודע אם למכשיר או לארכיטקטורה יש מצביע מחסנית של 8 סיביות וכך
אין רישום "SPH" או לא.

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

ללא אפשרות זו, ניתן להשתמש ברישום "X" באותו אופן כמו "Y" או "Z" אשר
לאחר מכן מחקה על ידי הוראות נוספות. לדוגמה, טעינת ערך עם
"X+const" מפנה עם "const < 64" קטן לא שלילי לרישום Rn is
בוצע כ

adiw r26, const; X += const
ld , איקס ; = *X
sbiw r26, const; X -= קונסט

-mtiny-stack
שנה רק את 8@tie{}הסיביות התחתונות של מצביע המחסנית.

-Waddr-space-convert
התריע על המרות בין מרחבי כתובות במקרה שבו הכתובת המתקבלת
הרווח אינו כלול במרחב הכתובות הנכנסות.

"EIND" ומכשירים עם יותר מ-128 Ki Bytes של פלאש

המצביעים ביישום הם ברוחב של 16@tie{}סיביות. הכתובת של פונקציה או תווית
מיוצג ככתובת מילה כך שקפיצות ושיחות עקיפות יכולות למקד לכל קוד
כתובת בטווח של 64@tie{}מילים קי.

על מנת לאפשר קפיצה עקיפה למכשירים עם יותר מ-128@tie{}Ki bytes של
שטח זיכרון תוכנית, קיים אוגר פונקציות מיוחד בשם "EIND" המשמש כ
החלק המשמעותי ביותר של כתובת היעד כאשר הוראות "EICALL" או "EIJMP".
מְשׁוּמָשׁ.

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

· המהדר אף פעם לא מגדיר "EIND".

· המהדר משתמש ב-"EIND" באופן מרומז בהוראות "EICALL"/"EIJMP" או עשוי לקרוא
"EIND" ישירות על מנת לחקות קריאה/קפיצה עקיפה באמצעות "RET"
הוראה.

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

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

· יש להפעיל הרפיית קישור כך שהמקשר יפיק את הסטאבים
כהלכה מצב הכל. ראה את אפשרות המהדר "-mrelax" ואת אפשרות ה-linler
"--לְהִרָגַע". ישנם מקרים פינתיים שבהם המקשר אמור ליצור בדל אבל
מפסיק ללא הרפיה וללא הודעת שגיאה מועילה.

· סקריפט המקשר המוגדר כברירת מחדל מסודר לקוד עם "EIND = 0". אם קוד אמור
כדי לעבוד עבור הגדרה עם "EIND != 0", יש להשתמש בסקריפט קישור מותאם אישית לפי הסדר
למקם את הקטעים ששמם מתחיל ב-".טרמפולינות" לתוך הקטע שבו
"EIND" מצביע על.

· קוד האתחול מ-libgcc אף פעם לא מגדיר "EIND". שימו לב שקוד ההפעלה הוא שילוב
של קוד מ-libgcc ו-AVR-LibC. להשפעה של AVR-LibC על "EIND", ראה את AVR-
מדריך למשתמש LibC ("http://nongnu.org/avr-libc/user-manual/").

· זה לגיטימי עבור קוד הפעלה ספציפי למשתמש להגדיר את "EIND" מוקדם, למשל על ידי
אמצעי אתחול קוד הממוקם בסעיף ".init3". קוד כזה פועל לפני
קוד הפעלה כללי שמאתחל את זיכרון ה-RAM וקורא לבנאים, אך לאחר ה-bit of
קוד הפעלה מ-AVR-LibC שמגדיר "EIND" למקטע שבו נמצאת הטבלה הוקטורית
ממוקם.

#לִכלוֹל

חלל סטטי
__attribute__((section(".init3"),naked,used,no_instrument_function))
init3_set_eind (ריק)
{
__asm ​​volatile ("ldi r24,pm_hh8(__trampolines_start)\n\t"
"out %i0,r24" :: "n" (&EIND) : "r24","memory");
}

הסמל "__trampolines_start" מוגדר בסקריפט המקשר.

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

-
(קיצור ל ליצור תלים) ככה:

LDI r24, lo8(gs( ))
LDI r25, hi8(gs( ))

-
בחוץ הקטע שבו נמצאים הבדלים.

· המהדר פולט מתני "gs" כאלה עבור תוויות קוד במצבים הבאים:

-
-
- -mcall-פרולוגים>
אפשרות שורת פקודה.

-
טבלאות שאתה יכול לציין את -fno-jump-tables אפשרות שורת פקודה.

-
-
· קפיצה לכתובות לא סמליות כמו כך לֹא נתמך:

int main (ריק)
{
/* התקשר לפונקציה בכתובת המילה 0x2 */
return ((int(*)(void)) 0x2)();
}

במקום זאת, יש להגדיר בדל, כלומר יש לקרוא לפונקציה באמצעות סמל
("func_4" בדוגמה):

int main (ריק)
{
extern int func_4 (ריק);

/* פונקציית התקשרות בכתובת בייט 0x4 ​​*/
החזר func_4();
}

והאפליקציה תהיה מקושרת עם "-Wl,--defsym,func_4=0x4". לחלופין, "func_4"
ניתן להגדיר בסקריפט המקשר.

טיפול בפנקסי הפונקציות המיוחדות "RAMPD", "RAMPX", "RAMPY" ו-"RAMPZ"

חלק ממכשירי הרסיבר תומכים בזיכרונות גדולים יותר מטווח 64@tie{}KiB שניתן לגשת אליו
עם מצביעים של 16 סיביות. כדי לגשת למיקומי זיכרון מחוץ לטווח 64@tie{}KiB הזה, ה
התוכן של אוגר "RAMP" משמש כחלק גבוה של הכתובת: ה-"X", "Y", "Z"
אוגר הכתובות משורשר עם הפונקציה המיוחדת "RAMPX", "RAMPY", "RAMPZ".
הירשם, בהתאמה, כדי לקבל כתובת רחבה. באופן דומה, "RAMPD" משמש יחד עם
פנייה ישירה.

· קוד האתחול מאתחל את אוגרי הפונקציה המיוחדת "RAMP" באפס.

· אם AVR שם כתובת רווחים, בשם כתובת שטח מלבד גנרי או "__flash" הוא
בשימוש, אז "RAMPZ" מוגדר לפי הצורך לפני הפעולה.

· אם המכשיר תומך בזיכרון RAM גדול מ-64@tie{KiB} והקומפיילר צריך להשתנות
"RAMPZ" כדי לבצע פעולה, "RAMPZ" מאופס לאפס לאחר הפעולה.

· אם המכשיר מגיע עם אוגר "RAMP" ספציפי, הפרולוג/אפילוג של ISR
שומר/משחזר את ה-SFR הזה ומאתחל אותו באפס למקרה שקוד ה-ISR עלול
(במרומז) להשתמש בו.

· זיכרון RAM גדול מ-64@tie{KiB} אינו נתמך על ידי GCC עבור יעדי AVR. אם אתה משתמש
אסמבלר מוטבע כדי לקרוא ממיקומים מחוץ לטווח הכתובות של 16 סיביות ולשנות
אחד מהאוגרים של "RAMP", עליך לאפס אותו לאפס לאחר הגישה.

AVR מובנים מאקרו

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

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

"__AVR_ARCH__"
מאקרו מובנה שפותר למספר עשרוני המזהה את הארכיטקטורה ו
תלוי ב-"-mmcu=mcu" אוֹפְּצִיָה. ערכים אפשריים הם:

2, 25, 3, 31, 35, 4, 5, 51, 6, 102, 104, 105, 106, 107

ל מקו="avr2", "avr25", "avr3", "avr31", "avr35", "avr4", "avr5", "avr51", "avr6",
"avrxmega2", "avrxmega4", "avrxmega5", "avrxmega6", "avrxmega7", בהתאמה. אם מקו
מציין מכשיר, מאקרו מובנה זה מוגדר בהתאם. למשל, עם
"-mmcu=atmega8" המאקרו יוגדר ל-4.

"__AVR_מכשיר__"
הגדרת "-mmcu=התקן" מגדיר מאקרו מובנה זה המשקף את שם המכשיר.
לדוגמה, "-mmcu=atmega8" מגדיר את המאקרו המובנה "__AVR_ATmega8__",
"-mmcu=attiny261a" מגדיר "__AVR_ATtiny261A__", וכו'.

שמות פקודות המאקרו המובנות עוקבים אחר הסכימה "__AVR_מכשיר__" איפה מכשיר האם ה
שם המכשיר כמו ממדריך למשתמש של הרסיבר. ההבדל בין מכשיר במובנה
מאקרו ו מכשיר ב-"-mmcu=התקן" הוא שהאחרון הוא תמיד באותיות קטנות.

If מכשיר אינו מכשיר אלא רק ארכיטקטורת ליבה כמו "avr51", המאקרו הזה יעשה זאת
לא להיות מוגדר.

"__AVR_XMEGA__"
המכשיר/הארכיטקטורה שייכים למשפחת המכשירים XMEGA.

"__AVR_HAVE_ELPM__"
למכשיר יש את הוראת "ELPM".

"__AVR_HAVE_ELPMX__"
למכשיר יש את "ELPM Rn,Z" ו"ELPM Rn,Z+" הוראות.

"__AVR_HAVE_MOVW__"
למכשיר יש את ההוראה "MOVW" לבצע מהלכי אוגר-אוגר של 16 סיביות.

"__AVR_HAVE_LPMX__"
למכשיר יש את "LPM Rn,Z" ו"LPM Rn,Z+" הוראות.

"__AVR_HAVE_MUL__"
למכשיר יש מכפיל חומרה.

"__AVR_HAVE_JMP_CALL__"
למכשיר יש את ההוראות "JMP" ו-"CALL". זה המקרה עבור מכשירים עם
לפחות 16@tie{}KiB של זיכרון תוכנית.

"__AVR_HAVE_EIJMP_EICALL__"
"__AVR_3_BYTE_PC__"
למכשיר יש את ההוראות "EIJMP" ו-"EICALL". זה המצב לגבי מכשירים
עם יותר מ-128@tie{}KiB של זיכרון תוכנית. זה גם אומר שהתוכנית
מונה (PC) הוא ברוחב של 3@tie{}בתים.

"__AVR_2_BYTE_PC__"
מונה התוכניות (PC) הוא ברוחב של 2@tie{}בתים. זה המקרה עבור מכשירים עם עד
128@tie{}KiB של זיכרון תוכנית.

"__AVR_HAVE_8BIT_SP__"
"__AVR_HAVE_16BIT_SP__"
האוגר מצביע מחסנית (SP) מטופל כאוגר של 8 סיביות בהתאמה של 16 סיביות על ידי
המהדר. ההגדרה של פקודות מאקרו אלו מושפעת מ-"-mtiny-stack".

"__AVR_HAVE_SPH__"
"__AVR_SP8__"
למכשיר יש את פנקס הפונקציות המיוחד SPH (חלק גבוה של מחסנית) או יש
מצביע מחסנית של 8 סיביות, בהתאמה. ההגדרה של פקודות מאקרו אלו מושפעת מ
"-mmcu=" ובמקרים של "-mmcu=avr2" ו-"-mmcu=avr25" גם על-ידי "-msp8".

"__AVR_HAVE_RAMPD__"
"__AVR_HAVE_RAMPX__"
"__AVR_HAVE_RAMPY__"
"__AVR_HAVE_RAMPZ__"
למכשיר יש את פנקס הפונקציות המיוחדות "RAMPD", "RAMPX", "RAMPY", "RAMPZ",
בהתאמה.

"__NO_INTERRUPTS__"
מאקרו זה משקף את אפשרות שורת הפקודה "-mno-interrupts".

"__AVR_ERRATA_SKIP__"
"__AVR_ERRATA_SKIP_JMP_CALL__"
לחלק מהתקני רסיבר (AT90S8515, ATmega103) אסור לדלג על הוראות של 32 סיביות בגלל
תקלה בחומרה. הוראות הדילוג הן "SBRS", "SBRC", "SBIS", "SBIC" ו-"CPSE".
המאקרו השני מוגדר רק אם "__AVR_HAVE_JMP_CALL__" מוגדר גם כן.

"__AVR_SFR_OFFSET__=לְקַזֵז"
הוראות שיכולות להתייחס ישירות ל-I/O פונקציות מיוחדות כמו "IN",
"OUT", "SBI" וכו' עשויים להשתמש בכתובת אחרת כאילו מועברת בהוראה אל
גישה ל-RAM כמו "LD" או "STS". היסט זה תלוי בארכיטקטורת המכשיר ויש לו
לחסר מכתובת ה-RAM כדי לקבל את כתובת ה-I/O@tie{} המתאימה.

"__WITH_AVRLIBC__"
המהדר מוגדר לשימוש יחד עם AVR-Libc. ראה את
אפשרות תצורה של "--with-avrlibc".

שחור אפשרויות

-mcpu=מעבד[-סירטוויזיון]
מציין את השם של מעבד היעד Blackfin. כַּיוֹם, מעבד יכול להיות אחד מ
bf512, bf514, bf516, bf518, bf522, bf523, bf524, bf525, bf526, bf527, bf531, bf532,
bf533, bf534, bf536, bf537, bf538, bf539, bf542, bf544, bf547, bf548, bf549, bf542m,
bf544m, bf547m, bf548m, bf549m, bf561, bf592.

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

-msdata=הכל
שים את כל הנתונים, לא רק אובייקטים קטנים, בקטעים השמורים לנתונים קטנים, ו
השתמש בכתובת ביחס לרשום "B14" כדי לגשת אליהם.

-msdata=אין
אל תעשה שימוש בקטעים השמורים לנתונים קטנים, והשתמש בכתובות מוחלטות כדי
לגשת לכל הנתונים. שים את כל הנתונים הגלובאליים והסטטיים המאותחלים ב- .fardata סָעִיף,
וכל הנתונים הלא מאותחלים ב- .רָחוֹק סָעִיף. שים את כל הנתונים הקבועים לתוך .const
סָעִיף.

Cris אפשרויות

אפשרויות אלו מוגדרות במיוחד עבור יציאות CRIS.

-מרץ=סוג אדריכלות
-mcpu=סוג אדריכלות
צור קוד עבור הארכיטקטורה שצוינה. הבחירות עבור סוג אדריכלות יש לו
v3, v8 ו v10 עבור ETRAX 4, ETRAX 100 ו-ETRAX 100 LX בהתאמה. ברירת המחדל היא v0
מלבד cris-axis-linux-gnu, שם ברירת המחדל היא v10.

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

-mmax-stack-frame=n
אזהרה כאשר מסגרת המחסנית של פונקציה חורגת n בתים.

-מטרקס4
-מטרקס100
האפשרויות -מטרקס4 ו -מטרקס100 הן מילים נרדפות ל -מרץ=v3 ו -מרץ=v8
בהתאמה.

-mmul-bug-around
-mno-mul-bug-around
עקוף באג בהוראות "muls" ו-"mulu" עבור דגמי CPU שבהם הוא
חל. אפשרות זו פעילה כברירת מחדל.

-mpdebug
אפשר מידע מפורט על ניפוי באגים ספציפי ל-CRIS בקוד ה-assembly. זֶה
לאפשרות יש גם את ההשפעה של כיבוי #NO_APP מחוון קוד מעוצב ל-
assembler בתחילת קובץ ההרכבה.

-mcc-init
אל תשתמש בתוצאות קוד מצב מהוראה קודמת; תמיד פולט השווה ו
הוראות בדיקה לפני השימוש בקודי מצב.

-mno-תופעות לוואי
אין לפלוט הוראות עם תופעות לוואי במצבי התייחסות מלבד לאחר
תוֹסֶפֶת.

-mstack-align
-mno-stack-align
-mdata-align
-mno-data-align
-mconst-align
-mno-const-align
אפשרויות אלו (לא- אפשרויות) לארגן (לבטל סידורים) עבור מסגרת הערימה,
נתונים בודדים וקבועים שיש ליישור לגודל הגישה המקסימלית לנתונים בודדים
עבור דגם המעבד הנבחר. ברירת המחדל היא לארגן יישור של 32 סיביות. ABI
פרטים כגון פריסת המבנה אינם מושפעים מהאפשרויות הללו.

-m32-bit
-m16-bit
-m8-bit
בדומה לאפשרויות מחסנית-נתונים ו-const-align שלמעלה, אפשרויות אלו מתאימות
מסגרת מחסנית, נתונים ניתנים לכתיבה וקבועים שיהיו כולם מיושרים ב-32 סיביות, 16 סיביות או 8 סיביות.
ברירת המחדל היא יישור של 32 סיביות.

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

-mno-gotplt
-mgotplt
עם -fpic ו -fPIC, אל תיצור (תייצר) רצפי הוראות שנטענים
כתובות עבור פונקציות מחלק ה-PLT של GOT ולא (מסורתי באחר
ארכיטקטורות) קריאות ל-PLT. ברירת המחדל היא -mgotplt.

-מלף
אפשרות ללא הפעלה מדור קודם מזוהה רק עם ה-cris-axis-elf ו-cris-axis-linux-gnu
מטרות.

-mlinux
אפשרות מדור קודם ללא הפעלה מזוהה רק עם היעד cris-axis-linux-gnu.

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

-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) is 4
בעת קומפילציה עבור Darwin/PowerPC ו 1 בעת קומפילציה עבור Darwin/x86, אז אפשרות זו
אין השפעה על x86.

אַזהָרָה: השמיים -mone-byte-bool switch גורם ל-GCC ליצור קוד שאינו בינארי
תואם לקוד שנוצר ללא המתג הזה. שימוש במתג זה עשוי לדרוש
קומפילציה מחדש של כל המודולים האחרים בתוכנית, כולל ספריות מערכת. השתמש בזה
לעבור כדי להתאים למודל נתונים שאינו ברירת מחדל.

-mfix-and-continue
-תקן-ו-המשך
-finddirect-נתונים
צור קוד המתאים לפיתוח תפנית מהיר, כגון לאפשר ל-GDB
טען באופן דינמי קבצי ".o" לתוכניות שכבר פועלות. -finddirect-נתונים ו
-תקן-ו-המשך מסופקים עבור תאימות לאחור.

-כל_עומס
טוען את כל החברים בספריות ארכיון סטטי. ראה גבר ld(1) למידע נוסף.

-arch_errors_fatal
גורם לשגיאות הקשורות לקבצים שיש להם ארכיטקטורה שגויה להיות קטלניות.

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

-חבילה
הפק קובץ בפורמט חבילה של Mach-o. ראה גבר ld(1) למידע נוסף.

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

אינטל 386 ו AMD x86-64 אפשרויות

אלה -m אפשרויות מוגדרות עבור משפחת המחשבים i386 ו-x86-64:

-מרץ=סוג מעבד
צור הוראות עבור סוג המכונה סוג מעבד. בניגוד ל -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
תמיכה בערכת הוראות.

Corei7
Intel Core i7 CPU עם הרחבות של 64 סיביות, MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1 ו
תמיכה בערכת הוראות SSE4.2.

corei7-avx
מעבד Intel Core i7 עם הרחבות של 64 סיביות, MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1,
תמיכה בערכת הוראות SSE4.2, AVX, AES ו-PCLMUL.

core-avx-i
Intel Core CPU עם הרחבות של 64 סיביות, MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1,
תמיכה בערכת הוראות SSE4.2, AVX, AES, PCLMUL, FSGSBASE, RDRND ו-F16C.

core-avx2
Intel Core CPU עם הרחבות של 64 סיביות, MOVBE, MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1,
SSE4.2, AVX, AVX2, AES, PCLMUL, FSGSBASE, RDRND, FMA, BMI, BMI2 ו-F16C
תמיכה בערכת הוראות.

אטום
Intel Atom CPU עם הרחבות של 64 סיביות, MOVBE, MMX, SSE, SSE2, SSE3 ו-SSSE3
תמיכה בערכת הוראות.

k6 מעבד AMD K6 עם תמיכה בערכת הוראות MMX.

k6-2
k6-3
גרסאות משופרות של מעבד AMD K6 עם MMX ו-3DNow! תמיכה בערכת הוראות.

אתלון
אתלון-tbird
מעבד AMD Athlon עם MMX, 3dNOW!, 3DNow משופר! והוראות אחזור מראש של SSE
תומכים.

אתלון-4
athlon-xp
אתלון-mp
מעבד AMD Athlon משופר עם MMX, 3DNow!, 3DNow משופר! והוראת SSE מלאה
להגדיר תמיכה.

k8
אופטרון
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, 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, AVX, XOP, LWP, AES, PCL_MUL, CX16, MMX, SSE, SSE2,
הרחבות SSE3, SSE4A, SSSE3, SSE4.1, SSE4.2, ABM ו-64 סיביות.

btver1
מעבדים המבוססים על ליבות AMD Family 14h עם תמיכה בערכת הוראות x86-64. (זֶה
ערכות-על MMX, SSE, SSE2, SSE3, SSSE3, SSE4A, CX16, ABM ו-64 סיביות
הרחבות.)

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 תומך ב-
בחירה נוספת עבור סוג מעבד:

גנרית
הפק קוד מותאם למעבדי IA32/AMD64/EM64T הנפוצים ביותר. אם אתה
לדעת את ה-CPU שעליו יפעל הקוד שלך, אז עליך להשתמש בקוד המתאים
-mtune or -מרץ אפשרות במקום -mtune=גנרי. אבל, אם אתה לא יודע
בדיוק מה יהיה למשתמשי ה-CPU של האפליקציה שלך, אז אתה צריך להשתמש בזה
אוֹפְּצִיָה.

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

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

-mcpu=סוג מעבד
מילה נרדפת שהוצאה משימוש עבור -mtune.

-mfpmath=יחידה
צור אריתמטיקה של נקודה צפה עבור היחידה שנבחרה יחידה. הבחירות עבור יחידה הם:

387 השתמש במעבד המשנה הסטנדרטי של 387 נקודות צפה הקיים ברוב השבבים
וחיקוי אחרת. קוד הידור עם אפשרות זו פועל כמעט בכל מקום.
התוצאות הזמניות מחושבות בדיוק של 80 סיביות במקום בדיוק
מוגדר לפי הסוג, וכתוצאה מכך תוצאות מעט שונות בהשוואה לרוב
צ'יפס אחרים. לִרְאוֹת -ffloat-store לתיאור מפורט יותר.

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

ESS השתמש בהוראות נקודה צפה סקלריות הקיימות בערכת ההוראות של SSE. זֶה
ערכת ההוראות נתמכת על ידי פנטיום III ושבבים חדשים יותר, ובקו AMD
של Athlon-4, Athlon XP ו-Athlon MP שבבי. הגרסה הקודמת של ה-SSE
ערכת ההוראות תומכת רק בחשבון בעל דיוק יחיד, ולכן הכפול ו
אריתמטיקה עם דיוק מורחב עדיין נעשים באמצעות 387. גרסה מאוחרת יותר, קיימת
רק בשבבי Pentium 4 ו-AMD x86-64, תומך גם באריתמטיקה בעלת דיוק כפול.

עבור מהדר i386, עליך להשתמש -מרץ=סוג מעבד, -msse or -msse2 עובר ל
אפשר הרחבות SSE והפוך את האפשרות הזו ליעילה. עבור מהדר x86-64,
הרחבות אלו מופעלות כברירת מחדל.

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

זוהי בחירת ברירת המחדל עבור מהדר x86-64.

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

-masm=נִיב
פלט הוראות הרכבה באמצעות נבחר נִיב. בחירות נתמכות הן אינטל 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. ציין אפשרות זו כדי להימנע מיצירת הוראות אלו. אפשרות זו היא
ברירת המחדל ב-FreeBSD, OpenBSD ו-NetBSD. אפשרות זו נדחפת כאשר -מרץ
מציין שלמעבד היעד יש תמיד FPU ולכן אין צורך בהוראה
אמולציה. הוראות אלה אינן נוצרות אלא אם כן אתה משתמש גם ב-
-אופטימיזציות-funsafe-math מתג.

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

ב-x86-64, -ממאיר-כפול מופעל כברירת מחדל.

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

-m96bit-long-double
-m128bit-long-double
מתגים אלה שולטים בגודל של סוג "כפול ארוך". היישום הבינארי של i386
ממשק מציין את הגודל להיות 96 סיביות, אז -m96bit-long-double הוא ברירת המחדל ב
מצב 32 סיביות.

ארכיטקטורות מודרניות (פנטיום וחדשות יותר) מעדיפות "כפול ארוך" להיות מיושר ל-8-
או גבול של 16 בתים. במערכים או במבנים התואמים את ABI, זה לא
אפשרי. כל כך מפרט -m128bit-long-double מיישר את "כפול ארוך" ל-16 בתים
גבול על ידי ריפוד ה"כפול הארוך" באפס נוסף של 32 סיביות.

במהדר x86-64, -m128bit-long-double הוא ברירת המחדל כ-ABI שלו
מציין ש"כפול ארוך" מיושר על גבול של 16 בתים.

שימו לב שאף אחת מהאפשרויות הללו לא מאפשרת דיוק נוסף על תקן x87
של 80 סיביות עבור "כפול ארוך".

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

-מלונג-כפול-64
-מלונג-כפול-80
מתגים אלה שולטים בגודל של סוג "כפול ארוך". גודל של 64 סיביות עושה את
סוג "כפול ארוך" שווה ערך לסוג "כפול". זוהי ברירת המחדל עבור Bionic C
סִפְרִיָה.

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

-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
יישר מחדש את הערימה בכניסה. ב-Intel 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.

-מממקס
-mno-mmx
-msse
-מנו-סס
-msse2
-mno-sse2
-msse3
-mno-sse3
-mssse3
-mno-ssse3
-msse4.1
-mno-sse4.1
-msse4.2
-mno-sse4.2
-msse4
-mno-sse4
-mavx
-mno-avx
-mavx2
-mno-avx2
-מייס
-mno-aes
-mpclmul
-mno-pclmul
-mfsgsbase
-mno-fsgsbase
-mrdrnd
-mno-rdrnd
-mf16c
-mno-f16c
-mfma
-mno-fma
-msse4a
-mno-sse4a
-mfma4
-mno-fma4
-mxop
-mno-xop
-mlwp
-mno-lwp
-m3dnow
-mno-3dnow
-mpopcnt
-mno-popcnt
-מאבם
-מנו-אבם
-מבמי
-mbmi2
-mno-bmi
-mno-bmi2
-mlzcnt
-mno-lzcnt
-mrtm
-mtbm
-mno-tbm
מתגים אלה מאפשרים או משביתים את השימוש בהוראות ב-MMX, SSE, SSE2, SSE3,
SSSE3, SSE4.1, AVX, AVX2, AES, PCLMUL, FSGSBASE, RDRND, F16C, FMA, SSE4A, FMA4, XOP,
LWP, ABM, BMI, BMI2, LZCNT, RTM או 3DNow! ערכות הוראות מורחבות. אלה
הרחבות זמינות גם כפונקציות מובנות: ראה X86 Built-in פונקציות, עבור
פרטים על הפונקציות המופעלות ומושבתות על ידי מתגים אלה.

ליצור הוראות SSE/SSE2 באופן אוטומטי מקוד נקודה צפה (בניגוד
להוראות 387), ראה -mfpmath = sse.

GCC מדכא הוראות SSEx כאשר -mavx משמש. במקום זאת, הוא מייצר AVX חדש
הוראות או שקילות AVX עבור כל הוראות ה-SSEx בעת הצורך.

אפשרויות אלה מאפשרות ל-GCC להשתמש בהוראות המורחבות הללו בקוד שנוצר, אפילו
לְלֹא -mfpmath = sse. יישומים שמבצעים זיהוי CPU בזמן ריצה חייבים לבצע קומפילציה
קבצים נפרדים עבור כל ארכיטקטורה נתמכת, תוך שימוש בדגלים המתאימים. ב
במיוחד, הקובץ המכיל את קוד זיהוי ה-CPU צריך להיות הידור ללא
אפשרויות אלה.

-mcld
אפשרות זו מורה ל-GCC לפלוט הוראת "cld" בפרולוג הפונקציות
המשתמשים בהוראות מחרוזת. הוראות מחרוזת תלויות בדגל ה-DF לבחירה
בין מצב הגדלה אוטומטית או הפחתה אוטומטית. בעוד ה-ABI מציין את דגל ה-DF ל
יש לנקות בהזנת פונקציה, חלק ממערכות ההפעלה מפרות מפרט זה בכך שלא
ניקוי דגל DF בשולחי החריג שלהם. המטפל חריג יכול להיות
מופעל עם סט דגל DF, מה שמוביל למצב כיוון שגוי בעת מחרוזת
נעשה שימוש בהוראות. ניתן להפעיל אפשרות זו כברירת מחדל ביעדי x32 של 86 סיביות על ידי
הגדרת GCC עם ה --enable-cld אפשרות להגדיר. דור של "cld"
ניתן לדכא הוראות באמצעות ה -mno-cld אפשרות מהדר במקרה זה.

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

-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
השתמש תמיד בשיחת ספרייה.

-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" אינה אפשרית ב-
רגע עבור -מפנטרי ו -עמוד.

-m8bit-idiv
-mno-8bit-idiv
במעבדים מסוימים, כמו Intel Atom, חלוקת מספרים שלמים ללא סימנים של 8 סיביות היא הרבה יותר מהירה
חלוקת מספרים שלמים של 32 סיביות/64 סיביות. אפשרות זו יוצרת בדיקת זמן ריצה. אם שניהם
דיבידנד ומחלק נמצאים בטווח של 0 עד 255, חלוקת מספר שלם ללא סימן של 8 סיביות היא
בשימוש במקום חלוקת מספרים שלמים של 32 סיביות/64 סיביות.

-mavx256-split-unaligned-load
-mavx256-split-unaligned-store
פיצול 32-בייט AVX לא מיושר עומס ואחסון.

אלה -m מתגים נתמכים בנוסף לאמור לעיל במעבדי x86-64 ב-64 סיביות
סביבות.

-מ 32
-מ 64
-mx32
צור קוד עבור סביבת 32 סיביות או 64 סיביות. ה -מ 32 הגדרות אפשרויות "int", "long",
ומצביע מקליד ל-32 סיביות, ומייצר קוד שרץ על כל מערכת i386.

השמיים -מ 64 אפשרות מגדירה "int" ל-32 סיביות ו-"long" וסוגי מצביע ל-64 סיביות, ו
יוצר קוד עבור ארכיטקטורת x86-64. עבור דרווין רק את -מ 64 אפשרות גם
מכבה את -fno-pic ו -מדינמית-ללא-תמונה אפשרויות.

השמיים -mx32 אפשרות מגדירה "int", "long" וסוגי מצביע ל-32 סיביות, ומפיקה קוד
עבור ארכיטקטורת x86-64.

-mno-red-zone
אל תשתמש במה שנקרא "אזור אדום" עבור קוד x86-64. האזור האדום מוטל על ידי
x86-64 ABI; זהו אזור של 128 בתים מעבר למיקום של מצביע המחסנית שאינו
שונה על ידי מטפלי אותות או פסיקות ולכן ניתן להשתמש בו עבור נתונים זמניים
מבלי לכוונן את מצביע הערימה. הדגל -mno-red-zone משבית את האזור האדום הזה.

-mcmodel=small
צור קוד עבור מודל הקוד הקטן: יש לקשר את התוכנית והסמלים שלה
ה-2 GB התחתונים של מרחב הכתובות. מצביעים הם 64 סיביות. תוכניות יכולות להיות
מקושר סטטי או דינמי. זהו מודל הקוד המוגדר כברירת מחדל.

-mcmodel=kernel
צור קוד עבור מודל קוד הליבה. הקרנל פועל ב-2 GB השלילי של ה-
מרחב כתובת. יש להשתמש במודל זה עבור קוד ליבת לינוקס.

-mcmodel = בינוני
צור קוד עבור הדגם הבינוני: התוכנית מקושרת ב-2 GB התחתונים של
מרחב כתובת. גם סמלים קטנים ממוקמים שם. סמלים בגדלים גדולים מ
-הגדלת-נתונים-סף מוכנסים לקטעי נתונים גדולים או BSS וניתן לאתר אותם
מעל 2GB. תוכניות יכולות להיות מקושרות באופן סטטי או דינמי.

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

-מדdress-mode=ארוך
צור קוד למצב כתובת ארוכה. זה נתמך רק עבור 64 סיביות ו-x32
סביבות. זהו מצב הכתובת המוגדר כברירת מחדל עבור סביבות 64 סיביות.

-maddress-mode=קצר
צור קוד למצב כתובת קצרה. זה נתמך רק עבור 32 סיביות ו-x32
סביבות. זהו מצב הכתובת המוגדר כברירת מחדל עבור סביבות 32 סיביות ו-x32.

i386 ו x86-64 Windows אפשרויות

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

ראה גם תחת i386 ו x86-64 אפשרויות עבור אפשרויות סטנדרטיות.

IA-64 אפשרויות

אלה -m אפשרויות שהוגדרו עבור ארכיטקטורת Intel IA-64.

-mbig-endian
צור קוד עבור יעד גדול. זוהי ברירת המחדל עבור HP-UX.

-מעט-אנדיאן
צור קוד עבור יעד קטן. זוהי ברירת המחדל עבור AIX5 ו-GNU/Linux.

-mgnu-as
-mno-gnu-as
צור (או אל תעשה) קוד עבור ה-GNU assembler. זוהי ברירת המחדל.

-מגנו-לד
-mno-gnu-ld
צור (או לא) קוד עבור מקשר GNU. זוהי ברירת המחדל.

-מנו-תמונה
צור קוד שאינו משתמש באוגר מצביע גלובלי. התוצאה היא לא מיקום
קוד עצמאי, ומפר את IA-64 ABI.

-mvolatile-asm-stop
-MNO-VOLATILE-ASM-STOP
צור (או אל תעשה) סטופ ביט מיד לפני ואחרי הצהרות asm נדיפות.

-mregister-names
-מנו-רישום-שמות
ליצור (או לא) in, loc, ו הַחוּצָה רישום שמות עבור האוגרים המוערמים. זֶה
עשוי להפוך את פלט ה-assembler לקריאה יותר.

-mno-sdata
-msdata
השבת (או הפעל) אופטימיזציות המשתמשות בקטע הנתונים הקטנים. זה עשוי להיות שימושי
לעקוף באגים למיטוב.

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

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

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

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

-mno-inline-float-divide
אל תיצור קוד מוטבע עבור חלוקות של ערכי נקודה צפה.

-minline-int-divide-min-latency
צור קוד עבור חלוקות מוטבעות של ערכי מספר שלמים תוך שימוש בהשהייה המינימלית
אלגוריתם.

-minline-int-divide-max-throughput
צור קוד עבור חלוקות מוטבעות של ערכי מספרים שלמים באמצעות התפוקה המקסימלית
אלגוריתם.

-mno-inline-int-divide
אל תיצור קוד מוטבע עבור חלוקות של ערכים שלמים.

-minline-sqrt-min-latency
צור קוד עבור שורשים מרובעים מוטבעים באמצעות אלגוריתם השהייה המינימלית.

-minline-sqrt-max-throughput
צור קוד עבור שורשים מרובעים מוטבעים באמצעות אלגוריתם התפוקה המקסימלית.

-mno-inline-sqrt
אל תיצור קוד מוטבע עבור "sqrt".

-מfused-madd
-mno-fused-madd
האם (אל תיצור) קוד שמשתמש בכפל/הוספה או הכפל/החסר
הוראות. ברירת המחדל היא להשתמש בהוראות אלה.

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

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

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

-MCOP32.
מאפשר הוראות של מעבד 32 סיביות.

-MCOP64.
מאפשר הוראות של מעבד 64 סיביות.

-mivc2
מאפשר תזמון IVC2. IVC2 הוא מעבד שותף VLIW של 64 סיביות.

-mdc
גורם להצבת משתנים קבועים בסעיף ".near".

-מדיב
מאפשר את ההוראות "div" ו-"divu".

-מב
צור קוד גדול.

-מל
צור קוד קטן-אנדיאן.

-מיו נדיף
אומר למהדר שכל משתנה המסומן בתכונת "io" אמור להיות
נחשב נדיף.

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

-מלאדז
מאפשר את הוראת "leadz" (אפס מוביל).

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

-ממינמקס
מאפשר את ההוראות "מינימום" ו"מקסימום".

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

-mno-opts
משבית את כל ההוראות האופציונליות המופעלות על ידי "-mall-opts".

-חוזר על עצמו
מאפשר את ההוראות "חזרה" ו"חזרה", המשמשות ללולאה נמוכה.

-גברת גורם לכל המשתנים להיכנס כברירת מחדל לקטע ". זעיר". שימו לב שיש א
מגבלה של 65536 בתים לסעיף זה. גישה למשתנים אלה משתמשת בבסיס %gp
להירשם.

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

-msdram
קשר את זמן הריצה מבוסס SDRAM במקום את ברירת המחדל של זמן הריצה מבוסס ה-ROM.

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

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

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

-mtiny=n
משתנים שהם n בתים או פחות מוקצים לקטע ". זעיר". אלה
משתנים משתמשים באוגר הבסיס של $gp. ברירת המחדל עבור אפשרות זו היא 4, אך שים לב לכך
יש מגבלה של 65536 בתים לקטע ". זעיר".

MicroBlaze אפשרויות

-msoft-float
השתמש באמולציית תוכנה עבור נקודה צפה (ברירת מחדל).

-mhard-float
השתמש בהוראות נקודה צפה בחומרה.

-מממפי
אל תבצע אופטימיזציה של מהלכי בלוק, השתמש ב-"memcpy".

-mno-clearbss
אפשרות זו הוצאה משימוש. להשתמש -fno-zero-initialized-in-bss במקום.

-mcpu=סוג מעבד
השתמש בתכונות של, ובקוד תזמון עבור, המעבד הנתון. הערכים הנתמכים נמצאים ב-
פוּרמָט vX.YY.Z, שם X היא גרסה מרכזית, YY היא הגרסה המשנית, ו Z 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, mips64 ו MIPS64R2. שמות המעבדים הם: 4kc, 4km, 4kp, 4שק,
4kec, 4 ק"מ, 4 קפ, 4ksd, 5kc, 5 קילוגרם, 20kc, 24kc, 24KF2_1, 24KF1_1, 24kec, 24kef2_1,
24kef1_1, 34kc, 34KF2_1, 34KF1_1, 34kn, 74kc, 74KF2_1, 74KF1_1, 74KF3_2, 1004kc,
1004KF2_1, 1004KF1_1, loongson2e, longson2f, longson3a, M4K, אוקטאון, אוקטאון+,
אוקטאון2, אוריון, 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, שם Foo הוא הערך המהוון של _MIPS_ARCH. לדוגמה,
-March=r2000 סטים _MIPS_ARCH ל "r2000" ומגדיר את המאקרו _MIPS_ARCH_R2000.

שים לב כי _MIPS_ARCH מאקרו משתמש בשמות המעבדים שצוינו למעלה. במילים אחרות,
יש לו את הקידומת המלאה ואינו מקצר 000 as k. במקרה של מ-abi, ה
מאקרו נותן שם לארכיטקטורה שנפתרה (או "mips1" or "mips3"). זה קורא ל
ארכיטקטורת ברירת מחדל כאשר לא -מרץ ניתנת אפשרות.

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

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

-mtune מגדיר את פקודות המאקרו _MIPS_TUNE ו _MIPS_TUNE_Foo, אשר פועלים באותו אופן כמו
מה היא -מרץ אלה שתוארו לעיל.

-מיפס1
שווה ערך ל -march=mips1.

-מיפס2
שווה ערך ל -march=mips2.

-מיפס3
שווה ערך ל -march=mips3.

-מיפס4
שווה ערך ל -march=mips4.

-מיפס32
שווה ערך ל -march=mips32.

-mips32r2
שווה ערך ל -march=mips32r2.

-מיפס64
שווה ערך ל -march=mips64.

-mips64r2
שווה ערך ל -march=mips64r2.

-מיפס16
-mno-mips16
צור (אל תיצור) קוד MIPS16. אם GCC מכוון ל-MIPS32 או MIPS64
ארכיטקטורה, הוא עושה שימוש ב-MIPS16e ASE.

ניתן לשלוט בהפקת קוד MIPS16 גם על בסיס פונקציה באמצעות
תכונות "mips16" ו-"nomips16".

-mflip-mips16
צור קוד MIPS16 על פונקציות מתחלפות. אפשרות זו ניתנת עבור רגרסיה
בדיקה של יצירת קוד מעורב MIPS16/לא MIPS16, ואינה מיועדת לרגיל
להשתמש בהידור קוד משתמש.

-minterlink-mips16
-mno-interlink-mips16
דרוש (לא דורש) שקוד שאינו MIPS16 יהיה תואם קישור לקוד MIPS16.

לדוגמה, קוד שאינו MIPS16 אינו יכול לקפוץ ישירות לקוד MIPS16; זה חייב להשתמש ב-a
שיחה או קפיצה עקיפה. -minterlink-mips16 לכן משבית קפיצות ישירות אלא אם כן
GCC יודע שיעד הקפיצה אינו MIPS16.

-מאבי=32
-mabi=o64
-mabi=n32
-מאבי=64
-mabi=eabi
צור קוד עבור ה-ABI הנתון.

שימו לב של-EABI יש גרסה של 32 סיביות ו-64 סיביות. GCC יוצר בדרך כלל 64 סיביות
קוד כאשר אתה בוחר ארכיטקטורת 64 סיביות, אבל אתה יכול להשתמש -mgp32 כדי לקבל קוד 32 סיביות
במקום.

למידע על O64 ABI, ראהhttp://gcc.gnu.org/projects/mipso64-abi.html>.

GCC תומך בגרסה של o32 ABI שבה אוגרי נקודה צפה הם 64 במקום זאת
רוחב של יותר מ-32 ביטים. אתה יכול לבחור את השילוב הזה עם -מאבי=32 -mfp64. ה-ABI הזה
מסתמך על ההוראות "mthc1" ו-"mfhc1" ולכן הוא נתמך רק עבור
מעבדי MIPS32R2.

הקצאות האוגר עבור ארגומנטים וערכי החזר נשארות זהות, אבל כל אחת מהן
ערך סקלרי מועבר באוגר בודד של 64 סיביות ולא בזוג של 32 סיביות
רושמת. לדוגמה, ערכי נקודה צפה סקלרית מוחזרים פנימה $f0 רק, לא א
$f0/$f1 זוג. סט האוגרים שנשמרו בשיחות נשאר זהה, אבל כל 64 הסיביות
נשמרים.

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

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

תעשיות -מאביקלים הקוד היה באופן מסורתי בלתי תלוי במיקום, ללא קשר לאפשרויות
כמו -fPIC ו -fpic. עם זאת, כהרחבה, שרשרת הכלים של GNU מאפשרת קובצי הפעלה
להשתמש בגישה מוחלטת עבור סמלים מחייבים מקומית. זה יכול גם להשתמש ב-GP קצר יותר
רצפי אתחול ויצירת קריאות ישירות לפונקציות המוגדרות מקומית. זֶה
מצב נבחר על ידי -mno-משותף.

-mno-משותף תלוי ב-binutils 2.16 ומעלה ומייצר אובייקטים שיכולים להיות רק
מקושר על ידי מקשר GNU. עם זאת, האופציה אינה משפיעה על ה-ABI של הגמר
בר הפעלה; זה משפיע רק על ABI של אובייקטים הניתנים להזזה. באמצעות -mno-משותף
בדרך כלל הופך את קובצי ההפעלה לקטנים יותר ומהירים יותר.

-mshared הוא ברירת המחדל.

-mplt
-mno-plt
נניח (אל תניח) שהמקשרים הסטטיים והדינמיים תומכים ב-PLTs והעתקה
רילוקיישן. אפשרות זו משפיעה רק -mno-משותף -מאביקלים. עבור ה-n64 ABI, זה
לאופציה אין השפעה בלעדיו -msym32.

אתה יכול להרוויח -mplt ברירת המחדל על ידי הגדרת GCC עם --with-mips-plt. ברירת המחדל
is -mno-plt אחרת.

-mxgot
-mno-xgot
הרם (אל תרים) את ההגבלות הרגילות על גודל טבלת הקיזוז העולמית.

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

רילוקיישן קטוע כדי להתאים: R_MIPS_GOT16 foobar

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

שים לב שחלק מהמקשרים יכולים ליצור GOT מרובים. אם יש לך מקשר כזה, אתה
צריך רק להשתמש -mxgot כאשר קובץ אובייקט בודד ניגש ליותר מ-64k
בשווי כניסות GOT. מעט מאוד עושים זאת.

לאפשרויות אלו אין השפעה אלא אם כן GCC מייצר קוד בלתי תלוי במיקום.

-mgp32
נניח שהרגיסטרים לשימוש כללי הם ברוחב של 32 סיביות.

-mgp64
נניח שהרגיסטרים לשימוש כללי הם ברוחב של 64 סיביות.

-mfp32
נניח שרוחב אוגרי נקודה צפה הם 32 סיביות.

-mfp64
נניח שרוחב אוגרי נקודה צפה הם 64 סיביות.

-mhard-float
השתמש בהוראות מעבד שותף בנקודה צפה.

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

-mno-float
שווה ערך ל -msoft-float, אך בנוסף טוענת שהתוכנית הולכת
אינו מבצע שום פעולות נקודה צפה. אפשרות זו נתמכת כעת
רק על ידי כמה תצורות MIPS ממתכת חשופה, שבהן הוא עשוי לבחור סט מיוחד של
ספריות חסרות כל תמיכה בנקודה צפה (כולל, למשל, ה-floating-
פורמטים של נקודה "printf"). אם קוד הידור עם "-mno-float" מכיל בטעות
פעולות של נקודה צפה, היא צפויה לסבול מכשל בזמן קישור או ריצה.

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

-mdouble-float
נניח שהמעבד המשנה בנקודה צפה תומך בפעולות דיוק כפול. זֶה
הוא ברירת המחדל.

-mllsc
-mno-llsc
השתמש (לא להשתמש) ll, sc, ו לסנכרן הוראות ליישום זיכרון אטומי מובנה
פונקציות. כאשר אף אחת מהאפשרויות לא צוינה, GCC משתמש בהוראות אם היעד
האדריכלות תומכת בהם.

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

-mdsp
-mno-dsp
השתמש (אל תשתמש) בגרסה 1 של MIPS DSP ASE.
אפשרות זו מגדירה את המאקרו הקדם-מעבד __mips_dsp. זה גם מגדיר
__mips_dsp_rev אל 1.

-mdspr2
-mno-dspr2
השתמש (אל תשתמש) בגרסה 2 של MIPS DSP ASE.
אפשרות זו מגדירה את פקודות המאקרו הקדם-מעבד __mips_dsp ו __mips_dspr2. גם זה
מגדיר __mips_dsp_rev אל 2.

-msmartmips
-mno-smartmips
השתמש (אל תשתמש) ב-MIPS SmartMIPS ASE.

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

-mdmx
-mno-mdmx
השתמש (אל תשתמש) בהוראות MIPS Digital Media Extension. אפשרות זו יכולה להיות רק
משמש בעת יצירת קוד 64 סיביות ודורש תמיכת חומרה בנקודה צפה
מאופשר.

-mips3d
-mno-mips3d
השתמש (אל תשתמש) ב-MIPS-3D ASE. האפשרות -mips3d מרמז -לקוי-רווק.

-ממץ
-מנו-מט
השתמש (אל תשתמש) בהוראות MT Multithreading.

-ממקו
-mno-mcu
השתמש (אל תשתמש) בהוראות MIPS MCU ASE.

-מלונג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()" עבור מהלכי בלוק לא טריוויאליים. ברירת המחדל
is -mno-memcpy, המאפשר ל-GCC להטמיע את רוב העותקים בגודל קבוע.

-מלונג-שיחות
-שיחות ארוכות
השבת (אל תבטל) את השימוש בהוראה "jal". קריאה לפונקציות באמצעות "jal"
הוא יעיל יותר אך מחייב את המתקשר והמתקשר להיות באותו 256 מגה בייט
מגזר.

לאפשרות זו אין השפעה על קוד abicalls. ברירת המחדל היא -שיחות ארוכות.

-מאד
-מנון-משוגע
אפשר (השבת) שימוש בהוראות "mad", "madu" ו-"mul", כפי שסופקו על ידי
R4650 ISA.

-מ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-vr4120
-mno-fix-vr4120
עקיפת שגיאות מסוימות של VR4120:

- "dmultu" לא תמיד מניב את התוצאה הנכונה.

- "div" ו-"ddiv" לא תמיד מייצרים את התוצאה הנכונה אם אחד מהאופרנדים
הוא שלילי.

הדרכים לעקיפת הבעיה של שגיאות החלוקה מסתמכות על פונקציות מיוחדות ב libgcc.a. ליד
בהווה, פונקציות אלו מסופקות רק על ידי תצורות "mips64vr*-elf".

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

-mfix-vr4130
עקף את VR4130 "mflo"/"mfhi" errata. הדרכים לעקיפת הבעיה מיושמות על ידי
assembler ולא על ידי GCC, אם כי GCC נמנע משימוש ב-"mflo" ו-"mfhi" אם
הוראות VR4130 "macc", "macchi", "dmacc" ו-"dmacchi" זמינות במקום זאת.

-mfix-sb1
-mno-fix-sb1
עקיפת שגיאות הליבה של מעבד SB-1 מסוימות. (דגל זה פועל כעת סביב ה-SB-1
גרסה 2 "F1" ו-"F2" שגיאות בנקודה צפה.)

-mr10k-cache-barrier=הצבה
ציין אם GCC צריך להכניס מחסומי מטמון כדי למנוע את תופעות הלוואי של
ספקולציות לגבי מעבדי R10K.

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

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

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

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

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

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

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

אם תוכנית הקלט מכילה הצהרת פונקציה כגון:

void foo (ריק);

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

לאפשרות שלוש צורות:

-mr10k-cache-barrier=load-store
הכנס מחסום מטמון לפני טעינה או חנות שעלולים להתבצע באופן ספקולטיבי
ולכך עשויות להיות תופעות לוואי גם אם יופלו.

-mr10k-cache-barrier=חנות
הכנס מחסום מטמון לפני חנות שאולי תבוצע באופן ספקולטיבי ו
שיכולות להיות להן תופעות לוואי גם אם יופלו.

-mr10k-cache-barrier=none
השבת את הכנסת מחסומי המטמון. זוהי הגדרת ברירת המחדל.

-mflush-func=func
-mno-flush-func
מציין את הפונקציה להתקשר כדי לשטוף את המטמון I ו-D, או לא לקרוא לאף אחד כזה
פוּנקצִיָה. אם נקראת, הפונקציה חייבת לקבל את אותם ארגומנטים כמו ה-common
"_flush_func()", כלומר, הכתובת של טווח הזיכרון שעבורו נמצא המטמון
flushed, גודל טווח הזיכרון והמספר 3 (כדי לשטוף את שני המטמונים). ה
ברירת המחדל תלויה ביעד ש-GCC הוגדר עבורו, אך בדרך כלל הוא גם כן
_flush_func or __cpu_flush.

mbranch-cost=NUM
הגדר את עלות הסניפים לערך NUM הוראות "פשוטות". עלות זו היא רק א
היוריסטית ואינה מובטחת להפיק תוצאות עקביות בכל מהדורות. אפס
עלות בוחרת באופן מיותר את ברירת המחדל, המבוססת על -mtune הגדרה.

-סביר ענף
-מונו-ענף-סביר
אפשר או השבת את השימוש בהוראות Branch Likely, ללא קשר לברירת המחדל עבור
ארכיטקטורה נבחרה. כברירת מחדל, ניתן להפיק הוראות Branch Likely אם
הם נתמכים על ידי הארכיטקטורה שנבחרה. חריג הוא עבור MIPS32 ו
ארכיטקטורות ומעבדים MIPS64 המיישמים את הארכיטקטורות הללו; לאלה,
הוראות סניף סבירות אינן נוצרות כברירת מחדל מכיוון שה-MIPS32 ו
ארכיטקטורות MIPS64 פוסלות באופן ספציפי את השימוש בהן.

-mfp-חריגים
-mno-fp-חריגים
מציין אם חריגות FP מופעלות. זה משפיע על איך הוראות FP
מתוכנן למעבדים מסוימים. ברירת המחדל היא שחריגות FP מופעלות.

לדוגמה, ב-SB-1, אם חריגות FP מושבתות, ואנו פולטים 64 סיביות
קוד, אז נוכל להשתמש בשני צינורות ה-FP. אחרת, נוכל להשתמש רק בצינור FP אחד.

-mvr4130-align
-mno-vr4130-align
צינור ה-VR4130 הוא דו-כיווני על-סקלארי, אך יכול להוציא שתי הוראות בלבד
יחד אם הראשון מיושר ל-8 בתים. כאשר אפשרות זו מופעלת, GCC מתיישר
זוגות הוראות שלדעתה צריכות לבצע במקביל.

אפשרות זו משפיעה רק בעת אופטימיזציה עבור ה-VR4130. זה בדרך כלל עושה קוד
מהר יותר, אבל על חשבון הפיכתו לגדול יותר. זה מופעל כברירת מחדל ב
רמת אופטימיזציה -O3.

-msynci
-mno-synci
אפשר (השבת) יצירת הוראות "סינקי" בארכיטקטורות התומכות בכך.
הוראות ה-"synci" (אם מופעלות) נוצרות כאשר "__builtin___clear_cache()"
מורכב.

ברירת המחדל של אפשרות זו היא "-mno-synci", אך ניתן לעקוף את ברירת המחדל על ידי הגדרה
עם "--with-synci".

בעת הידור קוד עבור מערכות מעבד בודד, זה בדרך כלל בטוח להשתמש ב-"synci".
עם זאת, במערכות מרובות ליבות (SMP) רבות, זה לא מבטל את ההוראה
מטמון בכל הליבות ועלול להוביל להתנהגות לא מוגדרת.

-mrelax-pic-calls
-mno-relax-pic-calls
נסה להפוך שיחות PIC הנשלחות בדרך כלל באמצעות 25$ לרשום לשיחות ישירות.
זה אפשרי רק אם המקשר יכול לפתור את היעד בזמן הקישור ואם
היעד נמצא בטווח לשיחה ישירה.

-mrelax-pic-calls הוא ברירת המחדל אם GCC הוגדר להשתמש ב-assembler ו-a
קישור התומכים בהוראת הרכבה ".reloc" ו-"-mexplicit-relocs" נמצא ב
השפעה. עם "-mno-explicit-relocs", אופטימיזציה זו יכולה להתבצע על ידי
assembler והמקשר לבד ללא עזרה מהמהדר.

-mmcount-ra-address
-mno-mcount-ra-address
שלח (אל תפליט) קוד המאפשר ל-"_mcount" לשנות את החזרת הפונקציה הקוראת
כתובת. כאשר מופעלת, אפשרות זו מרחיבה את הממשק הרגיל "_mcount" עם ממשק חדש
כתובת ra פרמטר, בעל הסוג "intptr_t *" ומועבר ברישום $12.
לאחר מכן, "_mcount" יכול לשנות את כתובת ההחזרה על ידי ביצוע שתי הפעולות הבאות:

· החזרת הכתובת החדשה בפנקס 31$.

· אחסון הכתובת החדשה ב"*כתובת ra", אם כתובת ra אינו בטל.

ברירת המחדל היא -mno-mcount-ra-address.

MMIX אפשרויות

אפשרויות אלה מוגדרות עבור ה-MMIX:

-mlibfuncs
-mno-libfuncs
ציין שפונקציות ספרייה מהותית עוברות קומפילציה, תוך העברת כל הערכים פנימה
רושמים, לא משנה הגודל.

-מפסילון
-מנו-אפסילון
צור הוראות השוואה של נקודה צפה שמשוות ביחס ל-"rE"
רישום אפסילון.

-mabi=mmixware
-מאבי=גנו
צור קוד שמעביר פרמטרים של פונקציה ומחזיר ערכים ש(ב-call
function) נתפסים כריסטרים של $0 ומעלה, בניגוד ל-GNU ABI שמשתמש גלובלי
רושם $231 ומעלה.

-mzero-extend
-mno-zero-extend
בעת קריאת נתונים מהזיכרון בגדלים קצרים מ-64 סיביות, השתמש (אל תשתמש) אפס-
הרחבת הוראות הטעינה כברירת מחדל, במקום הרחבת סימנים.

-mknuthdiv
-מנו-קנוטדייב
הפוך את התוצאה של חלוקה שמניבה שארית להיות בעל סימן זהה למחלק.
עם ברירת המחדל, -מנו-קנוטדייב, סימן השארית עוקב אחר סימן ה
דיבידנד. שתי השיטות תקפות מבחינה אריתמטית, כאשר האחרונה היא כמעט בלעדית
מְשׁוּמָשׁ.

-mtoplevel-סמלים
-mno-toplevel-סמלים
להקדים (לא להקדים) א : לכל הסמלים הגלובאליים, כך שניתן להשתמש בקוד ההרכבה
עם הוראת ההרכבה "PREFIX".

-מלף
צור קובץ הפעלה בפורמט ELF, במקום ברירת המחדל mmo פורמט בשימוש על ידי
מה היא ממיקס מַדמֶה.

-ענף-ניבוי
-מנו-ענף-ניבוי
השתמש (אל תשתמש) בהוראות הסניף הסביר, כאשר חיזוי ענף סטטי
מציין ענף סביר.

-כתובות-base
-כתובות-mno-base
צור (אל תיצור) קוד שמשתמש בסיס כתובות. שימוש בכתובת בסיס
מייצר אוטומטית בקשה (מטופלת על ידי האסמבלר והמקשר) עבור א
קבוע שיוקם במרשם עולמי. האוגר משמש לבסיס אחד או יותר
בקשות כתובת בטווח של 0 עד 255 מהערך המוחזק במאגר. ה
בדרך כלל מוביל לקוד קצר ומהיר, אבל מספר פריטי נתונים שונים זה
ניתן לטפל מוגבל. זה אומר שתוכנית שמשתמשת בהרבה נתונים סטטיים
עשוי לדרוש -כתובות-mno-base.

-יציאה-יחידה
-mno-יציאה-יחידה
כפה (אל תכריח) קוד שנוצר שתהיה לו נקודת יציאה אחת בכל פונקציה.

MN10300 אפשרויות

אלה -m אפשרויות מוגדרות עבור ארכיטקטורות Matsushita MN10300:

-מולט-באג
צור קוד כדי למנוע באגים בהוראות הכפל עבור מעבדי MN10300.
זוהי ברירת המחדל.

-mno-mult-bug
אל תיצור קוד כדי למנוע באגים בהוראות הכפל של ה-MN10300
מעבדים.

-אמא33
צור קוד באמצעות תכונות ספציפיות למעבד AM33.

-mno-am33
אל תיצור קוד באמצעות תכונות ספציפיות למעבד AM33. זה
ברירת המחדל.

-מאמ33-2
צור קוד באמצעות תכונות ספציפיות למעבד AM33/2.0.

-אמא34
צור קוד באמצעות תכונות ספציפיות למעבד AM34.

-mtune=סוג מעבד
השתמש במאפייני התזמון של סוג המעבד המצוין בעת ​​תזמון הוראות.
זה לא משנה את סוג המעבד הממוקד. סוג המעבד חייב להיות אחד
mn10300, am33, בבוקר 33-2 or am34.

-mreturn-pointer-on-d0
בעת יצירת פונקציה שמחזירה מצביע, החזר את המצביע גם ב-"a0" וגם
"d0". אחרת, המצביע מוחזר רק ב-"a0", ומנסה לקרוא לזה
פונקציות ללא אב טיפוס גורמות לשגיאות. שימו לב שהאפשרות הזו פועלת עד
בְּרִירַת מֶחדָל; להשתמש -mno-return-pointer-on-d0 כדי להשבית אותו.

-mno-crt0
אין לקשר בקובץ אובייקט האתחול בזמן ריצה C.

-להירגע
ציין למקשר שעליו לבצע מעבר אופטימיזציה של הרפיה אליו
לקצר סניפים, שיחות וכתובות זיכרון מוחלטות. אפשרות זו משפיעה רק
כאשר נעשה שימוש בשורת הפקודה עבור שלב הקישור האחרון.

אפשרות זו הופכת איתור באגים סמלי לבלתי אפשרי.

-mliw
אפשר למהדר ליצור ארוך הוראה Word הוראות אם המטרה היא
AM33 או מאוחר יותר. זוהי ברירת המחדל. אפשרות זו מגדירה את המאקרו הקדם-מעבד
__LIW__.

-מנוליב
אל תאפשר למהדר ליצור ארוך הוראה Word הוראות. אפשרות זו
מגדיר את המאקרו הקדם-מעבד __NO_LIW__.

-מסתלב
אפשר למהדר ליצור את ה SETLB ו Lcc הוראות אם המטרה היא
AM33 או מאוחר יותר. זוהי ברירת המחדל. אפשרות זו מגדירה את המאקרו הקדם-מעבד
__SETLB__.

-mnosetlb
אל תאפשר למהדר ליצור SETLB or Lcc הוראות. אפשרות זו מגדירה
המאקרו הקדם-מעבד __NO_SETLB__.

מוקסי אפשרויות

-מב
צור קוד גדול. זוהי ברירת המחדל עבור מוקסי-*-* תצורות.

-מל
צור קוד קטן-אנדיאן.

-mno-crt0
אין לקשר בקובץ אובייקט האתחול בזמן ריצה C.

PDP-11 אפשרויות

אפשרויות אלה מוגדרות עבור PDP-11:

-mfpu
השתמש בחומרה FPP נקודה צפה. זוהי ברירת המחדל. (נקודה צפה FIS על
PDP-11/40 אינו נתמך.)

-msoft-float
אל תשתמש בנקודה צפה חומרה.

-mac0
החזר תוצאות נקודה צפה ב-ac0 (fr0 בתחביר אסמבלר יוניקס).

-mno-ac0
החזר תוצאות נקודה צפה בזיכרון. זוהי ברירת המחדל.

-מ 40
צור קוד עבור PDP-11/40.

-מ 45
צור קוד עבור PDP-11/45. זוהי ברירת המחדל.

-מ 10
צור קוד עבור PDP-11/10.

-mbcopy-builtin
השתמש בתבניות "movmemhi" מוטבעות להעתקת זיכרון. זוהי ברירת המחדל.

-mbcopy
אל תשתמש בתבניות "movmemhi" מוטבעות להעתקת זיכרון.

-מנטה16
-mno-int32
השתמש ב-16 סיביות "int". זוהי ברירת המחדל.

-מנטה32
-mno-int16
השתמש ב-32 סיביות "int".

-mfloat64
-mno-float32
השתמש ב-"float" של 64 סיביות. זוהי ברירת המחדל.

-mfloat32
-mno-float64
השתמש ב-"float" של 32 סיביות.

-מבשי
השתמש בתבנית "abshi2". זוהי ברירת המחדל.

-מנו-אבשי
אל תשתמש בתבנית "abshi2".

-ענף-יקר
העמידו פנים שהסניפים יקרים. זה בשביל להתנסות ביצירת קוד
בלבד.

-ענף-זול
אל תעמיד פנים שהסניפים יקרים. זוהי ברירת המחדל.

-munix-asm
השתמש בתחביר ה-Unix assembler. זוהי ברירת המחדל כאשר היא מוגדרת עבור pdp11-*-bsd.

-mdec-asm
השתמש בתחביר DEC assembler. זוהי ברירת המחדל כאשר היא מוגדרת עבור כל יעד PDP-11
אחר מאשר pdp11-*-bsd.

picoChip אפשרויות

אלה -m אפשרויות מוגדרות עבור יישומי picoChip:

-מיי=ae_type
הגדר את ערכת ההוראות, ערכת הרישום ותזמון ההוראות עבור מערך
סוג אלמנט ae_type. ערכים נתמכים עבור ae_type יש לו כל, MUL, ו מק.

-mae=כל בוחר סוג AE גנרי לחלוטין. קוד שנוצר עם אפשרות זו פועל
על כל אחד מסוגי AE אחרים. הקוד אינו יעיל כפי שהוא היה אם היה מורכב
עבור סוג AE ספציפי, וסוגי פעולה מסוימים (למשל, כפל) אינם פועלים
כראוי על כל סוגי AE.

-mae=MUL בוחר סוג MUL AE. זהו סוג ה-AE השימושי ביותר עבור קוד הידור,
והוא ברירת המחדל.

-mae=MAC בוחר MAC AE בסגנון DSP. קוד שנערך עם אפשרות זו עלול לסבול
ביצועים גרועים של מניפולציה של בתים (char), מכיוון שה-DSP AE אינו מספק
תמיכת חומרה לעומס בתים/חנויות.

-msymbol-as-address
אפשר למהדר להשתמש ישירות בשם סמל ככתובת בטעינה/חנות
הוראה, מבלי לטעון אותה תחילה לפנקס. בדרך כלל, השימוש בזה
option מייצר תוכניות גדולות יותר, אשר פועלות מהר יותר מאשר כאשר האפשרות אינה בשימוש.
עם זאת, התוצאות משתנות מתוכנית לתוכנית, ולכן היא נשארת כאפשרות משתמש,
במקום להיות מופעל לצמיתות.

-אזהרות-לא-יעילות
משבית אזהרות לגבי יצירת קוד לא יעיל. אזהרות אלה יכולות להיות
נוצר, למשל, בעת הידור קוד שמבצע פעולות זיכרון ברמת בתים
על סוג MAC AE. ל-MAC AE אין תמיכה בחומרה עבור זיכרון ברמת בתים
פעולות, כך שכל הטעינה/מאגרי הבתים חייבים להיות מסונתזים מ-load/store של מילים
פעולות. זה לא יעיל ומופקת אזהרה כדי לציין שאתה
צריך לשכתב את הקוד כדי להימנע מפעולות בייט, או כדי למקד לסוג AE שיש לו את
תמיכת חומרה הכרחית. אפשרות זו משביתה את האזהרות הללו.

PowerPC אפשרויות

אלה מפורטים למטה

RL78 אפשרויות

-מסים
קישורים בספריות יעד נוספות לתמיכה בהפעלה בתוך סימולטור.

-ממול=אין
-mmul=g13
-mmul=rl78
מציין את סוג התמיכה בכפל החומרה שיש להשתמש בה. ברירת המחדל היא
"ללא", המשתמש בפונקציות כפל תוכנה. האפשרות "g13" מיועדת ל-
הכפל/חלק ציוד היקפי של חומרה רק ביעדי RL78/G13. אפשרות "rl78".
מיועד לכפל החומרה הסטנדרטי המוגדר במדריך התוכנה RL78.

יבמ RS/6000 ו PowerPC אפשרויות

אלה -m אפשרויות מוגדרות עבור IBM RS/6000 ו-PowerPC:

-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 סיביות.

-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". לשים קטן
נתונים גלובליים וסטטיים מאתחלים שאינם "קונסטטים" ב- .sdata סעיף, שהוא מחודד
על ידי הרשמה "r13". שים נתונים גלובליים וסטטיים קטנים לא מאותחלים ב- .sbss
קטע, אשר צמוד ל .sdata סָעִיף. ה -msdata=eabi האפשרות היא
לא תואם את -ניתן להזזה אוֹפְּצִיָה. ה -msdata=eabi אפשרות מגדיר גם את
-חבר אוֹפְּצִיָה.

-msdata=sysv
במערכת V.4 ומערכות PowerPC משובצות, הכנס נתונים גלובליים וסטטיים קטנים ב-
.sdata סעיף, שאליו מצביע הרשום "r13". שים עולמי קטן לא מאותחל
ונתונים סטטיים ב- .sbss קטע, אשר צמוד ל .sdata סָעִיף. ה
-msdata=sysv האפשרות אינה תואמת את -ניתן להזזה אוֹפְּצִיָה.

-msdata = ברירת מחדל
-msdata
במערכת V.4 ומערכות PowerPC משובצות, אם -מאבי נעשה שימוש, קוד קומפילציה זהה
as -msdata=eabi, אחרת הידור קוד זהה ל -msdata=sysv.

-msdata=נתונים
במערכת V.4 ומערכות PowerPC משובצות, הכנס נתונים גלובליים קטנים ב- .sdata
סָעִיף. שים נתונים גלובליים קטנים לא מאותחלים ב- .sbss סָעִיף. אל תשתמש
עם זאת, רשום "r13" כדי לטפל בנתונים קטנים. זוהי התנהגות ברירת המחדל אלא אם כן
אַחֵר -msdata נעשה שימוש באפשרויות.

-msdata=אין
-mno-sdata
במערכות PowerPC משובצות, שים את כל הנתונים הגלובאליים והסטטיים המאתחלים ב- נתונים
סעיף, וכל הנתונים הלא מאותחלים ב- .bss סָעִיף.

-mblock-move-inline-limit=NUM
כל מהלכי הבלוק (כגון קריאות ל-"memcpy" או עותקי מבנה) מוטבעים פחות מ- או
שווה ל NUM בתים. הערך המינימלי עבור NUM הוא 32 בתים על יעדים של 32 סיביות ו-64
בתים על יעדים של 64 סיביות. ערך ברירת המחדל הוא יעד ספציפי.

-G NUM
במערכות PowerPC משובצות, שים פריטים גלובליים וסטטיים פחות או שווה ל NUM
בתים לתוך קטעי הנתונים הקטנים או BSS במקום לקטע הנתונים הרגיל או BSS.
כברירת מחדל, NUM הוא בן 8. ה -G NUM מתג מועבר גם למקשר. כל המודולים
צריך להיות מורכב עם אותו הדבר -G NUM ערך.

-מרגשמות
-mno-regnames
במערכת V.4 ומערכות PowerPC משובצות (לא) פולטות שמות רישום ב-
פלט שפת assembly באמצעות צורות סמליות.

-mlongcall
-mno-longcall
כברירת מחדל נניח שכל השיחות רחוקות כך שיותר ויקר יותר
נדרש רצף שיחות. זה נדרש עבור שיחות רחוקות מ-32 מגה בייט
(33,554,432 בתים) מהמיקום הנוכחי. נוצרת שיחה קצרה אם
המהדר יודע שהשיחה לא יכולה להיות כל כך רחוקה. ניתן לעקוף הגדרה זו על ידי
תכונת הפונקציה "shortcall", או לפי "#pragma שיחה ארוכה(0) ".

חלק מהמקשרים מסוגלים לזהות שיחות מחוץ לטווח ולהפיק קוד דבק
הזבוב. במערכות אלו שיחות ארוכות מיותרות ומייצרות קוד איטי יותר. כפי ש
לפי כתיבת שורות אלה, מקשר AIX יכול לעשות זאת, וכך גם מקשר GNU עבור PowerPC/64. זה
מתוכנן להוסיף תכונה זו למקשר של GNU גם עבור מערכות PowerPC של 32 סיביות.

במערכות Darwin/PPC, "#pragma longcall" מייצר "jbsr callee, L42", פלוס סניף
אי (קוד דבק). שתי כתובות היעד מייצגות את המוקדן ואת הסניף
אִי. המקשר של Darwin/PPC מעדיף את הכתובת הראשונה ויוצר "bl callee"
אם הוראת ה-PPC "bl" מגיעה ישירות למוקדן; אחרת, המקשר
יוצר "bl L42" כדי לקרוא לאי הסניף. האי הסניף מצורף ל-
גוף הפונקציה המתקשרת; הוא מחשב את הכתובת המלאה של 32 סיביות של הנמען ו
קופץ אליו.

במערכות Mach-O (Darwin), אפשרות זו מכוונת את פליטת המהדר לדבק עבור
כל שיחה ישירה, והמקשר של דארווין מחליט אם להשתמש בה או להשליך אותה.

בעתיד, GCC עשוי להתעלם מכל מפרטי ה-longcall כאשר המקשר ידוע
ליצור דבק.

-mtls-markers
-mno-tls-markers
סמן (אל תסמן) קריאות ל-"__tls_get_addr" עם רילוקיישן המציין את הפונקציה
טַעֲנָה. ההעברה מאפשרת למקשר לשייך באופן מהימן את קריאת הפונקציה
הוראות הגדרת ארגומנטים עבור אופטימיזציה של 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.

בגרסה זו של המהדר, ה -mcompat-align-parm הוא ברירת המחדל, למעט מתי
באמצעות Linux ELFv2 ABI.

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. בעת יצירת קוד באמצעות ההוראות הזמינות ב
z/אדריכלות, ברירת המחדל היא -מרץ=z900. אחרת, ברירת המחדל היא -מרץ=g5.

-mtune=סוג מעבד
כוון ל סוג מעבד כל מה שיש לקוד שנוצר, מלבד ה-ABI
וערכת ההוראות הזמינות. רשימת סוג מעבד הערכים זהים לזה של
-מרץ. ברירת המחדל היא הערך המשמש עבור -מרץ.

-mtpf-trace
-mno-tpf-trace
צור קוד שמוסיף (לא מוסיף) בענפים ספציפיים ל-TPF OS כדי להתחקות אחר שגרות
במערכת ההפעלה. אפשרות זו כבויה כברירת מחדל, גם בעת קומפילציה עבור ה
מערכת הפעלה TPF.

-מfused-madd
-mno-fused-madd
צור קוד שמשתמש (אינו משתמש) בנקודה הצפה כפולה וצבירה
הוראות. הוראות אלה נוצרות כברירת מחדל אם חומרה נקודה צפה
משמש.

-mwarn-framesize=גודל מסגרת
שלח אזהרה אם הפונקציה הנוכחית חורגת מגודל המסגרת הנתון. כי זהו
בדיקת זמן הידור זה לא צריך להיות בעיה אמיתית כשהתוכנית פועלת. זה
נועד לזהות פונקציות שככל הנראה גורמות להצפת מחסנית. זה
שימושי לשימוש בסביבה עם גודל מחסנית מוגבל, למשל ליבת הלינוקס.

-mwarn-dynamicstack
שלח אזהרה אם הפונקציה קוראת "alloca" או משתמשת במערכים בגודל דינמי. זֶה
הוא בדרך כלל רעיון רע עם גודל ערימה מוגבל.

-mstack-guard=מחסנית
-mstack-size=גודל ערימה
אם אפשרויות אלה מסופקות, הקצה האחורי של 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.

-mcbranchdi
אפשר את דפוס ההוראות "cbranchdi4".

-מקמפקדי
פלט את דפוס ההוראות "cmpeqdi_t" גם כאשר -mcbranchdi הוא בתוקף.

-מfused-madd
-mno-fused-madd
צור קוד שמשתמש (אינו משתמש) בנקודה הצפה כפולה וצבירה
הוראות. הוראות אלה נוצרות כברירת מחדל אם חומרה נקודה צפה
משמש. התלוי במכונה -מfused-madd האפשרות ממופה כעת למכונה-
עצמאי -ffp-contract=מהיר אפשרות ו -mno-fused-madd ממופה ל
-ffp-contract=off.

-mfsca
-mno-fsca
אפשר או לא לאפשר למהדר לפלוט את הוראת "fsca" עבור סינוס וקוסינוס
קירובים. יש להשתמש באפשרות "-mfsca" בשילוב עם
"-funsafe-math-optimizations". זה מופעל כברירת מחדל בעת יצירת קוד עבור
SH4A. שימוש ב-"-mno-fsca" משבית את קירובי הסינוס והקוסינוס גם אם
"-funsafe-math-optimizations" בתוקף.

-mfsrra
-מנו-פסרה
אפשר או לא לאפשר למהדר לפלוט את הוראת "fsrra" עבור ריבוע הדדי
קירובי שורש. יש להשתמש באפשרות "-mfsrra" בשילוב עם
"-funsafe-math-optimizations" ו-"-finite-math-only". זה מופעל כברירת מחדל כאשר
יצירת קוד עבור SH4A. שימוש ב-"-mno-fsrra" משבית שורש ריבועי הדדי
קירובים גם אם "-funsafe-math-optimizations" ו-"-finite-math-only" נמצאים ב
השפעה.

-mpretend-cmove
העדיפו ענפים מותנים באפס תזוזה להוראת תנועה מותנית
דפוסים. זה יכול לגרום לקוד מהיר יותר במעבד SH4.

Solaris 2 אפשרויות

אלה -m אפשרויות נתמכות על Solaris 2:

-טקסט-מימפור
-טקסט-מימפור, בשימוש בנוסף ל -מְשׁוּתָף, אומר למהדר לא לעבור -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-user-mode.

-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 סיביות.

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 "__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.

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-64 אפשרויות

אלה מפורטים למטה

Xstormy16 אפשרויות

אפשרויות אלה מוגדרות עבור Xstormy16:

-מסים
בחר קבצי הפעלה וסקריפט קישור מתאים לסימולטור.

Xtensa אפשרויות

אפשרויות אלה נתמכות עבור יעדי Xtensa:

-mconst16
-mno-const16
אפשר או השבת את השימוש בהוראות "CONST16" לטעינת ערכים קבועים. ה
הוראת "CONST16" היא כרגע לא אופציה סטנדרטית של Tensilica. מתי
מופעלת, הוראות "CONST16" משמשות תמיד במקום הסטנדרטי "L32R"
הוראות. השימוש ב-"CONST16" מופעל כברירת מחדל רק אם ה-"L32R"
הדרכה אינה זמינה.

-מfused-madd
-mno-fused-madd
אפשר או השבת את השימוש בהוראות הכפל/הוספה והכפל/הפחתה מתמזגות ב-
אפשרות לנקודה צפה. אין לכך השפעה אם אפשרות הנקודה הצפה אינה גם כן
מופעל. השבתת הוראות הכפל/הוספה והכפל/הפחתה מתמזגות מאלצת את
מהדר להשתמש בהוראות נפרדות עבור פעולות הכפל וחיבור/חיסור.
זה עשוי להיות רצוי במקרים מסוימים שבהם תוצאות קפדניות תואמות IEEE 754
נדרש: הוראות החיבור/ההפחתה של הכפל המתוכה אינן מעגלות את התווך
תוצאה, ובכך לייצר תוצאות עם יותר פיסות דיוק ממה שצוין על ידי
תקן IEEE. השבתת הוראות הוספה/חיסור של כפל מתוכה גם מבטיחה זאת
פלט התוכנית אינו רגיש ליכולתו של המהדר לשלב כפל ו
פעולות הוספה/הורדה.

-מסריאליזה-נדיף
-mno-serialize-נדיף
כאשר אפשרות זו מופעלת, GCC מוסיף הוראות "MEMW" לפני זיכרון "נדיף".
הפניות כדי להבטיח עקביות ברצף. ברירת המחדל היא -מסריאליזה-נדיף.
השתמש -mno-serialize-נדיף להשמיט את הוראות "MEMW".

-mforce-no-pic
עבור יעדים, כמו GNU/Linux, שבהם כל קוד Xtensa במצב משתמש חייב להיות מיקום-
קוד עצמאי (PIC), אפשרות זו משביתה את ה-PIC להידור קוד ליבה.

-mtext-section-literals
-mno-text-section-literals
שליטה בטיפול בבריכות תרתי משמע. ברירת המחדל היא -mno-text-section-literals,
מה שמציב מילים בקטע נפרד בקובץ הפלט. זה מאפשר את
מאגר מילולי למקם ב-RAM/ROM נתונים, והוא גם מאפשר לקישור לשלב
מאגרים מילוליים מקובצי אובייקט נפרדים כדי להסיר מילוליות מיותרות ולשפר קוד
גודל. עם -mtext-section-literals, המילולים משובצים בקטע הטקסט
על מנת לשמור אותם קרובים ככל האפשר להפניות שלהם. זה עשוי להיות נחוץ
עבור קבצי הרכבה גדולים.

-mtarget-align
-mno-target-align
כאשר אפשרות זו מופעלת, GCC מורה להרכב ליישר אוטומטית
הוראות להפחתת עונשי ענף על חשבון צפיפות מסוימת של קוד. ה
אסמבלר מנסה להרחיב את הוראות הצפיפות כדי ליישר את מטרות הסניף וה-
הוראות בעקבות הוראות השיחה. אם אין מספיק קודמים בטוחים
הוראות צפיפות ליישור מטרה, לא מתבצעת הרחבה. ברירת המחדל היא
-mtarget-align. אפשרויות אלו אינן משפיעות על הטיפול ב-auto-aligned
הוראות כמו "LOOP", שאותן ההרכב תמיד מיישר, או על ידי הרחבה
הוראות צפיפות או על ידי הכנסת הוראות 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 להיות קצר לא חתום int במקום ה
ברירת המחדל עבור היעד. אפשרות זו שימושית לבניית תוכניות לרוץ בהן
יַיִן.

אַזהָרָה: מה היא -fshort-wchar switch גורם ל-GCC ליצור קוד שאינו בינארי
תואם לקוד שנוצר ללא המתג הזה. השתמש בו כדי להתאים לא-
ממשק בינארי של יישום ברירת המחדל.

-fno-נפוץ
בקוד C, שולט במיקום של משתנים גלובליים לא מאותחלים. מהדרים של Unix C
באופן מסורתי אפשרו מספר הגדרות של משתנים כאלה בשונות
יחידות קומפילציה על ידי הצבת המשתנים בבלוק משותף. זו ההתנהגות
שצוין על ידי -נפוץ, והוא ברירת המחדל עבור GCC ברוב היעדים. מצד שני,
התנהגות זו אינה נדרשת על ידי ISO C, ובמטרות מסוימות עשויה לשאת מהירות או קוד
קנס גודל על הפניות משתנות. ה -fno-נפוץ האפשרות מציינת כי
מהדר צריך למקם משתנים גלובליים לא מאותחלים בקטע הנתונים של האובייקט
קובץ, במקום ליצור אותם כבלוקים נפוצים. יש לכך השפעה שאם ה
אותו משתנה מוצהר (ללא "extern") בשני קומפילציות שונות, אתה מקבל א
שגיאה מרובת הגדרות כאשר אתה מקשר אותם. במקרה זה, עליך לבצע קומפילציה עם
-נפוץ במקום זאת. קומפילציה עם -fno-נפוץ שימושי במטרות שעבורן זה
מספק ביצועים טובים יותר, או אם ברצונך לוודא שהתוכנית תעבוד
מערכות אחרות שתמיד מתייחסות כך להצהרות משתנות לא מאותחלות.

-fno-ident
התעלם מה- #זהה הוראה.

-finhibit-size-directive
אל תוציא הנחיית assembler מסוג ".size", או כל דבר אחר שיגרום לבעיות
אם הפונקציה מפוצלת באמצע, ושני החצאים ממוקמים במקומות רחוקים
בנפרד בזיכרון. אפשרות זו משמשת בעת קומפילציה crtstuff.c; אתה לא צריך
להשתמש בו לכל דבר אחר.

-fverbose-asm
שים מידע פרשנות נוסף בקוד ההרכבה שנוצר כדי להפוך אותו ליותר
קָרִיא. אפשרות זו מועילה בדרך כלל רק למי שבאמת צריך לקרוא את
קוד assembly שנוצר (אולי תוך איתור באגים במהדר עצמו).

-fno-verbose-asm, ברירת המחדל, גורמת להשמטת המידע הנוסף והוא קיים
שימושי בעת השוואת שני קבצי אסמבלר.

-frecord-gcc-מתגים
מתג זה גורם להקלטה של ​​שורת הפקודה המשמשת להפעלת המהדר
קובץ האובייקט שנוצר. מתג זה מיושם רק בחלקם
מטרות והפורמט המדויק של ההקלטה הוא פורמט יעד וקובץ בינארי
תלוי, אבל זה בדרך כלל לובש צורה של קטע המכיל טקסט ASCII. זֶה
מתג קשור ל- -fverbose-asm מתג, אבל המתג הזה רק מתעד
מידע בקובץ הפלט של ה-assembler כהערות, כך שהוא לעולם לא מגיע לאובייקט
קוֹבֶץ. ראה גם -grecord-gcc-מתגים לדרך אחרת לאחסן אפשרויות מהדר לתוך
קובץ האובייקט.

-fpic
צור קוד בלתי תלוי במיקום (PIC) המתאים לשימוש בספרייה משותפת, אם
נתמך עבור מכונת היעד. קוד כזה ניגש לכל הכתובות הקבועות דרך a
טבלת אופסט גלובלית (GOT). המטען הדינמי פותר את ערכי ה-GOT כאשר
התוכנית מתחילה (המטעין הדינמי אינו חלק מ-GCC; הוא חלק מההפעלה
מערכת). אם גודל ה-GOT עבור קובץ ההפעלה המקושר חורג ממקסימום ספציפי למכונה
גודל, אתה מקבל הודעת שגיאה מהמקשר שמציינת זאת -fpic לא עובד; ב
במקרה זה, הידור מחדש עם -fPIC במקום זאת. (המקסימום הוא 8k ב-SPARC ו-32k
ב-m68k וב-RS/6000. ל-386 אין מגבלה כזו.)

קוד בלתי תלוי במיקום דורש תמיכה מיוחדת, ולכן עובד רק על
מכונות מסוימות. עבור ה-386, GCC תומך ב-PIC עבור System V אך לא עבור ה-Sun
386i. הקוד שנוצר עבור IBM RS/6000 הוא תמיד בלתי תלוי במיקום.

כאשר הדגל הזה מוגדר, פקודות המאקרו "__pic__" ו-"__PIC__" מוגדרות ל-1.

-fPIC
אם נתמך עבור מכונת היעד, פלט קוד בלתי תלוי במיקום, מתאים ל
קישור דינמי והימנעות מכל הגבלה על גודל טבלת ההיסט הגלובלית. זֶה
אפשרות עושה את ההבדל ב-m68k, PowerPC ו-SPARC.

קוד בלתי תלוי במיקום דורש תמיכה מיוחדת, ולכן עובד רק על
מכונות מסוימות.

כאשר הדגל הזה מוגדר, פקודות המאקרו "__pic__" ו-"__PIC__" מוגדרות ל-2.

-fpie
-fPIE
אפשרויות אלה דומות ל -fpic ו -fPIC, אבל נוצר קוד עצמאי במיקום
ניתן לקשר רק לקובצי הפעלה. בדרך כלל משתמשים באפשרויות אלו כאשר -פַּאִי GCC
האפשרות משמשת במהלך הקישור.

-fpie ו -fPIE שניהם מגדירים את פקודות המאקרו "__pie__" ו- "__PIE__". לפקודות המאקרו יש את
ערך 1 עבור -fpie ו 2 עבור -fPIE.

-fno-jump-tables
אל תשתמש בטבלאות קפיצה להצהרות מתג, אפילו אם זה יהיה יעיל יותר
מאשר אסטרטגיות יצירת קוד אחרות. אפשרות זו שימושית בשילוב עם
-fpic or -fPIC לבניית קוד שמהווה חלק ממקשר דינמי ואינו יכול
התייחס לכתובת של טבלת קפיצה. בחלק מהמטרות, טבלאות קפיצה אינן דורשות א
GOT ואפשרות זו אינה נחוצה.

-תוקן-רג
התייחסו לפנקס ששמו רג כפנקס קבוע; קוד שנוצר לעולם לא אמור להתייחס אליו
זה (למעט אולי כמצביע מחסנית, מצביע מסגרת או בתפקיד קבוע אחר).

רג חייב להיות שם של פנקס. שמות הרישום המקובלים הם ספציפיים למכונה
ומוגדרים במאקרו "REGISTER_NAMES" בקובץ המאקרו של תיאור המכונה.

לדגל זה אין צורה שלילית, מכיוון שהוא מציין בחירה תלת כיוונית.

-fcall-used-רג
התייחסו לפנקס ששמו רג כפנקס בר-הקצאה הנתון לפי פונקציה
שיחות. זה עשוי להיות מוקצה עבור זמניים או משתנים שאינם חיים על פני a
שִׂיחָה. פונקציות שהידור בדרך זו אינן שומרות ומשחזרות את האוגר רג.

זו שגיאה להשתמש בדגל זה עם מצביע המסגרת או מצביע הערימה. שימוש בזה
דגל עבור רגיסטרים אחרים שיש להם תפקידים מקובעים בביצוע המכונה
המודל מייצר תוצאות הרות אסון.

לדגל זה אין צורה שלילית, מכיוון שהוא מציין בחירה תלת כיוונית.

-fcall-sved-רג
התייחסו לפנקס ששמו רג כפנקס ניתן להקצאה שנשמר על ידי פונקציות. זה יכול להיות
מוקצה אפילו עבור זמניים או משתנים שחיים על פני שיחה. פונקציות
הידור בדרך זו שמור ושחזר את הרישום רג אם הם משתמשים בו.

זו שגיאה להשתמש בדגל זה עם מצביע המסגרת או מצביע הערימה. שימוש בזה
דגל עבור רגיסטרים אחרים שיש להם תפקידים מקובעים בביצוע המכונה
המודל מייצר תוצאות הרות אסון.

סוג אחר של אסון נובע מהשימוש בדגל זה עבור רישום שבו
ניתן להחזיר ערכי פונקציה.

לדגל זה אין צורה שלילית, מכיוון שהוא מציין בחירה תלת כיוונית.

-fpack-struct[=n]
ללא ערך שצוין, ארזו את כל איברי המבנה יחד ללא חורים. כש
הערך מצוין (שחייב להיות כוח קטן של שניים), חברי מבנה חבילה
לפי ערך זה, המייצג את היישור המקסימלי (כלומר, אובייקטים עם
דרישות יישור ברירת מחדל גדולות מזה עשויות להיות לא מיושרות בפלט
מיקום ההתאמה הבא.

אַזהָרָה: מה היא -fpack-struct switch גורם ל-GCC ליצור קוד שאינו בינארי
תואם לקוד שנוצר ללא המתג הזה. בנוסף, זה עושה את הקוד
לא אופטימלי. השתמש בו כדי להתאים לממשק בינארי של יישום שאינו ברירת מחדל.

-finstrument-פונקציות
צור קריאות מכשור לכניסה ויציאה לפונקציות. רק אחרי פונקציה
כניסה וממש לפני יציאת הפונקציה, פונקציות הפרופיל הבא נקראות עם
הכתובת של הפונקציה הנוכחית ואת אתר ההתקשרות שלה. (בכמה פלטפורמות,
"__builtin_return_address" לא עובד מעבר לפונקציה הנוכחית, אז אתר ההתקשרות
ייתכן שמידע לא יהיה זמין לפונקציות הפרופיל אחרת.)

void __cyg_profile_func_enter (void *this_fn,
void *call_site);
void __cyg_profile_func_exit (void *this_fn,
void *call_site);

הארגומנט הראשון הוא הכתובת של ההתחלה של הפונקציה הנוכחית, שיכול להיות
הסתכל למעלה בדיוק בטבלת הסמלים.

מכשור זה נעשה גם עבור פונקציות המורחבות בשורה בפונקציות אחרות.
שיחות הפרופיל מציינות היכן, מבחינה רעיונית, הפונקציה המוטבעת מוזנת ו
יצא. המשמעות היא שגרסאות ניתנות להתייחסות של פונקציות כאלה חייבות להיות זמינות. אם
כל השימושים שלך בפונקציה מורחבים בשורה, המשמעות עשויה להיות הרחבה נוספת
בגודל קוד. אם אתה משתמש חיצוני מוטבע בקוד C שלך, גרסה ניתנת להתייחסות של כזה
יש לספק פונקציות. (בדרך כלל זה המצב בכל מקרה, אבל אם יש לך מזל
והאופטימיזר תמיד מרחיב את הפונקציות בשורה, אולי יצאת משם
מבלי לספק עותקים סטטיים.)

ניתן לתת לפונקציה את התכונה "no_instrument_function", ובמקרה זה
מכשור לא נעשה. זה יכול לשמש, למשל, עבור הפרופיל
פונקציות המפורטות לעיל, שגרות פסיקות בעדיפות גבוהה וכל פונקציה שממנה
לא ניתן לקרוא בבטחה לפונקציות הפרופיל (אולי מטפלי אותות, אם
שגרות פרופיל מייצרות פלט או מקצות זיכרון).

-finstrument-functions-exclude-file-list=פילה,פילה, ...
הגדר את רשימת הפונקציות שאינן נכללות במכשור (ראה את התיאור
של "-finstrument-functions"). אם הקובץ שמכיל הגדרת פונקציה תואם
עם אחד מ פילה, אז הפונקציה הזו אינה מכשירה. ההתאמה מתבצעת ב
מחרוזות משנה: אם ה פילה פרמטר הוא מחרוזת משנה של שם הקובץ, הוא נחשב ל
להיות התאמה.

לדוגמה:

-finstrument-functions-exclude-file-list=/bits/stl,include/sys

אינו כולל כל פונקציה מוטבעת המוגדרת בקבצים ששמות הנתיבים שלהם מכילים "/bits/stl" או
"include/sys".

אם, מסיבה כלשהי, אתה רוצה לכלול את האות ',' באחת מהן SYM, כתוב ','. ל
דוגמה, "-finstrument-functions-exclude-file-list=',,tmp'" (שימו לב למרטוט היחיד
סביב האפשרות).

-finstrument-functions-exclude-function-list=SYM,SYM, ...
זה דומה ל-"-finstrument-functions-exclude-file-list", אבל אפשרות זו נקבעת
רשימת שמות הפונקציות שיש להוציא מהמכשיר. שם הפונקציה ל
be matched הוא השם הגלוי למשתמש, כגון "vector blah(const vector &)",
לא השם המעוות הפנימי (למשל, "_Z4blahRSt6vectorIiSaIiEE"). השידוך נעשה
על מחרוזות משנה: אם ה SYM פרמטר הוא מחרוזת משנה של שם הפונקציה, הוא כן
נחשב לשידוך. עבור מזהים מורחבים C99 ו-C++, שם הפונקציה
חייב להינתן ב-UTF-8, לא באמצעות שמות תווים אוניברסליים.

-fstack-check
צור קוד כדי לוודא שאינך עובר את גבול המחסנית. אתה
צריך לציין את הדגל הזה אם אתה פועל בסביבה עם שרשורים מרובים,
אבל רק לעתים רחוקות אתה צריך לציין את זה בסביבה עם חוט יחיד מאז הערימה
הצפה מזוהה אוטומטית כמעט בכל המערכות אם יש רק מחסנית אחת.

שימו לב שמתג זה אינו גורם למעשה לביצוע בדיקה; ההפעלה
מערכת או זמן הריצה של השפה חייבות לעשות זאת. המתג גורם ליצירת קוד
להבטיח שהם רואים את הערימה מורחבת.

אתה יכול גם לציין פרמטר מחרוזת: "לא" פירושו ללא בדיקה, "גנרי"
פירושו לכפות שימוש בבדיקה בסגנון ישן, "ספציפי" פירושו להשתמש בבדיקה הטובה ביותר
שיטה והוא שווה ערך לחשוף -fstack-check.

בדיקה בסגנון ישן הוא מנגנון גנרי שלא דורש תמיכת יעד ספציפית ב
המהדר אבל מגיע עם החסרונות הבאים:

1. אסטרטגיית הקצאה שונה עבור אובייקטים גדולים: הם תמיד מוקצים
באופן דינמי אם הגודל שלהם עולה על סף קבוע.

2. הגבלה קבועה על גודל המסגרת הסטטית של פונקציות: כאשר בראשה א
פונקציה מסוימת, בדיקת מחסנית אינה אמינה ומונפקת אזהרה על ידי
מהדר.

3. חוסר יעילות: הן בגלל אסטרטגיית ההקצאה המותאמת והן בגלל הגנרית
יישום, ביצועי הקוד נפגעים.

שימו לב שבדיקת מחסנית בסגנון ישן היא גם שיטת החזרה ל"ספציפית" אם לא
תמיכת יעד נוספה במהדר.

-fstack-limit-register=רג
-fstack-limit-symbol=SYM
-fno-stack-limit
צור קוד כדי להבטיח שגם המחסנית לא תגדל מעבר לערך מסוים
הערך של פנקס או כתובת של סמל. אם נדרשת ערימה גדולה יותר, א
האות מורם בזמן הריצה. עבור רוב המטרות, האות מורם לפני הערימה
חוצה את הגבול, כך שאפשר לתפוס את האות בלי לקחת מיוחד
אמצעי זהירות.

למשל, אם המחסנית מתחילה בכתובת מוחלטת 0x80000000 וגדל כלפי מטה,
אתה יכול להשתמש בדגלים -fstack-limit-symbol=__stack_limit ו
-Wl,--defsym,__stack_limit=0x7ffe0000 לאכוף מגבלת מחסנית של 128KB. ציין זאת
זה עשוי לעבוד רק עם מקשר GNU.

-fsplit-מחסנית
צור קוד כדי לפצל אוטומטית את הערימה לפני שהיא עולה על גדותיה. המתקבל
לתוכנית יש מחסנית לא רציפה שיכולה לעלות על גדותיה רק ​​אם התוכנית אינה מסוגלת
להקצות עוד זיכרון. זה שימושי ביותר בעת הפעלת תוכניות משורשרות, שכן
אין עוד צורך לחשב גודל ערימה טוב לשימוש עבור כל חוט. זה
כרגע מיושם רק עבור הקצה האחורי של i386 ו-x86_64 עם GNU/Linux.

כאשר קוד קומפילד עם -fsplit-מחסנית קוד שיחות הידור ללא -fsplit-מחסנית, שם
ייתכן שלא יהיה הרבה שטח מחסנית זמין להפעלת הקוד האחרון. אם קומפילציה של הכל
קוד, כולל קוד ספריה, עם -fsplit-מחסנית זה לא אופציה, אז המקשר יכול
תקן את השיחות האלה כך שהקוד יודר ללא -fsplit-מחסנית תמיד יש גדול
לַעֲרוֹם. תמיכה לכך מיושמת במקשר הזהב במהדורת GNU binutils
2.21 ואילך.

-בורח-קו תחתון
אפשרות זו ומקבילה לה, -fno-מוביל-קו תחתון, לשנות בכוח את הדרך C
סמלים מיוצגים בקובץ האובייקטים. שימוש אחד הוא לעזור לקשר עם מורשת
קוד הרכבה.

אַזהָרָה: מה היא -בורח-קו תחתון switch גורם ל-GCC ליצור קוד שאינו
בינארי תואם לקוד שנוצר ללא המתג הזה. השתמש בו כדי להתאים את א
ממשק בינארי של יישום שאינו ברירת מחדל. לא כל היעדים מספקים תמיכה מלאה
עבור המתג הזה.

-ftls-model=מודל
שנה את מודל האחסון המקומי של חוט לשימוש. ה מודל הטיעון צריך להיות אחד מהם
"גלובלי-דינמי", "מקומי-דינמי", "ראשוני-מנהל" או "מנהל מקומי".

ברירת המחדל ללא -fpic הוא "initial-exec"; עם -fpic ברירת המחדל היא
"גלובלי-דינמי".

-fvisibility=ברירת מחדל|פנימי|מוסתר|מוגן
הגדר את ברירת המחדל של נראות סמל תמונת ELF לאפשרות שצוינה --- כל הסמלים הם
מסומן עם זה אלא אם כן נדחק בתוך הקוד. שימוש בתכונה זו יכול מאוד
לשפר משמעותית את זמני הקישור והטעינה של ספריות אובייקטים משותפות, לייצר יותר
קוד אופטימלי, לספק ייצוא ממשק API כמעט מושלם ולמנוע התנגשויות סמלים. זה
בְּתוֹקֶף מומלץ להשתמש בזה בכל אובייקט משותף שתפיץ.

למרות המינוח, "ברירת מחדל" פירושו תמיד ציבורי; כלומר, זמין לקישור
נגד האובייקט המשותף מבחוץ. "מוגן" ו"פנימי" הם די חסרי תועלת
בשימוש בעולם האמיתי, כך שהאפשרות היחידה האחרת הנפוצה היא "מוסתרת". ברירת המחדל
if -נראות לא צוין הוא "ברירת מחדל", כלומר, הפוך כל סמל לציבורי --- זה
גורם לאותה התנהגות כמו גרסאות קודמות של GCC.

הסבר טוב על היתרונות המוצעים על ידי הבטחת סמלי ELF בעלי הערך הנכון
הנראות ניתנת על ידי "איך לכתוב ספריות משותפות" מאת אולריך דרפר (שיכול להיות
נמצא בhttp://people.redhat.com/~drepper/>) --- עם זאת נעשה פתרון מעולה
אפשרי על ידי אפשרות זו לסמן דברים מוסתרים כאשר ברירת המחדל היא ציבורית היא לעשות
ברירת המחדל מוסתרת וסימון דברים ציבוריים. זו הנורמה עם קובצי DLL ב-Windows ו-
עם -נראות = מוסתרת ו-"__attribute__ ((visibility("default"))" במקום
"__declspec(dllexport)" אתה מקבל סמנטיקה כמעט זהה עם תחביר זהה.
זהו ברכה גדולה למי שעובד עם פרויקטים חוצי פלטפורמה.

לאלו שמוסיפים תמיכת נראות לקוד קיים, ייתכן שתמצאו #פרגמה GCC
ראות בשימוש. זה עובד בכך שאתה מצרף את ההצהרות שברצונך לקבוע
נראות עבור עם (לדוגמה) #פרגמה GCC ראות push (מוסתר) ו #פרגמה GCC
ראות פופ. זכור שיש לראות את נראות הסמלים as חלק of מה היא
API ממשק חוזה ולכן כל הקוד החדש צריך תמיד לציין את הנראות כאשר הוא
אינו ברירת המחדל; כלומר, הצהרות רק לשימוש בתוך ה-DSO המקומי צריך תמיד
להיות מסומן במפורש כמו מוסתר כדי למנוע תקורה עקיפה PLT --- מה שהופך את זה
ברור בשפע גם מסייע לקריאה ותיעוד עצמי של הקוד. ציין זאת
עקב דרישות מפרט ISO C++, חייבים "מפעיל חדש" ו"מחיקת מפעיל".
תמיד תהיה ברירת מחדל.

שים לב לכך שכותרות מחוץ לפרויקט שלך, בפרט כותרות מערכת ו
כותרות מכל ספרייה אחרת שבה אתה משתמש, אולי לא מצפים להידור איתן
נראות מלבד ברירת המחדל. אולי תצטרך לומר במפורש #פרגמה GCC
ראות push (ברירת מחדל) לפני הכללת כותרות כאלה.

חיצוני הצהרות אינן מושפעות מ -נראות, אז הרבה קוד יכול להיות
הידור מחדש עם -נראות = מוסתרת ללא שינויים. עם זאת, המשמעות היא זאת
קריאות לפונקציות "חיצוניות" ללא חשיפה מפורשת משתמשות ב-PLT, אז זה יותר
יעיל להשתמש ב-"__attribute ((visibility))" ו/או "#pragma GCC visibility" כדי לדעת
המהדר אשר יש להתייחס להצהרות "חיצוניות" כאל מוסתרות.

שים לב כי -נראות אכן משפיע על ישויות קישור מעורפלות של C++. זה אומר שעבור
למשל, מחלקה חריגה שנזרקת בין DSOs חייבת להיות מסומנת במפורש
עם נראות ברירת מחדל כך שה סוג_מידע צמתים מאוחדים בין DSOs.

סקירה כללית של טכניקות אלה, היתרונות שלהן ואופן השימוש בהן נמצאת ב
<http://gcc.gnu.org/wiki/Visibility>.

-פניקט-נדיפות-שדות
יש להשתמש באפשרות זו אם יש גישה לשדות סיביות נדיפים (או מבנה אחר
שדות, למרות שהמהדר בדרך כלל מכבד את הטיפוסים האלה בכל מקרה) צריך להשתמש בסינגל
גישה של רוחב סוג השדה, מיושר ליישור טבעי במידת האפשר.
לדוגמה, מטרות עם אוגרים היקפיים ממופי זיכרון עשויים לדרוש את כל אלה
גישה ברוחב של 16 סיביות; עם הדגל הזה אתה יכול להכריז על כל שדות הסיביות ההיקפיים
בתור "קצר לא חתום" (בהנחה שהקצר הוא 16 סיביות במטרות אלו) כדי לאלץ את GCC להשתמש
גישה של 16 סיביות במקום, אולי, גישה יעילה יותר של 32 סיביות.

אם אפשרות זו מושבתת, המהדר משתמש בהוראה היעילה ביותר. בתוך ה
דוגמה קודמת, זו עשויה להיות הוראת טעינה של 32 סיביות, למרות שהיא ניגשת
בתים שאינם מכילים אף חלק משדה הסיביות, או אוגרים ממופי זיכרון
לא קשור לזה המעודכן.

אם המטרה דורשת יישור קפדני, וכיבוד סוג השדה ידרוש
הפרה של יישור זה, ניתנת אזהרה. אם בשדה יש ​​תכונה "ארוז",
הגישה מתבצעת מבלי לכבד את סוג השדה. אם לשדה אין
תכונת "ארוז", הגישה נעשית תוך כיבוד סוג השדה. בשני המקרים, GCC
מניח שהמשתמש יודע משהו על חומרת היעד שהוא לא מודע אליו.

ערך ברירת המחדל של אפשרות זו נקבע על ידי הממשק הבינארי של היישום עבור
מעבד היעד.

-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 ולא -ממ. אולם, ה
התלות בקובץ הקלט הראשי נשמטת.

השתמש ב- aarch64-linux-gnu-g++-4.8 באופן מקוון באמצעות שירותי onworks.net