; Options for the S/390 / zSeries port of the compiler.

; Copyright (C) 2005-2021 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_ARCH14)

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.