gcc/config/s390/s390.opt

   1 ; Options for the S/390 / zSeries port of the compiler.
   2
   3 ; Copyright (C) 2005-2024 Free Software Foundation, Inc.
   4 ;
   5 ; This file is part of GCC.
   6 ;
   7 ; GCC is free software; you can redistribute it and/or modify it under
   8 ; the terms of the GNU General Public License as published by the Free
   9 ; Software Foundation; either version 3, or (at your option) any later
  10 ; version.
  11 ;
  12 ; GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  13 ; WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 ; FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15 ; for more details.
  16 ;
  17 ; You should have received a copy of the GNU General Public License
  18 ; along with GCC; see the file COPYING3.  If not see
  19 ; <http://www.gnu.org/licenses/>.
  20
  21 HeaderInclude
  22 config/s390/s390-opts.h
  23
  24 ;; Definitions to add to the cl_target_option and gcc_options structures
  25
  26 ;; whether -march was specified
  27 TargetVariable
  28 unsigned char s390_arch_specified
  29
  30 ;; Flags derived from s390_arch
  31 TargetVariable
  32 int s390_arch_flags
  33
  34 ;; whether -mtune was specified
  35 TargetVariable
  36 unsigned char s390_tune_specified
  37
  38 ;; Flags derived from s390_tune
  39 TargetVariable
  40 int s390_tune_flags
  41
  42 ;; Cpu cost table (this is actually a "const struct processor_cost *")
  43 Variable
  44 long s390_cost_pointer
  45
  46 m31
  47 Target RejectNegative Negative(m64) InverseMask(64BIT)
  48 31 bit ABI.
  49
  50 m64
  51 Target RejectNegative Negative(m31) Mask(64BIT)
  52 64 bit ABI.
  53
  54 march=
  55 Target RejectNegative Joined Enum(processor_type) Var(s390_arch) Init(PROCESSOR_max) Save
  56 Generate code for given CPU.
  57
  58 Enum
  59 Name(processor_type) Type(enum processor_type)
  60
  61 EnumValue
  62 Enum(processor_type) String(z900) Value(PROCESSOR_2064_Z900)
  63
  64 EnumValue
  65 Enum(processor_type) String(arch5) Value(PROCESSOR_2064_Z900)
  66
  67 EnumValue
  68 Enum(processor_type) String(z990) Value(PROCESSOR_2084_Z990)
  69
  70 EnumValue
  71 Enum(processor_type) String(arch6) Value(PROCESSOR_2084_Z990)
  72
  73 EnumValue
  74 Enum(processor_type) String(z9-109) Value(PROCESSOR_2094_Z9_109)
  75
  76 EnumValue
  77 Enum(processor_type) String(z9-ec) Value(PROCESSOR_2094_Z9_EC)
  78
  79 EnumValue
  80 Enum(processor_type) String(arch7) Value(PROCESSOR_2094_Z9_EC)
  81
  82 EnumValue
  83 Enum(processor_type) String(z10) Value(PROCESSOR_2097_Z10)
  84
  85 EnumValue
  86 Enum(processor_type) String(arch8) Value(PROCESSOR_2097_Z10)
  87
  88 EnumValue
  89 Enum(processor_type) String(z196) Value(PROCESSOR_2817_Z196)
  90
  91 EnumValue
  92 Enum(processor_type) String(arch9) Value(PROCESSOR_2817_Z196)
  93
  94 EnumValue
  95 Enum(processor_type) String(zEC12) Value(PROCESSOR_2827_ZEC12)
  96
  97 EnumValue
  98 Enum(processor_type) String(arch10) Value(PROCESSOR_2827_ZEC12)
  99
 100 EnumValue
 101 Enum(processor_type) String(z13) Value(PROCESSOR_2964_Z13)
 102
 103 EnumValue
 104 Enum(processor_type) String(arch11) Value(PROCESSOR_2964_Z13)
 105
 106 EnumValue
 107 Enum(processor_type) String(z14) Value(PROCESSOR_3906_Z14)
 108
 109 EnumValue
 110 Enum(processor_type) String(arch12) Value(PROCESSOR_3906_Z14)
 111
 112 EnumValue
 113 Enum(processor_type) String(z15) Value(PROCESSOR_8561_Z15)
 114
 115 EnumValue
 116 Enum(processor_type) String(arch13) Value(PROCESSOR_8561_Z15)
 117
 118 EnumValue
 119 Enum(processor_type) String(arch14) Value(PROCESSOR_3931_Z16)
 120
 121 EnumValue
 122 Enum(processor_type) String(z16) Value(PROCESSOR_3931_Z16)
 123
 124 EnumValue
 125 Enum(processor_type) String(native) Value(PROCESSOR_NATIVE) DriverOnly
 126
 127 mbackchain
 128 Target Mask(BACKCHAIN) Save
 129 Maintain backchain pointer.
 130
 131 mdebug
 132 Target Mask(DEBUG_ARG) Save
 133 Additional debug prints.
 134
 135 mesa
 136 Target RejectNegative Negative(mzarch) InverseMask(ZARCH)
 137 ESA/390 architecture.
 138
 139 mhard-dfp
 140 Target Mask(HARD_DFP) Save
 141 Enable decimal floating point hardware support.
 142
 143 mhard-float
 144 Target RejectNegative Negative(msoft-float) InverseMask(SOFT_FLOAT, HARD_FLOAT) Save
 145 Enable hardware floating point.
 146
 147 mhotpatch=
 148 Target RejectNegative Joined Var(s390_deferred_options) Defer
 149 Takes two non-negative integer numbers separated by a comma.
 150 Prepend the function label with the number of two-byte Nop
 151 instructions indicated by the first.  Append Nop instructions
 152 covering the number of halfwords indicated by the second after the
 153 label.  Nop instructions of the largest possible size are used
 154 (six, four or two bytes), beginning with the largest possible
 155 size.  Using 0 for both values disables hotpatching.
 156
 157 mlong-double-128
 158 Target RejectNegative Negative(mlong-double-64) Mask(LONG_DOUBLE_128)
 159 Use 128-bit long double.
 160
 161 mlong-double-64
 162 Target RejectNegative Negative(mlong-double-128) InverseMask(LONG_DOUBLE_128)
 163 Use 64-bit long double.
 164
 165 mhtm
 166 Target Mask(OPT_HTM) Save
 167 Use hardware transactional execution instructions.
 168
 169 mvx
 170 Target Mask(OPT_VX) Save
 171 Use hardware vector facility instructions and enable the vector ABI.
 172
 173 mpacked-stack
 174 Target Mask(PACKED_STACK) Save
 175 Use packed stack layout.
 176
 177 msmall-exec
 178 Target Mask(SMALL_EXEC) Save
 179 Use bras for executable < 64k.
 180
 181 msoft-float
 182 Target RejectNegative Negative(mhard-float) Mask(SOFT_FLOAT) Save
 183 Disable hardware floating point.
 184
 185 mstack-guard=
 186 Target RejectNegative Negative(mno-stack-guard) Joined UInteger Var(s390_stack_guard) Save
 187 Set the max. number of bytes which has to be left to stack size before a trap instruction is triggered.
 188
 189 mno-stack-guard
 190 Target RejectNegative Alias(mstack-guard=,0) Negative(mstack-guard=)
 191 Switches off the -mstack-guard= option.
 192
 193 mstack-size=
 194 Target RejectNegative Joined UInteger Var(s390_stack_size) Save
 195 Emit extra code in the function prologue in order to trap if the stack size exceeds the given limit.
 196
 197 mno-stack-size
 198 Target RejectNegative Alias(mstack-size=,0) Negative(mstack-size=)
 199 Switches off the -mstack-size= option.
 200
 201 mtune=
 202 Target RejectNegative Joined Enum(processor_type) Var(s390_tune) Init(PROCESSOR_max) Save
 203 Schedule code for given CPU.
 204
 205 mmvcle
 206 Target Mask(MVCLE) Save
 207 Use the mvcle instruction for block moves.
 208
 209 mzvector
 210 Target Mask(ZVECTOR) Save
 211 Enable the z vector language extension providing the context-sensitive
 212 vector macro and enable the Altivec-style builtins in vecintrin.h.
 213
 214 mwarn-dynamicstack
 215 Target Var(s390_warn_dynamicstack_p) Save
 216 Warn if a function uses alloca or creates an array with dynamic size.
 217
 218 mwarn-framesize=
 219 Target RejectNegative Joined UInteger Var(s390_warn_framesize) Save
 220 Warn if a single function's framesize exceeds the given framesize.
 221
 222 mzarch
 223 Target RejectNegative Negative(mesa) Mask(ZARCH)
 224 z/Architecture.
 225
 226 mbranch-cost=
 227 Target Joined RejectNegative UInteger Var(s390_branch_cost) Init(1) Save
 228 Set the branch costs for conditional branch instructions.  Reasonable
 229 values are small, non-negative integers.  The default branch cost is
 230 1.
 231
 232 mlra
 233 Target Var(s390_lra_flag) Init(1) Save
 234 Use LRA instead of reload.
 235
 236 mpic-data-is-text-relative
 237 Target Var(s390_pic_data_is_text_relative) Init(TARGET_DEFAULT_PIC_DATA_IS_TEXT_RELATIVE)
 238 Assume data segments are relative to text segment.
 239
 240
 241 mindirect-branch=
 242 Target RejectNegative Joined Enum(indirect_branch) Var(s390_indirect_branch) Init(indirect_branch_keep)
 243 Wrap all indirect branches into execute in order to disable branch
 244 prediction.
 245
 246 mindirect-branch-jump=
 247 Target RejectNegative Joined Enum(indirect_branch) Var(s390_indirect_branch_jump) Init(indirect_branch_keep)
 248 Wrap indirect table jumps and computed gotos into execute in order to
 249 disable branch prediction.  Using thunk or thunk-extern with this
 250 option requires the thunks to be considered signal handlers to order to
 251 generate correct CFI.  For environments where unwinding (e.g. for
 252 exceptions) is required please use thunk-inline instead.
 253
 254 mindirect-branch-call=
 255 Target RejectNegative Joined Enum(indirect_branch) Var(s390_indirect_branch_call) Init(indirect_branch_keep)
 256 Wrap all indirect calls into execute in order to disable branch prediction.
 257
 258 mfunction-return=
 259 Target RejectNegative Joined Enum(indirect_branch) Var(s390_function_return) Init(indirect_branch_keep)
 260 Wrap all indirect return branches into execute in order to disable branch
 261 prediction.
 262
 263 mfunction-return-mem=
 264 Target RejectNegative Joined Enum(indirect_branch) Var(s390_function_return_mem) Init(indirect_branch_keep)
 265 Wrap indirect return branches into execute in order to disable branch
 266 prediction. This affects only branches where the return address is
 267 going to be restored from memory.
 268
 269 mfunction-return-reg=
 270 Target RejectNegative Joined Enum(indirect_branch) Var(s390_function_return_reg) Init(indirect_branch_keep)
 271 Wrap indirect return branches into execute in order to disable branch
 272 prediction. This affects only branches where the return address
 273 doesn't need to be restored from memory.
 274
 275 Enum
 276 Name(indirect_branch) Type(enum indirect_branch)
 277 Known indirect branch choices (for use with the -mindirect-branch=/-mfunction-return= options):
 278
 279 EnumValue
 280 Enum(indirect_branch) String(keep) Value(indirect_branch_keep)
 281
 282 EnumValue
 283 Enum(indirect_branch) String(thunk) Value(indirect_branch_thunk)
 284
 285 EnumValue
 286 Enum(indirect_branch) String(thunk-inline) Value(indirect_branch_thunk_inline)
 287
 288 EnumValue
 289 Enum(indirect_branch) String(thunk-extern) Value(indirect_branch_thunk_extern)
 290
 291 mindirect-branch-table
 292 Target Var(s390_indirect_branch_table) Init(TARGET_DEFAULT_INDIRECT_BRANCH_TABLE)
 293 Generate sections .s390_indirect_jump, .s390_indirect_call,
 294 .s390_return_reg, and .s390_return_mem to contain the indirect branch
 295 locations which have been patched as part of using one of the
 296 -mindirect-branch* or -mfunction-return* options.  The sections
 297 consist of an array of 32 bit elements. Each entry holds the offset
 298 from the entry to the patched location.
 299
 300 mfentry
 301 Target Var(flag_fentry)
 302 Emit profiling counter call at function entry before prologue. The compiled
 303 code will require a 64-bit CPU and glibc 2.29 or newer to run.
 304
 305 mrecord-mcount
 306 Target Var(flag_record_mcount)
 307 Generate __mcount_loc section with all _mcount and __fentry__ calls.
 308
 309 mnop-mcount
 310 Target Var(flag_nop_mcount)
 311 Generate mcount/__fentry__ calls as nops. To activate they need to be
 312 patched in.
 313
 314 mvx-long-double-fma
 315 Target Undocumented Var(flag_vx_long_double_fma)
 316 Emit fused multiply-add instructions for long doubles in vector registers
 317 (wfmaxb, wfmsxb, wfnmaxb, wfnmsxb).  Reassociation pass does not handle
 318 fused multiply-adds, therefore code generated by the middle-end is prone to
 319 having long fused multiply-add chains.  This is not pipeline-friendly,
 320 and the default behavior is to emit separate multiplication and addition
 321 instructions for long doubles in vector registers, because measurements show
 322 that this improves performance.  This option allows overriding it for testing
 323 purposes.
 324
 325 munroll-only-small-loops
 326 Target Undocumented Var(unroll_only_small_loops) Init(0) Save
 327 ; Use conservative small loop unrolling.
 328
 329 mpreserve-args
 330 Target Var(s390_preserve_args_p) Init(0)
 331 Store all argument registers on the stack.
 332
 333 munaligned-symbols
 334 Target Var(s390_unaligned_symbols_p) Init(0)
 335 Assume external symbols to be potentially unaligned.  By default all
 336 symbols without explicit alignment are assumed to reside on a 2 byte
 337 boundary as mandated by the IBM Z ABI.
 338