CbC/CbC_gcc: gcc/fortran/invoke.texi comparison

comparison gcc/fortran/invoke.texi @ 145:1830386684a0

gcc-9.2.0

author	anatofuz
date	Thu, 13 Feb 2020 11:34:05 +0900
parents	84e7813d76e9
children

comparison

equal deleted inserted replaced

-:84e7813d76e9
+:1830386684a0
-@c Copyright (C) 2004-2018 Free Software Foundation, Inc.
+@c Copyright (C) 2004-2020 Free Software Foundation, Inc.
 @c This is part of the GNU Fortran manual.
 @c For copying conditions, see the file gfortran.texi.
 @ignore
 @c man begin COPYRIGHT
-Copyright @copyright{} 2004-2018 Free Software Foundation, Inc.
+Copyright @copyright{} 2004-2020 Free Software Foundation, Inc.
 Permission is granted to copy, distribute and/or modify this document
 under the terms of the GNU Free Documentation License, Version 1.3 or
 any later version published by the Free Software Foundation; with the
 Invariant Sections being ``Funding Free Software'', the Front-Cover
 by type.  Explanations are in the following sections.
 @table @emph
 @item Fortran Language Options
 @xref{Fortran Dialect Options,,Options controlling Fortran dialect}.
-@gccoptlist{-fall-intrinsics -fbackslash -fcray-pointer -fd-lines-as-code @gol
+@gccoptlist{-fall-intrinsics -fallow-argument-mismatch -fallow-invalid-boz @gol
--fd-lines-as-comments @gol
+-fbackslash -fcray-pointer -fd-lines-as-code -fd-lines-as-comments @gol
--fdec -fdec-structure -fdec-intrinsic-ints -fdec-static -fdec-math @gol
+-fdec -fdec-char-conversions -fdec-structure -fdec-intrinsic-ints @gol
--fdefault-double-8 -fdefault-integer-8 -fdefault-real-8 @gol
+-fdec-static -fdec-math -fdec-include -fdec-format-defaults @gol
--fdefault-real-10 -fdefault-real-16 -fdollar-ok -ffixed-line-length-@var{n} @gol
+-fdec-blank-format-item -fdefault-double-8 -fdefault-integer-8 @gol
--ffixed-line-length-none -ffree-form -ffree-line-length-@var{n} @gol
+-fdefault-real-8 -fdefault-real-10 -fdefault-real-16 -fdollar-ok @gol
--ffree-line-length-none -fimplicit-none -finteger-4-integer-8 @gol
+-ffixed-line-length-@var{n} -ffixed-line-length-none -fpad-source @gol
--fmax-identifier-length -fmodule-private -ffixed-form -fno-range-check @gol
+-ffree-form -ffree-line-length-@var{n} -ffree-line-length-none @gol
--fopenacc -fopenmp -freal-4-real-10 -freal-4-real-16 -freal-4-real-8 @gol
+-fimplicit-none -finteger-4-integer-8 -fmax-identifier-length @gol
--freal-8-real-10 -freal-8-real-16 -freal-8-real-4 -std=@var{std}
+-fmodule-private -ffixed-form -fno-range-check -fopenacc -fopenmp @gol
--ftest-forall-temp
+-freal-4-real-10 -freal-4-real-16 -freal-4-real-8 -freal-8-real-10 @gol
+-freal-8-real-16 -freal-8-real-4 -std=@var{std} -ftest-forall-temp
 }
 @item Preprocessing Options
 @xref{Preprocessing Options,,Enable and customize preprocessing}.
 @gccoptlist{-A-@var{question}@r{[}=@var{answer}@r{]}
 }
 @item Error and Warning Options
 @xref{Error and Warning Options,,Options to request or suppress errors
 and warnings}.
-@gccoptlist{-Waliasing -Wall -Wampersand -Wargument-mismatch -Warray-bounds
+@gccoptlist{-Waliasing -Wall -Wampersand -Warray-bounds @gol
 -Wc-binding-type -Wcharacter-truncation -Wconversion @gol
 -Wdo-subscript -Wfunction-elimination -Wimplicit-interface @gol
--Wimplicit-procedure -Wintrinsic-shadow -Wuse-without-only -Wintrinsics-std @gol
+-Wimplicit-procedure -Wintrinsic-shadow -Wuse-without-only @gol
--Wline-truncation -Wno-align-commons -Wno-tabs -Wreal-q-constant @gol
+-Wintrinsics-std -Wline-truncation -Wno-align-commons @gol
--Wsurprising -Wunderflow -Wunused-parameter -Wrealloc-lhs @gol
+-Wno-overwrite-recursive -Wno-tabs -Wreal-q-constant -Wsurprising @gol
--Wrealloc-lhs-all -Wfrontend-loop-interchange -Wtarget-lifetime @gol
+-Wunderflow -Wunused-parameter -Wrealloc-lhs -Wrealloc-lhs-all @gol
--fmax-errors=@var{n} -fsyntax-only -pedantic -pedantic-errors @gol
+-Wfrontend-loop-interchange -Wtarget-lifetime -fmax-errors=@var{n} @gol
+-fsyntax-only -pedantic @gol
+-pedantic-errors @gol
 }
 @item Debugging Options
 @xref{Debugging Options,,Options for debugging your program or GNU Fortran}.
 @gccoptlist{-fbacktrace -fdump-fortran-optimized -fdump-fortran-original @gol
--fdump-parse-tree -ffpe-trap=@var{list} -ffpe-summary=@var{list}
+-fdump-fortran-global -fdump-parse-tree -ffpe-trap=@var{list} @gol
+-ffpe-summary=@var{list}
 }
 @item Directory Options
 @xref{Directory Options,,Options for directory search}.
 @gccoptlist{-I@var{dir}  -J@var{dir} -fintrinsic-modules-path @var{dir}}
 -frecord-marker=@var{length} -fsign-zero
 }
 @item Interoperability Options
 @xref{Interoperability Options,,Options for interoperability}.
-@gccoptlist{-fc-prototypes}
+@gccoptlist{-fc-prototypes -fc-prototypes-external}
 @item Code Generation Options
 @xref{Code Gen Options,,Options for code generation conventions}.
 @gccoptlist{-faggressive-function-elimination -fblas-matmul-limit=@var{n} @gol
--fbounds-check -fcheck-array-temporaries @gol
+-fbounds-check -ftail-call-workaround -ftail-call-workaround=@var{n} @gol
--fcheck=@var{<all|array-temps|bounds|do|mem|pointer|recursion>} @gol
+-fcheck-array-temporaries @gol
--fcoarray=@var{<none|single|lib>} -fexternal-blas -ff2c
+-fcheck=@var{<all|array-temps|bits|bounds|do|mem|pointer|recursion>} @gol
--ffrontend-loop-interchange @gol
+-fcoarray=@var{<none|single|lib>} -fexternal-blas -ff2c @gol
--ffrontend-optimize @gol
+-ffrontend-loop-interchange -ffrontend-optimize @gol
 -finit-character=@var{n} -finit-integer=@var{n} -finit-local-zero @gol
--finit-derived @gol
+-finit-derived -finit-logical=@var{<true|false>} @gol
--finit-logical=@var{<true|false>}
+-finit-real=@var{<zero|inf|-inf|nan|snan>}
--finit-real=@var{<zero|inf|-inf|nan|snan>} @gol
 -finline-matmul-limit=@var{n} @gol
--fmax-array-constructor=@var{n} -fmax-stack-var-size=@var{n}
+-finline-arg-packing -fmax-array-constructor=@var{n} @gol
--fno-align-commons @gol
+-fmax-stack-var-size=@var{n} -fno-align-commons -fno-automatic @gol
--fno-automatic -fno-protect-parens -fno-underscoring @gol
+-fno-protect-parens -fno-underscoring -fsecond-underscore @gol
--fsecond-underscore -fpack-derived -frealloc-lhs -frecursive @gol
+-fpack-derived -frealloc-lhs -frecursive -frepack-arrays @gol
--frepack-arrays -fshort-enums -fstack-arrays
+-fshort-enums -fstack-arrays
 }
 @end table
 @node Fortran Dialect Options
 @section Options controlling Fortran dialect
 force standard-compliance but get access to the full range of intrinsics
 available with @command{gfortran}.  As a consequence, @option{-Wintrinsics-std}
 will be ignored and no user-defined procedure with the same name as any
 intrinsic will be called except when it is explicitly declared @code{EXTERNAL}.
+@item -fallow-argument-mismatch
+@opindex @code{fallow-argument-mismatch}
+Some code contains calls to external procedures whith mismatches
+between the calls and the procedure definition, or with mismatches
+between different calls. Such code is non-conforming, and will usually
+be flagged wi1th an error.  This options degrades the error to a
+warning, which can only be disabled by disabling all warnings vial
+@option{-w}.  Only a single occurrence per argument is flagged by this
+warning.  @option{-fallow-argument-mismatch} is implied by
+@option{-std=legacy}.
+Using this option is @emph{strongly} discouraged.  It is possible to
+provide standard-conforming code which allows different types of
+arguments by using an explicit interface and @code{TYPE(*)}.
+@item -fallow-invalid-boz
+@opindex @code{allow-invalid-boz}
+A BOZ literal constant can occur in a limited number of contexts in
+standard conforming Fortran.  This option degrades an error condition
+to a warning, and allows a BOZ literal constant to appear where the
+Fortran standard would otherwise prohibit its use.
 @item -fd-lines-as-code
 @itemx -fd-lines-as-comments
 @opindex @code{fd-lines-as-code}
 @opindex @code{fd-lines-as-comments}
 Enable special treatment for lines beginning with @code{d} or @code{D}
 These features are non-standard and should be avoided at all costs.
 For details on GNU Fortran's implementation of these extensions see the
 full documentation.
 Other flags enabled by this switch are:
-@option{-fdollar-ok} @option{-fcray-pointer} @option{-fdec-structure}
+@option{-fdollar-ok} @option{-fcray-pointer} @option{-fdec-char-conversions}
-@option{-fdec-intrinsic-ints} @option{-fdec-static} @option{-fdec-math}
+@option{-fdec-structure} @option{-fdec-intrinsic-ints} @option{-fdec-static}
+@option{-fdec-math} @option{-fdec-include} @option{-fdec-blank-format-item}
+@option{-fdec-format-defaults}
 If @option{-fd-lines-as-code}/@option{-fd-lines-as-comments} are unset, then
 @option{-fdec} also sets @option{-fd-lines-as-comments}.
+@item -fdec-char-conversions
+@opindex @code{fdec-char-conversions}
+Enable the use of character literals in assignments and @code{DATA} statements
+for non-character variables.
 @item -fdec-structure
 @opindex @code{fdec-structure}
 Enable DEC @code{STRUCTURE} and @code{RECORD} as well as @code{UNION},
 @code{MAP}, and dot ('.') as a member separator (in addition to '%'). This is
 @item -fdec-static
 @opindex @code{fdec-static}
 Enable DEC-style STATIC and AUTOMATIC attributes to explicitly specify
 the storage of variables and other objects.
+@item -fdec-include
+@opindex @code{fdec-include}
+Enable parsing of INCLUDE as a statement in addition to parsing it as
+INCLUDE line.  When parsed as INCLUDE statement, INCLUDE does not have to
+be on a single line and can use line continuations.
+@item -fdec-format-defaults
+@opindex @code{fdec-format-defaults}
+Enable format specifiers F, G and I to be used without width specifiers,
+default widths will be used instead.
+@item -fdec-blank-format-item
+@opindex @code{fdec-blank-format-item}
+Enable a blank format item at the end of a format specification i.e. nothing
+following the final comma.
 @item -fdollar-ok
 @opindex @code{fdollar-ok}
 @cindex @code{$}
 @cindex symbol names
 @item -ffixed-line-length-@var{n}
 @opindex @code{ffixed-line-length-}@var{n}
 @cindex file format, fixed
 Set column after which characters are ignored in typical fixed-form
-lines in the source file, and through which spaces are assumed (as
+lines in the source file, and, unless @code{-fno-pad-source}, through which
-if padded to that length) after the ends of short fixed-form lines.
+spaces are assumed (as if padded to that length) after the ends of short
+fixed-form lines.
 Popular values for @var{n} include 72 (the
 standard and the default), 80 (card image), and 132 (corresponding
 to ``extended-source'' options in some popular compilers).
 @var{n} may also be @samp{none}, meaning that the entire line is meaningful
 and that continued character constants never have implicit spaces appended
 to them to fill out the line.
 @option{-ffixed-line-length-0} means the same thing as
 @option{-ffixed-line-length-none}.
+@item -fno-pad-source
+@opindex @code{fpad-source}
+By default fixed-form lines have spaces assumed (as if padded to that length)
+after the ends of short fixed-form lines.  This is not done either if
+@option{-ffixed-line-length-0}, @option{-ffixed-line-length-none} or
+if @option{-fno-pad-source} option is used.  With any of those options
+continued character constants never have implicit spaces appended
+to them to fill out the line.
 @item -ffree-line-length-@var{n}
 @opindex @code{ffree-line-length-}@var{n}
 @cindex file format, free
 Set column after which characters are ignored in typical free-form
 directives in free form and @code{c$acc}, @code{*$acc} and
 @code{!$acc} directives in fixed form, @code{!$} conditional
 compilation sentinels in free form and @code{c$}, @code{*$} and
 @code{!$} sentinels in fixed form, and when linking arranges for the
 OpenACC runtime library to be linked in.
-Note that this is an experimental feature, incomplete, and subject to
-change in future versions of GCC.  See
-@w{@uref{https://gcc.gnu.org/wiki/OpenACC}} for more information.
 @item -fopenmp
 @opindex @code{fopenmp}
 @cindex OpenMP
 Enable the OpenMP extensions.  This includes OpenMP @code{!$omp} directives
 @option{-finteger-4-integer-8}, it does not promote variables with explicit
 kind declaration.
 @item -fdefault-real-8
 @opindex @code{fdefault-real-8}
-Set the default real type to an 8 byte wide type. This option also affects
+Set the default real type to an 8 byte wide type.  This option also affects
-the kind of non-double real constants like @code{1.0}, and does promote
+the kind of non-double real constants like @code{1.0}.  This option promotes
-the default width of @code{DOUBLE PRECISION} to 16 bytes if possible, unless
+the default width of @code{DOUBLE PRECISION} and double real constants
-@code{-fdefault-double-8} is given, too. Unlike @option{-freal-4-real-8},
+like @code{1.d0} to 16 bytes if possible.  If @code{-fdefault-double-8}
-it does not promote variables with explicit kind declaration.
+is given along with @code{fdefault-real-8}, @code{DOUBLE PRECISION}
+and double real constants are not promoted.  Unlike @option{-freal-4-real-8},
+@code{fdefault-real-8} does not promote variables with explicit kind
+declarations.
 @item -fdefault-real-10
 @opindex @code{fdefault-real-10}
-Set the default real type to a 10 byte wide type. This option also affects
+Set the default real type to an 10 byte wide type.  This option also affects
-the kind of non-double real constants like @code{1.0}, and does promote
+the kind of non-double real constants like @code{1.0}.  This option promotes
-the default width of @code{DOUBLE PRECISION} to 16 bytes if possible, unless
+the default width of @code{DOUBLE PRECISION} and double real constants
-@code{-fdefault-double-8} is given. Unlike @option{-freal-4-real-10},
+like @code{1.d0} to 16 bytes if possible.  If @code{-fdefault-double-8}
-it does not promote variables with explicit kind declaration.
+is given along with @code{fdefault-real-10}, @code{DOUBLE PRECISION}
+and double real constants are not promoted.  Unlike @option{-freal-4-real-10},
+@code{fdefault-real-10} does not promote variables with explicit kind
+declarations.
 @item -fdefault-real-16
 @opindex @code{fdefault-real-16}
-Set the default real type to a 16 byte wide type. This option also affects
+Set the default real type to an 16 byte wide type.  This option also affects
-the kind of non-double real constants like @code{1.0}, and does promote
+the kind of non-double real constants like @code{1.0}.  This option promotes
-the default width of @code{DOUBLE PRECISION} to 16 bytes if possible, unless
+the default width of @code{DOUBLE PRECISION} and double real constants
-@code{-fdefault-double-8} is given. Unlike @option{-freal-4-real-16},
+like @code{1.d0} to 16 bytes if possible.  If @code{-fdefault-double-8}
-it does not promote variables with explicit kind declaration.
+is given along with @code{fdefault-real-16}, @code{DOUBLE PRECISION}
+and double real constants are not promoted.  Unlike @option{-freal-4-real-16},
+@code{fdefault-real-16} does not promote variables with explicit kind
+declarations.
 @item -fdefault-double-8
 @opindex @code{fdefault-double-8}
-Set the @code{DOUBLE PRECISION} type to an 8 byte wide type.  Do nothing if this
+Set the @code{DOUBLE PRECISION} type and double real constants
-is already the default.  If @option{-fdefault-real-8} is given,
+like @code{1.d0} to an 8 byte wide type.  Do nothing if this
-@code{DOUBLE PRECISION} would instead be promoted to 16 bytes if possible, and
+is already the default.  This option prevents @option{-fdefault-real-8},
-@option{-fdefault-double-8} can be used to prevent this.  The kind of real
+@option{-fdefault-real-10}, and @option{-fdefault-real-16},
-constants like @code{1.d0} will not be changed by @option{-fdefault-real-8}
+from promoting @code{DOUBLE PRECISION} and double real constants like
-though, so also @option{-fdefault-double-8} does not affect it.
+@code{1.d0} to 16 bytes.
 @item -finteger-4-integer-8
 @opindex @code{finteger-4-integer-8}
 Promote all @code{INTEGER(KIND=4)} entities to an @code{INTEGER(KIND=8)}
 entities.  If @code{KIND=8} is unavailable, then an error will be issued.
 @option{-std=f2018}. Note: With no ampersand given in a continued
 character constant, GNU Fortran assumes continuation at the first
 non-comment, non-whitespace character after the ampersand that
 initiated the continuation.
-@item -Wargument-mismatch
-@opindex @code{Wargument-mismatch}
-@cindex warnings, argument mismatch
-@cindex warnings, parameter mismatch
-@cindex warnings, interface mismatch
-Warn about type, rank, and other mismatches between formal parameters and actual
-arguments to functions and subroutines.  These warnings are recommended and
-thus enabled by default.
 @item -Warray-temporaries
 @opindex @code{Warray-temporaries}
 @cindex warnings, array temporaries
 Warn about array temporaries generated by the compiler.  The information
 generated by this warning is sometimes useful in optimization, in order to
 @item -Wfrontend-loop-interchange
 @opindex @code{Wfrontend-loop-interchange}
 @cindex warnings, loop interchange
 @cindex loop interchange, warning
-Enable warning for loop interchanges performed by the
+Warn when using @option{-ffrontend-loop-interchange} for performing loop
-@option{-ffrontend-loop-interchange} option.
+interchanges.
 @item -Wimplicit-interface
 @opindex @code{Wimplicit-interface}
 @cindex warnings, implicit interface
 Warn if a procedure is called without an explicit interface.
 @item -Winteger-division
 @opindex @code{Winteger-division}
 @cindex warnings, integer division
 @cindex warnings, division of integers
-Warn if a constant integer division truncates it result.
+Warn if a constant integer division truncates its result.
 As an example, 3/5 evaluates to 0.
 @item -Wintrinsics-std
 @opindex @code{Wintrinsics-std}
 @cindex warnings, non-standard intrinsics
 Warn if @command{gfortran} finds a procedure named like an intrinsic not
 available in the currently selected standard (with @option{-std}) and treats
 it as @code{EXTERNAL} procedure because of this.  @option{-fall-intrinsics} can
 be used to never trigger this behavior and always link to the intrinsic
 regardless of the selected standard.
+@item -Wno-overwrite-recursive
+@opindex @code{Woverwrite-recursive}
+@cindex  warnings, overwrite recursive
+Do not warn when @option{-fno-automatic} is used with @option{-frecursive}. Recursion
+will be broken if the relevant local variables do not have the attribute
+@code{AUTOMATIC} explicitly declared. This option can be used to suppress the warning
+when it is known that recursion is not broken. Useful for build environments that use
+@option{-Werror}.
 @item -Wreal-q-constant
 @opindex @code{Wreal-q-constant}
 @cindex warnings, @code{q} exponent-letter
 Produce a warning if a real-literal-constant contains a @code{q}
 time.  This option is implied by @option{-Wall}.
 @item -Wdo-subscript
 @opindex @code{Wdo-subscript}
 Warn if an array subscript inside a DO loop could lead to an
-out-of-bounds access even if the compiler can not prove that the
+out-of-bounds access even if the compiler cannot prove that the
 statement is actually executed, in cases like
 @smallexample
 real a(3)
 do i=1,4
 if (condition(i)) then
 into internal representation.  Mostly useful for debugging the GNU
 Fortran compiler itself. The output generated by this option might
 change between releases. This option may also generate internal
 compiler errors for features which have only recently been added. This
 option is deprecated; use @code{-fdump-fortran-original} instead.
+@item -fdump-fortran-global
+@opindex @code{fdump-fortran-global}
+Output a list of the global identifiers after translating into
+middle-end representation. Mostly useful for debugging the GNU Fortran
+compiler itself. The output generated by this option might change
+between releases.  This option may also generate internal compiler
+errors for features which have only recently been added.
 @item -ffpe-trap=@var{list}
 @opindex @code{ffpe-trap=}@var{list}
 Specify a list of floating point exception traps to enable.  On most
 systems, if a floating point exception occurs and the trap for that
 The first three exceptions (@samp{invalid}, @samp{zero}, and
 @samp{overflow}) often indicate serious errors, and unless the program
 has provisions for dealing with these exceptions, enabling traps for
 these three exceptions is probably a good idea.
+If the option is used more than once in the command line, the lists will
+be joined: '@code{ffpe-trap=}@var{list1} @code{ffpe-trap=}@var{list2}'
+is equivalent to @code{ffpe-trap=}@var{list1},@var{list2}.
+Note that once enabled an exception cannot be disabled (no negative form).
 Many, if not most, floating point operations incur loss of precision
 due to rounding, and hence the @code{ffpe-trap=inexact} is likely to
 be uninteresting in practice.
 By default no exception traps are enabled.
 to @code{ERROR_UNIT} when invoking @code{STOP} and @code{ERROR STOP}.
 @var{list} can be either @samp{none}, @samp{all} or a comma-separated list
 of the following exceptions: @samp{invalid}, @samp{zero}, @samp{overflow},
 @samp{underflow}, @samp{inexact} and @samp{denormal}. (See
 @option{-ffpe-trap} for a description of the exceptions.)
+If the option is used more than once in the command line, only the
+last one will be used.
 By default, a summary for all exceptions but @samp{inexact} is shown.
 @item -fno-backtrace
 @opindex @code{fno-backtrace}
 referenced in it. Does not affect common blocks. (Some Fortran compilers
 provide this option under the name @option{-static} or @option{-save}.)
 The default, which is @option{-fautomatic}, uses the stack for local
 variables smaller than the value given by @option{-fmax-stack-var-size}.
 Use the option @option{-frecursive} to use no static memory.
+Local variables or arrays having an explicit @code{SAVE} attribute are
+silently ignored unless the @option{-pedantic} option is added.
 @item -ff2c
 @opindex ff2c
 @cindex calling convention
 @cindex @command{f2c} calling convention
 @item -fcheck=@var{<keyword>}
 @opindex @code{fcheck}
 @cindex array, bounds checking
+@cindex bit intrinsics checking
 @cindex bounds checking
 @cindex pointer checking
 @cindex memory checking
 @cindex range checking
 @cindex subscript checking
 had to be generated. The information generated by this warning is
 sometimes useful in optimization, in order to avoid such temporaries.
 Note: The warning is only printed once per location.
+@item @samp{bits}
+Enable generation of run-time checks for invalid arguments to the bit
+manipulation intrinsics.
 @item @samp{bounds}
 Enable generation of run-time checks for array subscripts
 and against the declared minimum and maximum values.  It also
 checks array indices for assumed and deferred
 shape arrays against the actual allocated bounds and ensures that all string
 @item -fbounds-check
 @opindex @code{fbounds-check}
 @c Note: This option is also referred in gcc's manpage
 Deprecated alias for @option{-fcheck=bounds}.
+@item -ftail-call-workaround
+@itemx -ftail-call-workaround=@var{n}
+@opindex @code{tail-call-workaround}
+Some C interfaces to Fortran codes violate the gfortran ABI by
+omitting the hidden character length arguments as described in
+@xref{Argument passing conventions}.  This can lead to crashes
+because pushing arguments for tail calls can overflow the stack.
+To provide a workaround for existing binary packages, this option
+disables tail call optimization for gfortran procedures with character
+arguments.  With @option{-ftail-call-workaround=2} tail call optimization
+is disabled in all gfortran procedures with character arguments,
+with @option{-ftail-call-workaround=1} or equivalent
+@option{-ftail-call-workaround} only in gfortran procedures with character
+arguments that call implicitly prototyped procedures.
+Using this option can lead to problems including crashes due to
+insufficient stack space.
+It is @emph{very strongly} recommended to fix the code in question.
+The @option{-fc-prototypes-external} option can be used to generate
+prototypes which conform to gfortran's ABI, for inclusion in the
+source code.
+Support for this option will likely be withdrawn in a future release
+of gfortran.
+The negative form, @option{-fno-tail-call-workaround} or equivalent
+@option{-ftail-call-workaround=0}, can be used to disable this option.
+Default is currently @option{-ftail-call-workaround}, this will change
+in future releases.
 @item -fcheck-array-temporaries
 @opindex @code{fcheck-array-temporaries}
 Deprecated alias for @option{-fcheck=array-temps}.
 This option currently only affects local arrays declared with constant
 bounds, and may not apply to all character variables.
 Future versions of GNU Fortran may improve this behavior.
-The default value for @var{n} is 32768.
+The default value for @var{n} is 65536.
 @item -fstack-arrays
 @opindex @code{fstack-arrays}
 Adding this option will make the Fortran compiler put all arrays of
 unknown size and array temporaries onto stack memory.  If your program uses very
 @opindex @code{fshort-enums}
 This option is provided for interoperability with C code that was
 compiled with the @option{-fshort-enums} option.  It will make
 GNU Fortran choose the smallest @code{INTEGER} kind a given
 enumerator set will fit in, and give all its enumerators this kind.
+@item -finline-arg-packing
+@opindex @code{finline-arg-packing}
+When passing an assumed-shape argument of a procedure as actual
+argument to an assumed-size or explicit size or as argument to a
+procedure that does not have an explicit interface, the argument may
+have to be packed, that is put into contiguous memory. An example is
+the call to @code{foo} in
+@smallexample
+subroutine foo(a)
+real, dimension(*) :: a
+end subroutine foo
+subroutine bar(b)
+real, dimension(:) :: b
+call foo(b)
+end subroutine bar
+@end smallexample
+When @option{-finline-arg-packing} is in effect, this packing will be
+performed by inline code. This allows for more optimization while
+increasing code size.
+@option{-finline-arg-packing} is implied by any of the @option{-O} options
+except when optimizing for size via @option{-Os}.  If the code
+contains a very large number of argument that have to be packed, code
+size and also compilation time may become excessive.  If that is the
+case, it may be better to disable this option.  Instances of packing
+can be found by using by using @option{-Warray-temporaries}.
 @item -fexternal-blas
 @opindex @code{fexternal-blas}
 This option will make @command{gfortran} generate calls to BLAS functions
 for some matrix operations like @code{MATMUL}, instead of using our own
 and @code{COMPLEX} variables with a quiet NaN. For a signalling NaN
 use @option{-finit-real=snan}; note, however, that compile-time
 optimizations may convert them into quiet NaN and that trapping
 needs to be enabled (e.g. via @option{-ffpe-trap}).
+The @option{-finit-integer} option will parse the value into an
+integer of type @code{INTEGER(kind=C_LONG)} on the host.  Said value
+is then assigned to the integer variables in the Fortran code, which
+might result in wraparound if the value is too large for the kind.
 Finally, note that enabling any of the @option{-finit-*} options will
 silence warnings that would have been emitted by @option{-Wuninitialized}
 for the affected local variables.
 @item -falign-commons
 @table @asis
 @item -fc-prototypes
 @opindex @code{c-prototypes}
-@cindex Generating C prototypes from Fortran source code
+@cindex Generating C prototypes from Fortran BIND(C) enteties
 This option will generate C prototypes from @code{BIND(C)} variable
 declarations, types and procedure interfaces and writes them to
 standard output.  @code{ENUM} is not yet supported.
 The generated prototypes may need inclusion of an appropriate header,
 @smallexample
 $ gfortran -fc-prototypes -fsyntax-only foo.f90 > foo.h
 @end smallexample
 where the C code intended for interoperating with the Fortran code
 then  uses @code{#include "foo.h"}.
+@item -fc-prototypes-external
+@opindex @code{c-prototypes-external}
+@cindex Generating C prototypes from external procedures
+This option will generate C prototypes from external functions and
+subroutines and write them to standard output.  This may be useful for
+making sure that C bindings to Fortran code are correct.  This option
+does not generate prototypes for @code{BIND(C)} procedures, use
+@option{-fc-prototypes} for that.
+The generated prototypes may need inclusion of an appropriate
+header, such as as @code{<stdint.h>} or @code{<stdlib.h>}.
+This is primarily meant for legacy code to ensure that existing C
+bindings match what @command{gfortran} emits.  The generated C
+prototypes should be correct for the current version of the compiler,
+but may not match what other compilers or earlier versions of
+@command{gfortran} need.  For new developments, use of the
+@code{BIND(C)} features is recommended.
+Example of use:
+@smallexample
+$ gfortran -fc-prototypes-external -fsyntax-only foo.f > foo.h
+@end smallexample
+where the C code intended for interoperating with the Fortran code
+then  uses @code{#include "foo.h"}.
 @end table
 @node Environment Variables
 @section Environment variables affecting @command{gfortran}
 @cindex environment variable

Mercurial > hg > CbC > CbC_gcc

comparison gcc/fortran/invoke.texi @ 145:1830386684a0