| ; Options for the S/390 / zSeries port of the compiler. |
| |
| ; Copyright (C) 2005-2022 Free Software Foundation, Inc. |
| ; |
| ; This file is part of GCC. |
| ; |
| ; GCC is free software; you can redistribute it and/or modify it under |
| ; the terms of the GNU General Public License as published by the Free |
| ; Software Foundation; either version 3, or (at your option) any later |
| ; version. |
| ; |
| ; GCC is distributed in the hope that it will be useful, but WITHOUT ANY |
| ; WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| ; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| ; for more details. |
| ; |
| ; You should have received a copy of the GNU General Public License |
| ; along with GCC; see the file COPYING3. If not see |
| ; <http://www.gnu.org/licenses/>. |
| |
| HeaderInclude |
| config/s390/s390-opts.h |
| |
| ;; Definitions to add to the cl_target_option and gcc_options structures |
| |
| ;; whether -march was specified |
| TargetVariable |
| unsigned char s390_arch_specified |
| |
| ;; Flags derived from s390_arch |
| TargetVariable |
| int s390_arch_flags |
| |
| ;; whether -mtune was specified |
| TargetVariable |
| unsigned char s390_tune_specified |
| |
| ;; Flags derived from s390_tune |
| TargetVariable |
| int s390_tune_flags |
| |
| ;; Cpu cost table (this is actually a "const struct processor_cost *") |
| Variable |
| long s390_cost_pointer |
| |
| m31 |
| Target RejectNegative Negative(m64) InverseMask(64BIT) |
| 31 bit ABI. |
| |
| m64 |
| Target RejectNegative Negative(m31) Mask(64BIT) |
| 64 bit ABI. |
| |
| march= |
| Target RejectNegative Joined Enum(processor_type) Var(s390_arch) Init(PROCESSOR_max) Save |
| Generate code for given CPU. |
| |
| Enum |
| Name(processor_type) Type(enum processor_type) |
| |
| EnumValue |
| Enum(processor_type) String(z900) Value(PROCESSOR_2064_Z900) |
| |
| EnumValue |
| Enum(processor_type) String(arch5) Value(PROCESSOR_2064_Z900) |
| |
| EnumValue |
| Enum(processor_type) String(z990) Value(PROCESSOR_2084_Z990) |
| |
| EnumValue |
| Enum(processor_type) String(arch6) Value(PROCESSOR_2084_Z990) |
| |
| EnumValue |
| Enum(processor_type) String(z9-109) Value(PROCESSOR_2094_Z9_109) |
| |
| EnumValue |
| Enum(processor_type) String(z9-ec) Value(PROCESSOR_2094_Z9_EC) |
| |
| EnumValue |
| Enum(processor_type) String(arch7) Value(PROCESSOR_2094_Z9_EC) |
| |
| EnumValue |
| Enum(processor_type) String(z10) Value(PROCESSOR_2097_Z10) |
| |
| EnumValue |
| Enum(processor_type) String(arch8) Value(PROCESSOR_2097_Z10) |
| |
| EnumValue |
| Enum(processor_type) String(z196) Value(PROCESSOR_2817_Z196) |
| |
| EnumValue |
| Enum(processor_type) String(arch9) Value(PROCESSOR_2817_Z196) |
| |
| EnumValue |
| Enum(processor_type) String(zEC12) Value(PROCESSOR_2827_ZEC12) |
| |
| EnumValue |
| Enum(processor_type) String(arch10) Value(PROCESSOR_2827_ZEC12) |
| |
| EnumValue |
| Enum(processor_type) String(z13) Value(PROCESSOR_2964_Z13) |
| |
| EnumValue |
| Enum(processor_type) String(arch11) Value(PROCESSOR_2964_Z13) |
| |
| EnumValue |
| Enum(processor_type) String(z14) Value(PROCESSOR_3906_Z14) |
| |
| EnumValue |
| Enum(processor_type) String(arch12) Value(PROCESSOR_3906_Z14) |
| |
| EnumValue |
| Enum(processor_type) String(z15) Value(PROCESSOR_8561_Z15) |
| |
| EnumValue |
| Enum(processor_type) String(arch13) Value(PROCESSOR_8561_Z15) |
| |
| EnumValue |
| Enum(processor_type) String(arch14) Value(PROCESSOR_3931_Z16) |
| |
| EnumValue |
| Enum(processor_type) String(z16) Value(PROCESSOR_3931_Z16) |
| |
| EnumValue |
| Enum(processor_type) String(native) Value(PROCESSOR_NATIVE) DriverOnly |
| |
| mbackchain |
| Target Mask(BACKCHAIN) Save |
| Maintain backchain pointer. |
| |
| mdebug |
| Target Mask(DEBUG_ARG) Save |
| Additional debug prints. |
| |
| mesa |
| Target RejectNegative Negative(mzarch) InverseMask(ZARCH) |
| ESA/390 architecture. |
| |
| mhard-dfp |
| Target Mask(HARD_DFP) Save |
| Enable decimal floating point hardware support. |
| |
| mhard-float |
| Target RejectNegative Negative(msoft-float) InverseMask(SOFT_FLOAT, HARD_FLOAT) Save |
| Enable hardware floating point. |
| |
| mhotpatch= |
| Target RejectNegative Joined Var(s390_deferred_options) Defer |
| Takes two non-negative integer numbers separated by a comma. |
| Prepend the function label with the number of two-byte Nop |
| instructions indicated by the first. Append Nop instructions |
| covering the number of halfwords indicated by the second after the |
| label. Nop instructions of the largest possible size are used |
| (six, four or two bytes), beginning with the largest possible |
| size. Using 0 for both values disables hotpatching. |
| |
| mlong-double-128 |
| Target RejectNegative Negative(mlong-double-64) Mask(LONG_DOUBLE_128) |
| Use 128-bit long double. |
| |
| mlong-double-64 |
| Target RejectNegative Negative(mlong-double-128) InverseMask(LONG_DOUBLE_128) |
| Use 64-bit long double. |
| |
| mhtm |
| Target Mask(OPT_HTM) Save |
| Use hardware transactional execution instructions. |
| |
| mvx |
| Target Mask(OPT_VX) Save |
| Use hardware vector facility instructions and enable the vector ABI. |
| |
| mpacked-stack |
| Target Mask(PACKED_STACK) Save |
| Use packed stack layout. |
| |
| msmall-exec |
| Target Mask(SMALL_EXEC) Save |
| Use bras for executable < 64k. |
| |
| msoft-float |
| Target RejectNegative Negative(mhard-float) Mask(SOFT_FLOAT) Save |
| Disable hardware floating point. |
| |
| mstack-guard= |
| Target RejectNegative Negative(mno-stack-guard) Joined UInteger Var(s390_stack_guard) Save |
| Set the max. number of bytes which has to be left to stack size before a trap instruction is triggered. |
| |
| mno-stack-guard |
| Target RejectNegative Alias(mstack-guard=,0) Negative(mstack-guard=) |
| Switches off the -mstack-guard= option. |
| |
| mstack-size= |
| Target RejectNegative Joined UInteger Var(s390_stack_size) Save |
| Emit extra code in the function prologue in order to trap if the stack size exceeds the given limit. |
| |
| mno-stack-size |
| Target RejectNegative Alias(mstack-size=,0) Negative(mstack-size=) |
| Switches off the -mstack-size= option. |
| |
| mtune= |
| Target RejectNegative Joined Enum(processor_type) Var(s390_tune) Init(PROCESSOR_max) Save |
| Schedule code for given CPU. |
| |
| mmvcle |
| Target Mask(MVCLE) Save |
| Use the mvcle instruction for block moves. |
| |
| mzvector |
| Target Mask(ZVECTOR) Save |
| Enable the z vector language extension providing the context-sensitive |
| vector macro and enable the Altivec-style builtins in vecintrin.h. |
| |
| mwarn-dynamicstack |
| Target Var(s390_warn_dynamicstack_p) Save |
| Warn if a function uses alloca or creates an array with dynamic size. |
| |
| mwarn-framesize= |
| Target RejectNegative Joined UInteger Var(s390_warn_framesize) Save |
| Warn if a single function's framesize exceeds the given framesize. |
| |
| mzarch |
| Target RejectNegative Negative(mesa) Mask(ZARCH) |
| z/Architecture. |
| |
| mbranch-cost= |
| Target Joined RejectNegative UInteger Var(s390_branch_cost) Init(1) Save |
| Set the branch costs for conditional branch instructions. Reasonable |
| values are small, non-negative integers. The default branch cost is |
| 1. |
| |
| mlra |
| Target Var(s390_lra_flag) Init(1) Save |
| Use LRA instead of reload. |
| |
| mpic-data-is-text-relative |
| Target Var(s390_pic_data_is_text_relative) Init(TARGET_DEFAULT_PIC_DATA_IS_TEXT_RELATIVE) |
| Assume data segments are relative to text segment. |
| |
| |
| mindirect-branch= |
| Target RejectNegative Joined Enum(indirect_branch) Var(s390_indirect_branch) Init(indirect_branch_keep) |
| Wrap all indirect branches into execute in order to disable branch |
| prediction. |
| |
| mindirect-branch-jump= |
| Target RejectNegative Joined Enum(indirect_branch) Var(s390_indirect_branch_jump) Init(indirect_branch_keep) |
| Wrap indirect table jumps and computed gotos into execute in order to |
| disable branch prediction. Using thunk or thunk-extern with this |
| option requires the thunks to be considered signal handlers to order to |
| generate correct CFI. For environments where unwinding (e.g. for |
| exceptions) is required please use thunk-inline instead. |
| |
| mindirect-branch-call= |
| Target RejectNegative Joined Enum(indirect_branch) Var(s390_indirect_branch_call) Init(indirect_branch_keep) |
| Wrap all indirect calls into execute in order to disable branch prediction. |
| |
| mfunction-return= |
| Target RejectNegative Joined Enum(indirect_branch) Var(s390_function_return) Init(indirect_branch_keep) |
| Wrap all indirect return branches into execute in order to disable branch |
| prediction. |
| |
| mfunction-return-mem= |
| Target RejectNegative Joined Enum(indirect_branch) Var(s390_function_return_mem) Init(indirect_branch_keep) |
| Wrap indirect return branches into execute in order to disable branch |
| prediction. This affects only branches where the return address is |
| going to be restored from memory. |
| |
| mfunction-return-reg= |
| Target RejectNegative Joined Enum(indirect_branch) Var(s390_function_return_reg) Init(indirect_branch_keep) |
| Wrap indirect return branches into execute in order to disable branch |
| prediction. This affects only branches where the return address |
| doesn't need to be restored from memory. |
| |
| Enum |
| Name(indirect_branch) Type(enum indirect_branch) |
| Known indirect branch choices (for use with the -mindirect-branch=/-mfunction-return= options): |
| |
| EnumValue |
| Enum(indirect_branch) String(keep) Value(indirect_branch_keep) |
| |
| EnumValue |
| Enum(indirect_branch) String(thunk) Value(indirect_branch_thunk) |
| |
| EnumValue |
| Enum(indirect_branch) String(thunk-inline) Value(indirect_branch_thunk_inline) |
| |
| EnumValue |
| Enum(indirect_branch) String(thunk-extern) Value(indirect_branch_thunk_extern) |
| |
| mindirect-branch-table |
| Target Var(s390_indirect_branch_table) Init(TARGET_DEFAULT_INDIRECT_BRANCH_TABLE) |
| Generate sections .s390_indirect_jump, .s390_indirect_call, |
| .s390_return_reg, and .s390_return_mem to contain the indirect branch |
| locations which have been patched as part of using one of the |
| -mindirect-branch* or -mfunction-return* options. The sections |
| consist of an array of 32 bit elements. Each entry holds the offset |
| from the entry to the patched location. |
| |
| mfentry |
| Target Var(flag_fentry) |
| Emit profiling counter call at function entry before prologue. The compiled |
| code will require a 64-bit CPU and glibc 2.29 or newer to run. |
| |
| mrecord-mcount |
| Target Var(flag_record_mcount) |
| Generate __mcount_loc section with all _mcount and __fentry__ calls. |
| |
| mnop-mcount |
| Target Var(flag_nop_mcount) |
| Generate mcount/__fentry__ calls as nops. To activate they need to be |
| patched in. |
| |
| mvx-long-double-fma |
| Target Undocumented Var(flag_vx_long_double_fma) |
| Emit fused multiply-add instructions for long doubles in vector registers |
| (wfmaxb, wfmsxb, wfnmaxb, wfnmsxb). Reassociation pass does not handle |
| fused multiply-adds, therefore code generated by the middle-end is prone to |
| having long fused multiply-add chains. This is not pipeline-friendly, |
| and the default behavior is to emit separate multiplication and addition |
| instructions for long doubles in vector registers, because measurements show |
| that this improves performance. This option allows overriding it for testing |
| purposes. |
| |
| munroll-only-small-loops |
| Target Undocumented Var(unroll_only_small_loops) Init(0) Save |
| ; Use conservative small loop unrolling. |
