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