The following tables show the compiler options available in the XL Fortran compiler that you can enter in the configuration file, on the command line, or in the Fortran source code by using the @PROCESS compiler directive.
You can enter compiler options that start with -q, suboptions, and @PROCESS directives in either uppercase or lowercase. However, note that if you specify the -qmixed option, procedure names that you specify for the -qextern option are case-sensitive.
In general, this book uses the convention of lowercase for -q compiler options and suboptions and uppercase for @PROCESS directives. However, in the "Syntax" sections of this chapter and in the "Command-Line Option" column of the summary tables, we use uppercase letters in the names of -q options, suboptions, and @PROCESS directives to represent the minimum abbreviation for the keyword. For example, valid abbreviations for -qOPTimize are -qopt, -qopti, and so on.
Understanding the significance of the options you use and knowing the alternatives available can save you considerable time and effort in making your programs work correctly and efficiently.
The following options affect the compiler input at a high level. They determine which source files are processed and select case sensitivity, column sensitivity, and other global format issues.
Many of the options in Options for Compatibility change the permitted input format slightly.
Table 3. Options That Control Input to the Compiler
| Command-Line Option | @PROCESS Directive | Description | See Page |
|---|---|---|---|
| -Idir | Adds a directory to the search path for include files and
.mod files. If XL Fortran calls cpp, this
option adds a directory to the search path for #include files.
Before checking the default directories for include and .mod
files, the compiler checks each directory in the search path. For
include files, this path is only used if the file name in an INCLUDE
line is not provided with an absolute path. For #include
files, refer to the cpp documentation for the details of the
-I option.
| -I Option | |
| -qci=numbers | CI(numbers) | Activates the specified INCLUDE lines.
| -qci Option |
|
-qdirective [=directive_list] -qnodirective [=directive_list] |
DIRECTIVE [(directive_list)] NODIRECTIVE [(directive_list)] | Specifies sequences of characters, known as trigger constants, that
identify comment lines as compiler comment directives.
| -qdirective Option |
|
-qfixed [=right_margin] |
FIXED [(right_margin)] | Indicates that the input source program is in fixed form and optionally
specifies the maximum line length.
| -qfixed Option |
|
-qfree[={f90|ibm}] -k |
FREE[({F90| IBM})] | Indicates that the source code is in free form. The ibm and f90 suboptions specify compatibility with the free form defined for VS
FORTRAN and Fortran 90/Fortran 95, respectively. -k and -qfree are short forms for
-qfree=f90.
| -qfree Option |
|
-qmbcs -qnombcs |
MBCS NOMBCS | Indicates to the compiler whether character literal constants, Hollerith
constants, H edit descriptors, and character string edit descriptors can
contain Multibyte Character Set (MBCS) or Unicode characters.
| -qmbcs Option |
|
-U -qmixed -qnomixed |
MIXED NOMIXED | Makes the compiler sensitive to the case of letters in names.
| -U Option |
| -qsuffix={suboptions} | Specifies the source-file suffix on the command line. | -qsuffix Option |
The following options specify names or directories where the compile stores output files.
In the table, an * indicates that the option is processed by the ld command, rather than by the XL Fortran compiler; you can find more information about these options in the AIX information for the ld command.
Table 4. Options That Specify the Locations of Output Files
| Command-Line Option | @PROCESS Directive | Description | See Page |
|---|---|---|---|
| -d | Leaves preprocessed source files produced by cpp, instead of
deleting them.
| -d Option | |
| -o name* | Specifies a name for the output object, executable, or assembler source
file.
| -o Option | |
| -qmoddir=directory | Specifies the location for any module (.mod) files that
the compiler writes.
| -qmoddir Option |
The following options can help you to speed up the execution of your XL Fortran programs or to find areas of poor performance that can then be tuned. The most important such option is -O. In general, the other performance-related options work much better in combination with -O; some have no effect at all without -O.
Some of the options in Options for Floating-Point Processing can also improve performance, but you must use them with
care to avoid error conditions and incorrect results.
Table 5. Options for Performance Optimization
| Command-Line Option |
| @PROCESS Directive | Description | See Page |
|---|---|---|---|---|
|
-O[level] -qoptimize[=level] -qnooptimize |
|
OPTimize[(level)] NOOPTimize | Specifies whether code is optimized during compilation and, if so, at
which level (0, 2, 3, 4, or 5).
| -O Option |
| -P{v|k}[!] |
| Invokes the selected optimizing preprocessor. Adding ! prevents the compilation step from following
preprocessing.
| -P Option | |
|
-p -pg |
| Sets up the object file for profiling.
| -p Option | |
|
-Q -Q! -Q+names -Q-names |
| Specifies whether procedures are inlined and/or particular procedures
that should or should not be inlined. names is a list of
procedure names separated by colons.
| -Q Option | |
|
-qalias= {[no]aryovrlp | [no]intptr| [no]pteovrlp| [no]std}...] |
|
ALIAS( {[NO]ARYOVRLP |[NO]INTPTR |[NO]PTEOVRLP |[NO]STD}... ) | Indicates whether a program contains certain categories of
aliasing. The compiler limits the scope of some optimizations when
there is a possibility that different names are aliases for the same storage
locations.
| -qalias Option |
| -qalign={[no]4k|struct [=packed | natural| port]} |
| ALIGN( {[NO]4K | STRUCT[packed | natural| port]}) | Specifies the alignment of data objects in storage, which avoids
performance problems with misaligned data. Both the [no]4k and struct options can be specified and are not mutually
exclusive. The default setting is
-qalign=no4k:struct=natural. The [no]4K option is useful
primarily in combination with logical volume I/O and disk striping.
| -qalign Option |
| -qarch=architecture |
| Controls which instructions the compiler can generate. Changing the default can improve performance but might produce code
that can only be run on specific machines. The choices are com, auto, rs64a, rs64b, rs64c, p2sc, pwr, pwr2 (or pwrx), pwr3, pwr4, pwr2s, ppc, 601, 603, and 604.
| -qarch Option | |
|
-qassert={ deps | nodeps | itercnt=n} |
| Provides information about the characteristics of the files that can help
to fine-tune optimizations.
| -qassert Option | |
|
-qcache={ auto | assoc=number | cost=cycles | level=level | line=bytes | size=Kbytes | type={C|D|I}}[:...] |
| Specifies the cache configuration for a specific execution
machine. The compiler uses this information to tune program
performance, especially for loop operations that can be structured (or blocked) to process only the amount of data that can fit into the data
cache.
| -qcache Option | |
|
-qcompact -qnocompact |
|
COMPACT NOCOMPACT | Reduces optimizations that increase code size.
| -qcompact Option |
|
-qfdpr -qnofdpr |
| Provides object files with information needed for the AIX fdpr (Feedback
Directed Program Restructuring) performance-tuning utility to optimize the
resulting executable file.
| -qfdpr Option | |
|
-qhot[=suboptions] -qnohot |
|
HOT[=suboptions] NOHOT | Determines whether to perform high-order transformations on loops and
array language during optimization and whether to pad array dimensions and
data objects to avoid cache misses.
| -qhot Option |
| -qipa[=suboptions] |
| Enhances -O optimization by doing detailed analysis across procedures
(interprocedural analysis or IPA).
| -qipa Option | |
|
-qlargepage -qnolargepage |
|
| Indicates to the compiler that a program, designed to execute in a large page memory environment, can take advantage of large 16 MB pages provided on POWER4 and higher based systems. | -qlargepage Option |
| -qpdf{1|2} |
| Tunes optimizations through profile-directed feedback (PDF),
where results from sample program execution are used to improve optimization
near conditional branches and in frequently executed code sections.
| -qpdf Option | |
|
-qsmallstack -qnosmallstack |
|
|
Specifies that the compiler will minimize stack usage where
possible.
| -qsmallstack Option |
|
-qsmp[=suboptions] -qnosmp |
| When used with xlf_r, xlf_r7, xlf90_r,
xlf90_r7, xlf95_r, or xlf95_r7, controls automatic
parallelization of loops, user-directed parallelization of loops and other items, and the choice of chunking algorithm.
| -qsmp Option | |
|
-qstrict -qnostrict |
|
STRICT NOSTRICT | Ensures that optimizations done by the -O3, -O4, -O5, -qhot, and -qipa options do not alter the semantics of a Fortran 90 or Fortran 95
program.
| -qstrict Option |
|
-qstrictieeemod -qnostrictieeemod |
|
STRICTIEEE- MOD NOSTRICTIEEE- MOD | Specifies whether the compiler will adhere to the Fortran 2000 IEEE
arithmetic rules for the ieee_arithmetic and ieee_exceptions
intrinsic modules.
| -qstrictieeemod Option |
|
-qstrict_induction -qnostrict_induction |
|
|
Prevents the compiler from performing induction (loop counter) variable optimizations. These optimizations may be unsafe (may alter the semantics of your program) when there are integer overflow operations involving the induction variables.
| -qstrict_induction Option |
|
-qsuppress= nnnn-mmm[:nnnn-mmm...] -qnosuppress |
| Specifies selective messages to suppress from the output stream. | -qsuppress Option | |
| -qthreaded |
| Specifies that the compiler should generate thread-safe code. This is turned on by default for the xlf_r, xlf_r7, xlf90_r, xlf90_r7, xlf95_r, and xlf95_r7 commands. | -qthreaded Option | |
| -qtune=implementation |
| Tunes instruction selection, scheduling, and other
implementation-dependent performance enhancements for a specific
implementation of a hardware architecture. The following settings are
valid: auto, 601, 603, 604, pwr, pwr2 (or pwrx), pwr3, pwr4, pwr2s, rs64a,
rs64b, rs64c, or p2sc.
| -qtune Option | |
|
-qunroll [=auto | yes] -qnounroll |
|
| Specifies whether the compiler is allowed to automatically unroll
DO loops.
| -qunroll Option |
|
-qunwind -qnounwind |
|
UNWIND NOUNWIND | Specifies default behavior for saving and restoring from volatile
registers during a procedure call.
| -qunwind Option |
|
-qzerosize -qnozerosize |
|
ZEROSIZE NOZEROSIZE | Improves performance of FORTRAN 77 and some Fortran 90 and Fortran 95
programs by preventing checking for zero-sized character strings and
arrays.
| -qzerosize Option |
The following options help you avoid, detect, and correct problems in your XL Fortran programs and can save you having to refer as frequently to Chapter 11, Problem Determination and Debugging.
In particular, -qlanglvl helps detect portability problems early in the compilation process by warning of potential violations of the Fortran standards. These can be due to extensions in the program or due to compiler options that allow such extensions.
Other options, such as -C and -qflttrap, detect and/or prevent run-time errors in calculations, which could otherwise produce incorrect output.
Because these options require additional checking at compile time and some of them introduce run-time error checking that slows execution, you may need to experiment to find the right balance between extra checking and slower compilation and execution performance.
Using these options can help to minimize the amount of problem determination and debugging you have to do. Other options you may find useful while debugging include:
Table 6. Options for Debugging and Error Checking
| Command-Line Option | @PROCESS Directive | Description | See Page |
|---|---|---|---|
|
-C -qcheck -qnocheck |
CHECK NOCHECK | Checks each reference to an array element, array section, or character
substring for correctness. Out-of-bounds references are reported as
severe errors if found at compile time and generate SIGTRAP signals
at run time.
| -C Option |
|
-D -qdlines -qnodlines |
DLINES NODLINES | Specifies whether fixed-form lines with a D in column 1 are compiled or
treated as comments.
| -D Option |
|
-g -qdbg -qnodbg |
DBG NODBG | Generates debug information for use by a symbolic debugger.
| -g Option |
|
-qdpcl -qnodpcl |
DPCL NODPCL | Generates symbols that tools based on the Dynamic Probe Class Library
(DPCL) can use to see the structure of an executable file.
| -qdpcl Option |
|
-qextchk -qnoextchk |
EXTCHK NOEXTCHK | Sets up type-checking information for common blocks, procedure
definitions, procedure references, and module data. Later, the linker
can detect mismatches across compilation units by using this
information.
| -qextchk Option |
|
-qflttrap [=suboptions] -qnoflttrap |
FLTTRAP [(suboptions)] NOFLTTRAP | Determines what types of floating-point exception conditions to detect at
run time. The program receives a SIGTRAP signal when the
corresponding exception occurs.
| -qflttrap Option |
|
-qfullpath -qnofullpath | Records the full, or absolute, path names of source and include files in
object files compiled with debugging information (-g option).
| -qfullpath Option | |
| -qhalt=sev | HALT(sev) | Stops before producing any object, executable, or assembler source files
if the maximum severity of compile-time messages equals or exceeds the
specified severity. severity is one of i, l, w, e, s, u, or q, meaning informational, language, warning, error, severe error,
unrecoverable error, or a severity indicating "don't stop".
| -qhalt Option |
|
-qinitauto[=hex_value] -qnoinitauto | Initializes each byte or word (4 bytes) of storage for automatic
variables to a specific value, depending on the length of the
hex_value. This helps you to locate variables that are
referenced before being defined. For example, by using both the -qinitauto option to initialize REAL variables with a NaNS
value and the -qflttrap option, it is possible to identify references to uninitialized
REAL variables at run time.
| -qinitauto Option | |
|
-qlanglvl={ 77std | 90std | 90pure | 90ext | 95std | 95pure | extended}
|
LANGLVL({ 77STD | 90STD | 90PURE | 90EXT | 95STD | 95PURE | EXTENDED}) | Determines which language standard (or superset or subset of a standard)
to consult for nonconformance. It identifies nonconforming source code and
also options that allow such nonconformances.
| -qlanglvl Option |
|
-qsaa -qnosaa |
SAA NOSAA | Checks for conformance to the SAA FORTRAN language definition. It identifies nonconforming source code and also options that allow such nonconformances. | -qsaa Option |
|
-qsigtrap[= trap_handler] | Installs xl_ _trce or a predefined or user-written
trap handler in a main program.
| -qsigtrap Option | |
|
-qtbtable={none | small | full} | Limits the amount of debugging traceback information in object files, to
reduce the size of the program.
| -qtbtable Option | |
|
-qwarn64 -qnowarn64 | Detects the truncation of an 8-byte integer pointer to 4 bytes.
Identifies, through informational messsages, statements that might cause problems during the 32-bit to 64-bit migration.
|
| |
|
-qxlines -qnoxlines |
XLINES NOXLINES | Specifies whether fixed-form lines with a X in column 1 are treated as
source code and compiled, or treated instead as comments.
| -qxlines Option |
The following options determine whether the compiler produces a listing (.lst file), what kinds of information go into the listing, and what the compiler does about any error conditions it detects.
Some of the options in Options for Error Checking and Debugging can also produce compiler messages.
Table 7. Options That Control Listings and Messages
| Command-Line Option | @PROCESS Directive | Description | See Page |
|---|---|---|---|
| -# | Generates information on the progress of the compilation without actually running the individual components.
| -# Option | |
|
-qattr[=full] -qnoattr |
ATTR[(FULL)] NOATTR | Specifies whether to produce the attribute component of the attribute and
cross-reference section of the listing.
| -qattr Option |
|
-qflag= listing_severity: terminal_severity -w |
FLAG (listing_severity, terminal_severity) | Limits the diagnostic messages to those of a specified level or
higher. Only messages with severity listing_severity or higher
are written to the listing file. Only messages with severity
terminal_severity or higher are written to the terminal. -w is a short form for -qflag=e:e.
| -qflag Option |
|
-qlist -qnolist |
LIST NOLIST | Specifies whether to produce the object section of the listing.
| -qlist Option |
|
-qlistopt -qnolistopt |
LISTOPT NOLISTOPT | Determines whether to show the setting of every compiler option in the
listing file or only selected options. These selected options include
those specified on the command line or directives plus some that are
always put in the listing.
| -qlistopt Option |
| -qnoprint | Prevents the listing file from being created, regardless of the settings
of other listing options.
| -qnoprint Option | |
|
-qphsinfo -qnophsinfo |
PHSINFO NOPHSINFO | Determines whether timing information is displayed on the terminal for
each compiler phase.
| -qphsinfo Option |
|
-qreport[={smplist | hotlist}...] -qnoreport |
REPORT [({SMPLIST | HOTLIST}...)] NOREPORT | Determines whether to produce transformation reports showing how the
program is parallelized and how loops are optimized.
| -qreport Option |
|
-qsource -qnosource |
SOURCE NOSOURCE | Determines whether to produce the source section of the listing.
| -qsource Option |
|
-qxref -qnoxref -qxref=full |
XREF NOXREF XREF(FULL) | Determines whether to produce the cross-reference component of the
attribute and cross-reference section of the listing.
| -qxref Option |
| -S | Produces one or more .s files showing equivalent
assembler source for each Fortran source file.
| -S Option | |
| -v | Traces the progress of the compilation by displaying the name and
parameters of each compiler component that is executed by the invocation
command.
| -v Option | |
| -V | Traces the progress of the compilation by displaying the name and
parameters of each compiler component that is executed by the invocation
command. These are displayed in a shell-executable format.
| -V Option |
The following options help you maintain compatibility between your XL Fortran source code on past, current, and future hardware platforms or help you port programs to XL Fortran with a minimum of changes.
The -qfree=ibm form of the -qfree Option also provides compatibility with VS FORTRAN free
form.
Table 8. Options for Compatibility
| Command-Line Option | @PROCESS Directive | Description | See Page |
|---|---|---|---|
| -qautodbl=setting | AUTODBL(setting) | Provides an automatic means of converting single-precision floating-point
calculations to double-precision and of converting double-precision
calculations to extended-precision. Use one of the following
settings: none, dbl, dbl4, dbl8, dblpad, dblpad4, or dblpad8.
| -qautodbl Option |
|
-qcclines -qnocclines |
CCLINES NOCCLINES | Determines whether the compiler recognizes conditional compilation
lines.
| -qcclines Option |
|
-qctyplss [=([no]arg)] -qnoctyplss |
CTYPLSS [([NO]ARG)] NOCTYPLSS | Specifies whether character constant expressions are allowed wherever
typeless constants may be used. This language extension might be needed
when you are porting programs from other platforms. Suboption
arg specifies that Hollerith constants used as actual arguments will
be treated as integer actual arguments.
| -qctyplss Option |
|
-qddim -qnoddim |
DDIM NODDIM | Specifies that the bounds of pointee arrays are re-evaluated each time
the arrays are referenced and removes some restrictions on the bounds
expressions for pointee arrays.
| -qddim Option |
|
-qdpc -qdpc=e -qnodpc |
DPC DPC(E) NODPC | Increases the precision of real constants, for maximum accuracy when
assigning real constants to DOUBLE PRECISION variables. This language extension might be needed when you are porting
programs from other platforms.
| -qdpc Option |
|
-qescape -qnoescape |
ESCAPE NOESCAPE | Specifies how the backslash is treated in character strings, Hollerith
constants, H edit descriptors, and character string edit descriptors.
It can be treated as an escape character or as a backslash character.
This language extension might be needed when you are porting
programs from other platforms.
| -qescape Option |
| -qessl |
Allows the use of ESSL routines in place of Fortran 90 Intrinsic Procedures. Use the ESSL Serial Library when linking with -lessl. Use the ESSL SMP Library when linking with -lesslsmp.
| -qessl Option | |
| -qextern=names | Allows user-written procedures to be called instead of XL Fortran
intrinsics. names is a list of procedure names separated by
colons. The procedure names are treated as if they appear in an
EXTERNAL statement in each compilation unit being compiled.
If any of your procedure names conflict with XL Fortran intrinsic
procedures, use this option to call the procedures in the source code instead
of the intrinsic ones.
| -qextern Option | |
|
-qextname -qnoextname |
EXTNAME NOEXTNAME | Adds an underscore to the names of global entities, which helps in
porting programs from systems where this is a convention for mixed-language
programs.
| -qextname Option |
|
-qintlog -qnointlog |
INTLOG NOINTLOG | Specifies that you can mix integer and logical values in expressions and
statements.
| -qintlog Option |
| -qintsize=bytes | INTSIZE(bytes) | Sets the size of default INTEGER and LOGICAL
values.
| -qintsize Option |
|
-qlog4 -qnolog4 |
LOG4 NOLOG4 | Specifies whether the result of a logical operation with logical operands
is a LOGICAL(4) or is a LOGICAL with the maximum length of
the operands.
| -qlog4 Option |
|
-qnullterm -qnonullterm |
NULLTERM NONULLTERM | Appends a null character to each character constant expression that is
passed as a dummy argument, to make it more convenient to pass strings to C
functions.
| -qnullterm Option |
|
-1 -qonetrip -qnoonetrip |
ONETRIP NOONETRIP | Executes each DO loop in the compiled program at least once if
its DO statement is executed, even if the iteration count is
0.
| -1 Option |
|
-qport [=suboptions] -qnoport |
PORT [(suboptions)] NOPORT | Increases flexibility when porting programs to XL Fortran by providing a
number of options to accommodate other Fortran language extensions.
| -qport Option |
|
-qposition= {appendold | appendunknown} |
POSITION( {APPENDOLD | APPENDUNKNOWN}) | Positions the file pointer at the end of the file when data is written
after an OPEN statement with no POSITION= specifier and the
corresponding STATUS= value (OLD or UNKNOWN) is
specified.
| -qposition Option |
|
-qqcount -qnoqcount |
QCOUNT NOQCOUNT | Accepts the Q character-count edit descriptor (Q) as
well as the extended-precision Q edit descriptor
(Qw.d). With -qnoqcount, all Q edit descriptors are interpreted as the
extended-precision Q edit descriptor.
| -qqcount Option |
| -qrealsize=bytes | REALSIZE(bytes) | Sets the default size of REAL, DOUBLE PRECISION,
COMPLEX, and DOUBLE COMPLEX values.
| -qrealsize Option |
|
-qsave[={all | defaultinit}] -qnosave |
SAVE{(ALL | DEFAULTINIT)} NOSAVE | Specifies the default storage class for local variables. -qsave, -qsave=all, or -qsave=defaultinit sets the default storage
class to STATIC, while -qnosave sets it to AUTOMATIC.
Specify -qsave for the xlf, xlf_r, xlf_r7, f77, or fort77 to duplicate the behaviour of FORTRAN77 commands. | -qsave Option |
|
-qswapomp -qnoswapomp |
SWAPOMP NOSWAPOMP | Specifies that the compiler should recognize and substitute OpenMP
routines in XL Fortran programs.
| -qswapomp Option |
|
-u -qundef -qnoundef |
UNDEF NOUNDEF | Specifies whether implicit typing of variable names is permitted.
-u and -qundef have the same effect as the IMPLICIT NONE statement that
appears in each scope that allows implicit statements.
| -u Option |
| -qxflag=oldtab | XFLAG(OLDTAB) | Interprets a tab in columns 1 to 5 as a single character (for fixed-form
programs), for compatibility with XL Fortran Version 1.
| -qxflag=oldtab Option |
| -qxlf77=settings | XLF77(settings) | Provides backward compatibility with the language from XL Fortran
Versions 1 and 2 for aspects of language semantics and I/O data format that
have changed. Most of these changes are required by the Fortran 90
standard.
| -qxlf77 Option |
|
-qxlf90= {[no]signedzero | [no]autodealloc} |
XLF90( {[no]signedzero | [no]autodealloc}) | Determines whether the compiler provides the Fortran 90 or the Fortran 95
level of support for certain aspects of the language.
| -qxlf90 Option |
The following option is intended for writing new programs. It
changes the program in ways that would otherwise require source-code
changes.
Table 9. Option for Fortran 90 Extensions
| Command-Line Option | @PROCESS Directive | Description | See Page |
|---|---|---|---|
| -qinit=f90ptr | INIT(f90ptr) | Makes the initial association status of pointers disassociated.
| -qinit Option |
To take maximum advantage of the system floating-point performance and precision, you may need to specify details of how the compiler and XLF-compiled programs perform floating-point calculations.
Table 10. Options for Floating-Point Processing
| Command-Line Option | @PROCESS Directive | Description | See Page |
|---|---|---|---|
| -qfloat=options | FLOAT(options) | Determines how the compiler generates or optimizes code to handle
particular types of floating-point calculations.
| -qfloat Option |
|
-qieee={ Near | Minus | Plus | Zero} -y{n|m|p|z} |
IEEE({Near | Minus | Plus | Zero}) | Specifies the rounding mode for the compiler to use when evaluating
constant floating-point expressions at compile time.
| -qieee Option |
The following options control the way the ld command processes object files during compilation. Some of these options are passed on to ld and are not processed by the compiler at all.
You can actually include ld options on the compiler command line, because the compiler passes unrecognized options on to the linker.
In the table, an * indicates that the option is processed by the ld command, rather than the XL Fortran compiler; you can find more information about these options in the AIX information for the ld command.
Other linker options you might find helpful are the following:
Table 11. Options That Control Linking
| Command-Line Option | @PROCESS Directive | Description | See Page |
|---|---|---|---|
| -b64* | Instructs ld to bind 64-bit objects in 64-bit mode. | -b64 Option | |
|
-bdynamic* -bshared* -bstatic* | These options are toggles used to control the processing of -l options and the way that shared objects are processed. | -bdynamic, -bshared, and -bstatic Options | |
| -bhalt:error_level* | Specifies the maximum error level allowed before linker command processing
halts.
| -bhalt Option | |
| -bloadmap:name* | Requests that a log of linker actions and messages be saved in file
name.
| -bloadmap Option | |
|
-bmaxdata:bytes* -bmaxstack:bytes* | Specifies the maximum amount of space to reserve for the program data
segment and stack segment for programs where the size of these regions is a
constraint.
| -bmaxdata, -bmaxstack Options | |
|
-brtl* -bnortl* | Determines which algorithm is used to find libraries (specified with the -l option). | -brtl Option | |
| -c | Produces an object file instead of an executable file.
| -c Option | |
| -Ldir* | Looks in the specified directory for libraries specified by the
-l option.
| -L Option | |
| -lkey* | Searches the specified library file, where key selects the file
libkey.a.
| -l Option | |
|
-qOBJect -qNOOBJect |
OBJect NOOBJect | Specifies whether to produce an object file or to stop immediately after
checking the syntax of the source files.
| -qobject Option |
These options can help to do the following:
Table 12. Options That Control the Compiler Internal Operation
| Command-Line Option | @PROCESS Directive | Description | See Page |
|---|---|---|---|
| -Bprefix | Determines a substitute path name for executable files used during
compilation, such as the compiler or linker. It can be used in
combination with the -t option, which determines which of these components are affected by
-B.
| -B Option | |
|
-Fconfig_file -Fconfig_file: stanza -F:stanza | Specifies an alternative configuration file, the stanza to use within the configuration file,
or both.
| -F Option | |
| -q32 | Sets the bit mode and instruction set for a 32-bit target architecture. | -q32 Option | |
| -q64 | Sets the bit mode and instruction set for a 64-bit target architecture. | -q64 Option | |
|
-qlm -qnolm | Disables the license management control.
| -qlm Option | |
|
-NSbytes -qSPILLsize= bytes |
SPILLsize (bytes) | Specifies the size of internal program storage areas.
| -N Option |
|
-qmaxmem= Kbytes |
MAXMEM (Kbytes) | Limits the amount of memory that the compiler allocates while performing
specific, memory-intensive optimizations to the specified number of
kilobytes. A value of -1 allows optimization to take as much memory as
it needs without checking for limits.
| -qmaxmem Option |
| -qsclk=[centi | micro ] |
| Specifies that when returning a value using the SYSTEM_CLOCK
intrinsic procedure, the compiler will use centisecond resolution. You
can specify a microsecond resolution by using
-qsclk=micro.
Default: -qsclk=centi | -qsclk Option |
| -tcomponents | Applies the prefix specified by the -B option to the designated components. components
can be one or more of p, F, c, d, I, a, h, b, z, or l, with no
separators, corresponding to an optimizing preprocessor, the C preprocessor,
the compiler, the -S disassembler, the interprocedural analysis (IPA) tool, the
assembler, the loop optimizer, the code generator, the binder (fast linker),
and the linker, respectively.
| -t Option | |
| -Wcomponent,options | Passes the listed options to a component that is executed during
compilation. component is p, F, c, d, I, a, z, or l, corresponding to an optimizing preprocessor, the C
preprocessor, the compiler, the -S disassembler, the interprocedural analysis (IPA) tool, the
assembler, the binder (fast linker), and the linker, respectively.
| -W Option |
The following options are obsolete for either or both of the following reasons:
Notes:
Table 13. Options That Are Obsolete or Not Recommended
| Command-Line Option | @PROCESS Directive | Description | See Page |
|---|---|---|---|
|
-qcharlen= length |
CHARLEN (length) | Obsolete. It is still accepted, but it has no effect. The maximum length for character constants and subobjects of constants is 32 767 bytes (32 KB). The maximum length for character variables is 268 435 456 bytes (256 MB) in 32-bit mode. The maximum length for character variables is 2**40 bytes in 64-bit mode. These limits are always in effect and are intended to be high enough to avoid portability problems with programs that contain long strings. | -qcharlen Option |
|
-qrecur -qnorecur |
RECUR NORECUR | Not recommended. Specifies whether external subprograms may be
called recursively.
For new programs, use the RECURSIVE keyword, which provides a standard-conforming way of using recursive procedures. If you specify the -qrecur option, the compiler must assume that any procedure could be recursive. Code generation for recursive procedures may be less efficient. Using the RECURSIVE keyword allows you to specify exactly which procedures are recursive. | -qrecur Option |