|
145
|
1 @c Copyright (C) 2004-2020 Free Software Foundation, Inc.
|
|
111
|
2 @c This is part of the GNU Fortran manual.
|
|
|
3 @c For copying conditions, see the file gfortran.texi.
|
|
|
4
|
|
|
5 @ignore
|
|
|
6 @c man begin COPYRIGHT
|
|
145
|
7 Copyright @copyright{} 2004-2020 Free Software Foundation, Inc.
|
|
111
|
8
|
|
|
9 Permission is granted to copy, distribute and/or modify this document
|
|
|
10 under the terms of the GNU Free Documentation License, Version 1.3 or
|
|
|
11 any later version published by the Free Software Foundation; with the
|
|
|
12 Invariant Sections being ``Funding Free Software'', the Front-Cover
|
|
|
13 Texts being (a) (see below), and with the Back-Cover Texts being (b)
|
|
|
14 (see below). A copy of the license is included in the gfdl(7) man page.
|
|
|
15
|
|
|
16 (a) The FSF's Front-Cover Text is:
|
|
|
17
|
|
|
18 A GNU Manual
|
|
|
19
|
|
|
20 (b) The FSF's Back-Cover Text is:
|
|
|
21
|
|
|
22 You have freedom to copy and modify this GNU Manual, like GNU
|
|
|
23 software. Copies published by the Free Software Foundation raise
|
|
|
24 funds for GNU development.
|
|
|
25 @c man end
|
|
|
26 @c Set file name and title for the man page.
|
|
|
27 @setfilename gfortran
|
|
|
28 @settitle GNU Fortran compiler.
|
|
|
29 @c man begin SYNOPSIS
|
|
|
30 gfortran [@option{-c}|@option{-S}|@option{-E}]
|
|
|
31 [@option{-g}] [@option{-pg}] [@option{-O}@var{level}]
|
|
|
32 [@option{-W}@var{warn}@dots{}] [@option{-pedantic}]
|
|
|
33 [@option{-I}@var{dir}@dots{}] [@option{-L}@var{dir}@dots{}]
|
|
|
34 [@option{-D}@var{macro}[=@var{defn}]@dots{}] [@option{-U}@var{macro}]
|
|
|
35 [@option{-f}@var{option}@dots{}]
|
|
|
36 [@option{-m}@var{machine-option}@dots{}]
|
|
|
37 [@option{-o} @var{outfile}] @var{infile}@dots{}
|
|
|
38
|
|
|
39 Only the most useful options are listed here; see below for the
|
|
|
40 remainder.
|
|
|
41 @c man end
|
|
|
42 @c man begin SEEALSO
|
|
|
43 gpl(7), gfdl(7), fsf-funding(7),
|
|
131
|
44 cpp(1), gcov(1), gcc(1), as(1), ld(1), gdb(1), dbx(1)
|
|
111
|
45 and the Info entries for @file{gcc}, @file{cpp}, @file{gfortran}, @file{as},
|
|
|
46 @file{ld}, @file{binutils} and @file{gdb}.
|
|
|
47 @c man end
|
|
|
48 @c man begin BUGS
|
|
|
49 For instructions on reporting bugs, see
|
|
|
50 @w{@value{BUGURL}}.
|
|
|
51 @c man end
|
|
|
52 @c man begin AUTHOR
|
|
|
53 See the Info entry for @command{gfortran} for contributors to GCC and
|
|
|
54 GNU Fortran.
|
|
|
55 @c man end
|
|
|
56 @end ignore
|
|
|
57
|
|
|
58 @node Invoking GNU Fortran
|
|
|
59 @chapter GNU Fortran Command Options
|
|
|
60 @cindex GNU Fortran command options
|
|
|
61 @cindex command options
|
|
|
62 @cindex options, @command{gfortran} command
|
|
|
63
|
|
|
64 @c man begin DESCRIPTION
|
|
|
65
|
|
|
66 The @command{gfortran} command supports all the options supported by the
|
|
|
67 @command{gcc} command. Only options specific to GNU Fortran are documented
|
|
|
68 here.
|
|
|
69
|
|
|
70 @xref{Invoking GCC,,GCC Command Options,gcc,Using the GNU Compiler
|
|
|
71 Collection (GCC)}, for information
|
|
|
72 on the non-Fortran-specific aspects of the @command{gcc} command (and,
|
|
|
73 therefore, the @command{gfortran} command).
|
|
|
74
|
|
|
75 @cindex options, negative forms
|
|
|
76 All GCC and GNU Fortran options
|
|
|
77 are accepted both by @command{gfortran} and by @command{gcc}
|
|
|
78 (as well as any other drivers built at the same time,
|
|
|
79 such as @command{g++}),
|
|
|
80 since adding GNU Fortran to the GCC distribution
|
|
|
81 enables acceptance of GNU Fortran options
|
|
|
82 by all of the relevant drivers.
|
|
|
83
|
|
|
84 In some cases, options have positive and negative forms;
|
|
|
85 the negative form of @option{-ffoo} would be @option{-fno-foo}.
|
|
|
86 This manual documents only one of these two forms, whichever
|
|
|
87 one is not the default.
|
|
|
88 @c man end
|
|
|
89
|
|
|
90 @menu
|
|
|
91 * Option Summary:: Brief list of all @command{gfortran} options,
|
|
|
92 without explanations.
|
|
|
93 * Fortran Dialect Options:: Controlling the variant of Fortran language
|
|
|
94 compiled.
|
|
|
95 * Preprocessing Options:: Enable and customize preprocessing.
|
|
|
96 * Error and Warning Options:: How picky should the compiler be?
|
|
|
97 * Debugging Options:: Symbol tables, measurements, and debugging dumps.
|
|
|
98 * Directory Options:: Where to find module files
|
|
|
99 * Link Options :: Influencing the linking step
|
|
|
100 * Runtime Options:: Influencing runtime behavior
|
|
|
101 * Code Gen Options:: Specifying conventions for function calls, data layout
|
|
|
102 and register usage.
|
|
|
103 * Interoperability Options:: Options for interoperability with other
|
|
|
104 languages.
|
|
|
105 * Environment Variables:: Environment variables that affect @command{gfortran}.
|
|
|
106 @end menu
|
|
|
107
|
|
|
108 @node Option Summary
|
|
|
109 @section Option summary
|
|
|
110
|
|
|
111 @c man begin OPTIONS
|
|
|
112
|
|
|
113 Here is a summary of all the options specific to GNU Fortran, grouped
|
|
|
114 by type. Explanations are in the following sections.
|
|
|
115
|
|
|
116 @table @emph
|
|
|
117 @item Fortran Language Options
|
|
|
118 @xref{Fortran Dialect Options,,Options controlling Fortran dialect}.
|
|
145
|
119 @gccoptlist{-fall-intrinsics -fallow-argument-mismatch -fallow-invalid-boz @gol
|
|
|
120 -fbackslash -fcray-pointer -fd-lines-as-code -fd-lines-as-comments @gol
|
|
|
121 -fdec -fdec-char-conversions -fdec-structure -fdec-intrinsic-ints @gol
|
|
|
122 -fdec-static -fdec-math -fdec-include -fdec-format-defaults @gol
|
|
|
123 -fdec-blank-format-item -fdefault-double-8 -fdefault-integer-8 @gol
|
|
|
124 -fdefault-real-8 -fdefault-real-10 -fdefault-real-16 -fdollar-ok @gol
|
|
|
125 -ffixed-line-length-@var{n} -ffixed-line-length-none -fpad-source @gol
|
|
|
126 -ffree-form -ffree-line-length-@var{n} -ffree-line-length-none @gol
|
|
|
127 -fimplicit-none -finteger-4-integer-8 -fmax-identifier-length @gol
|
|
|
128 -fmodule-private -ffixed-form -fno-range-check -fopenacc -fopenmp @gol
|
|
|
129 -freal-4-real-10 -freal-4-real-16 -freal-4-real-8 -freal-8-real-10 @gol
|
|
|
130 -freal-8-real-16 -freal-8-real-4 -std=@var{std} -ftest-forall-temp
|
|
111
|
131 }
|
|
|
132
|
|
|
133 @item Preprocessing Options
|
|
|
134 @xref{Preprocessing Options,,Enable and customize preprocessing}.
|
|
|
135 @gccoptlist{-A-@var{question}@r{[}=@var{answer}@r{]}
|
|
|
136 -A@var{question}=@var{answer} -C -CC -D@var{macro}@r{[}=@var{defn}@r{]}
|
|
|
137 -H -P @gol
|
|
|
138 -U@var{macro} -cpp -dD -dI -dM -dN -dU -fworking-directory
|
|
|
139 -imultilib @var{dir} @gol
|
|
|
140 -iprefix @var{file} -iquote -isysroot @var{dir} -isystem @var{dir} -nocpp
|
|
|
141 -nostdinc @gol
|
|
|
142 -undef
|
|
|
143 }
|
|
|
144
|
|
|
145 @item Error and Warning Options
|
|
|
146 @xref{Error and Warning Options,,Options to request or suppress errors
|
|
|
147 and warnings}.
|
|
145
|
148 @gccoptlist{-Waliasing -Wall -Wampersand -Warray-bounds @gol
|
|
111
|
149 -Wc-binding-type -Wcharacter-truncation -Wconversion @gol
|
|
|
150 -Wdo-subscript -Wfunction-elimination -Wimplicit-interface @gol
|
|
145
|
151 -Wimplicit-procedure -Wintrinsic-shadow -Wuse-without-only @gol
|
|
|
152 -Wintrinsics-std -Wline-truncation -Wno-align-commons @gol
|
|
|
153 -Wno-overwrite-recursive -Wno-tabs -Wreal-q-constant -Wsurprising @gol
|
|
|
154 -Wunderflow -Wunused-parameter -Wrealloc-lhs -Wrealloc-lhs-all @gol
|
|
|
155 -Wfrontend-loop-interchange -Wtarget-lifetime -fmax-errors=@var{n} @gol
|
|
|
156 -fsyntax-only -pedantic @gol
|
|
|
157 -pedantic-errors @gol
|
|
111
|
158 }
|
|
|
159
|
|
|
160 @item Debugging Options
|
|
|
161 @xref{Debugging Options,,Options for debugging your program or GNU Fortran}.
|
|
|
162 @gccoptlist{-fbacktrace -fdump-fortran-optimized -fdump-fortran-original @gol
|
|
145
|
163 -fdump-fortran-global -fdump-parse-tree -ffpe-trap=@var{list} @gol
|
|
|
164 -ffpe-summary=@var{list}
|
|
111
|
165 }
|
|
|
166
|
|
|
167 @item Directory Options
|
|
|
168 @xref{Directory Options,,Options for directory search}.
|
|
|
169 @gccoptlist{-I@var{dir} -J@var{dir} -fintrinsic-modules-path @var{dir}}
|
|
|
170
|
|
|
171 @item Link Options
|
|
|
172 @xref{Link Options,,Options for influencing the linking step}.
|
|
|
173 @gccoptlist{-static-libgfortran}
|
|
|
174
|
|
|
175 @item Runtime Options
|
|
|
176 @xref{Runtime Options,,Options for influencing runtime behavior}.
|
|
|
177 @gccoptlist{-fconvert=@var{conversion} -fmax-subrecord-length=@var{length} @gol
|
|
|
178 -frecord-marker=@var{length} -fsign-zero
|
|
|
179 }
|
|
|
180
|
|
|
181 @item Interoperability Options
|
|
|
182 @xref{Interoperability Options,,Options for interoperability}.
|
|
145
|
183 @gccoptlist{-fc-prototypes -fc-prototypes-external}
|
|
111
|
184
|
|
|
185 @item Code Generation Options
|
|
|
186 @xref{Code Gen Options,,Options for code generation conventions}.
|
|
|
187 @gccoptlist{-faggressive-function-elimination -fblas-matmul-limit=@var{n} @gol
|
|
145
|
188 -fbounds-check -ftail-call-workaround -ftail-call-workaround=@var{n} @gol
|
|
|
189 -fcheck-array-temporaries @gol
|
|
|
190 -fcheck=@var{<all|array-temps|bits|bounds|do|mem|pointer|recursion>} @gol
|
|
|
191 -fcoarray=@var{<none|single|lib>} -fexternal-blas -ff2c @gol
|
|
|
192 -ffrontend-loop-interchange -ffrontend-optimize @gol
|
|
111
|
193 -finit-character=@var{n} -finit-integer=@var{n} -finit-local-zero @gol
|
|
145
|
194 -finit-derived -finit-logical=@var{<true|false>} @gol
|
|
|
195 -finit-real=@var{<zero|inf|-inf|nan|snan>}
|
|
111
|
196 -finline-matmul-limit=@var{n} @gol
|
|
145
|
197 -finline-arg-packing -fmax-array-constructor=@var{n} @gol
|
|
|
198 -fmax-stack-var-size=@var{n} -fno-align-commons -fno-automatic @gol
|
|
|
199 -fno-protect-parens -fno-underscoring -fsecond-underscore @gol
|
|
|
200 -fpack-derived -frealloc-lhs -frecursive -frepack-arrays @gol
|
|
|
201 -fshort-enums -fstack-arrays
|
|
111
|
202 }
|
|
|
203 @end table
|
|
|
204
|
|
|
205 @node Fortran Dialect Options
|
|
|
206 @section Options controlling Fortran dialect
|
|
|
207 @cindex dialect options
|
|
|
208 @cindex language, dialect options
|
|
|
209 @cindex options, dialect
|
|
|
210
|
|
|
211 The following options control the details of the Fortran dialect
|
|
|
212 accepted by the compiler:
|
|
|
213
|
|
|
214 @table @gcctabopt
|
|
|
215 @item -ffree-form
|
|
|
216 @itemx -ffixed-form
|
|
|
217 @opindex @code{ffree-form}
|
|
|
218 @opindex @code{ffixed-form}
|
|
|
219 @cindex options, Fortran dialect
|
|
|
220 @cindex file format, free
|
|
|
221 @cindex file format, fixed
|
|
|
222 Specify the layout used by the source file. The free form layout
|
|
|
223 was introduced in Fortran 90. Fixed form was traditionally used in
|
|
|
224 older Fortran programs. When neither option is specified, the source
|
|
|
225 form is determined by the file extension.
|
|
|
226
|
|
|
227 @item -fall-intrinsics
|
|
|
228 @opindex @code{fall-intrinsics}
|
|
|
229 This option causes all intrinsic procedures (including the GNU-specific
|
|
|
230 extensions) to be accepted. This can be useful with @option{-std=f95} to
|
|
|
231 force standard-compliance but get access to the full range of intrinsics
|
|
|
232 available with @command{gfortran}. As a consequence, @option{-Wintrinsics-std}
|
|
|
233 will be ignored and no user-defined procedure with the same name as any
|
|
|
234 intrinsic will be called except when it is explicitly declared @code{EXTERNAL}.
|
|
|
235
|
|
145
|
236 @item -fallow-argument-mismatch
|
|
|
237 @opindex @code{fallow-argument-mismatch}
|
|
|
238 Some code contains calls to external procedures whith mismatches
|
|
|
239 between the calls and the procedure definition, or with mismatches
|
|
|
240 between different calls. Such code is non-conforming, and will usually
|
|
|
241 be flagged wi1th an error. This options degrades the error to a
|
|
|
242 warning, which can only be disabled by disabling all warnings vial
|
|
|
243 @option{-w}. Only a single occurrence per argument is flagged by this
|
|
|
244 warning. @option{-fallow-argument-mismatch} is implied by
|
|
|
245 @option{-std=legacy}.
|
|
|
246
|
|
|
247 Using this option is @emph{strongly} discouraged. It is possible to
|
|
|
248 provide standard-conforming code which allows different types of
|
|
|
249 arguments by using an explicit interface and @code{TYPE(*)}.
|
|
|
250
|
|
|
251 @item -fallow-invalid-boz
|
|
|
252 @opindex @code{allow-invalid-boz}
|
|
|
253 A BOZ literal constant can occur in a limited number of contexts in
|
|
|
254 standard conforming Fortran. This option degrades an error condition
|
|
|
255 to a warning, and allows a BOZ literal constant to appear where the
|
|
|
256 Fortran standard would otherwise prohibit its use.
|
|
|
257
|
|
111
|
258 @item -fd-lines-as-code
|
|
|
259 @itemx -fd-lines-as-comments
|
|
|
260 @opindex @code{fd-lines-as-code}
|
|
|
261 @opindex @code{fd-lines-as-comments}
|
|
|
262 Enable special treatment for lines beginning with @code{d} or @code{D}
|
|
|
263 in fixed form sources. If the @option{-fd-lines-as-code} option is
|
|
|
264 given they are treated as if the first column contained a blank. If the
|
|
|
265 @option{-fd-lines-as-comments} option is given, they are treated as
|
|
|
266 comment lines.
|
|
|
267
|
|
|
268 @item -fdec
|
|
|
269 @opindex @code{fdec}
|
|
|
270 DEC compatibility mode. Enables extensions and other features that mimic
|
|
|
271 the default behavior of older compilers (such as DEC).
|
|
|
272 These features are non-standard and should be avoided at all costs.
|
|
|
273 For details on GNU Fortran's implementation of these extensions see the
|
|
|
274 full documentation.
|
|
|
275
|
|
|
276 Other flags enabled by this switch are:
|
|
145
|
277 @option{-fdollar-ok} @option{-fcray-pointer} @option{-fdec-char-conversions}
|
|
|
278 @option{-fdec-structure} @option{-fdec-intrinsic-ints} @option{-fdec-static}
|
|
|
279 @option{-fdec-math} @option{-fdec-include} @option{-fdec-blank-format-item}
|
|
|
280 @option{-fdec-format-defaults}
|
|
111
|
281
|
|
|
282 If @option{-fd-lines-as-code}/@option{-fd-lines-as-comments} are unset, then
|
|
|
283 @option{-fdec} also sets @option{-fd-lines-as-comments}.
|
|
|
284
|
|
145
|
285 @item -fdec-char-conversions
|
|
|
286 @opindex @code{fdec-char-conversions}
|
|
|
287 Enable the use of character literals in assignments and @code{DATA} statements
|
|
|
288 for non-character variables.
|
|
|
289
|
|
111
|
290 @item -fdec-structure
|
|
|
291 @opindex @code{fdec-structure}
|
|
|
292 Enable DEC @code{STRUCTURE} and @code{RECORD} as well as @code{UNION},
|
|
|
293 @code{MAP}, and dot ('.') as a member separator (in addition to '%'). This is
|
|
|
294 provided for compatibility only; Fortran 90 derived types should be used
|
|
|
295 instead where possible.
|
|
|
296
|
|
|
297 @item -fdec-intrinsic-ints
|
|
|
298 @opindex @code{fdec-intrinsic-ints}
|
|
|
299 Enable B/I/J/K kind variants of existing integer functions (e.g. BIAND, IIAND,
|
|
|
300 JIAND, etc...). For a complete list of intrinsics see the full documentation.
|
|
|
301
|
|
|
302 @item -fdec-math
|
|
|
303 @opindex @code{fdec-math}
|
|
|
304 Enable legacy math intrinsics such as COTAN and degree-valued trigonometric
|
|
|
305 functions (e.g. TAND, ATAND, etc...) for compatability with older code.
|
|
|
306
|
|
|
307 @item -fdec-static
|
|
|
308 @opindex @code{fdec-static}
|
|
|
309 Enable DEC-style STATIC and AUTOMATIC attributes to explicitly specify
|
|
|
310 the storage of variables and other objects.
|
|
|
311
|
|
145
|
312 @item -fdec-include
|
|
|
313 @opindex @code{fdec-include}
|
|
|
314 Enable parsing of INCLUDE as a statement in addition to parsing it as
|
|
|
315 INCLUDE line. When parsed as INCLUDE statement, INCLUDE does not have to
|
|
|
316 be on a single line and can use line continuations.
|
|
|
317
|
|
|
318 @item -fdec-format-defaults
|
|
|
319 @opindex @code{fdec-format-defaults}
|
|
|
320 Enable format specifiers F, G and I to be used without width specifiers,
|
|
|
321 default widths will be used instead.
|
|
|
322
|
|
|
323 @item -fdec-blank-format-item
|
|
|
324 @opindex @code{fdec-blank-format-item}
|
|
|
325 Enable a blank format item at the end of a format specification i.e. nothing
|
|
|
326 following the final comma.
|
|
|
327
|
|
111
|
328 @item -fdollar-ok
|
|
|
329 @opindex @code{fdollar-ok}
|
|
|
330 @cindex @code{$}
|
|
|
331 @cindex symbol names
|
|
|
332 @cindex character set
|
|
|
333 Allow @samp{$} as a valid non-first character in a symbol name. Symbols
|
|
|
334 that start with @samp{$} are rejected since it is unclear which rules to
|
|
|
335 apply to implicit typing as different vendors implement different rules.
|
|
|
336 Using @samp{$} in @code{IMPLICIT} statements is also rejected.
|
|
|
337
|
|
|
338 @item -fbackslash
|
|
|
339 @opindex @code{backslash}
|
|
|
340 @cindex backslash
|
|
|
341 @cindex escape characters
|
|
|
342 Change the interpretation of backslashes in string literals from a single
|
|
|
343 backslash character to ``C-style'' escape characters. The following
|
|
|
344 combinations are expanded @code{\a}, @code{\b}, @code{\f}, @code{\n},
|
|
|
345 @code{\r}, @code{\t}, @code{\v}, @code{\\}, and @code{\0} to the ASCII
|
|
|
346 characters alert, backspace, form feed, newline, carriage return,
|
|
|
347 horizontal tab, vertical tab, backslash, and NUL, respectively.
|
|
|
348 Additionally, @code{\x}@var{nn}, @code{\u}@var{nnnn} and
|
|
|
349 @code{\U}@var{nnnnnnnn} (where each @var{n} is a hexadecimal digit) are
|
|
|
350 translated into the Unicode characters corresponding to the specified code
|
|
|
351 points. All other combinations of a character preceded by \ are
|
|
|
352 unexpanded.
|
|
|
353
|
|
|
354 @item -fmodule-private
|
|
|
355 @opindex @code{fmodule-private}
|
|
|
356 @cindex module entities
|
|
|
357 @cindex private
|
|
|
358 Set the default accessibility of module entities to @code{PRIVATE}.
|
|
|
359 Use-associated entities will not be accessible unless they are explicitly
|
|
|
360 declared as @code{PUBLIC}.
|
|
|
361
|
|
|
362 @item -ffixed-line-length-@var{n}
|
|
|
363 @opindex @code{ffixed-line-length-}@var{n}
|
|
|
364 @cindex file format, fixed
|
|
|
365 Set column after which characters are ignored in typical fixed-form
|
|
145
|
366 lines in the source file, and, unless @code{-fno-pad-source}, through which
|
|
|
367 spaces are assumed (as if padded to that length) after the ends of short
|
|
|
368 fixed-form lines.
|
|
111
|
369
|
|
|
370 Popular values for @var{n} include 72 (the
|
|
|
371 standard and the default), 80 (card image), and 132 (corresponding
|
|
|
372 to ``extended-source'' options in some popular compilers).
|
|
|
373 @var{n} may also be @samp{none}, meaning that the entire line is meaningful
|
|
|
374 and that continued character constants never have implicit spaces appended
|
|
|
375 to them to fill out the line.
|
|
|
376 @option{-ffixed-line-length-0} means the same thing as
|
|
|
377 @option{-ffixed-line-length-none}.
|
|
|
378
|
|
145
|
379 @item -fno-pad-source
|
|
|
380 @opindex @code{fpad-source}
|
|
|
381 By default fixed-form lines have spaces assumed (as if padded to that length)
|
|
|
382 after the ends of short fixed-form lines. This is not done either if
|
|
|
383 @option{-ffixed-line-length-0}, @option{-ffixed-line-length-none} or
|
|
|
384 if @option{-fno-pad-source} option is used. With any of those options
|
|
|
385 continued character constants never have implicit spaces appended
|
|
|
386 to them to fill out the line.
|
|
|
387
|
|
111
|
388 @item -ffree-line-length-@var{n}
|
|
|
389 @opindex @code{ffree-line-length-}@var{n}
|
|
|
390 @cindex file format, free
|
|
|
391 Set column after which characters are ignored in typical free-form
|
|
|
392 lines in the source file. The default value is 132.
|
|
|
393 @var{n} may be @samp{none}, meaning that the entire line is meaningful.
|
|
|
394 @option{-ffree-line-length-0} means the same thing as
|
|
|
395 @option{-ffree-line-length-none}.
|
|
|
396
|
|
|
397 @item -fmax-identifier-length=@var{n}
|
|
|
398 @opindex @code{fmax-identifier-length=}@var{n}
|
|
|
399 Specify the maximum allowed identifier length. Typical values are
|
|
|
400 31 (Fortran 95) and 63 (Fortran 2003 and Fortran 2008).
|
|
|
401
|
|
|
402 @item -fimplicit-none
|
|
|
403 @opindex @code{fimplicit-none}
|
|
|
404 Specify that no implicit typing is allowed, unless overridden by explicit
|
|
|
405 @code{IMPLICIT} statements. This is the equivalent of adding
|
|
|
406 @code{implicit none} to the start of every procedure.
|
|
|
407
|
|
|
408 @item -fcray-pointer
|
|
|
409 @opindex @code{fcray-pointer}
|
|
|
410 Enable the Cray pointer extension, which provides C-like pointer
|
|
|
411 functionality.
|
|
|
412
|
|
|
413 @item -fopenacc
|
|
|
414 @opindex @code{fopenacc}
|
|
|
415 @cindex OpenACC
|
|
|
416 Enable the OpenACC extensions. This includes OpenACC @code{!$acc}
|
|
|
417 directives in free form and @code{c$acc}, @code{*$acc} and
|
|
|
418 @code{!$acc} directives in fixed form, @code{!$} conditional
|
|
|
419 compilation sentinels in free form and @code{c$}, @code{*$} and
|
|
|
420 @code{!$} sentinels in fixed form, and when linking arranges for the
|
|
|
421 OpenACC runtime library to be linked in.
|
|
|
422
|
|
|
423 @item -fopenmp
|
|
|
424 @opindex @code{fopenmp}
|
|
|
425 @cindex OpenMP
|
|
|
426 Enable the OpenMP extensions. This includes OpenMP @code{!$omp} directives
|
|
|
427 in free form
|
|
|
428 and @code{c$omp}, @code{*$omp} and @code{!$omp} directives in fixed form,
|
|
|
429 @code{!$} conditional compilation sentinels in free form
|
|
|
430 and @code{c$}, @code{*$} and @code{!$} sentinels in fixed form,
|
|
|
431 and when linking arranges for the OpenMP runtime library to be linked
|
|
|
432 in. The option @option{-fopenmp} implies @option{-frecursive}.
|
|
|
433
|
|
|
434 @item -fno-range-check
|
|
|
435 @opindex @code{frange-check}
|
|
|
436 Disable range checking on results of simplification of constant
|
|
|
437 expressions during compilation. For example, GNU Fortran will give
|
|
|
438 an error at compile time when simplifying @code{a = 1. / 0}.
|
|
|
439 With this option, no error will be given and @code{a} will be assigned
|
|
|
440 the value @code{+Infinity}. If an expression evaluates to a value
|
|
|
441 outside of the relevant range of [@code{-HUGE()}:@code{HUGE()}],
|
|
|
442 then the expression will be replaced by @code{-Inf} or @code{+Inf}
|
|
|
443 as appropriate.
|
|
|
444 Similarly, @code{DATA i/Z'FFFFFFFF'/} will result in an integer overflow
|
|
|
445 on most systems, but with @option{-fno-range-check} the value will
|
|
|
446 ``wrap around'' and @code{i} will be initialized to @math{-1} instead.
|
|
|
447
|
|
|
448 @item -fdefault-integer-8
|
|
|
449 @opindex @code{fdefault-integer-8}
|
|
|
450 Set the default integer and logical types to an 8 byte wide type. This option
|
|
|
451 also affects the kind of integer constants like @code{42}. Unlike
|
|
|
452 @option{-finteger-4-integer-8}, it does not promote variables with explicit
|
|
|
453 kind declaration.
|
|
|
454
|
|
|
455 @item -fdefault-real-8
|
|
|
456 @opindex @code{fdefault-real-8}
|
|
145
|
457 Set the default real type to an 8 byte wide type. This option also affects
|
|
|
458 the kind of non-double real constants like @code{1.0}. This option promotes
|
|
|
459 the default width of @code{DOUBLE PRECISION} and double real constants
|
|
|
460 like @code{1.d0} to 16 bytes if possible. If @code{-fdefault-double-8}
|
|
|
461 is given along with @code{fdefault-real-8}, @code{DOUBLE PRECISION}
|
|
|
462 and double real constants are not promoted. Unlike @option{-freal-4-real-8},
|
|
|
463 @code{fdefault-real-8} does not promote variables with explicit kind
|
|
|
464 declarations.
|
|
111
|
465
|
|
|
466 @item -fdefault-real-10
|
|
|
467 @opindex @code{fdefault-real-10}
|
|
145
|
468 Set the default real type to an 10 byte wide type. This option also affects
|
|
|
469 the kind of non-double real constants like @code{1.0}. This option promotes
|
|
|
470 the default width of @code{DOUBLE PRECISION} and double real constants
|
|
|
471 like @code{1.d0} to 16 bytes if possible. If @code{-fdefault-double-8}
|
|
|
472 is given along with @code{fdefault-real-10}, @code{DOUBLE PRECISION}
|
|
|
473 and double real constants are not promoted. Unlike @option{-freal-4-real-10},
|
|
|
474 @code{fdefault-real-10} does not promote variables with explicit kind
|
|
|
475 declarations.
|
|
111
|
476
|
|
|
477 @item -fdefault-real-16
|
|
|
478 @opindex @code{fdefault-real-16}
|
|
145
|
479 Set the default real type to an 16 byte wide type. This option also affects
|
|
|
480 the kind of non-double real constants like @code{1.0}. This option promotes
|
|
|
481 the default width of @code{DOUBLE PRECISION} and double real constants
|
|
|
482 like @code{1.d0} to 16 bytes if possible. If @code{-fdefault-double-8}
|
|
|
483 is given along with @code{fdefault-real-16}, @code{DOUBLE PRECISION}
|
|
|
484 and double real constants are not promoted. Unlike @option{-freal-4-real-16},
|
|
|
485 @code{fdefault-real-16} does not promote variables with explicit kind
|
|
|
486 declarations.
|
|
111
|
487
|
|
|
488 @item -fdefault-double-8
|
|
|
489 @opindex @code{fdefault-double-8}
|
|
145
|
490 Set the @code{DOUBLE PRECISION} type and double real constants
|
|
|
491 like @code{1.d0} to an 8 byte wide type. Do nothing if this
|
|
|
492 is already the default. This option prevents @option{-fdefault-real-8},
|
|
|
493 @option{-fdefault-real-10}, and @option{-fdefault-real-16},
|
|
|
494 from promoting @code{DOUBLE PRECISION} and double real constants like
|
|
|
495 @code{1.d0} to 16 bytes.
|
|
111
|
496
|
|
|
497 @item -finteger-4-integer-8
|
|
|
498 @opindex @code{finteger-4-integer-8}
|
|
|
499 Promote all @code{INTEGER(KIND=4)} entities to an @code{INTEGER(KIND=8)}
|
|
|
500 entities. If @code{KIND=8} is unavailable, then an error will be issued.
|
|
|
501 This option should be used with care and may not be suitable for your codes.
|
|
|
502 Areas of possible concern include calls to external procedures,
|
|
|
503 alignment in @code{EQUIVALENCE} and/or @code{COMMON}, generic interfaces,
|
|
|
504 BOZ literal constant conversion, and I/O. Inspection of the intermediate
|
|
|
505 representation of the translated Fortran code, produced by
|
|
|
506 @option{-fdump-tree-original}, is suggested.
|
|
|
507
|
|
|
508 @item -freal-4-real-8
|
|
|
509 @itemx -freal-4-real-10
|
|
|
510 @itemx -freal-4-real-16
|
|
|
511 @itemx -freal-8-real-4
|
|
|
512 @itemx -freal-8-real-10
|
|
|
513 @itemx -freal-8-real-16
|
|
|
514 @opindex @code{freal-4-real-8}
|
|
|
515 @opindex @code{freal-4-real-10}
|
|
|
516 @opindex @code{freal-4-real-16}
|
|
|
517 @opindex @code{freal-8-real-4}
|
|
|
518 @opindex @code{freal-8-real-10}
|
|
|
519 @opindex @code{freal-8-real-16}
|
|
|
520 @cindex options, real kind type promotion
|
|
|
521 Promote all @code{REAL(KIND=M)} entities to @code{REAL(KIND=N)} entities.
|
|
|
522 If @code{REAL(KIND=N)} is unavailable, then an error will be issued.
|
|
|
523 All other real kind types are unaffected by this option.
|
|
|
524 These options should be used with care and may not be suitable for your
|
|
|
525 codes. Areas of possible concern include calls to external procedures,
|
|
|
526 alignment in @code{EQUIVALENCE} and/or @code{COMMON}, generic interfaces,
|
|
|
527 BOZ literal constant conversion, and I/O. Inspection of the intermediate
|
|
|
528 representation of the translated Fortran code, produced by
|
|
|
529 @option{-fdump-tree-original}, is suggested.
|
|
|
530
|
|
|
531 @item -std=@var{std}
|
|
|
532 @opindex @code{std=}@var{std} option
|
|
131
|
533 Specify the standard to which the program is expected to conform,
|
|
|
534 which may be one of @samp{f95}, @samp{f2003}, @samp{f2008},
|
|
|
535 @samp{f2018}, @samp{gnu}, or @samp{legacy}. The default value for
|
|
|
536 @var{std} is @samp{gnu}, which specifies a superset of the latest
|
|
|
537 Fortran standard that includes all of the extensions supported by GNU
|
|
|
538 Fortran, although warnings will be given for obsolete extensions not
|
|
|
539 recommended for use in new code. The @samp{legacy} value is
|
|
|
540 equivalent but without the warnings for obsolete extensions, and may
|
|
|
541 be useful for old non-standard programs. The @samp{f95},
|
|
|
542 @samp{f2003}, @samp{f2008}, and @samp{f2018} values specify strict
|
|
|
543 conformance to the Fortran 95, Fortran 2003, Fortran 2008 and Fortran
|
|
|
544 2018 standards, respectively; errors are given for all extensions
|
|
|
545 beyond the relevant language standard, and warnings are given for the
|
|
|
546 Fortran 77 features that are permitted but obsolescent in later
|
|
|
547 standards. The deprecated option @samp{-std=f2008ts} acts as an alias for
|
|
|
548 @samp{-std=f2018}. It is only present for backwards compatibility with
|
|
|
549 earlier gfortran versions and should not be used any more.
|
|
111
|
550
|
|
|
551 @item -ftest-forall-temp
|
|
|
552 @opindex @code{ftest-forall-temp}
|
|
|
553 Enhance test coverage by forcing most forall assignments to use temporary.
|
|
|
554
|
|
|
555 @end table
|
|
|
556
|
|
|
557 @node Preprocessing Options
|
|
|
558 @section Enable and customize preprocessing
|
|
|
559 @cindex preprocessor
|
|
|
560 @cindex options, preprocessor
|
|
|
561 @cindex CPP
|
|
|
562
|
|
|
563 Preprocessor related options. See section
|
|
|
564 @ref{Preprocessing and conditional compilation} for more detailed
|
|
|
565 information on preprocessing in @command{gfortran}.
|
|
|
566
|
|
|
567 @table @gcctabopt
|
|
|
568 @item -cpp
|
|
|
569 @itemx -nocpp
|
|
|
570 @opindex @code{cpp}
|
|
|
571 @opindex @code{fpp}
|
|
|
572 @cindex preprocessor, enable
|
|
|
573 @cindex preprocessor, disable
|
|
|
574 Enable preprocessing. The preprocessor is automatically invoked if
|
|
|
575 the file extension is @file{.fpp}, @file{.FPP}, @file{.F}, @file{.FOR},
|
|
|
576 @file{.FTN}, @file{.F90}, @file{.F95}, @file{.F03} or @file{.F08}. Use
|
|
|
577 this option to manually enable preprocessing of any kind of Fortran file.
|
|
|
578
|
|
|
579 To disable preprocessing of files with any of the above listed extensions,
|
|
|
580 use the negative form: @option{-nocpp}.
|
|
|
581
|
|
|
582 The preprocessor is run in traditional mode. Any restrictions of the
|
|
|
583 file-format, especially the limits on line length, apply for
|
|
|
584 preprocessed output as well, so it might be advisable to use the
|
|
|
585 @option{-ffree-line-length-none} or @option{-ffixed-line-length-none}
|
|
|
586 options.
|
|
|
587
|
|
|
588 @item -dM
|
|
|
589 @opindex @code{dM}
|
|
|
590 @cindex preprocessor, debugging
|
|
|
591 @cindex debugging, preprocessor
|
|
|
592 Instead of the normal output, generate a list of @code{'#define'}
|
|
|
593 directives for all the macros defined during the execution of the
|
|
|
594 preprocessor, including predefined macros. This gives you a way
|
|
|
595 of finding out what is predefined in your version of the preprocessor.
|
|
|
596 Assuming you have no file @file{foo.f90}, the command
|
|
|
597 @smallexample
|
|
|
598 touch foo.f90; gfortran -cpp -E -dM foo.f90
|
|
|
599 @end smallexample
|
|
|
600 will show all the predefined macros.
|
|
|
601
|
|
|
602 @item -dD
|
|
|
603 @opindex @code{dD}
|
|
|
604 @cindex preprocessor, debugging
|
|
|
605 @cindex debugging, preprocessor
|
|
|
606 Like @option{-dM} except in two respects: it does not include the
|
|
|
607 predefined macros, and it outputs both the @code{#define} directives
|
|
|
608 and the result of preprocessing. Both kinds of output go to the
|
|
|
609 standard output file.
|
|
|
610
|
|
|
611 @item -dN
|
|
|
612 @opindex @code{dN}
|
|
|
613 @cindex preprocessor, debugging
|
|
|
614 @cindex debugging, preprocessor
|
|
|
615 Like @option{-dD}, but emit only the macro names, not their expansions.
|
|
|
616
|
|
|
617 @item -dU
|
|
|
618 @opindex @code{dU}
|
|
|
619 @cindex preprocessor, debugging
|
|
|
620 @cindex debugging, preprocessor
|
|
|
621 Like @option{dD} except that only macros that are expanded, or whose
|
|
|
622 definedness is tested in preprocessor directives, are output; the
|
|
|
623 output is delayed until the use or test of the macro; and @code{'#undef'}
|
|
|
624 directives are also output for macros tested but undefined at the time.
|
|
|
625
|
|
|
626 @item -dI
|
|
|
627 @opindex @code{dI}
|
|
|
628 @cindex preprocessor, debugging
|
|
|
629 @cindex debugging, preprocessor
|
|
|
630 Output @code{'#include'} directives in addition to the result
|
|
|
631 of preprocessing.
|
|
|
632
|
|
|
633 @item -fworking-directory
|
|
|
634 @opindex @code{fworking-directory}
|
|
|
635 @cindex preprocessor, working directory
|
|
|
636 Enable generation of linemarkers in the preprocessor output that will
|
|
|
637 let the compiler know the current working directory at the time of
|
|
|
638 preprocessing. When this option is enabled, the preprocessor will emit,
|
|
|
639 after the initial linemarker, a second linemarker with the current
|
|
|
640 working directory followed by two slashes. GCC will use this directory,
|
|
|
641 when it is present in the preprocessed input, as the directory emitted
|
|
|
642 as the current working directory in some debugging information formats.
|
|
|
643 This option is implicitly enabled if debugging information is enabled,
|
|
|
644 but this can be inhibited with the negated form
|
|
|
645 @option{-fno-working-directory}. If the @option{-P} flag is present
|
|
|
646 in the command line, this option has no effect, since no @code{#line}
|
|
|
647 directives are emitted whatsoever.
|
|
|
648
|
|
|
649 @item -idirafter @var{dir}
|
|
|
650 @opindex @code{idirafter @var{dir}}
|
|
|
651 @cindex preprocessing, include path
|
|
|
652 Search @var{dir} for include files, but do it after all directories
|
|
|
653 specified with @option{-I} and the standard system directories have
|
|
|
654 been exhausted. @var{dir} is treated as a system include directory.
|
|
|
655 If dir begins with @code{=}, then the @code{=} will be replaced by
|
|
|
656 the sysroot prefix; see @option{--sysroot} and @option{-isysroot}.
|
|
|
657
|
|
|
658 @item -imultilib @var{dir}
|
|
|
659 @opindex @code{imultilib @var{dir}}
|
|
|
660 @cindex preprocessing, include path
|
|
|
661 Use @var{dir} as a subdirectory of the directory containing target-specific
|
|
|
662 C++ headers.
|
|
|
663
|
|
|
664 @item -iprefix @var{prefix}
|
|
|
665 @opindex @code{iprefix @var{prefix}}
|
|
|
666 @cindex preprocessing, include path
|
|
|
667 Specify @var{prefix} as the prefix for subsequent @option{-iwithprefix}
|
|
|
668 options. If the @var{prefix} represents a directory, you should include
|
|
|
669 the final @code{'/'}.
|
|
|
670
|
|
|
671 @item -isysroot @var{dir}
|
|
|
672 @opindex @code{isysroot @var{dir}}
|
|
|
673 @cindex preprocessing, include path
|
|
|
674 This option is like the @option{--sysroot} option, but applies only to
|
|
|
675 header files. See the @option{--sysroot} option for more information.
|
|
|
676
|
|
|
677 @item -iquote @var{dir}
|
|
|
678 @opindex @code{iquote @var{dir}}
|
|
|
679 @cindex preprocessing, include path
|
|
|
680 Search @var{dir} only for header files requested with @code{#include "file"};
|
|
|
681 they are not searched for @code{#include <file>}, before all directories
|
|
|
682 specified by @option{-I} and before the standard system directories. If
|
|
|
683 @var{dir} begins with @code{=}, then the @code{=} will be replaced by the
|
|
|
684 sysroot prefix; see @option{--sysroot} and @option{-isysroot}.
|
|
|
685
|
|
|
686 @item -isystem @var{dir}
|
|
|
687 @opindex @code{isystem @var{dir}}
|
|
|
688 @cindex preprocessing, include path
|
|
|
689 Search @var{dir} for header files, after all directories specified by
|
|
|
690 @option{-I} but before the standard system directories. Mark it as a
|
|
|
691 system directory, so that it gets the same special treatment as is
|
|
|
692 applied to the standard system directories. If @var{dir} begins with
|
|
|
693 @code{=}, then the @code{=} will be replaced by the sysroot prefix;
|
|
|
694 see @option{--sysroot} and @option{-isysroot}.
|
|
|
695
|
|
|
696 @item -nostdinc
|
|
|
697 @opindex @code{nostdinc}
|
|
|
698 Do not search the standard system directories for header files. Only
|
|
|
699 the directories you have specified with @option{-I} options (and the
|
|
|
700 directory of the current file, if appropriate) are searched.
|
|
|
701
|
|
|
702 @item -undef
|
|
|
703 @opindex @code{undef}
|
|
|
704 Do not predefine any system-specific or GCC-specific macros.
|
|
|
705 The standard predefined macros remain defined.
|
|
|
706
|
|
|
707 @item -A@var{predicate}=@var{answer}
|
|
|
708 @opindex @code{A@var{predicate}=@var{answer}}
|
|
|
709 @cindex preprocessing, assertion
|
|
|
710 Make an assertion with the predicate @var{predicate} and answer @var{answer}.
|
|
|
711 This form is preferred to the older form -A predicate(answer), which is still
|
|
|
712 supported, because it does not use shell special characters.
|
|
|
713
|
|
|
714 @item -A-@var{predicate}=@var{answer}
|
|
|
715 @opindex @code{A-@var{predicate}=@var{answer}}
|
|
|
716 @cindex preprocessing, assertion
|
|
|
717 Cancel an assertion with the predicate @var{predicate} and answer @var{answer}.
|
|
|
718
|
|
|
719 @item -C
|
|
|
720 @opindex @code{C}
|
|
|
721 @cindex preprocessing, keep comments
|
|
|
722 Do not discard comments. All comments are passed through to the output
|
|
|
723 file, except for comments in processed directives, which are deleted
|
|
|
724 along with the directive.
|
|
|
725
|
|
|
726 You should be prepared for side effects when using @option{-C}; it causes
|
|
|
727 the preprocessor to treat comments as tokens in their own right. For example,
|
|
|
728 comments appearing at the start of what would be a directive line have the
|
|
|
729 effect of turning that line into an ordinary source line, since the first
|
|
|
730 token on the line is no longer a @code{'#'}.
|
|
|
731
|
|
|
732 Warning: this currently handles C-Style comments only. The preprocessor
|
|
|
733 does not yet recognize Fortran-style comments.
|
|
|
734
|
|
|
735 @item -CC
|
|
|
736 @opindex @code{CC}
|
|
|
737 @cindex preprocessing, keep comments
|
|
|
738 Do not discard comments, including during macro expansion. This is like
|
|
|
739 @option{-C}, except that comments contained within macros are also passed
|
|
|
740 through to the output file where the macro is expanded.
|
|
|
741
|
|
|
742 In addition to the side-effects of the @option{-C} option, the @option{-CC}
|
|
|
743 option causes all C++-style comments inside a macro to be converted to C-style
|
|
|
744 comments. This is to prevent later use of that macro from inadvertently
|
|
|
745 commenting out the remainder of the source line. The @option{-CC} option
|
|
|
746 is generally used to support lint comments.
|
|
|
747
|
|
|
748 Warning: this currently handles C- and C++-Style comments only. The
|
|
|
749 preprocessor does not yet recognize Fortran-style comments.
|
|
|
750
|
|
|
751 @item -D@var{name}
|
|
|
752 @opindex @code{D@var{name}}
|
|
|
753 @cindex preprocessing, define macros
|
|
|
754 Predefine name as a macro, with definition @code{1}.
|
|
|
755
|
|
|
756 @item -D@var{name}=@var{definition}
|
|
|
757 @opindex @code{D@var{name}=@var{definition}}
|
|
|
758 @cindex preprocessing, define macros
|
|
|
759 The contents of @var{definition} are tokenized and processed as if they
|
|
|
760 appeared during translation phase three in a @code{'#define'} directive.
|
|
|
761 In particular, the definition will be truncated by embedded newline
|
|
|
762 characters.
|
|
|
763
|
|
|
764 If you are invoking the preprocessor from a shell or shell-like program
|
|
|
765 you may need to use the shell's quoting syntax to protect characters such
|
|
|
766 as spaces that have a meaning in the shell syntax.
|
|
|
767
|
|
|
768 If you wish to define a function-like macro on the command line, write
|
|
|
769 its argument list with surrounding parentheses before the equals sign
|
|
|
770 (if any). Parentheses are meaningful to most shells, so you will need
|
|
|
771 to quote the option. With sh and csh, @code{-D'name(args...)=definition'}
|
|
|
772 works.
|
|
|
773
|
|
|
774 @option{-D} and @option{-U} options are processed in the order they are
|
|
|
775 given on the command line. All -imacros file and -include file options
|
|
|
776 are processed after all -D and -U options.
|
|
|
777
|
|
|
778 @item -H
|
|
|
779 @opindex @code{H}
|
|
|
780 Print the name of each header file used, in addition to other normal
|
|
|
781 activities. Each name is indented to show how deep in the @code{'#include'}
|
|
|
782 stack it is.
|
|
|
783
|
|
|
784 @item -P
|
|
|
785 @opindex @code{P}
|
|
|
786 @cindex preprocessing, no linemarkers
|
|
|
787 Inhibit generation of linemarkers in the output from the preprocessor.
|
|
|
788 This might be useful when running the preprocessor on something that
|
|
|
789 is not C code, and will be sent to a program which might be confused
|
|
|
790 by the linemarkers.
|
|
|
791
|
|
|
792 @item -U@var{name}
|
|
|
793 @opindex @code{U@var{name}}
|
|
|
794 @cindex preprocessing, undefine macros
|
|
|
795 Cancel any previous definition of @var{name}, either built in or provided
|
|
|
796 with a @option{-D} option.
|
|
|
797 @end table
|
|
|
798
|
|
|
799
|
|
|
800 @node Error and Warning Options
|
|
|
801 @section Options to request or suppress errors and warnings
|
|
|
802 @cindex options, warnings
|
|
|
803 @cindex options, errors
|
|
|
804 @cindex warnings, suppressing
|
|
|
805 @cindex messages, error
|
|
|
806 @cindex messages, warning
|
|
|
807 @cindex suppressing warnings
|
|
|
808
|
|
|
809 Errors are diagnostic messages that report that the GNU Fortran compiler
|
|
|
810 cannot compile the relevant piece of source code. The compiler will
|
|
|
811 continue to process the program in an attempt to report further errors
|
|
|
812 to aid in debugging, but will not produce any compiled output.
|
|
|
813
|
|
|
814 Warnings are diagnostic messages that report constructions which
|
|
|
815 are not inherently erroneous but which are risky or suggest there is
|
|
|
816 likely to be a bug in the program. Unless @option{-Werror} is specified,
|
|
|
817 they do not prevent compilation of the program.
|
|
|
818
|
|
|
819 You can request many specific warnings with options beginning @option{-W},
|
|
|
820 for example @option{-Wimplicit} to request warnings on implicit
|
|
|
821 declarations. Each of these specific warning options also has a
|
|
|
822 negative form beginning @option{-Wno-} to turn off warnings;
|
|
|
823 for example, @option{-Wno-implicit}. This manual lists only one of the
|
|
|
824 two forms, whichever is not the default.
|
|
|
825
|
|
|
826 These options control the amount and kinds of errors and warnings produced
|
|
|
827 by GNU Fortran:
|
|
|
828
|
|
|
829 @table @gcctabopt
|
|
|
830 @item -fmax-errors=@var{n}
|
|
|
831 @opindex @code{fmax-errors=}@var{n}
|
|
|
832 @cindex errors, limiting
|
|
|
833 Limits the maximum number of error messages to @var{n}, at which point
|
|
|
834 GNU Fortran bails out rather than attempting to continue processing the
|
|
|
835 source code. If @var{n} is 0, there is no limit on the number of error
|
|
|
836 messages produced.
|
|
|
837
|
|
|
838 @item -fsyntax-only
|
|
|
839 @opindex @code{fsyntax-only}
|
|
|
840 @cindex syntax checking
|
|
|
841 Check the code for syntax errors, but do not actually compile it. This
|
|
|
842 will generate module files for each module present in the code, but no
|
|
|
843 other output file.
|
|
|
844
|
|
|
845 @item -Wpedantic
|
|
|
846 @itemx -pedantic
|
|
|
847 @opindex @code{pedantic}
|
|
|
848 @opindex @code{Wpedantic}
|
|
131
|
849 Issue warnings for uses of extensions to Fortran.
|
|
111
|
850 @option{-pedantic} also applies to C-language constructs where they
|
|
|
851 occur in GNU Fortran source files, such as use of @samp{\e} in a
|
|
|
852 character constant within a directive like @code{#include}.
|
|
|
853
|
|
131
|
854 Valid Fortran programs should compile properly with or without
|
|
111
|
855 this option.
|
|
|
856 However, without this option, certain GNU extensions and traditional
|
|
|
857 Fortran features are supported as well.
|
|
|
858 With this option, many of them are rejected.
|
|
|
859
|
|
|
860 Some users try to use @option{-pedantic} to check programs for conformance.
|
|
|
861 They soon find that it does not do quite what they want---it finds some
|
|
|
862 nonstandard practices, but not all.
|
|
|
863 However, improvements to GNU Fortran in this area are welcome.
|
|
|
864
|
|
|
865 This should be used in conjunction with @option{-std=f95},
|
|
131
|
866 @option{-std=f2003}, @option{-std=f2008} or @option{-std=f2018}.
|
|
111
|
867
|
|
|
868 @item -pedantic-errors
|
|
|
869 @opindex @code{pedantic-errors}
|
|
|
870 Like @option{-pedantic}, except that errors are produced rather than
|
|
|
871 warnings.
|
|
|
872
|
|
|
873 @item -Wall
|
|
|
874 @opindex @code{Wall}
|
|
|
875 @cindex all warnings
|
|
|
876 @cindex warnings, all
|
|
|
877 Enables commonly used warning options pertaining to usage that
|
|
|
878 we recommend avoiding and that we believe are easy to avoid.
|
|
|
879 This currently includes @option{-Waliasing}, @option{-Wampersand},
|
|
|
880 @option{-Wconversion}, @option{-Wsurprising}, @option{-Wc-binding-type},
|
|
|
881 @option{-Wintrinsics-std}, @option{-Wtabs}, @option{-Wintrinsic-shadow},
|
|
|
882 @option{-Wline-truncation}, @option{-Wtarget-lifetime},
|
|
|
883 @option{-Winteger-division}, @option{-Wreal-q-constant}, @option{-Wunused}
|
|
|
884 and @option{-Wundefined-do-loop}.
|
|
|
885
|
|
|
886 @item -Waliasing
|
|
|
887 @opindex @code{Waliasing}
|
|
|
888 @cindex aliasing
|
|
|
889 @cindex warnings, aliasing
|
|
|
890 Warn about possible aliasing of dummy arguments. Specifically, it warns
|
|
|
891 if the same actual argument is associated with a dummy argument with
|
|
|
892 @code{INTENT(IN)} and a dummy argument with @code{INTENT(OUT)} in a call
|
|
|
893 with an explicit interface.
|
|
|
894
|
|
|
895 The following example will trigger the warning.
|
|
|
896 @smallexample
|
|
|
897 interface
|
|
|
898 subroutine bar(a,b)
|
|
|
899 integer, intent(in) :: a
|
|
|
900 integer, intent(out) :: b
|
|
|
901 end subroutine
|
|
|
902 end interface
|
|
|
903 integer :: a
|
|
|
904
|
|
|
905 call bar(a,a)
|
|
|
906 @end smallexample
|
|
|
907
|
|
|
908 @item -Wampersand
|
|
|
909 @opindex @code{Wampersand}
|
|
|
910 @cindex warnings, ampersand
|
|
|
911 @cindex @code{&}
|
|
131
|
912 Warn about missing ampersand in continued character constants. The
|
|
|
913 warning is given with @option{-Wampersand}, @option{-pedantic},
|
|
|
914 @option{-std=f95}, @option{-std=f2003}, @option{-std=f2008} and
|
|
|
915 @option{-std=f2018}. Note: With no ampersand given in a continued
|
|
|
916 character constant, GNU Fortran assumes continuation at the first
|
|
|
917 non-comment, non-whitespace character after the ampersand that
|
|
|
918 initiated the continuation.
|
|
111
|
919
|
|
|
920 @item -Warray-temporaries
|
|
|
921 @opindex @code{Warray-temporaries}
|
|
|
922 @cindex warnings, array temporaries
|
|
|
923 Warn about array temporaries generated by the compiler. The information
|
|
|
924 generated by this warning is sometimes useful in optimization, in order to
|
|
|
925 avoid such temporaries.
|
|
|
926
|
|
|
927 @item -Wc-binding-type
|
|
|
928 @opindex @code{Wc-binding-type}
|
|
|
929 @cindex warning, C binding type
|
|
|
930 Warn if the a variable might not be C interoperable. In particular, warn if
|
|
|
931 the variable has been declared using an intrinsic type with default kind
|
|
|
932 instead of using a kind parameter defined for C interoperability in the
|
|
|
933 intrinsic @code{ISO_C_Binding} module. This option is implied by
|
|
|
934 @option{-Wall}.
|
|
|
935
|
|
|
936 @item -Wcharacter-truncation
|
|
|
937 @opindex @code{Wcharacter-truncation}
|
|
|
938 @cindex warnings, character truncation
|
|
|
939 Warn when a character assignment will truncate the assigned string.
|
|
|
940
|
|
|
941 @item -Wline-truncation
|
|
|
942 @opindex @code{Wline-truncation}
|
|
|
943 @cindex warnings, line truncation
|
|
|
944 Warn when a source code line will be truncated. This option is
|
|
|
945 implied by @option{-Wall}. For free-form source code, the default is
|
|
|
946 @option{-Werror=line-truncation} such that truncations are reported as
|
|
|
947 error.
|
|
|
948
|
|
|
949 @item -Wconversion
|
|
|
950 @opindex @code{Wconversion}
|
|
|
951 @cindex warnings, conversion
|
|
|
952 @cindex conversion
|
|
|
953 Warn about implicit conversions that are likely to change the value of
|
|
|
954 the expression after conversion. Implied by @option{-Wall}.
|
|
|
955
|
|
|
956 @item -Wconversion-extra
|
|
|
957 @opindex @code{Wconversion-extra}
|
|
|
958 @cindex warnings, conversion
|
|
|
959 @cindex conversion
|
|
|
960 Warn about implicit conversions between different types and kinds. This
|
|
|
961 option does @emph{not} imply @option{-Wconversion}.
|
|
|
962
|
|
|
963 @item -Wextra
|
|
|
964 @opindex @code{Wextra}
|
|
|
965 @cindex extra warnings
|
|
|
966 @cindex warnings, extra
|
|
|
967 Enables some warning options for usages of language features which
|
|
|
968 may be problematic. This currently includes @option{-Wcompare-reals},
|
|
|
969 @option{-Wunused-parameter} and @option{-Wdo-subscript}.
|
|
|
970
|
|
131
|
971 @item -Wfrontend-loop-interchange
|
|
|
972 @opindex @code{Wfrontend-loop-interchange}
|
|
|
973 @cindex warnings, loop interchange
|
|
|
974 @cindex loop interchange, warning
|
|
145
|
975 Warn when using @option{-ffrontend-loop-interchange} for performing loop
|
|
|
976 interchanges.
|
|
131
|
977
|
|
111
|
978 @item -Wimplicit-interface
|
|
|
979 @opindex @code{Wimplicit-interface}
|
|
|
980 @cindex warnings, implicit interface
|
|
|
981 Warn if a procedure is called without an explicit interface.
|
|
|
982 Note this only checks that an explicit interface is present. It does not
|
|
|
983 check that the declared interfaces are consistent across program units.
|
|
|
984
|
|
|
985 @item -Wimplicit-procedure
|
|
|
986 @opindex @code{Wimplicit-procedure}
|
|
|
987 @cindex warnings, implicit procedure
|
|
|
988 Warn if a procedure is called that has neither an explicit interface
|
|
|
989 nor has been declared as @code{EXTERNAL}.
|
|
|
990
|
|
|
991 @item -Winteger-division
|
|
|
992 @opindex @code{Winteger-division}
|
|
|
993 @cindex warnings, integer division
|
|
|
994 @cindex warnings, division of integers
|
|
145
|
995 Warn if a constant integer division truncates its result.
|
|
111
|
996 As an example, 3/5 evaluates to 0.
|
|
|
997
|
|
|
998 @item -Wintrinsics-std
|
|
|
999 @opindex @code{Wintrinsics-std}
|
|
|
1000 @cindex warnings, non-standard intrinsics
|
|
|
1001 @cindex warnings, intrinsics of other standards
|
|
|
1002 Warn if @command{gfortran} finds a procedure named like an intrinsic not
|
|
|
1003 available in the currently selected standard (with @option{-std}) and treats
|
|
|
1004 it as @code{EXTERNAL} procedure because of this. @option{-fall-intrinsics} can
|
|
|
1005 be used to never trigger this behavior and always link to the intrinsic
|
|
|
1006 regardless of the selected standard.
|
|
|
1007
|
|
145
|
1008 @item -Wno-overwrite-recursive
|
|
|
1009 @opindex @code{Woverwrite-recursive}
|
|
|
1010 @cindex warnings, overwrite recursive
|
|
|
1011 Do not warn when @option{-fno-automatic} is used with @option{-frecursive}. Recursion
|
|
|
1012 will be broken if the relevant local variables do not have the attribute
|
|
|
1013 @code{AUTOMATIC} explicitly declared. This option can be used to suppress the warning
|
|
|
1014 when it is known that recursion is not broken. Useful for build environments that use
|
|
|
1015 @option{-Werror}.
|
|
|
1016
|
|
111
|
1017 @item -Wreal-q-constant
|
|
|
1018 @opindex @code{Wreal-q-constant}
|
|
|
1019 @cindex warnings, @code{q} exponent-letter
|
|
|
1020 Produce a warning if a real-literal-constant contains a @code{q}
|
|
|
1021 exponent-letter.
|
|
|
1022
|
|
|
1023 @item -Wsurprising
|
|
|
1024 @opindex @code{Wsurprising}
|
|
|
1025 @cindex warnings, suspicious code
|
|
|
1026 Produce a warning when ``suspicious'' code constructs are encountered.
|
|
|
1027 While technically legal these usually indicate that an error has been made.
|
|
|
1028
|
|
|
1029 This currently produces a warning under the following circumstances:
|
|
|
1030
|
|
|
1031 @itemize @bullet
|
|
|
1032 @item
|
|
|
1033 An INTEGER SELECT construct has a CASE that can never be matched as its
|
|
|
1034 lower value is greater than its upper value.
|
|
|
1035
|
|
|
1036 @item
|
|
|
1037 A LOGICAL SELECT construct has three CASE statements.
|
|
|
1038
|
|
|
1039 @item
|
|
|
1040 A TRANSFER specifies a source that is shorter than the destination.
|
|
|
1041
|
|
|
1042 @item
|
|
|
1043 The type of a function result is declared more than once with the same type. If
|
|
|
1044 @option{-pedantic} or standard-conforming mode is enabled, this is an error.
|
|
|
1045
|
|
|
1046 @item
|
|
|
1047 A @code{CHARACTER} variable is declared with negative length.
|
|
|
1048 @end itemize
|
|
|
1049
|
|
|
1050 @item -Wtabs
|
|
|
1051 @opindex @code{Wtabs}
|
|
|
1052 @cindex warnings, tabs
|
|
|
1053 @cindex tabulators
|
|
|
1054 By default, tabs are accepted as whitespace, but tabs are not members
|
|
|
1055 of the Fortran Character Set. For continuation lines, a tab followed
|
|
131
|
1056 by a digit between 1 and 9 is supported. @option{-Wtabs} will cause a
|
|
|
1057 warning to be issued if a tab is encountered. Note, @option{-Wtabs} is
|
|
|
1058 active for @option{-pedantic}, @option{-std=f95}, @option{-std=f2003},
|
|
|
1059 @option{-std=f2008}, @option{-std=f2018} and
|
|
|
1060 @option{-Wall}.
|
|
111
|
1061
|
|
|
1062 @item -Wundefined-do-loop
|
|
|
1063 @opindex @code{Wundefined-do-loop}
|
|
|
1064 @cindex warnings, undefined do loop
|
|
|
1065 Warn if a DO loop with step either 1 or -1 yields an underflow or an overflow
|
|
|
1066 during iteration of an induction variable of the loop.
|
|
|
1067 This option is implied by @option{-Wall}.
|
|
|
1068
|
|
|
1069 @item -Wunderflow
|
|
|
1070 @opindex @code{Wunderflow}
|
|
|
1071 @cindex warnings, underflow
|
|
|
1072 @cindex underflow
|
|
|
1073 Produce a warning when numerical constant expressions are
|
|
|
1074 encountered, which yield an UNDERFLOW during compilation. Enabled by default.
|
|
|
1075
|
|
|
1076 @item -Wintrinsic-shadow
|
|
|
1077 @opindex @code{Wintrinsic-shadow}
|
|
|
1078 @cindex warnings, intrinsic
|
|
|
1079 @cindex intrinsic
|
|
|
1080 Warn if a user-defined procedure or module procedure has the same name as an
|
|
|
1081 intrinsic; in this case, an explicit interface or @code{EXTERNAL} or
|
|
|
1082 @code{INTRINSIC} declaration might be needed to get calls later resolved to
|
|
|
1083 the desired intrinsic/procedure. This option is implied by @option{-Wall}.
|
|
|
1084
|
|
|
1085 @item -Wuse-without-only
|
|
|
1086 @opindex @code{Wuse-without-only}
|
|
|
1087 @cindex warnings, use statements
|
|
|
1088 @cindex intrinsic
|
|
|
1089 Warn if a @code{USE} statement has no @code{ONLY} qualifier and
|
|
|
1090 thus implicitly imports all public entities of the used module.
|
|
|
1091
|
|
|
1092 @item -Wunused-dummy-argument
|
|
|
1093 @opindex @code{Wunused-dummy-argument}
|
|
|
1094 @cindex warnings, unused dummy argument
|
|
|
1095 @cindex unused dummy argument
|
|
|
1096 @cindex dummy argument, unused
|
|
|
1097 Warn about unused dummy arguments. This option is implied by @option{-Wall}.
|
|
|
1098
|
|
|
1099 @item -Wunused-parameter
|
|
|
1100 @opindex @code{Wunused-parameter}
|
|
|
1101 @cindex warnings, unused parameter
|
|
|
1102 @cindex unused parameter
|
|
|
1103 Contrary to @command{gcc}'s meaning of @option{-Wunused-parameter},
|
|
|
1104 @command{gfortran}'s implementation of this option does not warn
|
|
|
1105 about unused dummy arguments (see @option{-Wunused-dummy-argument}),
|
|
|
1106 but about unused @code{PARAMETER} values. @option{-Wunused-parameter}
|
|
|
1107 is implied by @option{-Wextra} if also @option{-Wunused} or
|
|
|
1108 @option{-Wall} is used.
|
|
|
1109
|
|
|
1110 @item -Walign-commons
|
|
|
1111 @opindex @code{Walign-commons}
|
|
|
1112 @cindex warnings, alignment of @code{COMMON} blocks
|
|
|
1113 @cindex alignment of @code{COMMON} blocks
|
|
|
1114 By default, @command{gfortran} warns about any occasion of variables being
|
|
|
1115 padded for proper alignment inside a @code{COMMON} block. This warning can be turned
|
|
|
1116 off via @option{-Wno-align-commons}. See also @option{-falign-commons}.
|
|
|
1117
|
|
|
1118 @item -Wfunction-elimination
|
|
|
1119 @opindex @code{Wfunction-elimination}
|
|
|
1120 @cindex function elimination
|
|
|
1121 @cindex warnings, function elimination
|
|
131
|
1122 Warn if any calls to impure functions are eliminated by the optimizations
|
|
111
|
1123 enabled by the @option{-ffrontend-optimize} option.
|
|
131
|
1124 This option is implied by @option{-Wextra}.
|
|
111
|
1125
|
|
|
1126 @item -Wrealloc-lhs
|
|
|
1127 @opindex @code{Wrealloc-lhs}
|
|
|
1128 @cindex Reallocate the LHS in assignments, notification
|
|
|
1129 Warn when the compiler might insert code to for allocation or reallocation of
|
|
|
1130 an allocatable array variable of intrinsic type in intrinsic assignments. In
|
|
|
1131 hot loops, the Fortran 2003 reallocation feature may reduce the performance.
|
|
|
1132 If the array is already allocated with the correct shape, consider using a
|
|
|
1133 whole-array array-spec (e.g. @code{(:,:,:)}) for the variable on the left-hand
|
|
|
1134 side to prevent the reallocation check. Note that in some cases the warning
|
|
|
1135 is shown, even if the compiler will optimize reallocation checks away. For
|
|
|
1136 instance, when the right-hand side contains the same variable multiplied by
|
|
|
1137 a scalar. See also @option{-frealloc-lhs}.
|
|
|
1138
|
|
|
1139 @item -Wrealloc-lhs-all
|
|
|
1140 @opindex @code{Wrealloc-lhs-all}
|
|
|
1141 Warn when the compiler inserts code to for allocation or reallocation of an
|
|
|
1142 allocatable variable; this includes scalars and derived types.
|
|
|
1143
|
|
|
1144 @item -Wcompare-reals
|
|
|
1145 @opindex @code{Wcompare-reals}
|
|
|
1146 Warn when comparing real or complex types for equality or inequality.
|
|
|
1147 This option is implied by @option{-Wextra}.
|
|
|
1148
|
|
|
1149 @item -Wtarget-lifetime
|
|
|
1150 @opindex @code{Wtargt-lifetime}
|
|
|
1151 Warn if the pointer in a pointer assignment might be longer than the its
|
|
|
1152 target. This option is implied by @option{-Wall}.
|
|
|
1153
|
|
|
1154 @item -Wzerotrip
|
|
|
1155 @opindex @code{Wzerotrip}
|
|
|
1156 Warn if a @code{DO} loop is known to execute zero times at compile
|
|
|
1157 time. This option is implied by @option{-Wall}.
|
|
|
1158
|
|
|
1159 @item -Wdo-subscript
|
|
|
1160 @opindex @code{Wdo-subscript}
|
|
|
1161 Warn if an array subscript inside a DO loop could lead to an
|
|
145
|
1162 out-of-bounds access even if the compiler cannot prove that the
|
|
111
|
1163 statement is actually executed, in cases like
|
|
|
1164 @smallexample
|
|
|
1165 real a(3)
|
|
|
1166 do i=1,4
|
|
|
1167 if (condition(i)) then
|
|
|
1168 a(i) = 1.2
|
|
|
1169 end if
|
|
|
1170 end do
|
|
|
1171 @end smallexample
|
|
|
1172 This option is implied by @option{-Wextra}.
|
|
|
1173
|
|
|
1174 @item -Werror
|
|
|
1175 @opindex @code{Werror}
|
|
|
1176 @cindex warnings, to errors
|
|
|
1177 Turns all warnings into errors.
|
|
|
1178 @end table
|
|
|
1179
|
|
|
1180 @xref{Warning Options,,Options to Request or Suppress Errors and
|
|
|
1181 Warnings, gcc,Using the GNU Compiler Collection (GCC)}, for information on
|
|
|
1182 more options offered by the GBE shared by @command{gfortran}, @command{gcc}
|
|
|
1183 and other GNU compilers.
|
|
|
1184
|
|
|
1185 Some of these have no effect when compiling programs written in Fortran.
|
|
|
1186
|
|
|
1187 @node Debugging Options
|
|
|
1188 @section Options for debugging your program or GNU Fortran
|
|
|
1189 @cindex options, debugging
|
|
|
1190 @cindex debugging information options
|
|
|
1191
|
|
|
1192 GNU Fortran has various special options that are used for debugging
|
|
|
1193 either your program or the GNU Fortran compiler.
|
|
|
1194
|
|
|
1195 @table @gcctabopt
|
|
|
1196 @item -fdump-fortran-original
|
|
|
1197 @opindex @code{fdump-fortran-original}
|
|
|
1198 Output the internal parse tree after translating the source program
|
|
|
1199 into internal representation. This option is mostly useful for
|
|
|
1200 debugging the GNU Fortran compiler itself. The output generated by
|
|
|
1201 this option might change between releases. This option may also
|
|
|
1202 generate internal compiler errors for features which have only
|
|
|
1203 recently been added.
|
|
|
1204
|
|
|
1205 @item -fdump-fortran-optimized
|
|
|
1206 @opindex @code{fdump-fortran-optimized}
|
|
|
1207 Output the parse tree after front-end optimization. Mostly useful for
|
|
|
1208 debugging the GNU Fortran compiler itself. The output generated by
|
|
|
1209 this option might change between releases. This option may also
|
|
|
1210 generate internal compiler errors for features which have only
|
|
|
1211 recently been added.
|
|
|
1212
|
|
|
1213 @item -fdump-parse-tree
|
|
|
1214 @opindex @code{fdump-parse-tree}
|
|
|
1215 Output the internal parse tree after translating the source program
|
|
|
1216 into internal representation. Mostly useful for debugging the GNU
|
|
|
1217 Fortran compiler itself. The output generated by this option might
|
|
|
1218 change between releases. This option may also generate internal
|
|
|
1219 compiler errors for features which have only recently been added. This
|
|
|
1220 option is deprecated; use @code{-fdump-fortran-original} instead.
|
|
|
1221
|
|
145
|
1222 @item -fdump-fortran-global
|
|
|
1223 @opindex @code{fdump-fortran-global}
|
|
|
1224 Output a list of the global identifiers after translating into
|
|
|
1225 middle-end representation. Mostly useful for debugging the GNU Fortran
|
|
|
1226 compiler itself. The output generated by this option might change
|
|
|
1227 between releases. This option may also generate internal compiler
|
|
|
1228 errors for features which have only recently been added.
|
|
|
1229
|
|
111
|
1230 @item -ffpe-trap=@var{list}
|
|
|
1231 @opindex @code{ffpe-trap=}@var{list}
|
|
|
1232 Specify a list of floating point exception traps to enable. On most
|
|
|
1233 systems, if a floating point exception occurs and the trap for that
|
|
|
1234 exception is enabled, a SIGFPE signal will be sent and the program
|
|
|
1235 being aborted, producing a core file useful for debugging. @var{list}
|
|
|
1236 is a (possibly empty) comma-separated list of the following
|
|
|
1237 exceptions: @samp{invalid} (invalid floating point operation, such as
|
|
|
1238 @code{SQRT(-1.0)}), @samp{zero} (division by zero), @samp{overflow}
|
|
|
1239 (overflow in a floating point operation), @samp{underflow} (underflow
|
|
|
1240 in a floating point operation), @samp{inexact} (loss of precision
|
|
|
1241 during operation), and @samp{denormal} (operation performed on a
|
|
|
1242 denormal value). The first five exceptions correspond to the five
|
|
|
1243 IEEE 754 exceptions, whereas the last one (@samp{denormal}) is not
|
|
|
1244 part of the IEEE 754 standard but is available on some common
|
|
|
1245 architectures such as x86.
|
|
|
1246
|
|
|
1247 The first three exceptions (@samp{invalid}, @samp{zero}, and
|
|
|
1248 @samp{overflow}) often indicate serious errors, and unless the program
|
|
|
1249 has provisions for dealing with these exceptions, enabling traps for
|
|
|
1250 these three exceptions is probably a good idea.
|
|
|
1251
|
|
145
|
1252 If the option is used more than once in the command line, the lists will
|
|
|
1253 be joined: '@code{ffpe-trap=}@var{list1} @code{ffpe-trap=}@var{list2}'
|
|
|
1254 is equivalent to @code{ffpe-trap=}@var{list1},@var{list2}.
|
|
|
1255
|
|
|
1256 Note that once enabled an exception cannot be disabled (no negative form).
|
|
|
1257
|
|
111
|
1258 Many, if not most, floating point operations incur loss of precision
|
|
|
1259 due to rounding, and hence the @code{ffpe-trap=inexact} is likely to
|
|
|
1260 be uninteresting in practice.
|
|
|
1261
|
|
|
1262 By default no exception traps are enabled.
|
|
|
1263
|
|
|
1264 @item -ffpe-summary=@var{list}
|
|
|
1265 @opindex @code{ffpe-summary=}@var{list}
|
|
|
1266 Specify a list of floating-point exceptions, whose flag status is printed
|
|
|
1267 to @code{ERROR_UNIT} when invoking @code{STOP} and @code{ERROR STOP}.
|
|
|
1268 @var{list} can be either @samp{none}, @samp{all} or a comma-separated list
|
|
|
1269 of the following exceptions: @samp{invalid}, @samp{zero}, @samp{overflow},
|
|
|
1270 @samp{underflow}, @samp{inexact} and @samp{denormal}. (See
|
|
|
1271 @option{-ffpe-trap} for a description of the exceptions.)
|
|
|
1272
|
|
145
|
1273 If the option is used more than once in the command line, only the
|
|
|
1274 last one will be used.
|
|
|
1275
|
|
111
|
1276 By default, a summary for all exceptions but @samp{inexact} is shown.
|
|
|
1277
|
|
|
1278 @item -fno-backtrace
|
|
|
1279 @opindex @code{fno-backtrace}
|
|
|
1280 @cindex backtrace
|
|
|
1281 @cindex trace
|
|
|
1282 When a serious runtime error is encountered or a deadly signal is
|
|
|
1283 emitted (segmentation fault, illegal instruction, bus error,
|
|
|
1284 floating-point exception, and the other POSIX signals that have the
|
|
|
1285 action @samp{core}), the Fortran runtime library tries to output a
|
|
|
1286 backtrace of the error. @code{-fno-backtrace} disables the backtrace
|
|
|
1287 generation. This option only has influence for compilation of the
|
|
|
1288 Fortran main program.
|
|
|
1289
|
|
|
1290 @end table
|
|
|
1291
|
|
|
1292 @xref{Debugging Options,,Options for Debugging Your Program or GCC,
|
|
|
1293 gcc,Using the GNU Compiler Collection (GCC)}, for more information on
|
|
|
1294 debugging options.
|
|
|
1295
|
|
|
1296 @node Directory Options
|
|
|
1297 @section Options for directory search
|
|
|
1298 @cindex directory, options
|
|
|
1299 @cindex options, directory search
|
|
|
1300 @cindex search path
|
|
|
1301 @cindex @code{INCLUDE} directive
|
|
|
1302 @cindex directive, @code{INCLUDE}
|
|
|
1303 These options affect how GNU Fortran searches
|
|
|
1304 for files specified by the @code{INCLUDE} directive and where it searches
|
|
|
1305 for previously compiled modules.
|
|
|
1306
|
|
|
1307 It also affects the search paths used by @command{cpp} when used to preprocess
|
|
|
1308 Fortran source.
|
|
|
1309
|
|
|
1310 @table @gcctabopt
|
|
|
1311 @item -I@var{dir}
|
|
|
1312 @opindex @code{I}@var{dir}
|
|
|
1313 @cindex directory, search paths for inclusion
|
|
|
1314 @cindex inclusion, directory search paths for
|
|
|
1315 @cindex search paths, for included files
|
|
|
1316 @cindex paths, search
|
|
|
1317 @cindex module search path
|
|
|
1318 These affect interpretation of the @code{INCLUDE} directive
|
|
|
1319 (as well as of the @code{#include} directive of the @command{cpp}
|
|
|
1320 preprocessor).
|
|
|
1321
|
|
|
1322 Also note that the general behavior of @option{-I} and
|
|
|
1323 @code{INCLUDE} is pretty much the same as of @option{-I} with
|
|
|
1324 @code{#include} in the @command{cpp} preprocessor, with regard to
|
|
|
1325 looking for @file{header.gcc} files and other such things.
|
|
|
1326
|
|
|
1327 This path is also used to search for @file{.mod} files when previously
|
|
|
1328 compiled modules are required by a @code{USE} statement.
|
|
|
1329
|
|
|
1330 @xref{Directory Options,,Options for Directory Search,
|
|
|
1331 gcc,Using the GNU Compiler Collection (GCC)}, for information on the
|
|
|
1332 @option{-I} option.
|
|
|
1333
|
|
|
1334 @item -J@var{dir}
|
|
|
1335 @opindex @code{J}@var{dir}
|
|
|
1336 @opindex @code{M}@var{dir}
|
|
|
1337 @cindex paths, search
|
|
|
1338 @cindex module search path
|
|
|
1339 This option specifies where to put @file{.mod} files for compiled modules.
|
|
|
1340 It is also added to the list of directories to searched by an @code{USE}
|
|
|
1341 statement.
|
|
|
1342
|
|
|
1343 The default is the current directory.
|
|
|
1344
|
|
|
1345 @item -fintrinsic-modules-path @var{dir}
|
|
|
1346 @opindex @code{fintrinsic-modules-path} @var{dir}
|
|
|
1347 @cindex paths, search
|
|
|
1348 @cindex module search path
|
|
|
1349 This option specifies the location of pre-compiled intrinsic modules, if
|
|
|
1350 they are not in the default location expected by the compiler.
|
|
|
1351 @end table
|
|
|
1352
|
|
|
1353 @node Link Options
|
|
|
1354 @section Influencing the linking step
|
|
|
1355 @cindex options, linking
|
|
|
1356 @cindex linking, static
|
|
|
1357
|
|
|
1358 These options come into play when the compiler links object files into an
|
|
|
1359 executable output file. They are meaningless if the compiler is not doing
|
|
|
1360 a link step.
|
|
|
1361
|
|
|
1362 @table @gcctabopt
|
|
|
1363 @item -static-libgfortran
|
|
|
1364 @opindex @code{static-libgfortran}
|
|
|
1365 On systems that provide @file{libgfortran} as a shared and a static
|
|
|
1366 library, this option forces the use of the static version. If no
|
|
|
1367 shared version of @file{libgfortran} was built when the compiler was
|
|
|
1368 configured, this option has no effect.
|
|
|
1369 @end table
|
|
|
1370
|
|
|
1371
|
|
|
1372 @node Runtime Options
|
|
|
1373 @section Influencing runtime behavior
|
|
|
1374 @cindex options, runtime
|
|
|
1375
|
|
|
1376 These options affect the runtime behavior of programs compiled with GNU Fortran.
|
|
|
1377
|
|
|
1378 @table @gcctabopt
|
|
|
1379 @item -fconvert=@var{conversion}
|
|
|
1380 @opindex @code{fconvert=}@var{conversion}
|
|
|
1381 Specify the representation of data for unformatted files. Valid
|
|
|
1382 values for conversion are: @samp{native}, the default; @samp{swap},
|
|
|
1383 swap between big- and little-endian; @samp{big-endian}, use big-endian
|
|
|
1384 representation for unformatted files; @samp{little-endian}, use little-endian
|
|
|
1385 representation for unformatted files.
|
|
|
1386
|
|
|
1387 @emph{This option has an effect only when used in the main program.
|
|
|
1388 The @code{CONVERT} specifier and the GFORTRAN_CONVERT_UNIT environment
|
|
|
1389 variable override the default specified by @option{-fconvert}.}
|
|
|
1390
|
|
|
1391 @item -frecord-marker=@var{length}
|
|
|
1392 @opindex @code{frecord-marker=}@var{length}
|
|
|
1393 Specify the length of record markers for unformatted files.
|
|
|
1394 Valid values for @var{length} are 4 and 8. Default is 4.
|
|
|
1395 @emph{This is different from previous versions of @command{gfortran}},
|
|
|
1396 which specified a default record marker length of 8 on most
|
|
|
1397 systems. If you want to read or write files compatible
|
|
|
1398 with earlier versions of @command{gfortran}, use @option{-frecord-marker=8}.
|
|
|
1399
|
|
|
1400 @item -fmax-subrecord-length=@var{length}
|
|
|
1401 @opindex @code{fmax-subrecord-length=}@var{length}
|
|
|
1402 Specify the maximum length for a subrecord. The maximum permitted
|
|
|
1403 value for length is 2147483639, which is also the default. Only
|
|
|
1404 really useful for use by the gfortran testsuite.
|
|
|
1405
|
|
|
1406 @item -fsign-zero
|
|
|
1407 @opindex @code{fsign-zero}
|
|
|
1408 When enabled, floating point numbers of value zero with the sign bit set
|
|
|
1409 are written as negative number in formatted output and treated as
|
|
|
1410 negative in the @code{SIGN} intrinsic. @option{-fno-sign-zero} does not
|
|
|
1411 print the negative sign of zero values (or values rounded to zero for I/O)
|
|
|
1412 and regards zero as positive number in the @code{SIGN} intrinsic for
|
|
|
1413 compatibility with Fortran 77. The default is @option{-fsign-zero}.
|
|
|
1414 @end table
|
|
|
1415
|
|
|
1416 @node Code Gen Options
|
|
|
1417 @section Options for code generation conventions
|
|
|
1418 @cindex code generation, conventions
|
|
|
1419 @cindex options, code generation
|
|
|
1420 @cindex options, run-time
|
|
|
1421
|
|
|
1422 These machine-independent options control the interface conventions
|
|
|
1423 used in code generation.
|
|
|
1424
|
|
|
1425 Most of them have both positive and negative forms; the negative form
|
|
|
1426 of @option{-ffoo} would be @option{-fno-foo}. In the table below, only
|
|
|
1427 one of the forms is listed---the one which is not the default. You
|
|
|
1428 can figure out the other form by either removing @option{no-} or adding
|
|
|
1429 it.
|
|
|
1430
|
|
|
1431 @table @gcctabopt
|
|
|
1432 @item -fno-automatic
|
|
|
1433 @opindex @code{fno-automatic}
|
|
|
1434 @cindex @code{SAVE} statement
|
|
|
1435 @cindex statement, @code{SAVE}
|
|
|
1436 Treat each program unit (except those marked as RECURSIVE) as if the
|
|
|
1437 @code{SAVE} statement were specified for every local variable and array
|
|
|
1438 referenced in it. Does not affect common blocks. (Some Fortran compilers
|
|
|
1439 provide this option under the name @option{-static} or @option{-save}.)
|
|
|
1440 The default, which is @option{-fautomatic}, uses the stack for local
|
|
|
1441 variables smaller than the value given by @option{-fmax-stack-var-size}.
|
|
|
1442 Use the option @option{-frecursive} to use no static memory.
|
|
|
1443
|
|
145
|
1444 Local variables or arrays having an explicit @code{SAVE} attribute are
|
|
|
1445 silently ignored unless the @option{-pedantic} option is added.
|
|
|
1446
|
|
111
|
1447 @item -ff2c
|
|
|
1448 @opindex ff2c
|
|
|
1449 @cindex calling convention
|
|
|
1450 @cindex @command{f2c} calling convention
|
|
|
1451 @cindex @command{g77} calling convention
|
|
|
1452 @cindex libf2c calling convention
|
|
|
1453 Generate code designed to be compatible with code generated
|
|
|
1454 by @command{g77} and @command{f2c}.
|
|
|
1455
|
|
|
1456 The calling conventions used by @command{g77} (originally implemented
|
|
|
1457 in @command{f2c}) require functions that return type
|
|
|
1458 default @code{REAL} to actually return the C type @code{double}, and
|
|
|
1459 functions that return type @code{COMPLEX} to return the values via an
|
|
|
1460 extra argument in the calling sequence that points to where to
|
|
|
1461 store the return value. Under the default GNU calling conventions, such
|
|
|
1462 functions simply return their results as they would in GNU
|
|
|
1463 C---default @code{REAL} functions return the C type @code{float}, and
|
|
|
1464 @code{COMPLEX} functions return the GNU C type @code{complex}.
|
|
|
1465 Additionally, this option implies the @option{-fsecond-underscore}
|
|
|
1466 option, unless @option{-fno-second-underscore} is explicitly requested.
|
|
|
1467
|
|
|
1468 This does not affect the generation of code that interfaces with
|
|
|
1469 the @command{libgfortran} library.
|
|
|
1470
|
|
|
1471 @emph{Caution:} It is not a good idea to mix Fortran code compiled with
|
|
|
1472 @option{-ff2c} with code compiled with the default @option{-fno-f2c}
|
|
|
1473 calling conventions as, calling @code{COMPLEX} or default @code{REAL}
|
|
|
1474 functions between program parts which were compiled with different
|
|
|
1475 calling conventions will break at execution time.
|
|
|
1476
|
|
|
1477 @emph{Caution:} This will break code which passes intrinsic functions
|
|
|
1478 of type default @code{REAL} or @code{COMPLEX} as actual arguments, as
|
|
|
1479 the library implementations use the @option{-fno-f2c} calling conventions.
|
|
|
1480
|
|
|
1481 @item -fno-underscoring
|
|
|
1482 @opindex @code{fno-underscoring}
|
|
|
1483 @cindex underscore
|
|
|
1484 @cindex symbol names, underscores
|
|
|
1485 @cindex transforming symbol names
|
|
|
1486 @cindex symbol names, transforming
|
|
|
1487 Do not transform names of entities specified in the Fortran
|
|
|
1488 source file by appending underscores to them.
|
|
|
1489
|
|
|
1490 With @option{-funderscoring} in effect, GNU Fortran appends one
|
|
|
1491 underscore to external names with no underscores. This is done to ensure
|
|
|
1492 compatibility with code produced by many UNIX Fortran compilers.
|
|
|
1493
|
|
|
1494 @emph{Caution}: The default behavior of GNU Fortran is
|
|
|
1495 incompatible with @command{f2c} and @command{g77}, please use the
|
|
|
1496 @option{-ff2c} option if you want object files compiled with
|
|
|
1497 GNU Fortran to be compatible with object code created with these
|
|
|
1498 tools.
|
|
|
1499
|
|
|
1500 Use of @option{-fno-underscoring} is not recommended unless you are
|
|
|
1501 experimenting with issues such as integration of GNU Fortran into
|
|
|
1502 existing system environments (vis-@`{a}-vis existing libraries, tools,
|
|
|
1503 and so on).
|
|
|
1504
|
|
|
1505 For example, with @option{-funderscoring}, and assuming that @code{j()} and
|
|
|
1506 @code{max_count()} are external functions while @code{my_var} and
|
|
|
1507 @code{lvar} are local variables, a statement like
|
|
|
1508 @smallexample
|
|
|
1509 I = J() + MAX_COUNT (MY_VAR, LVAR)
|
|
|
1510 @end smallexample
|
|
|
1511 @noindent
|
|
|
1512 is implemented as something akin to:
|
|
|
1513 @smallexample
|
|
|
1514 i = j_() + max_count__(&my_var__, &lvar);
|
|
|
1515 @end smallexample
|
|
|
1516
|
|
|
1517 With @option{-fno-underscoring}, the same statement is implemented as:
|
|
|
1518
|
|
|
1519 @smallexample
|
|
|
1520 i = j() + max_count(&my_var, &lvar);
|
|
|
1521 @end smallexample
|
|
|
1522
|
|
|
1523 Use of @option{-fno-underscoring} allows direct specification of
|
|
|
1524 user-defined names while debugging and when interfacing GNU Fortran
|
|
|
1525 code with other languages.
|
|
|
1526
|
|
|
1527 Note that just because the names match does @emph{not} mean that the
|
|
|
1528 interface implemented by GNU Fortran for an external name matches the
|
|
|
1529 interface implemented by some other language for that same name.
|
|
|
1530 That is, getting code produced by GNU Fortran to link to code produced
|
|
|
1531 by some other compiler using this or any other method can be only a
|
|
|
1532 small part of the overall solution---getting the code generated by
|
|
|
1533 both compilers to agree on issues other than naming can require
|
|
|
1534 significant effort, and, unlike naming disagreements, linkers normally
|
|
|
1535 cannot detect disagreements in these other areas.
|
|
|
1536
|
|
|
1537 Also, note that with @option{-fno-underscoring}, the lack of appended
|
|
|
1538 underscores introduces the very real possibility that a user-defined
|
|
|
1539 external name will conflict with a name in a system library, which
|
|
|
1540 could make finding unresolved-reference bugs quite difficult in some
|
|
|
1541 cases---they might occur at program run time, and show up only as
|
|
|
1542 buggy behavior at run time.
|
|
|
1543
|
|
|
1544 In future versions of GNU Fortran we hope to improve naming and linking
|
|
|
1545 issues so that debugging always involves using the names as they appear
|
|
|
1546 in the source, even if the names as seen by the linker are mangled to
|
|
|
1547 prevent accidental linking between procedures with incompatible
|
|
|
1548 interfaces.
|
|
|
1549
|
|
|
1550 @item -fsecond-underscore
|
|
|
1551 @opindex @code{fsecond-underscore}
|
|
|
1552 @cindex underscore
|
|
|
1553 @cindex symbol names, underscores
|
|
|
1554 @cindex transforming symbol names
|
|
|
1555 @cindex symbol names, transforming
|
|
|
1556 @cindex @command{f2c} calling convention
|
|
|
1557 @cindex @command{g77} calling convention
|
|
|
1558 @cindex libf2c calling convention
|
|
|
1559 By default, GNU Fortran appends an underscore to external
|
|
|
1560 names. If this option is used GNU Fortran appends two
|
|
|
1561 underscores to names with underscores and one underscore to external names
|
|
|
1562 with no underscores. GNU Fortran also appends two underscores to
|
|
|
1563 internal names with underscores to avoid naming collisions with external
|
|
|
1564 names.
|
|
|
1565
|
|
|
1566 This option has no effect if @option{-fno-underscoring} is
|
|
|
1567 in effect. It is implied by the @option{-ff2c} option.
|
|
|
1568
|
|
|
1569 Otherwise, with this option, an external name such as @code{MAX_COUNT}
|
|
|
1570 is implemented as a reference to the link-time external symbol
|
|
|
1571 @code{max_count__}, instead of @code{max_count_}. This is required
|
|
|
1572 for compatibility with @command{g77} and @command{f2c}, and is implied
|
|
|
1573 by use of the @option{-ff2c} option.
|
|
|
1574
|
|
|
1575 @item -fcoarray=@var{<keyword>}
|
|
|
1576 @opindex @code{fcoarray}
|
|
|
1577 @cindex coarrays
|
|
|
1578
|
|
|
1579 @table @asis
|
|
|
1580 @item @samp{none}
|
|
|
1581 Disable coarray support; using coarray declarations and image-control
|
|
|
1582 statements will produce a compile-time error. (Default)
|
|
|
1583
|
|
|
1584 @item @samp{single}
|
|
|
1585 Single-image mode, i.e. @code{num_images()} is always one.
|
|
|
1586
|
|
|
1587 @item @samp{lib}
|
|
|
1588 Library-based coarray parallelization; a suitable GNU Fortran coarray
|
|
|
1589 library needs to be linked.
|
|
|
1590 @end table
|
|
|
1591
|
|
|
1592
|
|
|
1593 @item -fcheck=@var{<keyword>}
|
|
|
1594 @opindex @code{fcheck}
|
|
|
1595 @cindex array, bounds checking
|
|
145
|
1596 @cindex bit intrinsics checking
|
|
111
|
1597 @cindex bounds checking
|
|
|
1598 @cindex pointer checking
|
|
|
1599 @cindex memory checking
|
|
|
1600 @cindex range checking
|
|
|
1601 @cindex subscript checking
|
|
|
1602 @cindex checking subscripts
|
|
|
1603 @cindex run-time checking
|
|
|
1604 @cindex checking array temporaries
|
|
|
1605
|
|
|
1606 Enable the generation of run-time checks; the argument shall be
|
|
|
1607 a comma-delimited list of the following keywords. Prefixing a check with
|
|
|
1608 @option{no-} disables it if it was activated by a previous specification.
|
|
|
1609
|
|
|
1610 @table @asis
|
|
|
1611 @item @samp{all}
|
|
|
1612 Enable all run-time test of @option{-fcheck}.
|
|
|
1613
|
|
|
1614 @item @samp{array-temps}
|
|
|
1615 Warns at run time when for passing an actual argument a temporary array
|
|
|
1616 had to be generated. The information generated by this warning is
|
|
|
1617 sometimes useful in optimization, in order to avoid such temporaries.
|
|
|
1618
|
|
|
1619 Note: The warning is only printed once per location.
|
|
|
1620
|
|
145
|
1621 @item @samp{bits}
|
|
|
1622 Enable generation of run-time checks for invalid arguments to the bit
|
|
|
1623 manipulation intrinsics.
|
|
|
1624
|
|
111
|
1625 @item @samp{bounds}
|
|
|
1626 Enable generation of run-time checks for array subscripts
|
|
|
1627 and against the declared minimum and maximum values. It also
|
|
|
1628 checks array indices for assumed and deferred
|
|
|
1629 shape arrays against the actual allocated bounds and ensures that all string
|
|
|
1630 lengths are equal for character array constructors without an explicit
|
|
|
1631 typespec.
|
|
|
1632
|
|
|
1633 Some checks require that @option{-fcheck=bounds} is set for
|
|
|
1634 the compilation of the main program.
|
|
|
1635
|
|
|
1636 Note: In the future this may also include other forms of checking, e.g.,
|
|
|
1637 checking substring references.
|
|
|
1638
|
|
|
1639 @item @samp{do}
|
|
|
1640 Enable generation of run-time checks for invalid modification of loop
|
|
|
1641 iteration variables.
|
|
|
1642
|
|
|
1643 @item @samp{mem}
|
|
|
1644 Enable generation of run-time checks for memory allocation.
|
|
|
1645 Note: This option does not affect explicit allocations using the
|
|
|
1646 @code{ALLOCATE} statement, which will be always checked.
|
|
|
1647
|
|
|
1648 @item @samp{pointer}
|
|
|
1649 Enable generation of run-time checks for pointers and allocatables.
|
|
|
1650
|
|
|
1651 @item @samp{recursion}
|
|
|
1652 Enable generation of run-time checks for recursively called subroutines and
|
|
|
1653 functions which are not marked as recursive. See also @option{-frecursive}.
|
|
|
1654 Note: This check does not work for OpenMP programs and is disabled if used
|
|
|
1655 together with @option{-frecursive} and @option{-fopenmp}.
|
|
|
1656 @end table
|
|
|
1657
|
|
|
1658 Example: Assuming you have a file @file{foo.f90}, the command
|
|
|
1659 @smallexample
|
|
|
1660 gfortran -fcheck=all,no-array-temps foo.f90
|
|
|
1661 @end smallexample
|
|
|
1662 will compile the file with all checks enabled as specified above except
|
|
|
1663 warnings for generated array temporaries.
|
|
|
1664
|
|
|
1665
|
|
|
1666 @item -fbounds-check
|
|
|
1667 @opindex @code{fbounds-check}
|
|
|
1668 @c Note: This option is also referred in gcc's manpage
|
|
|
1669 Deprecated alias for @option{-fcheck=bounds}.
|
|
|
1670
|
|
145
|
1671 @item -ftail-call-workaround
|
|
|
1672 @itemx -ftail-call-workaround=@var{n}
|
|
|
1673 @opindex @code{tail-call-workaround}
|
|
|
1674 Some C interfaces to Fortran codes violate the gfortran ABI by
|
|
|
1675 omitting the hidden character length arguments as described in
|
|
|
1676 @xref{Argument passing conventions}. This can lead to crashes
|
|
|
1677 because pushing arguments for tail calls can overflow the stack.
|
|
|
1678
|
|
|
1679 To provide a workaround for existing binary packages, this option
|
|
|
1680 disables tail call optimization for gfortran procedures with character
|
|
|
1681 arguments. With @option{-ftail-call-workaround=2} tail call optimization
|
|
|
1682 is disabled in all gfortran procedures with character arguments,
|
|
|
1683 with @option{-ftail-call-workaround=1} or equivalent
|
|
|
1684 @option{-ftail-call-workaround} only in gfortran procedures with character
|
|
|
1685 arguments that call implicitly prototyped procedures.
|
|
|
1686
|
|
|
1687 Using this option can lead to problems including crashes due to
|
|
|
1688 insufficient stack space.
|
|
|
1689
|
|
|
1690 It is @emph{very strongly} recommended to fix the code in question.
|
|
|
1691 The @option{-fc-prototypes-external} option can be used to generate
|
|
|
1692 prototypes which conform to gfortran's ABI, for inclusion in the
|
|
|
1693 source code.
|
|
|
1694
|
|
|
1695 Support for this option will likely be withdrawn in a future release
|
|
|
1696 of gfortran.
|
|
|
1697
|
|
|
1698 The negative form, @option{-fno-tail-call-workaround} or equivalent
|
|
|
1699 @option{-ftail-call-workaround=0}, can be used to disable this option.
|
|
|
1700
|
|
|
1701 Default is currently @option{-ftail-call-workaround}, this will change
|
|
|
1702 in future releases.
|
|
|
1703
|
|
111
|
1704 @item -fcheck-array-temporaries
|
|
|
1705 @opindex @code{fcheck-array-temporaries}
|
|
|
1706 Deprecated alias for @option{-fcheck=array-temps}.
|
|
|
1707
|
|
|
1708 @item -fmax-array-constructor=@var{n}
|
|
|
1709 @opindex @code{fmax-array-constructor}
|
|
|
1710 This option can be used to increase the upper limit permitted in
|
|
|
1711 array constructors. The code below requires this option to expand
|
|
|
1712 the array at compile time.
|
|
|
1713
|
|
|
1714 @smallexample
|
|
|
1715 program test
|
|
|
1716 implicit none
|
|
|
1717 integer j
|
|
|
1718 integer, parameter :: n = 100000
|
|
|
1719 integer, parameter :: i(n) = (/ (2*j, j = 1, n) /)
|
|
|
1720 print '(10(I0,1X))', i
|
|
|
1721 end program test
|
|
|
1722 @end smallexample
|
|
|
1723
|
|
|
1724 @emph{Caution: This option can lead to long compile times and excessively
|
|
|
1725 large object files.}
|
|
|
1726
|
|
|
1727 The default value for @var{n} is 65535.
|
|
|
1728
|
|
|
1729
|
|
|
1730 @item -fmax-stack-var-size=@var{n}
|
|
|
1731 @opindex @code{fmax-stack-var-size}
|
|
|
1732 This option specifies the size in bytes of the largest array that will be put
|
|
|
1733 on the stack; if the size is exceeded static memory is used (except in
|
|
|
1734 procedures marked as RECURSIVE). Use the option @option{-frecursive} to
|
|
|
1735 allow for recursive procedures which do not have a RECURSIVE attribute or
|
|
|
1736 for parallel programs. Use @option{-fno-automatic} to never use the stack.
|
|
|
1737
|
|
|
1738 This option currently only affects local arrays declared with constant
|
|
|
1739 bounds, and may not apply to all character variables.
|
|
|
1740 Future versions of GNU Fortran may improve this behavior.
|
|
|
1741
|
|
145
|
1742 The default value for @var{n} is 65536.
|
|
111
|
1743
|
|
|
1744 @item -fstack-arrays
|
|
|
1745 @opindex @code{fstack-arrays}
|
|
|
1746 Adding this option will make the Fortran compiler put all arrays of
|
|
|
1747 unknown size and array temporaries onto stack memory. If your program uses very
|
|
|
1748 large local arrays it is possible that you will have to extend your runtime
|
|
|
1749 limits for stack memory on some operating systems. This flag is enabled
|
|
|
1750 by default at optimization level @option{-Ofast} unless
|
|
|
1751 @option{-fmax-stack-var-size} is specified.
|
|
|
1752
|
|
|
1753 @item -fpack-derived
|
|
|
1754 @opindex @code{fpack-derived}
|
|
|
1755 @cindex structure packing
|
|
|
1756 This option tells GNU Fortran to pack derived type members as closely as
|
|
|
1757 possible. Code compiled with this option is likely to be incompatible
|
|
|
1758 with code compiled without this option, and may execute slower.
|
|
|
1759
|
|
|
1760 @item -frepack-arrays
|
|
|
1761 @opindex @code{frepack-arrays}
|
|
|
1762 @cindex repacking arrays
|
|
|
1763 In some circumstances GNU Fortran may pass assumed shape array
|
|
|
1764 sections via a descriptor describing a noncontiguous area of memory.
|
|
|
1765 This option adds code to the function prologue to repack the data into
|
|
|
1766 a contiguous block at runtime.
|
|
|
1767
|
|
|
1768 This should result in faster accesses to the array. However it can introduce
|
|
|
1769 significant overhead to the function call, especially when the passed data
|
|
|
1770 is noncontiguous.
|
|
|
1771
|
|
|
1772 @item -fshort-enums
|
|
|
1773 @opindex @code{fshort-enums}
|
|
|
1774 This option is provided for interoperability with C code that was
|
|
|
1775 compiled with the @option{-fshort-enums} option. It will make
|
|
|
1776 GNU Fortran choose the smallest @code{INTEGER} kind a given
|
|
|
1777 enumerator set will fit in, and give all its enumerators this kind.
|
|
|
1778
|
|
145
|
1779 @item -finline-arg-packing
|
|
|
1780 @opindex @code{finline-arg-packing}
|
|
|
1781 When passing an assumed-shape argument of a procedure as actual
|
|
|
1782 argument to an assumed-size or explicit size or as argument to a
|
|
|
1783 procedure that does not have an explicit interface, the argument may
|
|
|
1784 have to be packed, that is put into contiguous memory. An example is
|
|
|
1785 the call to @code{foo} in
|
|
|
1786 @smallexample
|
|
|
1787 subroutine foo(a)
|
|
|
1788 real, dimension(*) :: a
|
|
|
1789 end subroutine foo
|
|
|
1790 subroutine bar(b)
|
|
|
1791 real, dimension(:) :: b
|
|
|
1792 call foo(b)
|
|
|
1793 end subroutine bar
|
|
|
1794 @end smallexample
|
|
|
1795
|
|
|
1796 When @option{-finline-arg-packing} is in effect, this packing will be
|
|
|
1797 performed by inline code. This allows for more optimization while
|
|
|
1798 increasing code size.
|
|
|
1799
|
|
|
1800 @option{-finline-arg-packing} is implied by any of the @option{-O} options
|
|
|
1801 except when optimizing for size via @option{-Os}. If the code
|
|
|
1802 contains a very large number of argument that have to be packed, code
|
|
|
1803 size and also compilation time may become excessive. If that is the
|
|
|
1804 case, it may be better to disable this option. Instances of packing
|
|
|
1805 can be found by using by using @option{-Warray-temporaries}.
|
|
|
1806
|
|
111
|
1807 @item -fexternal-blas
|
|
|
1808 @opindex @code{fexternal-blas}
|
|
|
1809 This option will make @command{gfortran} generate calls to BLAS functions
|
|
|
1810 for some matrix operations like @code{MATMUL}, instead of using our own
|
|
|
1811 algorithms, if the size of the matrices involved is larger than a given
|
|
|
1812 limit (see @option{-fblas-matmul-limit}). This may be profitable if an
|
|
|
1813 optimized vendor BLAS library is available. The BLAS library will have
|
|
|
1814 to be specified at link time.
|
|
|
1815
|
|
|
1816 @item -fblas-matmul-limit=@var{n}
|
|
|
1817 @opindex @code{fblas-matmul-limit}
|
|
|
1818 Only significant when @option{-fexternal-blas} is in effect.
|
|
|
1819 Matrix multiplication of matrices with size larger than (or equal to) @var{n}
|
|
|
1820 will be performed by calls to BLAS functions, while others will be
|
|
|
1821 handled by @command{gfortran} internal algorithms. If the matrices
|
|
|
1822 involved are not square, the size comparison is performed using the
|
|
|
1823 geometric mean of the dimensions of the argument and result matrices.
|
|
|
1824
|
|
|
1825 The default value for @var{n} is 30.
|
|
|
1826
|
|
|
1827 @item -finline-matmul-limit=@var{n}
|
|
|
1828 @opindex @code{finline-matmul-limit}
|
|
|
1829 When front-end optimiztion is active, some calls to the @code{MATMUL}
|
|
|
1830 intrinsic function will be inlined. This may result in code size
|
|
|
1831 increase if the size of the matrix cannot be determined at compile
|
|
|
1832 time, as code for both cases is generated. Setting
|
|
|
1833 @code{-finline-matmul-limit=0} will disable inlining in all cases.
|
|
|
1834 Setting this option with a value of @var{n} will produce inline code
|
|
|
1835 for matrices with size up to @var{n}. If the matrices involved are not
|
|
|
1836 square, the size comparison is performed using the geometric mean of
|
|
|
1837 the dimensions of the argument and result matrices.
|
|
|
1838
|
|
|
1839 The default value for @var{n} is 30. The @code{-fblas-matmul-limit}
|
|
|
1840 can be used to change this value.
|
|
|
1841
|
|
|
1842 @item -frecursive
|
|
|
1843 @opindex @code{frecursive}
|
|
|
1844 Allow indirect recursion by forcing all local arrays to be allocated
|
|
|
1845 on the stack. This flag cannot be used together with
|
|
|
1846 @option{-fmax-stack-var-size=} or @option{-fno-automatic}.
|
|
|
1847
|
|
|
1848 @item -finit-local-zero
|
|
|
1849 @itemx -finit-derived
|
|
|
1850 @itemx -finit-integer=@var{n}
|
|
|
1851 @itemx -finit-real=@var{<zero|inf|-inf|nan|snan>}
|
|
|
1852 @itemx -finit-logical=@var{<true|false>}
|
|
|
1853 @itemx -finit-character=@var{n}
|
|
|
1854 @opindex @code{finit-local-zero}
|
|
|
1855 @opindex @code{finit-derived}
|
|
|
1856 @opindex @code{finit-integer}
|
|
|
1857 @opindex @code{finit-real}
|
|
|
1858 @opindex @code{finit-logical}
|
|
|
1859 @opindex @code{finit-character}
|
|
|
1860 The @option{-finit-local-zero} option instructs the compiler to
|
|
|
1861 initialize local @code{INTEGER}, @code{REAL}, and @code{COMPLEX}
|
|
|
1862 variables to zero, @code{LOGICAL} variables to false, and
|
|
|
1863 @code{CHARACTER} variables to a string of null bytes. Finer-grained
|
|
|
1864 initialization options are provided by the
|
|
|
1865 @option{-finit-integer=@var{n}},
|
|
|
1866 @option{-finit-real=@var{<zero|inf|-inf|nan|snan>}} (which also initializes
|
|
|
1867 the real and imaginary parts of local @code{COMPLEX} variables),
|
|
|
1868 @option{-finit-logical=@var{<true|false>}}, and
|
|
|
1869 @option{-finit-character=@var{n}} (where @var{n} is an ASCII character
|
|
131
|
1870 value) options.
|
|
|
1871
|
|
|
1872 With @option{-finit-derived}, components of derived type variables will be
|
|
|
1873 initialized according to these flags. Components whose type is not covered by
|
|
|
1874 an explicit @option{-finit-*} flag will be treated as described above with
|
|
|
1875 @option{-finit-local-zero}.
|
|
|
1876
|
|
|
1877 These options do not initialize
|
|
111
|
1878 @itemize @bullet
|
|
|
1879 @item
|
|
|
1880 objects with the POINTER attribute
|
|
|
1881 @item
|
|
|
1882 allocatable arrays
|
|
|
1883 @item
|
|
|
1884 variables that appear in an @code{EQUIVALENCE} statement.
|
|
|
1885 @end itemize
|
|
|
1886 (These limitations may be removed in future releases).
|
|
|
1887
|
|
|
1888 Note that the @option{-finit-real=nan} option initializes @code{REAL}
|
|
|
1889 and @code{COMPLEX} variables with a quiet NaN. For a signalling NaN
|
|
|
1890 use @option{-finit-real=snan}; note, however, that compile-time
|
|
|
1891 optimizations may convert them into quiet NaN and that trapping
|
|
|
1892 needs to be enabled (e.g. via @option{-ffpe-trap}).
|
|
|
1893
|
|
145
|
1894 The @option{-finit-integer} option will parse the value into an
|
|
|
1895 integer of type @code{INTEGER(kind=C_LONG)} on the host. Said value
|
|
|
1896 is then assigned to the integer variables in the Fortran code, which
|
|
|
1897 might result in wraparound if the value is too large for the kind.
|
|
|
1898
|
|
111
|
1899 Finally, note that enabling any of the @option{-finit-*} options will
|
|
|
1900 silence warnings that would have been emitted by @option{-Wuninitialized}
|
|
|
1901 for the affected local variables.
|
|
|
1902
|
|
|
1903 @item -falign-commons
|
|
|
1904 @opindex @code{falign-commons}
|
|
|
1905 @cindex alignment of @code{COMMON} blocks
|
|
|
1906 By default, @command{gfortran} enforces proper alignment of all variables in a
|
|
|
1907 @code{COMMON} block by padding them as needed. On certain platforms this is mandatory,
|
|
|
1908 on others it increases performance. If a @code{COMMON} block is not declared with
|
|
|
1909 consistent data types everywhere, this padding can cause trouble, and
|
|
|
1910 @option{-fno-align-commons} can be used to disable automatic alignment. The
|
|
|
1911 same form of this option should be used for all files that share a @code{COMMON} block.
|
|
|
1912 To avoid potential alignment issues in @code{COMMON} blocks, it is recommended to order
|
|
|
1913 objects from largest to smallest.
|
|
|
1914
|
|
|
1915 @item -fno-protect-parens
|
|
|
1916 @opindex @code{fno-protect-parens}
|
|
|
1917 @cindex re-association of parenthesized expressions
|
|
|
1918 By default the parentheses in expression are honored for all optimization
|
|
|
1919 levels such that the compiler does not do any re-association. Using
|
|
|
1920 @option{-fno-protect-parens} allows the compiler to reorder @code{REAL} and
|
|
|
1921 @code{COMPLEX} expressions to produce faster code. Note that for the re-association
|
|
|
1922 optimization @option{-fno-signed-zeros} and @option{-fno-trapping-math}
|
|
|
1923 need to be in effect. The parentheses protection is enabled by default, unless
|
|
|
1924 @option{-Ofast} is given.
|
|
|
1925
|
|
|
1926 @item -frealloc-lhs
|
|
|
1927 @opindex @code{frealloc-lhs}
|
|
|
1928 @cindex Reallocate the LHS in assignments
|
|
|
1929 An allocatable left-hand side of an intrinsic assignment is automatically
|
|
|
1930 (re)allocated if it is either unallocated or has a different shape. The
|
|
|
1931 option is enabled by default except when @option{-std=f95} is given. See
|
|
|
1932 also @option{-Wrealloc-lhs}.
|
|
|
1933
|
|
|
1934 @item -faggressive-function-elimination
|
|
|
1935 @opindex @code{faggressive-function-elimination}
|
|
|
1936 @cindex Elimination of functions with identical argument lists
|
|
|
1937 Functions with identical argument lists are eliminated within
|
|
|
1938 statements, regardless of whether these functions are marked
|
|
|
1939 @code{PURE} or not. For example, in
|
|
|
1940 @smallexample
|
|
|
1941 a = f(b,c) + f(b,c)
|
|
|
1942 @end smallexample
|
|
|
1943 there will only be a single call to @code{f}. This option only works
|
|
|
1944 if @option{-ffrontend-optimize} is in effect.
|
|
|
1945
|
|
|
1946 @item -ffrontend-optimize
|
|
|
1947 @opindex @code{frontend-optimize}
|
|
|
1948 @cindex Front-end optimization
|
|
|
1949 This option performs front-end optimization, based on manipulating
|
|
131
|
1950 parts the Fortran parse tree. Enabled by default by any @option{-O} option
|
|
|
1951 except @option{-O0} and @option{-Og}. Optimizations enabled by this option
|
|
|
1952 include:
|
|
|
1953 @itemize @bullet
|
|
|
1954 @item inlining calls to @code{MATMUL},
|
|
|
1955 @item elimination of identical function calls within expressions,
|
|
|
1956 @item removing unnecessary calls to @code{TRIM} in comparisons and assignments,
|
|
|
1957 @item replacing @code{TRIM(a)} with @code{a(1:LEN_TRIM(a))} and
|
|
|
1958 @item short-circuiting of logical operators (@code{.AND.} and @code{.OR.}).
|
|
|
1959 @end itemize
|
|
|
1960 It can be deselected by specifying @option{-fno-frontend-optimize}.
|
|
|
1961
|
|
|
1962 @item -ffrontend-loop-interchange
|
|
|
1963 @opindex @code{frontend-loop-interchange}
|
|
|
1964 @cindex loop interchange, Fortran
|
|
|
1965 Attempt to interchange loops in the Fortran front end where
|
|
|
1966 profitable. Enabled by default by any @option{-O} option.
|
|
|
1967 At the moment, this option only affects @code{FORALL} and
|
|
|
1968 @code{DO CONCURRENT} statements with several forall triplets.
|
|
111
|
1969 @end table
|
|
|
1970
|
|
|
1971 @xref{Code Gen Options,,Options for Code Generation Conventions,
|
|
|
1972 gcc,Using the GNU Compiler Collection (GCC)}, for information on more options
|
|
|
1973 offered by the GBE
|
|
|
1974 shared by @command{gfortran}, @command{gcc}, and other GNU compilers.
|
|
|
1975
|
|
|
1976 @c man end
|
|
|
1977
|
|
|
1978 @node Interoperability Options
|
|
|
1979 @section Options for interoperability with other languages
|
|
|
1980
|
|
|
1981 @table @asis
|
|
|
1982
|
|
|
1983 @item -fc-prototypes
|
|
|
1984 @opindex @code{c-prototypes}
|
|
145
|
1985 @cindex Generating C prototypes from Fortran BIND(C) enteties
|
|
111
|
1986 This option will generate C prototypes from @code{BIND(C)} variable
|
|
|
1987 declarations, types and procedure interfaces and writes them to
|
|
|
1988 standard output. @code{ENUM} is not yet supported.
|
|
|
1989
|
|
|
1990 The generated prototypes may need inclusion of an appropriate header,
|
|
|
1991 such as @code{<stdint.h>} or @code{<stdlib.h>}. For types which are
|
|
|
1992 not specified using the appropriate kind from the @code{iso_c_binding}
|
|
|
1993 module, a warning is added as a comment to the code.
|
|
|
1994
|
|
|
1995 For function pointers, a pointer to a function returning @code{int}
|
|
|
1996 without an explicit argument list is generated.
|
|
|
1997
|
|
|
1998 Example of use:
|
|
|
1999 @smallexample
|
|
|
2000 $ gfortran -fc-prototypes -fsyntax-only foo.f90 > foo.h
|
|
|
2001 @end smallexample
|
|
|
2002 where the C code intended for interoperating with the Fortran code
|
|
|
2003 then uses @code{#include "foo.h"}.
|
|
145
|
2004
|
|
|
2005 @item -fc-prototypes-external
|
|
|
2006 @opindex @code{c-prototypes-external}
|
|
|
2007 @cindex Generating C prototypes from external procedures
|
|
|
2008 This option will generate C prototypes from external functions and
|
|
|
2009 subroutines and write them to standard output. This may be useful for
|
|
|
2010 making sure that C bindings to Fortran code are correct. This option
|
|
|
2011 does not generate prototypes for @code{BIND(C)} procedures, use
|
|
|
2012 @option{-fc-prototypes} for that.
|
|
|
2013
|
|
|
2014 The generated prototypes may need inclusion of an appropriate
|
|
|
2015 header, such as as @code{<stdint.h>} or @code{<stdlib.h>}.
|
|
|
2016
|
|
|
2017 This is primarily meant for legacy code to ensure that existing C
|
|
|
2018 bindings match what @command{gfortran} emits. The generated C
|
|
|
2019 prototypes should be correct for the current version of the compiler,
|
|
|
2020 but may not match what other compilers or earlier versions of
|
|
|
2021 @command{gfortran} need. For new developments, use of the
|
|
|
2022 @code{BIND(C)} features is recommended.
|
|
|
2023
|
|
|
2024 Example of use:
|
|
|
2025 @smallexample
|
|
|
2026 $ gfortran -fc-prototypes-external -fsyntax-only foo.f > foo.h
|
|
|
2027 @end smallexample
|
|
|
2028 where the C code intended for interoperating with the Fortran code
|
|
|
2029 then uses @code{#include "foo.h"}.
|
|
111
|
2030 @end table
|
|
|
2031
|
|
|
2032 @node Environment Variables
|
|
|
2033 @section Environment variables affecting @command{gfortran}
|
|
|
2034 @cindex environment variable
|
|
|
2035
|
|
|
2036 @c man begin ENVIRONMENT
|
|
|
2037
|
|
|
2038 The @command{gfortran} compiler currently does not make use of any environment
|
|
|
2039 variables to control its operation above and beyond those
|
|
|
2040 that affect the operation of @command{gcc}.
|
|
|
2041
|
|
|
2042 @xref{Environment Variables,,Environment Variables Affecting GCC,
|
|
|
2043 gcc,Using the GNU Compiler Collection (GCC)}, for information on environment
|
|
|
2044 variables.
|
|
|
2045
|
|
|
2046 @xref{Runtime}, for environment variables that affect the
|
|
|
2047 run-time behavior of programs compiled with GNU Fortran.
|
|
|
2048 @c man end
|
