Man Page f95.1
NAME
f95, f90 - Fortran 95 compiler
SYNOPSIS
May be invoked by either f95 or f90 commands; they are
equivalent.
f95 [ -a ] [ -aligncommon[=a] ] [ -ansi ]
[ -autopar ] [ -Bx ] [ -C ] [ -c ] [ -cg89 ] [ -cg92 ]
[ -copyargs ] [ -Dnm[=def] ] [ -dalign ]
[ -dbl_align_all[=yes|no] ] [ -depend ]
[ -dryrun ] [ -d[y|n] ] [ -e ] [ -erroff=taglist ]
[ -errtags[=yes|no] ] [ -explicitpar ] [ -ext_names=e ]
[ -F ] [ -f ] [ -f77[=list] ] [ -fast ] [ -fixed ]
[ -flags ] [ -fnonstd ] [ -fns=yes|no ]
[ -fpover=yes|no ] [ -fpp ] [ -free ]
[ -fround=r ] [ -fsimple[=n] ] [ -ftrap=t ]
[ -G ] [ -g ] [ -hnm ] [ -help ] [ -Ipath ]
[ -inline=rl ] [ -iorounding=r ] [ -KPIC ] [ -Kpic ]
[ -Lpath ] [ -lx ] [ -libmil ] [ -loopinfo ]
[ -M path ] [ -moddir=path ] [ -mp=x ] [ -mt ]
[ -native ] [ -noautopar ] [ -nodepend ]
[ -noexplicitpar ] [ -nolib ] [ -nolibmil ]
[ -noreduction ] [ -norunpath ] [ -O[n] ] [ -o nm ]
[ -onetrip ] [ -openmp ] [ -PIC ] [ -p ] [ -pad[=p] ]
[ -parallel] [ -pg ] [ -pic ]
[ -Qoption pr ls ] [ -qp ] [ -R list ] [ -r8const ]
[ -reduction ] [ -S ] [ -s ] [ -sb ] [ -sbfast ]
[ -silent ] [ -stackvar ] [ -stop_status=yes|no ]
[ -temp=path ] [ -time ] [ -U ] [ -Uname ] [ -u ]
[ -unroll=n ] [ -use=list ] [ -V ] [ -v ] [ -vpara ]
[ -w[n] ] [ -Xlist[z] ] [ -xa ]
[ -xalias[=v] ] [ -xarch=a ]
[ -xautopar ] [ -xcache=c ] [ -xcg89 ] [ -xcg92 ]
[ -xcheck=stkovf ] [ -xchip=c ] [ -xcode=v ]
[ -xcommonchk[=no|yes] ] [ -xcrossfile=n ]
[ -xdepend ] [ -xexplicitpar ] [ -xF ]
[ -xhasc[=yes|no] ] [ -xhelp=h ] [ -xia[=i] ]
[ -xildoff ] [ -xildon ] [ -xinline=rl ]
[ -xinterval=i ] [ -xipo[=n] ] [ -xknown_lib=lib ]
[ -xlang=f77 ] [ -xlibmil ] [ -xlibmopt ] [ -xlicinfo ]
[ -xlic_lib=sunperf ] [ -xloopinfo ] [ -xmaxopt[=n] ]
[ -xmemalign[=ab] ] [ -xnolib ] [ -xnolibmil ]
[ -xnolibmopt ] [ -xO[n] ] [ -xopenmp ] [ -xpad ]
[ -xparallel ] [ -xpg ] [ -xpp=p ] [ -xprefetch=a[,a]]
[ -xprefetch_level=n ] [ -xprofile=p ]
[ -xrecursive ] [ -xreduction ] [ -xregs=r ] [ -xs ]
[ -xsafe=mem ] [ -xsb ] [ -xsbfast ]
[ -xspace ] [ -xtarget=t ] [ -xtime ]
[ -xtypemap=spec ] [ -xunroll=n ]
[ -xvector=yes|no ] [ -ztext ]
source file(s) ... [ -lx ]
DESCRIPTION
Forte[tm] Developer 7 Fortran 95 compiler.
The f95 compiler accepts compliant Fortran 95 source code
programs. It also accepts extensions for interval arithmetic
constructs, and the OpenMP[tm] Fortran 95 API version 2.0.
It also accepts many FORTRAN 77 (f77) language extensions
under the -f77 compatibility option.
See the online readme file, viewable by calling
f95 -xhelp=readme
for the latest important information on platforms, environ-
ments, new features, limitations, problems, workarounds, and
software corrections.
A man page, by definition, is a quick reference. For more
detailed information on using the f95 compiler and its
options, see the Fortran User Guide and the Fortran Program-
ming Guide.
See the Fortran User's Guide for complete details on how to
use the f95 compiler. The user guide details all the
options, pragma directives, and environment variables
accepted by f95, and describes any differences between stan-
dard Fortran 95 and this Fortran 95 compiler.
See the Fortran Programming Guide for information on program
performance and optimization, parallelization, and porting
from other Fortran platforms.
A list of relevant Forte Developer documentation appears at
the end of this man page.
Access all the installed Forte Developer 7 documentation,
including readme files, user guides, and reference manuals
by pointing an HTML browser to
file:/opt/SUNWspro/docs/index.html
CHANGES
In this release of the Forte Developer 7 Fortran 95 com-
piler:
The following option flags are new:
-f77
-iorounding
-moddir
-use
-xalias
-xcheck=stkovf
-xknown_lib
-xprefetch_level
The following option flags have been enhanced:
-C
-M
-xipo
-Xlist
The following environment variable is new:
MODDIR
The following pragma directive is new:
!$PRAGMA IGNORE_TKR
For more information about this release of the compiler, see
the compiler readme file by by executing the command
f95 -xhelp=readme.
For details, see the Fortran User's Guide.
OPTIONS
See ld(1) for linker options.
f95 compiles "silently". Except for error and warning mes-
sages, it does not issue "progress" messages during compila-
tion.
In general, processing of the compiler options is from left
to right, permitting selective overriding of macro options.
This rule does not apply to linker or preprocessor options.
-a Profile by basic block for tcov (Obsolete)
Count how often each basic block is executed. Run
tcov(1) on the source file to generate statistics about
the program.
This is the old style of basic block profiling for
tcov. Use instead -xprofile=tcov.
-aligncommon[=1|2|4|8|16]
Specify alignment of data in common block.
The value specified indicates the maximum alignment (in
bytes) for data elements within common blocks. For
example, -aligncommon=4 would align common block data
elements with natural alignments of 4 bytes or more on
4-byte boundaries. This option does not affect data
with natural alignment smaller than the specified size.
The default, when -aligncommon is not specified, aligns
common block data on at most 4-byte boundaries.
Specifying -aligncommon without a value defaults to 1
on all platforms: all data aligns on byte boundaries
(no padding between elements).
-aligncommon=16 reverts to -aligncommon=8 on platforms
that are not 64-bit enabled (platforms other than v9,
v9a, or v9b).
See also -xmemalign
-ansi
Identify non-standard extensions.
-autopar
Enable automatic loop parallelization
Find and parallelize appropriate loops. Do dependence
analysis (analyze loops for data dependences). Do loop
restructuring. If optimization is not -O3 or higher,
it is raised to -O3.
Also specify the -stackvar option when using any of the
parallelization options, including -autopar. See the
description of the -stackvar option for information on
how to set the sizes for the main thread stack and for
the slave thread stacks.
Avoid -autopar if you do your own thread management.
See note under -mt.
Also, -autopar is inappropriate on a single-processor
system, and will degrade performance.
For more information, see the Parallelization chapter
in the Fortran Progammer's Guide.
Number of Threads: To run a parallelized program in a
multithreaded environment, you must set the PARALLEL or
OMP_NUM_THREADS envrionment variables prior to execu-
tion. These variables tell the runtime system the max-
imum number of threads the program can create. The
default is 1. In general, set PARALLEL or
OMP_NUM_THREADS to the available number of processors
on the target platform.
If -autopar is specified but -explicitpar is not, then
explicit parallelization directives are ignored.
If you use -autopar and compile and link in one step,
linking will automatically include the microtasking
library and the threads-safe Fortran runtime library.
If you use -autopar and compile and link in separate
steps, then you must link with f95 -autopar as well.
-B{dynamic|static}
Prefer dynamic or require static library linking.
Indicates that either dynamic library linking is pre-
ferred, or static linking required for any libraries
listed later in the command. x must be dynamic or
static. The default is dynamic. This is a linker
option.
-Bdynamic: Prefer dynamic linking (shared libraries)
-Bstatic : Require static linking (no shared
libraries)
If you specify static but the linker finds only a
dynamic library, then the library is not linked and a
warning issued.
However, if you specify dynamic but the linker finds
only a static version, that library is linked with no
warning.
You can toggle between -Bdynamic and -Bstatic on the
command line, linking some libraries statically and
others dynamically.
These are linker options. Compiling with -Bx requires
the same options on a linker command if done in
separate steps.
In a 64-bit environment, many system libraries are
available only as shared dynamic libraries. These
include libm.so and libc.so (libm.a and libc.a are not
provided). As a result, -Bstatic and -dn may cause
linking errors in 64-bit Solaris environments. Applica-
tions must link with the dynamic libraries in these
cases.
-C Check array references for out of range subscripts and
conformance.
Subscripting arrays beyond their declared sizes may
result in unexpected results, including segmentation
faults. The -C option checks for possible array sub-
script violations in the source code and during execu-
tion.
With the -C option specified, run-time array subscript
violations are treated as an error. The compiler will
also flag array subscript range violations in the
source code as warnings.
Compiling with -C also adds checks for array confor-
mance at runtime in statements using array syntax.
This option will increase the size of the executable
file and degrade execution performance. It should only
be used while debugging.
-c Compile only, do not make executable file.
Compile and produce a .o file for each source file but
suppress linking by the loader. You can name a single
object file explicitly using the -o option.
-cg89
Generate code for generic SPARC architecture (Obsolete)
This option is a macro for:
-xarch=v7 -xchip=old -xcache=64/32/1
and is equivalent to: -xtarget=ss2
-cg92
Generate code for SPARC V8 architecture (Obsolete)
This option is a macro for:
-xarch=v8 -xchip=super -xcache=16/32/4:1024/32/1.
and is equivalent to: -xtarget=ss1000
-copyargs
Allow assignment to constant arguments.
Allow a subprogram to change a dummy argument that is a
constant. This option is provided only to allow legacy
code to compile and execute without a runtime error for
changing a constant.
Without -copyargs, if you pass a constant argument to a
subroutine, and then within the subroutine try to
change that constant, the run gets a runtime error.
With -copyargs, if you pass a constant argument to a
subroutine, and then within the subroutine change that
constant, the run does not necessarily get a runtime
error.
Programs that require compilation with the -copyargs
flag are not Fortran standard-compliant.
-Dname[=def]
Define symbol name for the source code preprocessor.
This is equivalent to a #define directive in the
source. If no def is given, name is defined as 1. This
option applies to .F .F90 .F95 suffix files only.
The following symbols are predefined on appropriate
systems; note the two leading underscores:
__sparc, __sparcv9, __unix, __sun, __SVR4,
__SunOS_5_6, __SunOS_5_7, __SunOS_5_8
Fortran syntax may not support the actual values of
these symbols--they should appear only on fpp or cpp
preprocessor statements, such as conditionals:
#ifdef __sparc
Corresponding older values (prior releases) are:
sparc, unix, sun,
These earlier predefined values may be deleted in a
future release.
f95 uses the fpp(1) preprocessor by default. Like the C
preprocessor cpp(1), fpp expands source code macros and
enables conditional compilation of code. Unlike cpp,
fpp understand Fortran syntax, and is preferred as a
Fortran preprocessor. Use the -xpp=cpp flag to force
the compiler to specifically use cpp rather than fpp.
-dalign
Align COMMON blocks and numeric sequence types
and generate faster multi-word load/stores.
This flag changes the data layout in COMMON blocks (and
EQUIVALENCE classes), and enables the compiler to gen-
erate faster multi-word load/stores for that data.
-dalign is a macro equivalent to
-xmemalign=8s -aligncommon=16
The data layout effect is that of the -f flag: double-
and quad-precision data in COMMON blocks and
EQUIVALENCE classes are laid out in memory along their
"natural" alignment, which is on 8-byte boundaries (or
16-byte boundaries for quad-precision when compiling
for 64-bit platforms with -xarch=v9, v9a, or v9b.) The
default alignment in COMMON blocks is on 4-byte boun-
daries.
Using -dalign along with
-xtypemap=real:64,double:64,integer:64 also causes 64-
bit integer variables to be double-word aligned.
Using -dalign, may result in non-standard FORTRAN
alignment which could cause problems with variables in
EQUIVALENCE or COMMON and may render the program non-
portable if -dalign is required.
If you compile one subprogram or file with -dalign,
then all subprograms and files in the program unit must
be compiled with -dalign.
Because -dalign invokes -aligncommon, the alignment of
numeric sequence types is also affected.
The -fast flag selects -dalign.
-dbl_align_all=yes|no
Force alignment of data on 8-byte boundaries.
If yes all variables will be aligned on 8-byte boun-
daries. Default is -dbl_align_all=no. By itself,
-dbl_align_all is equivalent to -dbl_align_all=yes.
When compiling for 64-bit environments with -xarch=v9,
v9a, or v9b, this flag will align quad-precision data
on 16-byte boundaries.
This flag does not alter the layout of data in COMMON
blocks or user-defined structures.
If used, all routines must be compiled with this
option.
-depend
Analyze loops for data dependences
Analyze loops for data dependences and do loop restruc-
turing. -depend data dependence analysis is selected as
part of -fast, -parallel and -autopar. -depend will
raise the optimization level to -O3 if not specified or
is less than -O3.
-dryrun
Show commands built by the f95 driver but do not com-
pile.
Useful when debugging, this option displays the com-
mands the comiler will run to perform the compilation.
-d[y|n]
Allow/disallow dynamic libraries for executable
Allow or disallow dynamic libraries for the entire exe-
cutable. This flag is a linker option.
The default is -dy.
-dy: Allow dynamic libraries.
-dn: Do not allow dynamic libraries.
Unlike -B[dynamic|static], this option applies to the
whole executable and need appear only once on the com-
mand line.
-d[y|n] are linker options. If you compile and link in
separate steps with these options, then you need the
same option in the final link step.
In a 64-bit environment, many system libraries are
available only as shared dynamic libraries. These
include libm.so and libc.so (libm.a and libc.a are not
provided). As a result, -Bstatic and -dn may cause
linking errors in 64-bit Solaris environments. Applica-
tions must link with the dynamic libraries in these
cases.
-e Extend source line maximum length to 132 characters.
The compiler pads on the right with trailing blanks to
column 132. If you use continuation lines while com-
piling with -e, then do not split character constants
across lines, otherwise unnecessary blanks may be
inserted in the constants.
-erroff=taglist
Supress warning messages listed by tag name.
The taglist specifies a list of comma-separated tag
names that appear with warning messages. If the list
consists of %all all warnings are suppressed (this is
equivalent to the -w option.) (See also -errtags.)
-errtags[=yes|no]
Display the message tag with each warning message.
The compiler's internal error tag name appears along
with error messages. The default is not to display the
tag (-errtags=no). The second default (-errtags without
a value) is -errtags=yes.
-explicitpar
Enable parallelization of loops or regions explicitly
marked with directives
The compiler will generate parallel code even if there
are data dependences in the DO loop that would cause
the loop to generate incorrect results when run in
parallel. With explicit parallelization, it is the
user's responsibility to correctly analyze loops for
data dependence problems before marking them with
parallelization directives.
This option enables Sun, Cray, and/or OpenMP explicit
parallelization directives. DO loops immediately pre-
ceded by parallelization directives will have threaded
code generated for them. Parallelization is only
appropriate on multiprocessor systems. This option
should not be used to compile programs that do their
own multithreading with calls to the libthread library.
Note: Use -openmp, which invokes -explicitpar in its
expansion, to enable OpenMP parallelization directives.
Number of Threads: To run a parallelized program in a
multithreaded environment, you must set the PARALLEL or
OMP_NUM_THREADS envrionment variables prior to execu-
tion. These variables tell the runtime system the max-
imum number of threads the program can create. The
default is 1. In general, set PARALLEL or
OMP_NUM_THREADS to the available number of processors
on the target platform.
If you use -explicitpar and compile and link in one
step, then linking automatically includes the micro-
tasking library and the threads-safe FORTRAN runtime
library. If you use -explicitpar and compile and link
in separate steps, then link with -explicitpar.
See also the discussion of -autopar.
To improve performance, also specify the -stackvar
option when using any of the parallelization options,
including -explicitpar. See the description of the
-stackvar option for information on how to set the
sizes for the main thread stack and for the slave
thread stacks.
Use the -mp= option to select the style of paralleliza-
tion directives enabled: Sun, Cray, or OpenMP.
If the optimization level is not -O3 or higher, it is
raised to -O3 automatically.
For details, see the Parallelization chapter in the
Fortran Programming Guide.
-ext_names=e
Create external names with or without underscores.
e must be either plain or underscores. The default is
underscores.
plain: Do not use trailing underscores.
underscores: Use trailing underscores.
An external name is a name of a subroutine, function,
block data subprogram, or labeled common. This option
affects both the name in the routine itself and, of
course, the name used in the calling statement (both
symdefs and symrefs).
-F Invoke the source file preprocessor, but do not compile
Apply the fpp preprocessor to .F90, .F95, and .F files
and put the result in the file with the suffix changed
to .f90, .f95,or .f, but do not compile.
fpp is the default preprocessor for Fortran. The C
preprocessor, cpp, can be selected instead by specify-
ing -xpp=cpp.
-f Align double- and quad-precision data in COMMON blocks.
This flag changes the data layout in COMMON blocks (and
EQUIVALENCE classes): double- and quad-precision data
in COMMON blocks and EQUIVALENCE classes are laid out
in memory along their "natural" alignment, which is on
8-byte boundaries (or on 16-byte boundaries for quad-
precision when compiling for 64-bit environments with
-xarch=v9, v9a, or v9b). The default alignment of data
in COMMON blocks is on 4-byte boundaries.
-f is equivalent to -aligncommon=16.
This option applies to both real and complex data.
Resulting code may not be standard and may not be port-
able.
If you compile one subprogram with -f, compile all sub-
programs of the program with -f.
By itself, this option does not enable the compiler to
generate faster double word fetch/store instructions
ond double and quad precision data. Only -dalign will
do this.
-f77[=list]
Select Fortran 77 compatibility mode.
list is a comma-separated list selected from the fol-
lowing possible keywords:
%all Select all the f77 compatibility features.
%none Disable the f77 compatibility features.
output Generate f77-style formatted output, including
list-directed and namelist output.
input Accept input formats allowed by f77.
tab Enable f77-style TAB-formatting, including
unlimited source line length. Also, no blank
padding will be added to source lines shorter
than 72 characters.
backslash
Accept a backslash character as the beginning
of an escape sequence in character strings.
intrinsics
Limit recognition of intrinsics to only Fortran
77 intrinsics.
logical Accept Fortran 77 usage of logical variables,
such as:
- Allow assignment of integer values to logical
variables.
- Allow arithmetic expressions in place of log-
ical expressions in conditional statements,
with .NE.0 representing .TRUE..
- Allow use of relational operators .EQ. and
.NE. with logical operands.
subscript
Allow non-integer expressions as array sub-
scripts.
misc Allow other miscellaneous Fortran 77 extensions
not supported by Fortran 95.
All keywords may be prefixed by no% to disable the
corresponding feature, as in:
-f77=%all,no%backslash
The default, when -f77 is not specified is -f77=%none.
When -f77 is used without a list, it is equivalent to
-f77=%all.
Trapping on Exceptions
Specifying -f77 adds -ftrap=%none to the command line
to mimic Fortran 77's behavior regarding arithmetic
exception trapping, which was to allow execution to
continue after arithmetic exceptions. It also causes
the program to call ieee_retrospective on program exit
to report on any arithmetic exceptions that occurred
during execution. Specify -ftrap=common after -f77 to
revert to trapping immediately after the exception is
raised (the f95 default).
Migrating FORTRAN 77 Programs to Fortran
See the chapter on FORTRAN 77 compatibility in the For-
tran User's Guide for details on -f77 and the compati-
bility features it provides. See also the -xalias flag
for handling non-standard FORTRAN 77 programming that
may cause incorrect results.
-fast
Select options that optimize execution performance.
-fast provides high performance for certain benchmark
applications. However, the particular choice of
options may or may not be appropriate for your applica-
tion. Use -fast as a good starting point for compiling
your application for best performance. But additional
tuning may still be required. If your program behaves
improperly when compiled with -fast, look closely at
the individual options that make up -fast and invoke
only those appropriate to your program that preserve
correct behavior.
Note also that a program compiled with -fast may show
good performance and accurate results with some data
sets, but not with others. Avoid compiling with -fast
those programs that depend on particular properties of
floating-point arithmetic.
-fast selects the following options:
o -xtarget=native sets the hardware target.
If the program is intended to run on a different tar-
get than the compilation machine, follow the -fast
with the appropriate -xtarget= option. For example:
f95 -fast -xtarget=ultra ...
o -O5 selects optimization level 5.
o -libmil selects inlining of certain math library rou-
tines.
o -fsimple=2 selects aggressive floating-point optimi-
zations. This option may be unsuited for programs
requiring strict IEEE 754 standards compliance.
o -dalign selects generation of faster double word
load/store instructions, and alignment of double and
quad data on their natural boundaries in common
blocks. Using this option may generate nonstandard
Fortran data alignment.
o -xlibmopt selects linking the optimized math library.
o -depend selects dependence analysis to better optim-
ize DO loops.
o -fns selects faster (but nonstandard) handling of
floating-point arithmetic exceptions and gradual
underflow.
o -ftrap=common selects trapping on common floating-
point exceptions (this is the default for f95).
o -pad=local selects local padding to improve use of
cache.
o -xvector=yes selects the vectorized math library.
o -xprefetch=yes selects automatic generation of pre-
fetch instructions on platforms that support it.
o -xprefetch_level=2 sets the default prefetch level.
Note that this selection of component option flags is
subject to change with each release of the compiler.
For details on the options set by -fast, see the For-
tran User's Guide.
It is possible to add or subtract from this list by
following the -fast option with other options, as in:
f95 -fast -fsimple=1 -xnolibmopt
which overrides the -fsimple=2 flag and disables the
-xlibmopt selected by -fast.
Because -fast selects
-dalign -fns -fsimple=2
programs compiled with this option may result in non-
standard floating-point arithmetic, nonstandard align-
ment of data, and nonstandard ordering of expression
evaluation. These selections may not be appropriate for
most programs.
For separate compile and link steps: if you compile
with -fast, then be sure to link with -fast.
-fixed
Assume fixed-format source input.
Interpret all source files as Fortran 95 fixed-format.
Overrides the file suffix.
-flags
Synonym for -help.
-fnonstd
Initialize floating-point hardware to non-standard
preferences
This option is a macro for the combination
-fns -ftrap=common
which initializes the floating-point hardware to:
o Abort on exceptions
o Flush denormalized numbers to zero if it will
improve speed
To be effective, compile the main program with this
flag.
See -fns for a information on underflow and handling of
denormalized numbers.
The -fnonstd option enables hardware traps for
floating-point overflow, division by zero, and invalid
operation exceptions. These are converted into SIGFPE
signals, and if the program has no SIGFPE handler, it
aborts. See ieee_handler(3m), ieee_functions(3m), the
Numerical Computation Guide, and Fortran Programming
Guide for more information.
-fns[={no|yes}]
Select SPARC nonstandard floating point
The default, -fns=no, is SPARC standard floating-point
mode.
Optional use of =yes or =no provides a way of toggling
the -fns flag following some other macro flag that
includes -fns, such as -fast.
-fns is the same as -fns=yes.
-fns=yes selects non-standard floating-point.
-fns=no selects standard floating-point. (Default)
-fast selects -fns.
On some SPARC systems, the nonstandard floating point
mode disables "gradual underflow", causing tiny results
to be flushed to zero rather than producing subnormal
numbers. It also causes subnormal operands to be
silently replaced by zero. On those SPARC systems that
do not support gradual underflow and subnormal numbers
in hardware, use of this option can significantly
improve the performance of some programs.
Warning: When nonstandard mode is enabled, floating
point arithmetic may produce results that do not con-
form to the requirements of the IEEE 754 standard. See
the Numerical Computation Guide and the Fortran User's
Guide for more information.
This option is effective only if used when compiling
the main program.
-fpover[={yes|no}]
Detect floating-point overflow in formatted input.
With -fpover=yes specified, the I/O library will detect
floating-point overflows in formatted input and return
error condition 1031. The default is no such overflow
detection (-fpover=no). -fpover is equivalent to
-fpover=yes.
-fpp Force preprocessing of input files with fpp.
Pass all the input source files listed on the command
line through the fpp preprocessor, regardless of file
extension. (Files with .F90, .F95, .F extension are
automatically preprocessed by fpp. See also -xpp.)
-free
Assume free-format source input.
Interpret all source files as Fortran 95 free-format.
Overrides the file suffix.
-fround=r
Select the IEEE rounding mode in effect at startup.
r must be one of:
nearest, tozero, negative, positive.
The default is -fround=nearest.
When r is tozero, negative, or positive this flag
causes the rounding direction mode to be set to round-
to-zero, round-to-negative-infinity, or round-to-
positive-infinity respectively when the program begins
execution. When r is nearest or the -fround flag is
not used, the rounding direction mode is not altered
from its initial value (round-to-nearest by default).
This option is effective only if used when compiling
the main program.
-fsimple[=n]
Select floating-point optimization preferences
Allow the optimizer to make simplifying assumptions
concerning floating-point arithmetic.
If n is present, it must be 0, 1, or 2.
The defaults are:
With no -fsimple, f95 uses -fsimple=0
With only -fsimple, f95 uses -fsimple=1
-fsimple=0
Permit no simplifying assumptions. Preserve strict
IEEE 754 conformance.
-fsimple=1
Allow conservative simplifications. The resulting
code does not strictly conform to IEEE 754, but
numeric results of most programs are unchanged.
With -fsimple=1, the optimizer can assume the fol-
lowing:
IEEE 754 default rounding/trapping modes do not
change after process initialization.
Computations producing no visible result other
than potential floating point exceptions may be
deleted.
Computations with Infinity or NaNs as operands
need not propagate NaNs to their results; e.g.,
x*0 may be replaced by 0.
Computations do not depend on sign of zero.
With -fsimple=1, the optimizer is not allowed to
optimize completely without regard to roundoff or
exceptions. In particular, a floating-point computa-
tion cannot be replaced by one that produces dif-
ferent results with rounding modes held constant at
run time.
-fsimple=2
Permit aggressive floating-point optimizations that
may cause many programs to produce different numeric
results due to changes in rounding.
In particular, the Fortran standard rule requiring
compilers to honor explicit parentheses around
subexpressions to control expression evaluation
order may be broken with -fsimple=2. This could
result in numerical rounding differences with pro-
grams that depend on this rule.
For example, with -fsimple=2, the compiler may
evaluate C-(A-B) as (C-A)+B, breaking the standard's
rule about explicit parentheses, if the resulting
code is better optimized. The compiler may also
replace repeated computations of x/y with x*z, where
z=1/y is computed once and saved in a temporary, to
eliminate the costly divide operations.
Programs that depend on particular properties of
floating-point arithmetic should not be compiled
with -fsimple=2.
Even with -fsimple=2, the optimizer still tries not
to introduce a situation that could produce a
floating-point exception in a program that otherwise
produces none.
-fast selects -fsimple=2.
-ftrap=t
Set floating-point trapping mode
This option sets the IEEE floating-point trapping that
is in effect at startup.
t is a comma-separated list that consists of one or
more of the following:
%all, %none, common, [no%]invalid, [no%]overflow,
[no%]underflow, [no%]division, [no%]inexact.
The f95 default is -ftrap=common. (Note that the
default with f77 was -ftrap=%none.)
This option sets the IEEE 754 trapping modes that are
established at program initialization. Processing is
left-to-right.
Example: Set all atraps except inexact:
-ftrap=%all,no%inexact
The meanings are the same as for the ieee_flags func-
tion, except that:
o %all turns on all the trapping modes, and will cause
trapping of spurious and expected exceptions. Use
common instead.
o %none, turns off all trapping modes.
o A no% prefix turns off that specific trapping mode.
To be effective this option must be used when compiling
the main program.
-G Build a dynamic shared library
Direct the linker to make a shared dynamic library.
Without -G the linker builds an executable file. With
-G it builds a dynamic library (but no executable).
Use -o with -G to specify the name of the file to be
written.
-g Compile for debugging and performance analysis.
Produce additional symbol table information for debug-
ging with dbx(1) or the Forte Developer Debugger, and
for analysis with the Forte Developer Performance
Analyzer, analyzer(1).
Although some debugging is possible without specifying
-g, the full capabilities of dbx are only available to
those objects compiled with -g.
The -g option makes -xildon the default incremental
linker option (see -xildon). That is, with -g, the
compiler default behavior is to automatically invoke
ild in place of ld, unless the -G option is present, or
any source file is named on the command line.
To use the full capabilities of the Forte Developer
Performance Analyzer, compile with -g. While some per-
formance analysis features do not require -g, you must
compile with -g to view annotated source, some function
level information, and compiler commentary messages.
(See the analyzer(1) man page.)
The commentary messages generated with -g describe the
optimizations and transformations the compiler made
while compiling your program. You must use er_src(1),
er_print(1), or the performance analyzer, analyzer(1)
to view the commentary messages.
Note that commentary messages only appear if the com-
piler actually performed any optimizations. You are
more likely to see commentary messages when you request
high optimization levels, such as with -xO4, or -fast.
-h nm
Specify the name of the generated dynamic shared
library
If the library has an internal name, then whenever the
executable is run, the linker must find a library with
the same internal name; the file can be in any library
search path. If the library has no internal name, then
the linker must find a library with the same path as
when it was generated. Having an internal name allows
more flexibility at runtime.
Remarks:
o The space between the -h and nm is optional.
o -hnm is meaningless without -G.
o -hnm is a linker option.
o The names after -h and -o are usually the same.
o -hnm facilitates versions for dynamic libraries.
See the Solaris Linker and Libraries Guide.
-help
List the f95 command-line options.
See also -xhelp.
-Ipath
Add path to the include file search path.
Insert directory path path at the start of the include
file search path. No space is allowed between -I and
path.
The include file search path is the list of directories
searched for include files. This search path is used
by:
o The preprocessor directive #include
o The f95 statement INCLUDE
Example: To search for include files in /usr/applib:
f95 -I/usr/applib growth.F
To invoke the preprocessor, you must use a .F suffix;
and the f95 compiler INCLUDE statement allows the .f or
.F suffix.
The -Ipath search path is used while searching relative
path names on INCLUDE statements, not absolute path
names. The search order for relative path names is:
1. The directory containing the source file
2. Directory paths named in -I options
3. Directories in the default list of the compiler
4. /usr/include
-inline=rl
Enable/disable inlining of specified user-written rou-
tines.
Optimize by inlining the specified user-written rou-
tines named in the list rl. The list is a comma-
separated list of functions and subroutines.
The rl list may include the string %auto to enable
automatic inlining at optimization levels -O4 or
higher. Automatic inlining is normally turned off when
explicit inlining is specified on the command line by
-inline.
If you prefix the name of a routine on the list with
no%, inlining of that routine is inhibited.
For example, to enable automatic inlining while disa-
bling inlining of a specific routine (gflub), use:
-O5 -inline=%auto,no%gflub
Only routines in the file being compiled are con-
sidered. The optimizer decides which of these routines
are appropriate for inlining.
A routine is not inlined if any of the following condi-
tions apply, with no warnings:
o Optimization is less than -O3
o The routine cannot be found.
o Inlining it is not profitable or safe.
o The source is not in the file being compiled unless
-xipo or -xcrossfile are also specified.
-iorounding=[{processor-defined | compatible}]
Set rounding mode for formatted input/output.
Sets the ROUND= specifier globally for all formatted
input/output.
With -iorounding=compatible, the value resulting from
data conversion is the closer of the two nearest
representations, or the value away from zero if the
value is halfway between them.
With -iorounding=processor-defined, the rounding mode
is the processor's default mode. This is the default
when -iorounding is not specified.
-Kpic
Synonym for -pic
-KPIC
Synonym for -PIC
-Lpath
Add path to list of directory paths to search for
libraries.
path is added to the start of the search list. A space
between -L and path is optional.
Note: Do not use the -Lpath option to specify /usr/lib
or /usr/ccs/lib, since they are searched by default,
and including them here prevents using the unbundled
libm.
-lx Add library libx.a to the linker's list of search
libraries.
Direct the loader to link with object library libx.a,
where x is a string. See ld(1).
Example: -lsumex links in the library libsumex.a
Order on the Command Line: Place -lx options after any
.f, .F, or .o files. If you call functions in libx, and
they reference functions in liby, then place -lx before
-ly.
Search Order for -lx files: the linker searches for
libraries in several locations. For details, see the
chapter, "Libraries," in the Fortran Programming Guide.
See also ld(1).
-libmil
Inline selected libm math library routines for optimi-
zation.
Some of the simpler library routines can be inlined by
the compiler. This option inlines library calls depend-
ing on the floating-point options and platform curently
being used.
-loopinfo
Show which loops are parallelized
Show which loops are parallelized and which are not.
This option is normally for use with the
-autopar and -explicitpar options. It generates a list
of messages on standard error.
-Mpath
Specify MODULE directory, archive, or file.
Look in path for Fortran 95 modules referenced in the
current compilation. This path is searched in addition
to the current directory.
path may specify a directory, .a archive file of
precompiled module files, or a .mod precompiled module
file. The compiler determines the type of the file by
examining its contents.
A .a archive file must be explicitly specified on a -M
option flag to be searched for modules. The compiler
will not search archive files by default.
Only .mod files with the same names as the MODULE names
appearing on USE statements will be searched. For exam-
ple, the statement USE ME causes the compiler to look
only for the module file me.mod
When searching for modules, the compiler gives higher
priority to the directory where the module files are
being written. This is controlled by the -moddir flag
or the MODDIR environment variable. When neither are
specified, the default write-directory is the current
directory. When both are specified, the write-directory
is the path specified by the -moddir flag.
This means that if only the -M flag appears, the
current directory will be searched for modules first
before any object listed on the -M flag. To emulate the
behavior of previous releases, use:
-moddir=empty-dir -Mdir -M
where empty-dir is the path to an empty directory.
There should be no space between the -M and the path.
For example, -M/home/siri/PK15/Modules
-moddir=path
Specify the path to a directory where the compiler will
write .mod MODULE files. The path can also be specified
by using the MODDIR environment variable. If both are
specified, this option flag takes precedence.
The default directory for writing .mod files is the
current directory.
-mp=[%none|sun|cray|openmp]
Specify the style for parallelization directives
The default is sun.
-mp=sun: Accept Sun-style MP directives.
-mp=cray: Accept Cray-style MP directives.
-mp=openmp: Accept OpenMP directives
-mp=%none: Ignore all parallelization directives.
Sun-style parallelization directives start with C$PAR
or !$PAR. Cray-style parallelization directives start
with CMIC$ or !MIC$. Either style can appear in upper-
case or lowercase.
OpenMP directives start with C$OMP, !$OMP, *$OMP, in
fixed format, or !$OMP in free format.
You can combine OpenMP directives with either Cray or
Sun style directives in the same compilation unit. But
both Sun and Cray style directives cannot both be
active in the same compilation unit. For example:
-mp=sun,openmp and
-mp=cray,openmp are permitted, but NOT
-mp=sun,cray
You must also specify -explicitpar to have these direc-
tives enable parallelization. Also, -stackvar should be
specified with parallelization. For example:
-explicitpar -stackvar -mp=openmp
When compiling for OpenMP, use the -openmp flag, which
includes -mp=openmp as a component, along with the
other required flags.
-mt Use multithread safe libraries
If you are doing your own multithread coding and not
using -autopar, -explicitpar, or -parallel, then you
must use the -mt option in the compile and link steps.
The parallelization options use -mt automatically.
On a single-processor system, the generated code usu-
ally runs more slowly with this option.
-native
Optimize for the host system.
The -native option is a synonym for the -xtarget=native
option.
-noautopar
Cancel -autopar on the command line.
Cancel automatic parallelization of loops invoked by
-autopar on the command line.
-nodepend
Cancel -depend in command line
Cancel dependence analysis invoked by a -depend option
appearing earlier in the command line.
-noexplicitpar
Cancel -explicitpar
Cancel explicit parallelization of loops invoked by
-explicitpar earlier on the command line.
-nolib
Do not link with system libraries.
Do not automatically link with any system or language
library; that is, do not pass any default -lx options
to ld. The default is to link such libraries into exe-
cutables automatically, without users specifying them
on the command line.
The system and language libraries are required for
final execution. It is your responsibility to link them
in manually. This option provides you complete control
(and responsibility).
The -nolib option makes it easier to link these
libraries statically.
-nolibmil
Cancel -libmil on command line
Use with -fast to disable inlining of libm math rou-
tines:
demo% f95 -fast -nolibmil ...
-noreduction
Cancel -reduction on command line
-reduction is used along with parallelization options.
This option cancels a -reduction appearing earlier on
the command line.
-norunpath
Do not build a runtime library search path into the
executable
If an executable file uses shared libraries, then the
compiler normally builds in a path that tells the run-
time linker where to find those shared libraries. The
path depends on the directory where you installed the
compiler. The -norunpath option prevents that path from
being built into the executable.
This option is helpful when libraries have been
installed in some nonstandard location, and you do not
wish to make the loader search down those paths when
the executable is run at another site. Compare with
-R.
-O[n]
Specify optimization level (n).
If -O[n] is not specified, only a very basic level of
optimization limited to local common subexpression
elimination and dead code analysis is performed. A
program's performance may be significanly improved when
compiled with an explicit optimization level.
Each -On level includes the optimizations performed at
the levels below it. Generally, the higher the level of
optimization, the better the runtime performance. How-
ever, higher optimization levels may result in
increased compilation time and larger executable files.
There are five optimization levels that you can specify
with -On. The actual optimizations performed by the
compiler at each level may change with each compiler
release.
Use of -O (which implies -O3) or -fast (which implies
-O5) is recommended for most programs.
The -g option can be used with optimization.
If the optimizer runs out of memory, it attempts to
proceed over again at a lower level of optimization,
resuming compilation of subsequent routines at the ori-
ginal level.
For details on optimization, see the Fortran Program-
ming Guide chapters Performance Profiling, and Perfor-
mance and Optimization.
-O Optimize at the level most likely to give close to
the maximum performance for many realistic appli-
cations (equivalent to -O3).
-O1 Do only the basic local optimizations (peephole).
-O2 Do basic local and global optimization. This level
usually gives minimum code size.
-O3 Adds global optimizations at the function level.
In general, this level, and -O4, usually result in
the minimum code size when used with the -xspace
option.
-O4 Adds automatic inlining of functions in the same
file. -g suppresses automatic inlining. In gen-
eral, -O4 results in larger code unless combined
with -xspace.
See -inline to control which routines are inlined.
-O5 Does the highest level of optimization, suitable
only for the small fraction of a program that uses
the largest fraction of computer time. Uses optim-
ization algorithms that take more compilation time
or that do not have as high a certainty of improv-
ing execution time. Optimization at this level is
more likely to improve performance if it is done
with profile feedback. See -xprofile=collect|use.
Interactions:
If you use -g and the optimization level is -O3 or
lower, the compiler provides best-effort symbolic
information with almost full optimization. Tail-
call optimization and back-end inlining are dis-
abled.
For more information, see Debugging a Program With
dbx.
The -xcrossfile option is effective only if it is
used with -O4 or -O5.
See also: -fast, -xprofile=p, csh(1) man page
-o nm
Specify the name of the executable file to be written
There must be a blank between -o and nm. Without this
option, the default is to write the executable to
a.out. When used with -c, -o specifies the target .o
object file; with -G it specifies the target .so
library file.
-onetrip
Enable one-trip DO loops.
Compile DO loops so they are performed at least once if
reached.
Fortran 95 DO loops are not performed at all if the
upper limit is smaller than the lower limit, unlike
some legacy implementations of Fortran.
-openmp
Enable explicit parallelization with Fortran 95 OpenMP
version 2.0 directives.
This option is a macro for the combination of options:
-mp=openmp -explicitpar -stackvar -D_OPENMP=200011
The Fortran 95 OpenMP directives are described in the
OpenMP API User's Guide.
To run a parallelized program in a multithreaded
environment, you must set the PARALLEL or
OMP_NUM_THREADS environment variables prior to running
the program. This tells the runtime system the maximum
number of threads the program can create. The default
is 1. In general, set PARALLEL or OMP_NUM_THREADS to
the available number of processors on the target plat-
form.
-p Compile for profiling with prof. (Obsolete)
Prepare object files for profiling with prof(1). This
option makes profiles by procedure, showing the number
of calls to each procedure and the percent of time used
by each procedure.
For separate compile and link steps, and if you compile
with -p, then be sure to link with -p.
-pad[=p]
Insert padding for efficient use of cache.
This option inserts padding between arrays or character
strings if they are:
o Static local and not initialized, or
o In common blocks
For either one, the arrays or character strings can not
be equivalenced.
If =p is present, it must be one of the following (no
spaces):
local: Pad local variables
common: Pad variables in common blocks
local,common: Both local and common padding is done
common,local: Both local and common padding is done
Defaults:
Without the -pad[=p] option, no padding.
With -pad, without =p, local and common padding.
The following are equivalent:
f95 -pad any.f
f95 -pad=local,common any.f
f95 -pad=common,local any.f
Restrictions on -pad=common:
o If -pad=common is specified for a file that refer-
ences a common block, it must be specified for all
files that reference that common block.
o With -pad=common specified, declarations of common
block variables in different program units must be
the same except for the names of the variables.
o Padding is dependent on the setting of -xcache.
All files must be compiled with the same -xcache
settings when -pad=common is used.
o Do not specify -pad=common if the program
overindexes arrays in common blocks. The padding
inserted between arrays by the compiler will
interfere with the assumed layout of the data, and
will cause the array references to fail in
unpredictable ways.
o EQUIVALENCE declarations involving common block
variables will cause warning messages that padding
has been inhibited by EQUIVALENCE when compiled
with -pad=common. These arrays will not be pad-
ded.
-parallel
Enable a combination of automatic and explicit paral-
lelization features.
This option is a macro for a combination of options:
-autopar -explicitpar -depend
Parallelize loops chosen automatically by the compiler
and explicitly specified by user supplied directives.
Optimization level is automatically raised to -O3 if it
is lower.
To improve performance, also specify the -stackvar
option when using any of the parallelization options,
including -autopar. See the description of the
-stackvar option for information on how to set the
sizes for the main thread stack and for the slave
thread stacks.
Note: For OpenMP parallelization, use the -openmp
option flag, not -explicitpar.
Avoid -parallel if you do your own thread management.
See the discussion of -mt
Parallelization options like -parallel are intended to
produce executables programs to be run on multiproces-
sor systems. On a single-processor system, paralleliza-
tion generally degrades performance.
If you compile and link in separate steps, if -parallel
appears on the compile command it must also appear on
the link command.
See also the discussion of -autopar.
For more information, see the chapter on paralleliza-
tion in the Fortran Programming Guide.
Number of Threads: To run a parallelized program in a
multithreaded environment, you must set the PARALLEL or
OMP_NUM_THREADS envrionment variables prior to execu-
tion. This tells the runtime system the maximum number
of threads the program can create. The default is 1.
In general, set PARALLEL or OMP_NUM_THREADS to the
available number of processors on the target platform.
-pg Compile for profiling with gprof.
Prepare the object files for profiling with gprof(1).
This option makes profiles by procedure, showing the
number of calls to each procedure and the percent of
time used by each procedure.
This option also produces counting code in the manner
of -p, but invokes a runtime recording mechanism that
keeps more extensive statistics and produces a gmon.out
file at normal termination. You can then generate an
execution profile using gprof(1).
For separate compile and link steps, if you compile
with -pg, then link with -pg.
-pic Compile position-independent code for shared library.
Equivalent to -xcode=pic13
-PIC Similar to -pic, with 32-bit addresses
Equivalent to -xcode=pic32
-Qoption pr ls
Pass option list ls to the compilation phase pr.
This option is used primarily by customer service.
-qp Synonym for -p.
-R list
Build library search paths into executable
With this option, the linker, ld(1), adds a list of
library search paths into the executable file.
list is a colon-separated list of directories used to
specify library search paths to the runtime linker. The
list is added to the default list that f95 passes to
the linker.
The blank between -R and list is optional.
Multiple instances of this option are concatenated
together, with each list separated by a colon.
Use this option if you want to export an executable
that can run without any special option for paths to
your dynamic libraries.
Building an executable with this option adds paths to a
default path that is always searched last:
/opt/SUNWspro/lib
-r8const
Promote single-precision constants to REAL*8 constants.
All single precision literal constants are promoted to
REAL*8. Double-precision constants (REAL*8) are not
promoted.
This flag applies only to constants. Use -xtypemap to
promote both constants and variables.
Use this flag carefully. It could cause interface prob-
lems when calling a routine with a REAL*4 literal con-
stant as an actual argument where a REAL*4 value is
expected. It could also cause problems with programs
reading unformatted data files written by a write
statement with a literal REAL*4 constant on its I/O
list.
-reduction
Parallelize reduction operations in loops
Analyze loops for reduction in automatic paralleliza-
tion. To enable parallelization of reduction loops,
specify both -reduction and -autopar.
Example: demo% f95 -autopar -reduction any.f
A loop that transforms the elements of an array into a
single scalar value is called a reduction operation.
For example, summing the elements of a vector is a typ-
ical reduction operation. Although these operations
violate the criteria for parallelizability, the com-
piler can recognize them and parallelize them as spe-
cial cases when -reduction is specified. See the For-
tran Programming Guide chapter Parallelization for
information on reduction operations recognized by f95.
If you specify -reduction without -autopar, the com-
piler issues a warning.
On a single-processor system, the generated code usu-
ally runs more slowly.
There is always potential for roundoff error with
reduction.
-S Compile and only generate assembly code.
Compile the named programs and leave the assembly
language output on corresponding files suffixed .s (no
.o file is created).
-s Strip the symbol table from the executable file.
This option makes the executable file smaller and more
difficult to reverse engineer. However, this option
prevents debugging.
-sb Produce table information for the source browser.
See sbquery(1) and sbtags(1) for information abouth the
source browser.
Note: -sb cannot be used on source files the compiler
automatically passes through the fpp or cpp preproces-
sors; for example, source files with .F, .F90,or .F95
extensions, or used with the -F option.
-sbfast
Similar to -sb, but faster.
Produce only table information for the source browser.
Do not assemble, link, or make object files. (See also
the discussion of -sb and its use with source code
preprocessors.)
-silent
Supress compiler messages.
Normally, f95 does not issue messages, other than error
diagnostics, during compilation. This option is pro-
vided only for compatibility with older scripts and
makefiles. -silent is the default and its use is redun-
dant.
-stackvar
Force all local variables to be allocated on the stack.
Allocates all the local variables and arrays in
routinesonto the memory stack unless otherwise
specified. This option makes these variables automatic
rather than static and provides more freedom to the
optimizer when parallelizing loops with calls to sub-
programs.
Use of -stackvar is recommended with any of the paral-
lelization options.
Variables and arrays are local, unless they are:
o Arguments in a SUBROUTINE or FUNCTION statement
(already on stack)
o Global items in a COMMON or SAVE, or STATIC state-
ment
o Initialized items in a type statement or a DATA
statement, such as:
REAL X/8.0/ or DATA X/8.0/
Putting large arrays onto the stack with -stackvar can
overflow the stack causing segmentation faults.
Increasing the stack size may be required.
The initial thread executing the program has a main
stack, while each helper thread of a multithreaded pro-
gram has its own thread stack.
The default size for the main stack is about 8 Mega-
bytes. The default helper thread stack size is 4 Mega-
bytes on SPARC V8 platforms and 8 Megabytes on SPARC V9
platforms.
The limit command (with no parameters) shows the
current main stack size.
Use the limit shell command to set the size (in Kilo-
bytes) of the main thread stack. For example, to set
the main stack size to 64 Megabytes, use a
% limit stacksize 65536
command.
You can set the stack size to be used by each slave
thread by giving the STACKSIZE environment variable a
value (in Kilobytes):
% setenv STACKSIZE 8192
sets the stack size for each slave thread to 8 Mb. See
the Fortran Programming Guide chapter on paralleliza-
tion for details.
-stop_status={yes|no}
Permit STOP statement to return an integer status
value.
The optional argument is either yes or no. The default
is yes.
With -stop_status=yes a STOP statement may contain an
integer constant that will be passed to the environment
as the program terminates. This value will be avail-
able as $status for the C shell or $? for the Bourne
and Korn shells.
The value on the STOP statement can be any positive
integer. The value returned to the shell will be
modulo 256 (in the range 0 to 255).
-temp=dir
Define directory for temporary files.
Set the directory for temporary files used by f95 to be
dir instead of the /tmp directory.
-time
Show execution time for each compilation phase.
-U Recognize upper and lower case in source files.
Do not treat uppercase letters as equivalent to lower-
case. The default is to treat uppercase as lowercase
except within character-string constants.
With this option, the compiler treats Delta, DELTA, and
delta as different symbols.
Portability and mixing Fortran with other languages may
require use of -U.
Calls to intrinsic functions, Fortran library func-
tions, and routines explicitly declared EXTERNAL are
not affected by this option.
-Uname
Undefine preprocessor macro name
Removes any initial definition of the preprocessor
macro symbol name created by -Dname on the same command
line, or implicitly placed there by the command-line
driver, regardless of the order the options appear. It
has no affect on any macro definitions in source files.
Multiple -Uname flags may appear on the same line, and
there must be no space between -U and name.
This option applies only to .F, .F90, and .F95 source
files that invoke the fpp or cpp preprocessors.
-u Report on undeclared variables.
Equivalent to specifying IMPLICIT NONE in each compila-
tion unit. This has the affect of making the default
type of variables undeclared rather than using standard
Fortran implicit typing. This option does not override
any existing IMPLICIT statements or explicit type
statements.
-unroll=n
Enable unrolling of DO loops n times where possible.
n is a positive integer.
n = 1, inhibits all loop unrolling
n > 1, this option suggests to the optimizer that it
unroll loops n times.
If any loops are actually unrolled, then the executable
file is larger.
-use=list
Specify implicit MODULE usage, globally.
list is a comma-separated list of module names or
module file names. Compiling with -use=module_name in
effect adds a USE module_name to each subprogram being
compiled. Similarly, compiling with
-use=module_file_name effectively adds to each subpro-
gram being compiled a USE module_name for each of the
modules contained in the module_file_name file.
-V Show name and version of each compilation phase.
-v Verbose mode - show compilation details
Like -V but also details the options, macro flag expan-
sions, and environment variables used by the driver.
-vpara
Show verbose parallelization messages
As the compiler detects each explicitly parallelized
loop that has dependences, it issues a warning message
but the loop is parallelized.
Use with -explictpar and a C$MIC DOALL parallel pragma.
Example: f95 -explicitpar -vpara any.f
-w[0|1|2|3|4]
Show or suppress warning messages.
-w suppresses warning messages from the compiler.
-w0 shows just error messages.
-w1 shows errors and warnings. (This is the default.)
-w2 shows errors, warnings, and cautions.
-w3 shows errors, warnings, cautions, and notes.
-w4 shows errors, warnings, cautions, notes, and com-
ments.
If you specify two options, and the second one over-
rides all or part of the first one, the compiler issues
a warning.
-Xlist[z]
Produce listings and do global program checking.
Find potential programming bugs. Invokes an extra com-
piler pass to check for consistency in calls and common
across the global program. Generates line-numbered
source code listing with cross references.
Diagnostic messages from -Xlist are warnings and do not
prevent compiling and linking.
Be sure to correct all syntax errors first; -Xlist
might produce unpredictable reports when run on a
source program with syntax errors.
Output is to a file with a name like the first file
name but with a .lst extension.
Example: Errors, listing, and xref to file1.lst
demo% f95 -Xlist file1.f file2.f
Use the -Xlist options to check for interprocedural
problems, but only after all other compiler errors and
warnings have been resolved.
Summary of -Xlist Suboptions
-Xlist Default: listings, errors, xref
-Xlistc Call graphs and errors.
-XlistE Errors only (no xref or listings)
-Xlisterr Suppress all -Xlist error messages
-Xlisterr[n] Suppress -Xlist error message n.
-Xlistf Errors, listing, and cross references,
but no object files compiled.
-Xlisth Terminate if errors detected.
-XlistI Check include files also
-XlistL Listings only (no xref)
-Xlistl[n] Page length is n lines
-XlistMP Check OpenMP directives.
-Xlistonm Output to nm instead of to file.lst
-Xlists Suppress unreferenced names from cross-
reference table.
-Xlistvn Set checking level to n (1,2,3, or 4) -
default is 2
-Xlistw[nnn] Set output line width to n; default is
79
-Xlistwar Suppress all -Xlist warning messages
-Xlistwar[n] Suppress -Xlist warning message n.
-XlistX Xref only (no listings)
See the Fortran Programming Guide for details.
-xa Synonym for -a.
-xalias[=type_list]
Specify degree of aliasing to be assumed by the com-
piler.
Non-standard programming techniques can introduce
situations that interfere with the compiler's optimiza-
tion strategies. In particular, the use of overindex-
ing, pointers, and passing global or non-unique vari-
ables as subprogram arguments, introduce ambiguous
aliasing situations that prevent the compiler from
applying certain optimizations, and can introduce ambi-
guities that could result in unexpected results.
See the Fortran User's Guide for more information about
aliasing.
Use the -xalias flag to inform the compiler about the
ways in which the program deviates from the aliasing
requirements of the Fortran standard.
The flag may appear with or without a list. The
keywords on the list are comma-separated, and each key-
word indicates an aliasing situation present in the
program. Each keyword may be prefixed by no% to indi-
cate an aliasing type that is not present.
The aliasing keywords are:
dummy Dummy (formal) subprogram parameters can
alias each other and global variables.
no%dummy (Default). Usage of dummy parameters follows
the Fortran standard and may not alias each
other or global variables.
craypointer
(Default). The program uses Cray pointers
that can point anywhere.
no%craypointer
Cray pointers always point at distinct areas
of memory, or are not used.
actual Passing an argument to a subprogram might
result in aliasing through Cray pointers.
no%actual (Default). Passing an argument does not
result in further aliasing.
overindex (a) A reference to an element of an array in
a COMMON block could refer to any element in
a COMMON block or equivalence group.
(b) Passing any element of a COMMON block or
equivalence group as an actual argument to a
subprogram gives access to any element of
that COMMON block or equivalence group to the
called subprogram.
(c) Individual array bounds may be violated,
but except as noted above, the referenced
array element is assumed to stay within the
array.
Array syntax, WHERE, and FORALL statements
are not considered for overindexing.
no%overindex
(Default). Array bounds are not violated.
Array references do not reference other vari-
ables.
ftnpointer
Calls to external functions might cause for-
tran POINTERS to point at TARGET variables of
any type, kind, or rank.
no%ftnpointer
(Default). Fortran pointers follow the rules
of the standard.
The default, when -xalias is not specified on the com-
piler command line, corresponds to:
-xalias=no%dummy,craypointer,no%actual,no%overindex,\
no%ftnpointer
Specifying -xalias without a list gives the best per-
formance for most programs that do not violate Fortran
aliasing rules, and corresponds to:
-xalias=no%dummy,no%craypointer,no%actual,no%overindex,\
no%ftnpointer
To be effective, -xalias should be used when compiling
with optimzation levels -xO3 and higher.
See the Porting chapter of the Fortran Programming
Guide for further details.
-xarch=isa
Specifies the target architecture instruction set
(ISA).
This option limits the code generated by the compiler
to the instructions of the specified instruction set
architecture by allowing only the specified set of
instructions. This option does not guarantee use of any
target-specific instructions. However, use of this
option may affect the portability of a binary program.
See the Notes and Warnings sections at the end of this
entry.
Values (SPARC platforms):
Value Meaning
generic Compile for good performance on most 32-bit
architectures.
This is the default. This option uses the
best instruction set for good performance on
most 32-bit processors without major
performance degradation on any of them. With
each new release, the definition of "best"
instruction set may be adjusted, if appropri-
ate.
generic64 Compile for good performance on most 64-bit
architectures.
This option uses the best instruction set for
good performance on most 64-bit processors
without major performance degradation on any
of them. With each new release, the defini-
tion of "best" instruction set may be
adjusted, if appropriate.
native Compile for good performance on this system
(assuming a 32-bit architecture).
This is the default for the -fast option. The
compiler chooses the appropriate setting for
the current 32-bit system processor it is
running on.
native64 Compile for good performance on this system
(assuming a 64-bit architecture).
The compiler chooses the appropriate setting
for the current 64-bit system processor it is
running on.
v7 Compile for the SPARC-V7 ISA.
Enables the compiler to generate code for
good performance on the V7 ISA. This is
equivalent to using the best instruction set
for good performance on the V8 ISA, but with-
out integer mul and div instructions, and the
fsmuld instruction.
Examples: SPARCstation 1, SPARCstation 2
v8a Compile for the V8a version of the SPARC-V8
ISA.
By definition, V8a means the V8 ISA, but
without the fsmuld instruction. This option
enables the compiler to generate code for
good performance on the V8a ISA.
Example: Any system based on the microSPARC I
chip architecture
v8 Compile for the SPARC-V8 ISA.
Enables the compiler to generate code for
good performance on the V8 architecture.
Example: SPARCstation 10
v8plus Compile for the V8plus version of the SPARC-
V9 ISA.
By definition, V8plus means the V9 ISA, but
limited to the 32-bit subset defined by the
V8plus ISA specification, without the Visual
Instruction Set (VIS), and without other
implementation- specific ISA extensions.
This option enables the compiler to generate
code for good performance on the V8plus ISA.
The resulting object code is in SPARC-V8+
ELF32 format and only executes in a Solaris
UltraSPARC environment -- it does not run on
a V7 or V8 processor.
Example: Any system based on the UltraSPARC
chip architecture
v8plusa Compile for the V8plusa version of the
SPARC-V9 ISA.
By definition, V8plusa means the V8plus
architecture, plus the Visual Instruction Set
(VIS) version 1.0, and with UltraSPARC exten-
sions. This option enables the compiler to
generate code for good performance on the
UltraSPARC architecture, but limited to the
32-bit subset defined by the V8plus specifi-
cation. The resulting object code is in
SPARC-V8+ ELF32 format and only executes in a
Solaris UltraSPARC environment -- it does not
run on a V7 or V8 processor.
Example: Any system based on the UltraSPARC
chip architecture
v8plusb Compile for the V8plusb version of the
SPARC-V8plus ISA with UltraSPARC III exten-
sions.
Enables the compiler to generate object code
for the UltraSPARC architecture, plus the
Visual Instruction Set (VIS) version 2.0, and
with UltraSPARC III extensions. The resulting
object code is in SPARC-V8+ ELF32 format and
executes only in a Solaris UltraSPARC III
environment. Compiling with this option uses
the best instruction set for good performance
on the UltraSPARC III architecture.
v9 Compile for the SPARC-V9 ISA.
Enables the compiler to generate code for
good performance on the V9 SPARC architec-
ture. The resulting .o object files are in
ELF64 format and can only be linked with
other SPARC-V9 object files in the same for-
mat. The resulting executable can only be run
on an UltraSPARC processor running a 64-bit
enabled Solaris operating environment with
the 64-bit kernel.
-xarch=v9 is only available when compiling in
a 64-bit enabled Solaris environment.
v9a Compile for the SPARC-V9 ISA with UltraSPARC
extensions.
Adds to the SPARC-V9 ISA the Visual Instruc-
tion Set (VIS) and extensions specific to
UltraSPARC processors, and enables the com-
piler to generate code for good performance
on the V9 SPARC architecture. The resulting
.o object files are in ELF64 format and can
only be linked with other SPARC-V9 object
files in the same format. The resulting exe-
cutable can only be run on an UltraSPARC pro-
cessor running a 64-bit enabled Solaris
operating environment with the 64-bit kernel.
-xarch=v9a is only available when compiling
in a 64-bit enabled Solaris operating
environment.
v9b Compile for the SPARC-V9 ISA with UltraSPARC
III extensions.
Adds UltraSPARC III extensions and VIS ver-
sion 2.0 to the V9a version of the SPARC-V9
ISA. Compiling with this option uses the best
instruction set for good performance in a
Solaris UltraSPARC III environment. The
resulting object code is in SPARC-V9 ELF64
format and can only be linked with other
SPARC-V9 object files in the same format. The
resulting executable can only be run on an
UltraSPARC III processor running a 64-bit
enabled Solaris operating environment with
the 64-bit kernel.
-xarch=v9b is only available when compiling
in a 64-bit enabled Solaris operating
environment.
Notes:
o SPARC instruction set architectures V7, V8, and V8a
are all upwardly binary compatible.
o Object binary files (.o) compiled with v8plus and
v8plusa can be linked and can execute together, but
only on a SPARC V8plusa compatible platform.
o Object binary files (.o) compiled with v8plus,
v8plusa, and v8plusb can be linked and can execute
together, but only on a SPARC V8plusb compatible
platform.
o -xarch values v9, v9a, and v9b are only available on
UltraSPARC 64-bit Solaris environments.
o Object binary files (.o) compiled with v9 and v9a can
be linked and can execute together, but will run only
on a SPARC V9a compatible platform.
o Object binary files (.o) compiled with v9, v9a, and
v9b can be linked and can execute together, but will
run only on a SPARC V9b compatible platform.
For any particular choice, the generated executable
may run much more slowly on earlier architectures.
Also, although quad-precision (REAL*16 and long dou-
ble) floating-point instructions are available in
many of these instruction set architectures, the com-
piler does not use these instructions in the code it
generates.
Defaults:
If -xarch=isa is not specified, -xarch=generic is
assumed.
Interactions:
Although this option can be used alone, it is part of
the expansion of the -xtarget option and may be used
to override the -xarch value that is set by a
specific -xtarget option. For example,
-xtarget=ultra2 expands to -xarch=v8 -xchip=ultra2
-xcache=16/32/1:512/64/1. In the following command
-xarch=v8plusb overrides the -xarch=v8 that is set by
the expansion of -xtarget=ultra2.
example% f95 -xtarget=ultra2 -xarch=v8plusb ...
Warnings:
If this option is used with optimization, the
appropriate choice can provide good performance of
the executable on the specified architecture. An
inappropriate choice, however, might result in seri-
ous degradation of performance or in in a binary pro-
gram that is not executable on all intended target
platforms.
-xautopar
Synonym for -autopar
-xcache=c
Define cache for optimizer
Define cache properties for use by optimizer.
c must be one of the following:
o generic
o native
o s1/l1/a1
o s1/l1/a1:s2/l2/a2
o s1/l1/a1:s2/l2/a2:s3/l3/a3
The si, li, and ai, are defined as follows:
si The size of the data cache at level i, in kilobytes
li The line size of the data cache at level i, in bytes
ai The associativity of the data cache at level i
This option specifies the cache properties that the
optimizer can use. It does not guarantee that any par-
ticular cache property is used.
Although this option can be used alone, it is part of
the expansion of the -xtarget option; its primary use
is to override a value supplied by the -xtarget option.
The -xcache values are:
generic
Define the cache properties for good performance
on most SPARC platforms. This is the default.
native
Define the cache properties for good performance
on this host platform.
s1/l1/a1
Define level 1 cache properties.
s1/l1/a1:s2/l2/a2
Define levels 1 and 2 cache properties.
s1/l1/a1:s2/l2/a2:s3/l3/a3
Define levels 1, 2, and 3 cache properties.
-xcg89
Synonym for -cg89.
-xcg92
Synonym for -cg92.
-xcheck=stkovf
Detect stack overflow at runtime.
Compiling with -xcheck=stkovf generates code at each
routine entry to test for thread stack overflow.
-xcheck=no%stkovf disables stack overflow checking
The default is to do no runtime stack overflow check-
ing.
If a stack overflow is detected, a SIGSEGV fault will
be raised.
Note that compiling with -xcheck=stkovf does not
guarantee that all stack overflow situations will be
detected since they may occur in routines not compiled
with this option. Undetected stack overflow may cause
data corruption in a neighboring thread's stack.
-xchip=c
Specify target processor for optimizer.
Specify the target processor for use by the optimizer.
c must be one of the following, depending on platform.
On SPARC platforms: generic, native, old, super,
super2, micro, micro2, hyper, hyper2, powerup, ultra,
ultra2, ultra2e, ultra2i, ultra3.
This option specifies timing properties by specifying
the target processor.
Although this option can be used alone, it is part of
the expansion of the -xtarget option; its primary use
is to override a value supplied by the -xtarget option.
Some effects are:
o The ordering of instructions, that is, scheduling
o The way the compiler uses branches
o The instructions to use in cases where semantically
equivalent alternatives are available
The -xchip values on SPARC are:
generic Optimize for good performance on most 32-bit
SPARC platforms.
native Optimize for good performance on this 32-bit
host platform.
old Optimize for processors older than
SuperSPARC(TM).
super Optimize for the SuperSPARC chip.
super2 Optimize for the SuperSPARC II chip.
micro Optimize for the MicroSPARC(TM) chip.
micro2 Optimize for the MicroSPARC II chip.
hyper Optimize for the HyperSPARC(TM) chip.
hyper2 Optimize for the HyperSPARC II chip.
powerup Optimize for the Weitek(R) PowerUp(TM) chip.
ultra Optimize for the UltraSPARC(TM) chip.
ultra2 Optimize for the UltraSPARC II chip.
ultra2i Optimize for the UltraSPARC IIi chip.
ultra3 Optimize for the UltraSPARC III chip.
ultra3cu
Optimize for the UltraSPARC IIIcu chip.
For complete information, see the Fortran User's Guide
-xcode=v
Specify code address space
The following values for -xcode are:
abs32 Generate 32-bit absolute addresses.
Code + data + bss size is limited to 2**32
bytes. This is the default on 32-bit architec-
tures: -xarch=generic,v7,v8,v8a,v8plus,v8plusa
abs44 Generate 44-bit absolute addresses.
Code + data + bss size is limited to 2**44
bytes. Available only on 64-bit architectures:
-xarch=v9,v9a,v9b
abs64 Generate 64-bit absolute addresses.
Available only on 64-bit architectures:
B -xarch=v9,v9a,v9b
pic13 Generate position-independent code (small
model).
Equivalent to -pic. Permits references to at
most 2**11 unique external symbols on 32-bit
architectures, 2**10 on 64-bit.
pic32 Generate position-independent code (large
model).
Equivalent to -PIC. Permits references to at
most 2**30 unique external symbols on 32-bit
architectures, 2**29 on 64-bit.
The default is -xcode=abs32 for SPARC V8 and V7. The
default is -xcode=abs64 for UltraSPARC V9 (with
-xarch=v9,v9a,v9b).
Position-Independent Code:
Use -xcode=pic13 or -xcode=pic32 when creating
dynamic shared libraries to improve runtime perfor-
mance.
While the code within a dynamic executable is usu-
ally tied to a fixed address in memory, position-
independent code can be loaded anywhere in the
address space of the process.
When you use position-independent code, relocatable
references are generated as an indirect reference
through a global offset table. Frequently accessed
items in a shared object will benefit from compiling
with -xcode=pic13 or -xcode=pic32 by not requiring
the large number of relocations imposed by code that
is not position-independent.
The size of the global offset table is limited to
8Kb on SPARC.
There are two nominal performance costs with
-xcode={pic13|pic32} :
o A routine compiled with either -xcode=pic13 or
-xcode=pic32 executes a few extra instructions
upon entry to set a register to point at the
global offset table used for accessing a shared
library's global or static variables.
o Each access to a global or static variable
involves an extra indirect memory reference
through the global offset table. If the compile
is done with pic32, there are two additional
instructions per global and static memory
reference.
When considering the above costs, remember that
the use of -xcode=pic13 or -xcode=pic32 can signi-
ficantly reduce system memory requirements, due to
the effect of library code sharing. Every page of
code in a shared library compiled -xcode=pic13 or
-xcode=pic32 can be shared by every process that
uses the library. If a page of code in a shared
library contains even a single non-pic (that is,
absolute) memory reference, the page becomes
nonsharable, and a copy of the page must be
created each time a program using the library is
executed.
The easiest way to tell whether or not a .o file
has been compiled with -xcode=pic13 or
-xcode=pic32 is with the nm command:
nm file.o | grep _GLOBAL_OFFSET_TABLE_
A .o file containing position-independent code
will contain an unresolved external reference to
_GLOBAL_OFFSET_TABLE_ as marked by the letter U.
To determine whether to use -xcode=pic13 or
-xcode=pic32 use nm to identify the number of dis-
tinct global and static variables used or defined
in the library. If the size of
_GLOBAL_OFFSET_TABLE_ is under 8,192 bytes, you
can use pic13. Otherwise, you must use pic32.
Compiling with the -xcode=pic13 or pic32 (or -pic
or -PIC) options is recommended when building
dynamic libraries. See the Solaris Linker and
Libraries Guide.
-xcommonchk[={yes|no}]
Enable runtime checking of common block inconsisten-
cies.
This option is provided as a debugging aid for programs
using task common and parallelization (-explicitpar or
-parallel). (See the task common pragma.)
Normally, runtime checking for inconsistent task common
declarations is disabled. Compiling with
-xcommonchk=yes enables runtime checking.
If a common block is declared in one source module as a
regular common block, and somewhere else appears in a
task common pragma, the program will stop and a message
pointing to the first such inconsistency issued.
Because runtime checking degrades program performance,
it should only be used during program development and
debugging.
Specifying -xcommoncheck alone is equivalent to
-xcommoncheck=yes
-xcrossfile[=n]
Enable optimization and inlining across source files
If specified, n may be 0, or 1.
Normally, the scope of the compiler's analysis is lim-
ited to each separate file on the command line. For
example, -O4's automatic inlining is limited to subpro-
grams defined and referenced within the same source
file.
With -xcrossfile, the compiler analyzes all the files
named on the command line as if they had been con-
catenated into a single source file.
-xcrossfile is only effective when used with -O4 or
-O5.
The files produced from this compilation are inter-
dependent (due to possible inlining) must be used as a
unit when linking into a program. If any one routine is
changed and the files recompiled, they must all be
recompiled.
As a result, use of this option will affect how
makefiles are constructed.
The default, if not specified on the command line, is
-xcrossfile=0 and no cross file optimizations are per-
formed. -xcrossfile is equivalent to -xcrossfile=1.
-xdepend
Synonym for -depend
-xexplicitpar
Synonym for -explicitpar
-xF Allow function-level reordering by the Forte Developer
Performance Analyzer
Allow the reordering of functions (subprograms) in the
core image using the compiler, the Analyzer and the
linker. If you compile with the -xF option, then run
the Analyzer, you can generate a map file that optim-
izes the ordering of the functions in memory depending
on how they are used together. A subsequent link to
build the executable file can be directed to use that
map by using the linker -Mmapfile option. It places
each function from the executable file into a separate
section.
Reordering the subprograms in memory is useful only
when the application text page fault time is consuming
a large percentage of the application time. Otherwise,
reordering may not improve the overall performance of
the application. The Performance Analyzer is part of
Forte Developer. See the Program Performance Analysis
Tools manual for further information on the analyzer.
-xhasc[={yes|no}]
Treat Hollerith constant as character string in actual
argument lists.
With -xhasc=yes the compilers treat as character
strings Hollerith constants appearing as an actual
argument in a subprogram call. This is the default and
complies with the Fortran 77 standard.
With -xhasc=no Hollerith constants are treated as type-
less values in subprogram call lists.
This flag is provided to aid porting older Fortran pro-
grams. Compile routines calling subprograms with Hol-
lerith constants with -xhasc=no if the called subpro-
gram expects that argument as INTEGER or any other type
other than CHARACTER.
-xhelp=h
Show options summary or README file.
h is either readme or flags.
readme: Show the online README file.
flags: Show the compiler flags (options).
-xhelp=flags is a synonym for -help.
-xia[=widestneed|strict]
Enable interval arithmetic extensions and set a suit-
able floating-point environment.
Interval arithmetic is an extension to the numerical
computation techniques in Fortran 95. For further
information, see the Fortran 95 documentation.
-xia is a macro flag that expands as follows:
-xia and -xia=widestneed expand to:
-xinterval=widestneed -ftrap=%none -fns=no -fsimple=0
-xia=strict expands to:
-xinterval=strict -ftrap=%none -fns=no -fsimple=0
For more invormation, see the Fortran 95 Interval
Arithmetic Programming Reference.
-xildoff
Turn off Incremental Linker
This forces the use of the standard linker, ld.
This option is the default if you do not use -g. It is
also the default if you use -G or name any source file
on the command line.
Override this default by using -xildon.
-xildon
Turn on Incremental Linker
Turn on the Incremental Linker and force the use of ild
in incremental mode.
This option is the default if you use -g, and do not
use -G, and do not name any source file on the command
line.
Override this default by using -xildoff.
-xinline=rl
Synonym for -inline=rl.
-xinterval[=no|widestneed|strict]
Enable processing of interval arithmetic extensions.
Interval arithmetic is an extension to the numerical
computation techniques in Fortran 95. For further
information, see the Fortran 95 documentation.
This flag controls the expression evaluation syntax
permitted.
-xinterval specified without a value defaults to
widestneed.
no
Interval arithmetic is not enabled.
widestneed
Promotes all non-interval variables and literals in
any mixed-mode expression to the widest interval data
type in the expression.
strict
Prohibits mixed-type or mixed-length interval expres-
sions. All interval type and length conversions must
be explicit.
-xipo[={0|1|2}]
Perform interprocedural optimizations.
Invoke interprocedural analysis pass to perform whole-
program optimizations. Unlike -xcrossfile, -xipo optim-
izes across all object files in the link step, and is
not limited to just the source files on the compile
command.
Analysis and optimization is limited to object files
compiled with -xipo.
-xipo=0 disables interprocedural analysis.
-xipo=1 enables inlining across source files.
-xipo=2 adds whole-program detection and analysis,
including memory allocation and memory layout optimiza-
tions to improve cache performance.
The default is -xipo=0
If specifed without a value, -xipo=1 is assumed.
When compiling and linking in separate steps, you must
specify -xipo in both steps to be effective.
Libraries, even if compiled with -xipo do not partici-
pate in crossfile interprocedural analysis.
Additional information about -xipo:
Requires at least optimization level -xO4
Do not use with -xcrossfile. If used together a
compilation error will result.
Objects compiled without -xipo can be linked
freely with objects not compiled with this flag.
-xknown_lib=lib
Recognize calls to a known library.
With this flag specified, the compiler treats refer-
ences to certain known libraries as intrinsics, ignor-
ing any user-supplied versions. This enables the com-
piler to perform optimizations over calls to library
routines based on special knowledge of that library.
The flag is limited currently to
-xknown_lib=blas
and
-xknown_lib=intrinsics
-xknown_lib=blas
The compiler recognizes calls to the following
BLAS library routines and is free to optimize
appropriately for the Sun Performance Library
implementation.
The BLAS routines recognized are: SDOT DDOT
CDOTC ZDOTC CDOTU ZDOTU SAXPY DAXPY ZAXPY SCOPY
DCOPY CCOPY ZCOPY DSCAL CSCAL ZXCAL
The compiler will ignore user-supplied versions
of these library routines and link to the BLAS
routines in the Sun Performance Library.
-xknown_lib=intrinsics
Specifying intrinsics has the effect of
ignoring any explicit EXTERNAL declarations for
Fortran 95 intrinsics, thereby ignoring any
user-supplied intrinsic routines.
-xlang=f77
Include the appropriate runtime libraries and insure
the proper runtime environment for legacy Fortran 77.
Interactions:
The option -xlang=f77 implies linking with the
f77compat library, and is a shorthand way for linking
Fortran 95 object files with Fortran 77 object files.
Using -xlang=f77 insures the proper runtime environ-
ment.
Warnings:
Do not use -xnolib with -xlang.
If you are mixing Fortran object files with C++, link
with the C++ compiler and specify -xlang=f95.
If you are mixing parallel Fortran objects with C++
objects, the link line must specify the -mt flag.
-xlibmil
Synonym for -libmil.
-xlibmopt
Use library of optimized math routines
Use a library of selected math routines optimized for
performance. This option usually generates faster
code. It may produce slightly different results; if so,
they usually differ in the last bit. The order on the
command line for this library option is not signifi-
cant.
-xlicinfo
Show license information.
Return serial number entitlement information about the
installed Forte Developer software.
-xlic_lib=sunperf
Link with the Sun Performance Library
Example:
f95 -o pgx -fast -pgx.f -xlic_lib=sunperf
As with -l it should appear after all source and object
file names on the command line. This option must be
used to link with the Sun Performance Library.
-xloopinfo
Synonym for -loopinfo
-xmaxopt[=n]
Enable optimization pragma and set maximum optimization
level.
Limits the optimization level specified by a C$PRAGMA
SUN OPT=m directive to n. When a directive specifying
a level m greater than n on the -xmaxopt flag appears,
the compiler will use n.
The value n corresponds to the values 1 through 5 of
the -O optimization level flag. The value of n must be
greater or equal to the value of highest optimization
level specified by other options. So, for example:
f95 ... -O3 -xmaxopt=4
would be appropriate.
The flag -xmaxopt by itself defaults to -xmaxopt=5
-xmemalign[=ab]
Specify maximum assumed memory alignment and behavior
of misaligned data accesses.
For memory accesses where the alignment is determinable
at compile time, the compiler will generate the
appropriate load/store instruction sequence for that
alignment of data.
For memory accesses where the alignment cannot be
determined at compile time, the compiler must assume an
alignment to generate the needed load/store sequence.
The -xmemalign flag allows the user to specify the max-
imum memory alignment of data to be assumed by the com-
piler in these indeterminable situations. It also
specifies the error behavior to be followed at run-time
when a misaligned memory access does take place.
VALUES:
If a value is specified, it must consist of two parts:
a numerical alignment value, a, and an alphabetic
behavior flag, b.
Allowed values for alignment, a are:
1 Assume at most 1 byte alignment.
2 Assume at most 2 byte alignment.
4 Assume at most 4 byte alignment.
8 Assume at most 8 byte alignment.
16 Assume at most 16 byte alignment.
Allowed values for behavior, b are:
i Interpret access and continue execution.
s Raise signal SIGBUS.
f Raise signal SIGBUS for alignments less than or
equal to 4, otherwise interpret access and con-
tinue execution.
DEFAULTS:
The first default, which applies when no -xmemalign
flag appears, is:
-xmemalign=4s for
-xarch=generic,v7,v8,v8a,v8plus,v8plusa
-xmemalign=8s for -xarch=v9,v9a for C and C++
-xmemalign=8f for -xarch=v9,v9a for Fortran
The second default, which applies when -xmemalign
appears but without a value, is:
-xmemalign=1i for all platforms
-xnolib
Synonym for -nolib.
-xnolibmil
Synonym for -nolibmil.
-xnolibmopt
Cancel -xlibmopt
Use with -fast to cancel linking with the optimized
math library.
-xO[n]
Synonym for -O[n].
-xopenmp
Synonym for -openmp
-xpad
Synonym for -pad
-xparallel
Synonym for -parallel
-xpg Synonym for -pg.
-xpp=p
Select source file preprocessor.
p is either fpp or cpp. Selects the source file
preprocessor to be used with .F files. The default is
fpp, which is appropriate for Fortran. Previous ver-
sions of the compiler used cpp, the standard C language
preprocessor. To select cpp, specify -xpp=cpp.
-xprefetch[=a[,a]]
Enable and adjust prefetch instructions on those archi-
tectures that support prefetch, such as UltraSPARC III
(-xarch=v8plus, v8plusa, v8plusb, v9, v9a, v9b, gen-
eric64, or native64).
a must be one of the following values.
Value Meaning
auto Enable automatic generation of prefetch
instructions.
no%auto Disable automatic generation
explicit Enable explicit prefetch macros
no%explicit Disable explicit prefectch macros.
latx:factor Adjust the compiler's assumed prefetch-
to-load and prefetch-to-store latencies
by the specified factor. The factor
must be a positive floating-point or
integer number.
The prefetch latency is the hardware
delay between the execution of a pre-
fetch instruction and the time the data
being prefetched is available in the
cache.
The compiler assumes a prefetch latency
value when determining how far apart to
place a prefetch instruction and the
load or store instruction that uses the
prefetched data. Note - the assumed
latency between a prefetch and a load
may not be the same as the assumed
latency between a prefetch and a store.
The compiler tunes the prefetch mechan-
ism for optimal performance across a
wide range of machines and applications.
This tuning may not always be optimal.
For memory-intensive applications, espe-
cially applications intended to run on
large multiprocessors, you may be able
to obtain better performance by increas-
ing the prefetch latency values. To
increase the values, use a factor that
is greater than 1 (one). A value
between .5 and 2.0 will most likely pro-
vide the maximum performance.
For applications with datasets that
reside entrely within the external
cache, you may be able to obtain better
performance by decreasing the prefetch
latency values. To decrease the values,
use a factor that is less than one.
To use the latx:factor suboption, start
with a factor value near 1.0 and run
performance tests against the applica-
tion. Then increase or decrease the fac-
tor, as appropriate, and run the perfor-
mance tests again. Continue adjusting
the factor and running the performance
tests until you achieve optimum perfor-
mance. When you increase or decrease the
factor in small steps, you will see no
performance difference for a few steps,
then a sudden difference, then it will
level off again.
yes Same as -xprefetch=auto,explicit.
no Same as -xprefetch=no%auto,no%explicit.
With -xprefetch, -xprefetch=auto, and -xprefetch=yes,
the compiler is free to insert prefetch instructions
into the code it generates. This may result in a per-
formance improvement on architectures that support pre-
fetch.
Defaults:
If -xprefetch is not specified,
-xprefetch=no%auto,explicit is assumed.
If only -xprefetch is specified,
-xprefetch=auto,explicit is assumed.
The default of no%auto is assumed unless explicitly
overridden with the use of -xprefetch without any argu-
ments or with an argument of auto or yes. For example,
-xprefetch=explicit is the same as
-xprefetch=explicit,no%auto.
The default of explicit is assumed unless explicitly
overriden with no%explicit or no. For example,
-xprefetch=auto is the same as
-xprefetch=auto,explicit.
If automatic prefetching is enabled, such as with
-xprefetch or -xprefetch=yes, but a latency factor is
not specified, then latx:1.0 is assumed.
Interactions:
With -xprefetch=explicit, the compiler will recognize
the directives:
$PRAGMA SPARC_PREFETCH_READ_ONCE (address)
$PRAGMA SPARC_PREFETCH_READ_MANY (address)
$PRAGMA SPARC_PREFETCH_WRITE_ONCE (address)
$PRAGMA SPARC_PREFETCH_WRITE_MANY (address)
The -xchip setting effects the determination of the
assumed latencies and therefore the result of a
latx:factor setting.
The latx:factor suboption is valid only when automatic
prefetching is enabled. That is, latx:factor is ignored
unless it is used in conjunction with yes or auto.
Warnings:
Explicit prefetching should only be used under special
circumstances that are supported by measurements.
Because the compiler tunes the prefetch mechanism for
optimal performance across a wide range of machines and
applications, you should only use the latx:factor
suboption when the performance tests indicate there is
a clear benefit. The assumed prefetch latencies may
change from release to release. Therefore, retesting
the effect of the latency factor on performance when-
ever switching to a different release is highly recom-
mended.
-xprefetch_level=n
Control the degree of insertion of prefetch instruc-
tions.
This option is effective only when compiling with
-xprefetch=auto, with optimization level 3 or greater
(-xO3), and on a platform that supports prefetch (-
xarch=v8plus, v8plusa, v8plusb, v9, v9a, v9b, gen-
eric64, native64).
n may be 1, 2, or 3.
The default for -xprefetch=auto without specifying
-xprefetch_level is level 2.
Prefetch level 2 finds additional opportunities for
prefetch instructions than level 1. Prefetch level 3
finds additional prefetch instructions than level 2.
Prefetch levels 2 and 3 are only effective on
UltraSPARC III platforms (-xarch=v8plusb or v9b).
-xprofile=p
Collect or optimize with runtime profiling data
Collect and save execution frequency data during execu-
tion; then use the data in subsequent runs to improve
performance.
p must be collect[:nm], use[:nm], or tcov.
If compilation and linking are performed in separate
steps, the same -xprofile option must appear on the
compile as well as the link step.
collect[:nm]
Collect and save execution frequency data for
later use by the optimizer with -xprofile=use.
The compiler generates code to measure state-
ment execution frequency.
nm is the name of the program that is being
analyzed. This name is optional. If not speci-
fied, a.out is assumed to be the name of the
executable.
At runtime a program compiled with -
xprofile=collect:nm will create the subdirec-
tory nm.profile to hold the runtime feedback
information. Data is written to the file feed-
back in this subdirectory. If you run the pro-
gram several times, the execution frequency
data accumulates in the feedback file; that
is, output from prior runs is not lost.
Set the environment variables SUN_PROFDATA and
SUN_PROFDATA_DIR to control where the program
writes its runtime profile data. If set, the
program writes to
$SUN_PROFDATA_DIR/$SUN_PROFDATA in the current
directory, instead of nm.profile/feedback.
Note: Compiling shared libraries with -
xprofile=collect is not supported.
use[:nm] Use execution frequency data to optimize stra-
tegically.
As with collect:nm, the nm is optional and may
be used to specify the name of the program.
The program is optimized by using the execu-
tion frequency data previously generated and
saved in the feedback files written by a pre-
vious execution of the program compiled with
-xprofile=collect.
The source files and other compiler options
must be exactly the same as used for the com-
pilation that created the compiled program
that generated the feedback file. If compiled
with -xprofile=collect:nm, the same program
name nm must appear in the optimizing compila-
tion: -xprofile=use:nm.
tcov Basic block coverage analysis using "new"
style tcov(1).
Code instrumentation is similar to that of -a,
but .d files are no longer generated for each
source file. Instead, a single file is gen-
erated, whose name is based on the name of the
final executable. For example, if stuff is the
executable file, then stuff.profile/tcovd is
the data file.
When running tcov you must pass it the -x
option to make it use the new style of data.
If not, tcov uses the old .d files, if any, by
default for data, and produces unexpected out-
put.
Unlike -a, the TCOVDIR environment variable
has no effect at compile-time. However, its
value is used at program runtime to identify
where to create the profile subdirectory.
Note - The report produced by tcov can be unreliable if
there is inlining of subprograms due to -O4 or -inline.
Coverage of calls to routines that have been inlined is
not recorded.
-xrecursive
Allow routines defined without RECURSIVE attribute to
call themselves recursively.
Normally, only subprograms defined with the RECURSIVE
attribute can call themselves recursively.
Compiling with -xrecursive enables subprograms to call
themselves recursively even if they are not defined
with the attribute RECURSIVE. But, unlike the RECUR-
SIVE attribute, this flag does not cause local vari-
ables to be allocated on the stack by default. For
each recursive invocation of the subprogram to have
separate values for local variables, compile with
-stackvar to put local variables on the stack.
Compiling routines with -xrecursive may cause perfor-
mance degradations.
-xreduction
Synonym for -reduction
-xregs=r
Specify register usage
Specify usage of registers in generated code.
r is a comma-separated list of one or more of the fol-
lowing: [no%]appl, [no%]float.
Example: -xregs=appl,no%float
The -xregs values are for specific -xarch values):
appl Allow using registers g2, g3, and g4. (v8,
v8a)
Allow using registers g2, g3, and g4.
(v8plus, v8plusa)
Allow using registers g2, g3. (v9, v9a)
no%appl Do not use appl registers.
float Allow using floating-point registers as speci-
fied in the SPARC ABI.
no%float Do not use floating-point registers.
The default is: -xregs=appl,float.
-xs Allow debugging by dbx without .o files.
With -xs, if you move executables to another directory,
then you can use dbx and ignore the object (.o) files.
Use this option in case you cannot keep the .o files
around.
This option reverts to implementing symbol tables as
implemented in release 1.4 and earlier. For this older
way, if you move the executables, you must also move the
source files, but you can ignore the object files. Also,
the loader links more slowly, and dbx initializes more
slowly. For comparison, with the newer way, which is now
the default, the loader links faster, and dbx initial-
izes faster. If you move the executables, you must move
both the source files and the object ( .o ) files, or
set the path with the dbx pathmap or use command.
This option passes the -s option to the assembler.
-xsafe=mem
Allow the compiler to assume that no memory protection
violations occur.
This option allows the compiler to use the non-faulting
load instruction in the SPARC V9 architecture.
Warnings:
Because non-faulting loads do not cause a trap when a
fault such as address misalignment or segmentation vio-
lation occurs, you should use this option only for pro-
grams in which such faults cannot occur. Because few
programs incur memory-based traps, you can safely use
this option for most programs. Do not use this option
for programs that explicitly depend on memory-based
traps to handle exceptional conditions.
Interactions:
This option takes effect only when used with optimiza-
tion level -xO5 and one of the following -xarch values:
v8plus, v8plusa, v8plusb, v9, v9a, or v9b.
-xsb
Synonym for -sb.
-xsbfast
Synonym for -sbfast.
-xspace
Do not increase code size
Do no optimizations that increase the code size.
Example: Do not unroll loops.
-xtarget=t
Specify the target system for the instruction set and
optimization.
t must be one of: native, native64, generic, generic64,
platform-name.
The -xtarget option permits a quick and easy specifica-
tion of the -xarch, -xchip, and -xcache combinations
that occur on real systems. The only meaning of -xtarget
is in its expansion.
The -xtarget values are:
native: Get the best performance on the host system
(32-bit architecture):
-xarch=native -xchip=native -xcache=native
native64: Get the best performance on the host system
(64-bit architecture):
-xarch=native64 -xchip=native64 -xcache=native
generic: Get the best performance for most 32-bit plat-
forms This is the default and is equivalent to:
-xarch=generic -xchip=generic -xcache=generic
generic64: Get the best performance for most 64-bit
platforms This is equivalent to:
-xarch=generic64 -xchip=generic64 -xcache=generic
platform-name: Get the best performance for the speci-
fied platform.
Valid platform names on SPARC are:
sun4/15, sun4/20, sun4/25, sun4/30, sun4/40, sun4/50,
sun4/60, sun4/65, sun4/75, sun4/110, sun4/150, sun4/260,
sun4/280, sun4/330, sun4/370, sun4/390, sun4/470,
sun4/490, sun4/630, sun4/670, sun4/690, sselc, ssipc,
ssipx, sslc, sslt, sslx, sslx2, ssslc, ss1, ss1plus,
ss2, ss2p, ss4, ss4/85, ss4/110, ss5, ss5/85, ss5/110,
ssvyger, ss10, ss10/hs11, ss10/hs12, ss10/hs14, ss10/20,
ss10/hs21, ss10/hs22, ss10/30, ss10/40, ss10/41,
ss10/50, ss10/51, ss10/61, ss10/71, ss10/402, ss10/412,
ss10/512, ss10/514, ss10/612, ss10/712, ss20, ss20/hs11,
ss20/hs12, ss20/hs14, ss20/hs21, ss20/hs22, ss20/50,
ss20/51, ss20/61, ss20/71, ss20/151, ss20/152, ss20/502,
ss20/512, /514, ss20/612, ss20/712, ss600/41, ss600/51,
ss600/61, ss600/120, ss600/140, ss600/412, ss600/512,
ss600/514, ss600/612, ss1000, sc2000, cs6400, solb5,
solb6, ultra, ultra2, ultra2i, ultra1/140, ultra1/170,
tra1/200, ultra2/1170, ultra2/1200, ultra2/1300,
ultra2/2170, ultra2/2200, ultra2/2300, ultra2e, ultra2i,
ultra3, ultra3cu, entr2, entr2/1170, entr2/2170,
entr2/1200, 200, entr150, entr3000, entr4000, entr5000,
entr6000.
Compiling for a 64-bit Solaris environment on UltraSPARC
V9 platforms is indicated by the -xarch=v9 or -xarch=v9a
flag. Setting -xtarget=ultra or ultra2 is not necessary
or sufficient. If -xtarget is specified, the -xarch=v9
or v9a option must appear after the -xtarget, as in:
-xtarget=ultra2 ... -xarch=v9
otherwise the -xtarget setting will revert -xarch to v8.
See the Fortran User's Guide for the -xtarget expansions
that show the mnemonic encodings of the actual platform
names.
This option is a macro. Each specific value for -xtarget
expands into a specific set of values for the -xarch,
-xchip, and -xcache options. For example:
-xtarget=sun4/15 is equivalent to:
-xarch=v8a -xchip=micro -xcache=2/16/1
Use the fpversion(1) command to determine the -xtarget
or
-xarch, -xchip, and -xcache options equivalent to
-xtarget=native on a running system.
-xtime
Synonym for -time.
-xtypemap=spec
Specify default data mappings.
This option provides a flexible way to specify the byte
sizes for default data types.
The syntax of the string spec is:
type:bits,type:bits,...
The allowable data types are REAL, DOUBLE, INTEGER. The
data sizes accepted are 32, 64,and 128.
This option applies to all variables declared without
explicit byte sizes, as in REAL XYZ.
The allowable combinations are:
real:32 or real:64,
double:64 or double:128,
integer:32 or integer:64.
A useful mapping is:
-xtypemap=real:64,double:64:integer:64
which maps REAL and DOUBLE to 8 bytes, but does not pro-
mote DOUBLE PRECISION to QUAD PRECISION.
Note also that INTEGER and LOGICAL are treated the same,
and COMPLEX is mapped as two REAL data elements. Also,
DOUBLE COMPLEX will be treated the way DOUBLE is mapped.
For more information, see the Fortran User's Guide
-xunroll=n
Synonym for -unroll=n
-xvector[={yes|no}]
Enable automatic generation of calls to the vector
library functions.
-xvector=yes permits the compiler to transform math
library calls within DO loops into single calls to the
equivalent vector math routines when such transforma-
tions are possible. This could result in a performance
improvement for loops with large loop counts.
The default if not specified is -xvector=no. Specifying
-xvector is equivalent to -xvector=yes.
This option also triggers -depend if -depend is not
already specified prior to -xvector on the command line.
However, -nodepend following -xvector on the command
line will cancel the effect of -xvector.
The compiler automatically informs the linker to include
the libmvec and libc libraries in the load step. If com-
piling and linking are done in separate commands, -xvec-
tor must also appear on the linking f95 command.
-ztext
Make no library with relocations
Do not make the library if relocations remain. The gen-
eral purpose of -ztext is to verify that the generated
library is pure text; instructions are all position-
independent code. Therefore, it is generally used with
both -G and -pic.
With -ztext, if ld finds an incomplete relocation in the
text segment, then it does not build the library. If it
finds one in the data segment, then it generally builds
the library anyway; the data segment is writable.
Without -ztext, ld builds the library, relocations or
not.
A typical use is to make a library from both source
files and object files, where you do not know if the
object files were made with -pic.
Other arguments are taken to be either linker option argu-
ments, or names of f95-compatible object programs, typically
produced by an earlier run, or libraries of routines that
are f95-compatible. These programs, together with the
results of any compilations specified, are linked in the
order given to produce an executable program in the file
specified by the -o option, or in a file named a.out if the
-o option is not specified.
FILE SUFFIXES
Files with the following suffixes may appear on the compiler
command line. The suffix usually identifies the type of the
file and determines how the compiler processes it.
.f90 .f95
Free format Fortran 95 source files.
.f .for
Fixed format Fortran 95 or Fortran 77 source files.
.F Fixed format Fortran 77 or Fortran 95 source containing
preprocessor directives. These files are preprocessed
by fpp(1) before they are compiled. (See also the -xpp=
option.)
.F90 .F95
Free format Fortran 95 source containing preprocessor
directives. These files are preprocessed fpp(1) before
they are compiled. (See also the -xpp= option.)
.s SPARC[tm] assembler source files.
.il Inline assembler expansion code template files. Used
by the compiler to expand calls to selected routines
into inline code. See the inline(1) man page and -
inline option flag for more information on inline tem-
plate files.
.o Object files to be passed to the linker.
.so Shared object files or libraries to be passed to the
linker.
.a Library files passed to the linker, or searched for
MODULE subprograms (see the -M option flag.)
.mod Files containing precompiled MODULE program units.
These are generated by the compiler. See the -M option
flag.
COMPILING FOR 64-BIT SOLARIS ENVIRONMENTS:
This version of the compiler can produce 64-bit object
binaries on 32-bit or 64-bit Solaris 7 or 8 SPARC Platform
Editions. The resulting executable will run only on 64-bit
SPARC(tm) or UltraSPARC(tm) processors under Solaris 7 or 8
with the 64-bit kernel. Compilation, linking, and execution
of 64-bit objects can only take place in a Solaris 7 or 8
environment.
Compiling for a 64-bit Solaris environment is indicated by
the -xarch=v9, v9a, or v9b options. Note that one of these
options must be specified even if -xtarget or -fast are also
specified. In such a case, the -xarch= option must appear
after any -xtarget or other option that sets -xarch. For
example:
-xtarget=ultra -xarch=v9
Note that -xtarget=ultra, -xtarget=ultra2, and
-xtarget=ultra3 imply -xarch=v8 and do not automatically
cause 64-bit compilations.
When building shared dynamic libraries with -xarch=v9, v9a,
or v9b in a 64-bit Solaris environment, the -pic or -PIC
option MUST be specifie d.
See also the new -xcode=abs32|abs44|abs64|pic13|pic32 option
for specifying code address sizes.
64-bit Solaris operating environments not only enable 64-bit
integer and pointer data, but also support for large files
and large arrays.
For more details on compiling for 64-bit Solaris operating
environments, see the "Fortran User's Guide" and the
"Solaris 64-bit Developer's Guide" on http://docs.sun.com/
DIRECTIVES
General Directives: f95 allows general compiler directive
lines starting with C$PRAGMA, !$PRAGMA, or *$PRAGMA, and any
uppercase or lowercase is allowed.
C$PRAGMA C( suba, subz)
C$PRAGMA SUN UNROLL 2
C$PRAGMA WEAK FUNK
C$PRAGMA SUN OPT=4
C$PRAGMA PIPELOOP=5
C$PRAGMA SPARC_PREFETCH_READ_ONCE (name)
C$PRAGMA SPARC_PREFETCH_READ_MANY (name)
C$PRAGMA SPARC_PREFETCH_WRITE_ONCE (name)
C$PRAGMA SPARC_PREFETCH_WRITE_MANY (name)
!$PRAGMA IGNORE_TKR list
Parallelization Directives: f95 recognizes the OpenMP API
parallelization directives. OpenMP is the recommended model
for explicit parallelization for all the Forte Developer
compilers.
In this release, the f95 compiler accepts Version 2.0 of the
OpenMP Fortran 95 API. These have the sentinel !OMP.
For detailed information on the Forte Developer OpenMP
implementation, see the OpenMP API User's Guide.
f95 also recognizes legacy Sun-style and Cray-style paral-
lelization directives. Sun-style compiler directive lines
starting with C$PAR, !$PAR, or *$PAR, and any uppercase or
lowercase is allowed.
C$PAR DOALL
C$PAR DOSERIAL
C$PAR DOSERIAL*
C$PAR TASKCOMMON
Cray-style parallelization directives are also recognized.
The directive sentinel is CMIC$ or !MIC$
CMIC$ DOALL
CMIC$ TASKCOMMON
CMIC$ DOSERIAL
CMIC$ DOSERIAL*
See the Fortran User's Guide for details and variations.
See also the OpenMP API User's Guide for guidelines on con-
verting legacy Sun/Cray paralellization to OpenMP API direc-
tives.
ENVIRONMENT
The paths shown below assume a standard installation of the
Forte Developer compilers to /opt/SUNWspro/. Contact your
system administrator if your compilers were custom installed
to some other directory path.
PATH
To use f95, add the following to the start of the search
path:
/opt/SUNWspro/bin/
MANPATH
To access the f95 man pages, add the following to the MAN-
PATH environment variable:
/opt/SUNWspro/man/
MODDIR
Specifies the path to the directory where the compiler will
write .mod module files. See also -moddir, which takes pre-
cedence over the setting of the MODDIR environment variable.
LD_LIBRARY_PATH
Generally, you need not set up LD_LIBRARY_PATH. If you do
need to do so, then maybe there is some discrepancy in the
installation, or some executable has been built incorrectly.
Set the LD_LIBRARY_PATH, environment variable to:
/opt/SUNWspro/lib/
LD_LIBRARY_PATH_64
Like the LD_LIBRARY_PATH environment variable,
LD_LIBRARY_PATH_64 sets the path for searching for 64-bit
libraries.
When running in a 64-bit enabled Solaris environment on a
SPARC processor and linking in 32-bit mode,
LD_LIBRARY_PATH_64 is ignored. If only LD_LIBRARY_PATH is
defined, it us used for both 32-bit and 64-bit linking. If
both LD_LIBRARY_PATH and LD_LIBRARY_PATH_64 are defined, the
32-bit linking will be done using LD_LIBRARY_PATH and the
64-bit linking using LD_LIBRARY_PATH_64.
See Linker and Libraries Guide for more information on these
environment variables.
LD_RUN_PATH
If you use LD_RUN_PATH, note that for f95, LD_RUN_PATH is
not identical with -R. (For ld.so, they are identical.)
See -R, in the Fortran User's Guide, for details.
STACKSIZE
You can set the stack size to be used by each slave thread
in a multithreaded program by giving the STACKSIZE environ-
ment variable a value (in Kilobytes):
% setenv STACKSIZE 8192
sets the stack size for each slave thread to 8 Mb.
The default thread stack size on SPARC V8 systems is 4 mega-
bytes. On V9 systems it is 8 megabytes.
See the Fortran Programming Guide chapter on Parallelizaion
for details.
FILES
See the section FILE SUFFIXES above for files identified by
their name suffix that may appear on the compiler command
line.
In addition, the compiler uses the following files:
/usr/lib/libc.a
Standard C library, see intro(3)
/usr/lib/libp/libc.a
Profiling library, see intro(3)
/tmp/*
Compiler temporary files
mon.out
File produced for analysis by prof(1)
gmon.out
File produced for analysis by gprof(1)
For the remaining files, if no absolute path is shown then
they are in the following directory:
/opt/SUNWspro/
bin/fpp
Fortran preprocessor
bin/cpp
C preprocessor
prod/include/f95
Path searched for f95 INCLUDE statement
prod/include/f95/floatingpoint.h
f95 IEEE arithmetic type definitions
The following libraries exist in both .so and .a versions:
lib/libfsu
f95 support intrinsics
lib/libfui
f95 - UNIX interface
lib/libfio
Fortran 95 I/O
lib/lib*fai
Fortran 95 array intrinsics libraries
lib/libifai
Fortran 95 interval array intrinsics library
lib/libf77compat
f77 I/O compatibility library
/usr/lib/libm.a
Math lib
/usr/lib/libp/libm.a
Math profile lib
lib/libsunmath.a
Sun value-added math lib
lib/libsunimath.a
Sun value-added interval math lib
lib/libp/libsunmath.a
Sun value-added math profile lib
lib/libp/libsunimath.a
Sun value-added interval math profile lib
READMEs
A number of README files provide valuable last-minute infor-
mation on the compilers and libraries, including white
papers. Of particular interest are:
o fortran_95
o math_libraries
The path to the READMEs directory is:
/opt/SUNWspro/READMEs/
SEE ALSO
Access complete Forte Developer 7 documentation by pointing
an HTML browser at the following URL:
file:/opt/SUNWspro/docs/index.html
Consult the following man pages for additional information:
asa(1), cc(1), dbx(1), fpp(1), fpr(1), fsplit(1),
gprof(1), ild(1), ld(1), perror(3f), prof(1), tcov(1)
Consult the following manuals for detailed information:
Fortran User's Guide
Fortran Programming Guide
OpenMP API User's Guide
Numerical Computation Guide
Sun Performance Library User's Guide
Forte Developer 7 Program Performance Analysis Tools
Fortran Library Reference
Solaris Linker and Libraries Guide
Debugging a Program With dbx
Sun Performance Library User's Guide: This Forte Developer
release includes the Sun Performance Library containing sub-
routines and functions for operations in computational
linear algebra and Fourier transforms.
DIAGNOSTICS
The diagnostics produced by f95 itself are intended to be
self-explanatory. Occasional messages may be produced by the
linker.