The OpenNET Project / Index page

[ новости /+++ | форум | wiki | теги | ]

Интерактивная система просмотра системных руководств (man-ов)

 ТемаНаборКатегория 
 
 [Cписок руководств | Печать]

f77 (1)
  • >> f77 (1) ( Solaris man: Команды и прикладные программы пользовательского уровня )
  • 
    NAME
         f77 - FORTRAN 77 compiler
    
    SYNOPSIS
         f77 [ -386 ] [ -486 ] [ -a ] [ -ansi ]
              [ -arg=local ] [ -autopar ] [ -Bx ] [ -C ] [ -c ]
              [ -cg89 ] [ -cg92 ] [ -copyargs ] [ -Dnm[=def] ]
              [ -dalign ] [ -dbl ] [ -dbl_align_all=yes|no ]
              [ -depend ] [ -dryrun ] [ -dx ] [ -e ]
              [ -erroff=taglist ] [ -errtags ] [ -explicitpar ]
              [ -ext_names=e ] [ -F ] [ -f ] [ -fast ] [ -flags ]
              [ -fnonstd ] [ -fns=yes|no ]
              [ -fpover=yes|no ] [ -fprecision=p ]
              [ -fround=r ] [ -fsimplen ] [ -fstore ] [ -ftrap=t ]
              [ -G ] [ -g ] [ -hnm ] [ -help ] [ -Idir ] [ -i2 ]
              [ -i4 ] [ -inline=rl ] [ -Kpic ] [ -KPIC ] [ -Ldir ]
              [ -libmil ] [ -loopinfo ] [ -lx ] [ -misalign ]
              [ -mp=x ] [ -mt ] [ -native ] [ -noautopar ]
              [ -nodepend ] [ -noexplicitpar ] [ -nofstore ]
              [ -nolib ] [ -nolibmil ] [ -noqueue ] [ -noreduction ]
              [ -norunpath ] [ -O[n] ] [ -o nm ]
              [ -oldldo ] [ -onetrip ] [ -p ] [ -pad=p ]
              [ -parallel] [ -pentium] [ -pg ] [ -pic ] [ -PIC ]
              [ -Qoption pr ls ] [ -qp ] [ -R ls ] [ -r8 ]
              [ -reduction ] [ -S ] [ -s ] [ -sb ] [ -sbfast ]
              [ -silent ] [ -stackvar ] [ -stop_status=yes|no ]
              [ -temp=dir ] [ -time ] [ -U ] [ -u ] [ -unroll=n ]
              [ -V ] [ -v ] [ -vax=v ] [ -vpara ] [ -w ]
              [ -xa ] [ -xarch=a ] [ -xautopar ] [ -xcache=c ]
              [ -xcg89 ] [ -xcg92 ] [ -xchip=c ]
              [ -xcode=v ] [ -xcommonchk=no|yes ]
              [ -xcrossfile=n ] [ -xdepend ] [ -xexplicitpar ]
              [ -xF ] [ -xhelp=h ] [ -xildoff ] [ -xildon ]
              [ -xinline=rl ] [ -xl[d] ] [ -xlibmil ] [ -xlibmopt ]
              [ -xlicinfo ] [ -xlic_lib=libs ] [ -Xlist ]
              [ -xloopinfo ] [ -xmaxopt[=n] ] [ -xnolib ]
              [ -xnolibmil ] [ -xnolibmopt ] [ -xO[n] ]
              [ -xpad ] [ -xparallel ] [ -xpg ] [ -xpp=p ]
              [ -xprefetch=yes|no ] [ -xprofile=p ]
              [ -xreduction ] [ -xregs=r ] [ -xs ] [ -xsafe=mem ]
              [ -xsb ] [ -xsbfast ] [ -xspace ] [ -xtarget=t ]
              [ -xtime ] [ -xtypemap=spec ] [ -xunroll=n ]
              [ -xvector=yes|no ] [ -xvpara ] [ -Zlp ] [ -ztext ]
                source file(s) ...  [ -lx ]
    
    
    DESCRIPTION
         f77 is a superset of FORTRAN 77.
         Version:  FORTRAN 77 5.0
    
         See the online READMEs/fortran_77 file (viewable by running
         f77 -xhelp=readme) for current platforms and environments
         and latest information on new or changed features. Items
         marked SPARC apply only to SPARC(TM) platforms.  Items
         marked x86. apply only to f77 on x86 platforms running
         Solaris(TM) Intel Platform Edition.
    
         Note that the compiler's parallelization features are only
         available with the Sun Performance WorkShop(TM) Fortran on
         SPARC platforms.
    
         Purpose:  Translate Fortran source files into an executable
         (a.out) file
    
         Other Uses of the compiler:
    
         o  Make an executable for multiple processors, -parallel
         o  Do global checking of the source program, -Xlist
         o  Transform source to relocatable binary (.o) files, -c
         o  Transform source to a dynamic library (.so) file, -G
         o  Prepare for debugging, -g
         o  Prepare for profiling by statement or procedure, -pg
         o  Prepare for profiling by parallelized loop, -Zlp
         o  Link .o files into an executable file
         o  Relink only the changed files, -xildon
            The Incremental Link Editor, ild, is sometimes used in
            place of the standard linker, ld, for faster development.
            See -xildon and -xildoff for more information.
    
         Note:  A man page, by definition, is a quick reference, not
         a complete reference. See the list of Sun documentation at
         the end of this man page.
    
    COMPILING FOR 64-BIT SOLARIS 7:
         This version of the compiler can produce 64-bit object
         binaries on 32-bit or 64-bit Solaris 7 SPARC Platform Edi-
         tion.  The resulting executable will run only on 64-bit
         SPARC or UltraSPARC processors under Solaris 7 with the 64-
         bit kernel.  Compilation, linking, and execution of 64-bit
         objects can only take place in a Solaris 7 environment.
    
         Compiling for 64-bit Solaris 7 is indicated by the -xarch=v9
         and -xarch=v9a options. Note that one of these options must
         be specified even if -xtarget or -fast are also specified.
         In such a case, the -xarch=v9 (or -xarch=v9a) option must
         appear AFTER any -xtarget or other option that sets -xarch.
         For example:
    
               -xtarget=ultra -xarch=v9
    
         Note that -xtarget=ultra and -xtarget=ultra2 imply -xarch=v8
         and do not automatically signal -xarch=v9 or v9a.
    
         When building shared dynamic libraries with -xarch=v9 or v9a
         on 64-bit Solaris 7, the -pic or -PIC option MUST be speci-
         fied.
    
         See also the new -xcode=abs32|abs44|abs64|pic13|pic32 option
         for specifying code address sizes.
    
         64-bit Solaris 7 not only enables 64-bit integer and pointer
         data, but also support for large files and large arrays. For
         more details, see the README file:
    
          <install-directory>/SUNWspro/READMEs/64bit_Compilers
    
         (where <install-directory> is usually /opt in a standard
         install.)
    
         You can find more specific information about compiling f77
         programs for a 64-bit environment in the f77 README file.
         This is viewable by running the command f77 -xhelp=readme
    
         For general information on 64-bit Solaris for software
         developers, see the "Solaris 64-bit Developer's Guide" on
         AnswerBook2
    
    FILE SUFFIXES
         .f   Files with names ending in .f or .for are taken to be
              f77 source files; they are compiled, and each object
              program is put in the current directory in a file with
              the same name, with .o substituted for .f or .for.
    
         .for Same as .f files.
    
         .F   Files with names ending in .F are also taken to be f77
              source files, but they are preprocessed by the Fortran
              preprocessor fpp before they are compiled. (See also
              the -xpp= option.)
    
         .s   Files with names ending in .s are taken to be assembly
              source files and are assembled, producing .o files.
    
         .il  Files with names ending in .il are taken to be inline
              expansion code template files.  The compiler uses these
              to expand inline calls to selected routines.  The com-
              piler, not the linker, does this, so to get inline
              expansion, be sure to include these .il files in the
              compile command.
    
         .o   Files ending in .o are object files that are passed
              through to the linker.
    
         .a   Files ending in .a are libraries passed on to the
    
    
              linker.
    
    OPTIONS
         For details, check the Fortran User's Guide. See ld(1) for
         link-time options.
    
         In general, processing of the compiler options is from left
         to right, so selective overriding of macros can be done.
         This rule does not apply to linker options.
    
         -386 Generate code for 80386 (x86 Only).
    
              Generate code that exploits features available on Intel
              80386 compatible processors.
    
         -486 Generate code for 80486 (x86 Only).
    
              Generate code that exploits features available on Intel
              80486 compatible processors.
              Code compiled with -486 does run on 80386 hardware, but
              it may run slightly slower.
    
         -a   Profile by basic block for tcov.
    
              Count how often each basic block is executed. Run
              tcov(1) on the source file to generate statistics about
              the program.
    
              For separate compile and link steps, if you compile
              with -a, then link with -a.  You can mix -a with -O.
    
              When the program is run, a .d file is created for every
               .f file compiled that accumulates execution data for
              the corresponding source file. Invoking tcov after run-
              ning the program generates summary output on file.tcov
              for each source file.
    
              If set at compile-time, the TCOVDIR environment vari-
              able specifies the directory where the .d and .tcov
              files are located.  If this variable is not set, these
              file will be created in the same directory as the .f
              source files.
    
              This is the old style of basic block profiling for
              tcov.  See -xprofile=p.
    
         -ansi
              Identify many non-ANSI extensions.
    
         -arg=local
              preserve actual arguments over ENTRY statements.
    
              When you compile a subprogram with alternate entry
              points with this option, f77 uses copy restore to
              preserve the association of dummy and actual arguments.
              Code that relies on this option is non-standard.
    
         -autopar
              Enable automatic loop parallelization (SPARC Only).
    
              Find and parallelize appropriate loops. Do dependency
              analysis (analyze loops for inter-iteration data depen-
              dencies). Do loop restructuring.  If optimization is
              not -O3 or higher, it is raised to -O3.
    
              -g cancels -autopar.  Debugging is facilitated by
              specifying -g without any optimization or paralleliza-
              tion options since not all debugging features are
              available when these options are invoked. See the dbx
              documentation for details.
    
              To improve performance, also specify the -stackvar
              option when using any of the parallelization options,
              including -autopar.
    
              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 processors:  To request more than one proces-
              sor, at runtime set the PARALLEL environment variable.
              If N is the number of processors available on the
              machine, then for a one-user, multiprocessor machine,
              try PARALLEL=N-1.
    
              Note:  If one user alone asks (or all users together
              ask) for more processors than are available on the
              machine, there can be serious degradation of perfor-
              mance.
    
              If -autopar is specified but -explicitpar is not, then
              explicit parallelization directives (such as C$PAR
              DOALL) 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 f77 -autopar as well.
    
         -Bx  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.
    
              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.
    
              If the -C option is used, array subscript violations
              are treated as an error. If an array subscript range
              violation is detected in the source code during compi-
              lation, it is treated as a compilation error.
    
              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 (SPARC
              Only).
              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 (SPARC Only).
    
              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 aborts.
    
              With -copyargs, if you pass a constant argument to a
              subroutine, and then within the subroutine change that
              constant, the run does not necessarily abort.
    
              Code that aborts unless compiled with -copyargs is, of
              course, not FORTRAN standard compliant nor portable,
              and often gives unpredictable results.
    
         -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 suffix files only.
    
              The following values are predefined on appropriate sys-
              tems; there are two leading underscores:
    
                 __sparc, __sparcv9, __unix, __sun, __i386, __SVR4,
                 __SunOS_5_5_1, __SunOS_5_6, __SunOS_5_7
    
              They can be in such preprocessor conditionals as
                 #ifdef __sparc
    
              Corresponding older values (prior releases) are:
                  sparc, unix, sun, i386
    
              These earlier predefined values may be deleted in a
              future release.
    
              f77 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 block data and generate faster multi-word
              load/stores.  (SPARC only)
    
              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.
    
              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 or v9a.)  The
              default alignment in COMMON blocks is on 4-byte boun-
              daries.
    
              Using -dalign along with
              -xtypemap=real:64,double:64,integer:64 or -dbl 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.
    
    
         -dbl Double the default size for REAL, INTEGER, DOUBLE, COM-
              PLEX.
    
              NOTE: This option is now considered obsolete and may be
              removed in future releases. Use the more flexible
              -xtypemap option instead.
    
              With -dbl, f77 sets the default size for REAL, INTEGER,
              and DOUBLE as follows:
    
              For SPARC:  INTEGER and REAL are 8 bytes, DOUBLE is 16
              bytes.
    
              For x86:  INTEGER, REAL, and DOUBLE are 8 bytes.
    
              This option applies to variables, parameters, con-
              stants, and functions.
    
              LOGICAL is treated as INTEGER, COMPLEX as two REALs,
              and DOUBLE COMPLEX as two DOUBLEs.
    
              Compare -dbl with -r8 as expressed in terms of the more
              general -xtypemap= option:
    
              On SPARC:
              -dbl same as -xtypemap=real:64,double:128,integer:64
              -r8 same as -xtypemap=real:64,double:128,integer:mixed
    
              These options promote default DOUBLE PRECISION data to
              QUAD PRECISION (128 bits). This could be unwanted and
              cause performance degradation.
              -xtypemap=real:64,double:64,integer:64 might be more
              appropriate than -dbl or -r8 in these cases.
    
              On x86:
              -dbl same as -xtypemap=real:64,double:64,integer:64
              -r8 same as -xtypemap=real:64,double:64,integer:mixed
    
              o For all floating-point data types, -dbl works the
                same as -r8; using both -r8 and -dbl produces the
                same results as using only -dbl.
    
              o For INTEGER and LOGICAL data types, -dbl differs from
                -r8:
              o     with -dbl, f77 allocates 8 bytes and does 8-byte
                    arithmetic.
              o     with -r8, f77 allocates 8 bytes and does only 4-
                    byte arithmetic.
    
    
         -dbl_align_all=yes|no
              Force alignment of all 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
              or v9a, 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 dependencies (SPARC Only).
    
              Analyze loops for inter-iteration data dependencies and
              do loop restructuring. Data dependency analysis is
              included as part of -fast, -parallel and -autopar.
    
              -depend will raise the optimization level to -O3 if
              optimization is not specified or is less than -O3. -g
              cancels -depend.  Debugging is facilitated by specify-
              ing -g without any optimization or parallelization
              options since not all debugging features are available
              when these options are invoked. See the dbx documenta-
              tion for details.
    
         -dryrun
              Show commands built by the f77 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 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 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
              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.
    
         -explicitpar
              Enable parallelization of loops explicitly marked with
              directives (SPARC only).
    
              This option turns on explicit parallelization. DO loops
              immediately preceded by DOALL directives will have
              threaded, parallel code generated for them. Paralleli-
              zation is only appropriate on multiprocessor systems.
              This option should not be used to compile programs that
              already do their own multithreading with calls to the
              libthread library.
    
              The compiler may generate parallel code even if there
              are data dependencies 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 dependency problems before marking them with
              parallelization directives.
    
              If optimization is not at -O3 or higher, then it is
              raised to -O3.
              -g cancels -explicitpar.  Debugging is facilitated by
              specifying -g without any optimization or paralleliza-
              tion options since not all debugging features are
              available when these options are invoked. See the dbx
              documentation for details.
    
              Avoid -explicitpar if you do your own thread manage-
              ment. See -mt.
    
              On a single-processor system, the generated code usu-
              ally runs slower.
    
              To improve performance, also specify the -stackvar
              option when using any of the parallelization options,
              including -autopar.
    
              For more information, see the chapter on Paralleliza-
              tion in the Fortran Programming Guide.
    
              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.
    
         -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 .F files and put the
              result in the file with the suffix changed to .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 on 8-byte boundaries (SPARC only).
    
              Align all common blocks and all double-precision and
              quadruple-precision local data on 8-byte boundaries.
    
              This option applies to both real and complex data.
    
              Using both -dbl and -f also causes 64-bit integer data
              to be 8-byte aligned.
    
              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.
    
         -fast
              Optimize for speed of execution using a selection of
              options.
    
              Select the combination of options that optimizes for
              speed of execution without excessive compilation time.
              This option provides close to the maximum performance
              for many realistic applications.
    
              For some critical routines, it may be better to try for
              more optimization with the -fast -O5 combination. With
              combinations, the last specification applies. Even
              though the optimization for -fast alone is -O4, the
              optimization part of the -fast -O5 combination is -O5.
    
              If you do not specify an optimization level with -fast
              the default is -O4.
    
              This is a convenience option, and it chooses:
    
              o The -native 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:
                      f77 -fast -xtarget=ultra ...
    
              o The -O4 optimization level.
    
              o The -libmil option to inline certain math library
                routines.
    
              o The -fsimple=1 option (SPARC only) to optimize
                floating-point operations.
    
              o The -dalign option (SPARC only) to allow generation
                of faster double word load/store instructions.
    
              o The -xlibmopt option to link the optimized math
                library.
    
              o The -depend option (SPARC only) to better optimize DO
                loops.
    
              o The -fns option for possibly faster handling of
                underflow.
    
              o The -ftrap=%none option to disable floating-point
                traps.
    
              o The -nofstore option (x86 only)
    
    
              Note that this option is a particular selection of
              other options that is subject to change from one
              release of the compiler to another, and between com-
              pilers.  For details on the constituents of -fast, see
              the Fortran User's Guide.
    
              Do not use this option with programs that depend on
              IEEE standard exception handling; you can get different
              numerical results, premature program termination, or
              unexpected SIGFPE signals.
    
              For separate compile and link steps: if you compile
              with -fast, then be sure to link with -fast.
    
         -flags
              Synonym for -help.
    
         -fnonstd
              Initialize floating-point hardware to non-standard
              preferences
    
              This option is a synonym for the combination
                     -fns -ftrap=common    (on SPARC)
                     -ftrap=common    (on x86)
              which initializes the floating-point hardware to:
    
              o  Abort on exceptions
              o  Flush denormalized numbers to zero if it will
              improve speed (on SPARC only)
    
              Only trapping is affected by this option on x86.
    
              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 (SPARC Only).
    
              Select the SPARC nonstandard floating-point mode.  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.
    
              This flag causes the nonstandard floating point mode to
              be enabled when a program begins execution.  By
              default, the nonstandard floating point mode will not
              be enabled automatically.
    
              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 on SPARC systems and only
              if used when compiling the main program.  On x86 sys-
              tems, the option is ignored.
    
    
         -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.
    
    
         -fprecision=p
              Initialize non-default floating-point rounding preci-
              sion mode.  (x86 only.)
    
              On x86, sets the floating-point precision mode to
              either single, double, or extended.
    
              When p is "single" or "double", this flag causes the
              rounding precision mode to be set to single or double
              precision respectively when a program begins execution.
              When p is "extended" or the -fprecision flag is not
              used, the rounding precision mode is initialized to
              extended precision.
    
              This option is effective only on x86 systems and only
              if used when compiling the main program.  On SPARC sys-
              tems, the option is ignored.
    
         -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 a 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, f77 uses -fsimple=0
                 With only -fsimple, f77 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.
                 -fast implies -fsimple=1.
    
              -fsimple=2
    
                 Permit aggressive floating-point optimizations that
                 may cause many programs to produce different numeric
                 results due to changes in rounding.
    
                 For example, -fsimple=2 will permit the optimizer to
                 attempt replacing computations of x/y with x*z,
                 where z=1/y is computed once and saved in a tem-
                 porary, thereby eliminating costly divide opera-
                 tions.
    
                 Even with -fsimple=2, the optimizer still is not
                 permitted to introduce a floating-point exception in
                 a program that otherwise produces none.
    
         -fstore
              Force precision of floating-point expressions (x86
              Only).
    
              For assignment statements, this option forces all
              floating-point expressions to the precision of the des-
              tination variable. The default is -fstore.  However,
              the -fast option includes -nofstore to disable this
              option. Follow -fast with -fstore to turn this option
              back on.
    
         -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 default is -ftrap=%none.
    
              This option sets the IEEE 754 trapping modes that are
              established at program initialization. Processing is
              left-to-right. The common exceptions, by definition,
              are invalid, division by zero, and overflow.  For exam-
              ple:
              -ftrap=overflow.
    
              Example: Set all traps, 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.
    
              o %none, the default, 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.
    
              Produce additional symbol table information for dbx(1)
              or the WorkShop debugging utility.
    
              -g cancels any parallelization option ( -autopar,
              -explicitpar, -parallel) as well as -depend and -reduc-
              tion.  Debugging is facilitated by specifying -g
              without any optimization or parallelization options
              since not all debugging features are available when
              these options are invoked. See the dbx documentation
              for details.
    
              -g no longer overrides -O, but it does override the
              automatic inlining that is usually provided by -O4.
    
              For SPARC:  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.
    
              For x86:  -g is ignored when specified with an -On
              option 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.
              o A space between -h and nm is optional.
    
              See the Solaris Linker and Libraries Guide.
    
         -help
              List the f77 command-line options.
    
              See also -xhelp.
    
         -Idir
              Add dir to the include file search path.
    
              Insert directory dir at the start of the include file
              search path. No space is allowed between -I and dir.
    
              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 f77 statement INCLUDE
    
              Example: To search for include files in /usr/applib:
    
                  f77 -I/usr/applib growth.F
    
              Of course, to invoke the preprocessor, you must use a
              .F suffix; and the f77 compiler INCLUDE statement
              allows the .f or .F suffix.
    
              The -Idir search path is used while searching for rela-
              tive path names, not absolute path names. The search
              order for relative path names is:
    
               1. The directory containing the source file
               2. Directories named in -I options
               3. Directories in the default list of the compiler
    
              The default list depends on installation:
    
              Standard install:
                /opt/SUNWspro/SC5.0/include/f77    /usr/include
              Nonstandard install to /my/dir/:
                /my/dir/SC5.0/include/f77    /usr/include
    
         -i2  Set the default integer size two bytes.
    
              Set the default size two bytes for integer and logical
              constants and variables.  But for INTEGER*n Y, the Y
              uses n bytes, regardless of -i2.
    
         -i4  Set the default integer size four bytes.
    
              Set the default size in four bytes for integer and log-
              ical constants and variables.  But for INTEGER*n Y, the
              Y uses n bytes, regardless of the -i4 option.
    
         -inline=rl
              Request inlining of the 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.  Only rou-
              tines in the file being compiled are considered. The
              optimizer decides which of these routines are appropri-
              ate for inlining.
    
              If compiling with -O3, this option can increase optimi-
              zation by inlining some routines.  The -O3 option
              inlines none by itself.
    
              If compiling with -O4, this can decrease optimization
              by restricting inlining to only those routines in the
              list. With -O4, the optimizer normally tries to inline
              all appropriate user-written subroutines and functions.
    
              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. But, see
                -xcrossfile.
    
         -Kpic
              Synonym for -pic
    
         -KPIC
              Synonym for -PIC
    
         -Ldir
              Add dir to list of directories to search for libraries.
    
              dir is added to the start of the search list. A space
              between -L and dir is optional.
    
              Note:  Do not use the -Ldir 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 (SPARC Only).
    
              Show which loops are parallelized and which are not.
              This option is normally for use with the
              -autopar and -explicitpar options. It requires a Sun
              WorkShop license and generates a list of messages on
              standard error.
    
         -misalign
              Allow for misaligned data (SPARC Only).
    
              Use this option only if you get a warning that COMMON
              or EQUIVALENCE statements cause data to be misaligned.
    
              With -misalign, the compiler will allow intentional
              misalignment and will not add padding in COMMON blocks
              to insure proper data alignment. However, this seri-
              ously degrades performance.  Recoding the program to
              eliminate the cause of data misalignment is a better
              alternative than compiling with this option.
    
              For separate compile and link steps: if you compile
              with -misalign, then link with -misalign as well.
    
         -mp=x
         Specify the style for parallelization directives (SPARC
         Only).
    
         x must be either sun or cray.  The default is sun.
    
         sun:  Accept only the Sun-style MP directives.
         cray:  Accept only the Cray-style MP directives.
    
         Sun-style parallelization directives start with C$PAR or
         !$PAR.  Cray-style parallelization directives start with
         CMIC$ or !MIC$.  Either style can use any uppercase or
         lowercase.
         Use only one directive style in any single compilation unit.
    
         -mt
         Use multithread safe libraries (SPARC Only).
    
         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 paralleliza-
         tion options use -mt automatically.
    
         On a single-processor system, the generated code usually
         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.  (SPARC Only).
    
         Cancel automatic parallelization of loops invoked by -auto-
         par on the command line. (Parallelization options require a
         WorkShop license.)
    
         -nodepend
         Cancel -depend in command line (SPARC Only).
    
         Cancel dependency analysis invoked by a -depend option
         appearing earlier in the command line.
    
         -noexplicitpar
         Cancel -explicitpar (SPARC Only).
    
         Cancel explicit parallelization of loops invoked by -expli-
         citpar earlier on the command line. (Parallelization options
         require a WorkShop license.)
    
         -nofstore
         Cancel -fstore on command line (x86 Only).
    
         Cancels forcing expressions to have the precision of the
         destination variable invoked by -fstore.
    
         -nofstore is invoked by -fast. -fstore is the usual default.
    
         -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 executables
         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 manu-
         ally. This option provides you complete control (and respon-
         sibility).
    
         The -nolib option makes it easier to link one of these
         libraries statically.  For example, an application linked
         dynamically with libF77 fails on a machine that has no
         libF77.  You can avoid such failure by shipping libF77 to
         your customer, or by linking it statically.
         Example: Link libF77 statically, libc dynamically
    
         demo% f77 -nolib any.f -Bstatic -lF77 -Bdynamic -lm -lc
    
         The order for -lx options is important. Use the order shown
         in the example.
    
         -nolibmil
         Cancel -libmil on command line
    
         Use with -fast to disable inlining of libm math routines:
    
            demo% f77 -fast -nolibmil  ...
    
         -noqueue
         Disable license queueing.
    
         With this option, if no license is available, the compiler
         returns without queuing your request and without performing
         any compilation.  A nonzero status is returned for testing
         in makefiles.
    
         -noreduction
         Cancel -reduction on command line (SPARC Only).
    
         -reduction is used along with parallelization options. This
         option cancels a -reduction appearing earlier on the command
         line. (Parallelization options require a WorkShop license.)
    
         -norunpath
         Do not build a runtime library search path into the execut-
         able
    
         If an executable file uses shared libraries, then the com-
         piler normally builds in a path that tells the runtime
         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 optimizaion level
    
         If -O[n] is not specified, only a very basic level of optim-
         ization limited to local common subexpression elimination
         and dead code analysis is performed.  A program's perfor-
         mance may be significanly improved when compiled with an
         optimization level than without optimization. Use of -O
         (which implies -O3) or -fast (which implies -O4) are recom-
         mended for most programs.
    
         Each -On level includes the optimizations performed at the
         levels below it. Generally, the higher the level of optimi-
         zation a program is compiled with, the better runtime per-
         formance obtained. However, higher optimization levels may
         result in increased compilation time and larger executable
         files.
    
         The -g option no longer suppresses -O[n], but does limit
         debugging in certain ways.
    
         For SPARC: 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 original
         level.
    
         For details on optimization, see the Fortran Programming
         Guide chapters Performance Profiling, and Performance and
         Optimization.
    
    
         -O   Optimize at the level most likely to give close to the
              maximum
    
              performance for many realistic applications (currently
              -O3).
    
         -O1  Do only the minimum amount of optimization (peephole).
    
         -O2  Do basic local and global optimization. This level usu-
              ally gives minimum code size. -O3 is preferred over -O2
              unless -O3 results in excessive compilation time, run-
              ning out of swap space, or excessively large code size.
    
         -O3  Adds global optimizations at the function level.  Usu-
              ally generates larger executable files.
    
         -O4  Adds automatic inlining of functions in the same file.
              -g suppresses automatic inlining. In general, -O4
              results in larger code.
    
         -O5  Attempt aggressive optimizations
              Suitable only for that small fraction of a program that
              uses the largest fraction of compute time. -O5's optim-
              ization algorithms take more compilation time, and may
              also degrade performance when applied to too large a
              fraction of the source program.
    
              Optimization at this level is more likely to improve
              performance if it is done with profile feedback. See
              -xprofile=p.
         -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.
    
         -oldldo
         Use old list-directed output.
    
         Omit the blank that starts each record for list-directed
         output. This is a change from releases 1.4 and earlier. The
         default behavior is to provide that blank, since the FORTRAN
         standard requires it.
    
         This is a compile option; that is, each .o file could have
         its own -oldldo option.  See also the FORM='PRINT' option of
         OPEN.
    
         -onetrip
         Enable one-trip DO loops.
    
         Compile DO loops so they are performed at least once if
         reached.
    
         f77 FORTRAN DO loops are not performed at all if the upper
         limit is smaller than the lower limit, unlike some legacy
         implementations of Fortran.
    
         -p
         Compile for profiling with prof.
    
         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, 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
    
           Each -pad choice is one token; no internal spaces.
    
         Defaults:
           Without the -pad[=p] option, no padding.
           With -pad, without =p, local and common padding.
    
         The following are equivalent:
           f77 -pad any.f
           f77 -pad=local,common any.f
           f77 -pad=common,local any.f
           f77 -pad=local   -pad=common any.f
           f77 -pad=common   -pad=local any.f
    
         Restrictions on -pad=common:
    
         o    If -pad=common is specified for a file that references
              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    EQUIVALENCE declarations involving common block vari-
              ables cause a fatal compilation error when compiled
              with -pad=common.
    
         -parallel
         Enable parallelization of loops using -autopar, -explicit-
         par, -depend (SPARC Only).
    
         Parallelize loops chosen automatically by the compiler and
         explicitly specified by user supplied directives. Optimiza-
         tion level is automatically raised to -O3 if it is lower.
    
         -g cancels -parallel.  Debugging is facilitated by specify-
         ing -g without any optimization or parallelization options
         since not all debugging features are available when these
         options are invoked. See the dbx documentation for details.
    
         To improve performance, also specify the -stackvar option
         when using any of the parallelization options, including
         -autopar.
    
         Avoid -parallel if you do your own thread management. See
         the discussion of -mt
    
         Parallelization options like -parallel are intended to pro-
         duce executables programs to be run on multiprocessor sys-
         tems. On a single-processor system, parallelization gen-
         erally degrades performance.
    
         Parallelization options require a WorkShop license.
    
         If you compile and link in separate steps, if -parallel
         appears on the compile command it must also appear on the
         link command.
    
         For more information, see the chapter on parallelization in
         the Fortran Programming Guide.
    
         -pentium
         Generate code for Pentium (x86 Only).
    
         Generate code that exploits features available on Intel
         Pentium-compatible processors. The default on x86 is -386.
    
         This option is a synonym for -xtarget=pentium.
         -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.
    
         This option is used to create dynamic shared libraries. Each
         reference to a global datum is generated as a dereference of
         a pointer in the global offset table. Each function call is
         generated in program-counter-relative addressing mode
         through a procedure linkage table.
    
         o The size of the global offset table is limited to 8Kb on
           SPARC. The size of the table is unlimited on x86.
    
         o Do not mix -pic and -PIC.
    
         There are two nominal performance costs with -pic and -PIC:
    
              o A routine compiled with either -pic or -PIC executes
                a few extra instructions upon entry to set a register
                to point at the global offset table used for access-
                ing 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 -PIC, there
                are two additional instructions per global and static
                memory reference.
    
         When considering the above costs, remember that the use of
         -pic and -PIC can significantly reduce system memory
         requirements, due to the effect of library code sharing.
         Every page of code in a shared library compiled -pic or -PIC
         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 -pic or -PIC 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 -pic or -PIC, use nm to identify
         the number of distinct 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 -pic.  Otherwise, you must
         use -PIC.
    
         When building shared dynamic libraries with -xarch=v9 or v9a
         on 64-bit Solaris 7, the -pic or -PIC option (or their
         -xcode equivalents -xcode=pic13 or -xcode=pic32) MUST be
         specified.
    
         See also -xcode.
    
    
         -PIC
         Similar to -pic, with 32-bit addresses
    
         This allows the global offset table to span the range of
         32-bit addresses. Use it for those rare cases with too many
         global data objects for -pic.
    
         On x86, -pic is the same as -PIC.
    
         Do not mix -pic with -PIC.
    
         When building shared dynamic libraries with -xarch=v9 or v9a
         on 64-bit Solaris 7, the -pic or -PIC option (or their
         -xcode equivalents -xcode=pic13 or -xcode=pic32) MUST be
         specified.
    
         See also -xcode.
    
    
         -qp
         Synonym for -p.
    
         -Qoption pr ls
         Pass option list ls to the compilation phase pr.
    
         This option is used primarily by customer service.
    
         The list is a comma-separated list of options, no blanks
         within the list.  Each option must be appropriate to pr and
         may begin with a minus sign.
         pr may be any one of the following:
            as, fbe, cg, cpp, f77pass1, iropt, ld, or ratfor.
    
         Example: Load map:
    
         demo% f77 -Qoption ld -m any.f
    
         -Rlist
         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 f77 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   for standard installs
    
         -r8
         Double the size of default REAL, DOUBLE, INTEGER, and COM-
         PLEX data.
    
         NOTE: This option is now considered obsolete and may be
         removed in future releases. Use the more flexible -xtypemap
         option instead.
    
         This option sets the default size for REAL, INTEGER, and
         LOGICAL to 8, and for COMPLEX to 16.  For INTEGER and LOGI-
         CAL the compiler allocates 8 bytes, but does 4-byte arith-
         metic.  For actual 8-byte arithmetic,
         see -dbl.
    
         For SPARC:  This option also sets the default size for DOU-
         BLE PRECISION to 16, and for DOUBLE COMPLEX to 32.
         (On x86, the size of DOUBLE remains 8 bytes and DOUBLE COM-
    
    
         PLEX 16 bytes with -r8.
    
         Promoting default DOUBLE PRECISION data to QUAD PRECISION
         (128 bits) could be unwanted and cause performance degrada-
         tion. -xtypemap=real:64,double:64,integer:64 might be more
         appropriate than -r8 in these cases.
    
         If you specify the size, then the default size is not used.
         For example, with REAL*n R, INTEGER*n I, LOGICAL*n L, and
         COMPLEX*n Z, the sizes of R, I, L, and Z are not affected by
         -r8.
    
         This option adjusts declared variables, literal constants,
         and intrinsic functions. As an intrinsic function example,
         SQRT is treated as DSQRT.
    
         In general, if you compile a subprogram with -r8, then com-
         pile all subprograms of that program with -r8.
    
         If you select both -r8 and -i2, the results are unpredict-
         able.
    
         -reduction
         Parallelize reduction operations in loops (SPARC Only).
    
         Analyze loops for reduction in automatic parallelization. To
         enable parallelization of reduction loops, specify both
         -reduction and -autopar.
    
         A loop that transforms the elements of an array into a sin-
         gle scalar value is called a reduction operation. For exam-
         ple, summing the elements of a vector is a typical reduction
         operation. Although these operations violate the criteria
         for parallelizability, the compiler can recognize them and
         parallelize them as special cases when -reduction is speci-
         fied. See the Fortran Programming Guide chapter Paralleliza-
         tion for information on reduction operations recognized by
         f77. If you specify -reduction without -autopar, the com-
         piler issues a warning.
    
         -g cancels -reduction.  Debugging is facilitated by specify-
         ing -g without any optimization or parallelization options
         since not all debugging features are available when these
         options are invoked. See the dbx documentation for details.
    
         On a single-processor system, the generated code usually
         runs more slowly.
    
         Example:  demo% f77 -autopar -reduction any.f
    
         There is always potential for roundoff error with reduction.
    
         If you have a reduction loop to be parallelized, then use
         -reduction (with -autopar, of course). Do not use an expli-
         cit pragma, because the explicit pragma prevents reduction
         for that loop, resulting in wrong answers.
    
         -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 dif-
         ficult to reverse engineer. However, this option prevents
         debugging.
    
         -sb
         Produce table information for the SourceBrowser.
    
         -sbfast
         Similar to -sb, but faster.
    
         Produce only table information for the SourceBrowser. Do not
         assemble, link, or make object files.
    
         -silent
         Supress compiler messages.
    
         Normally, the default is to show the entry names and the
         file names.  This option supresses these messages; error and
         warning messages are still issued.
    
         -stackvar
         Force all local variables to be allocated on the stack.
    
         Allocate all the local variables and arrays in a routine
         onto the memory stack, unless otherwise specified. This
         option makes them automatic, rather than static, and pro-
         vides more freedom to the optimizer for parallelizing a CALL
         in a loop.
    
         Use of -stackvar is recommended with any of the paralleliza-
         tion 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 statement
    
         o    Initialized items in a type statement or a DATA state-
              ment, such as:
                  REAL X/8.0/ or DATA X/8.0/
    
         Putting large arrays onto the stack with -stackvar can over-
         flow the stack causing segmentation faults. Increasing the
         stack size may be required.
    
         There are two stacks:
    
            The whole program has a main stack.
            Each thread of a multi-threaded program has a thread
            stack.
    
         The default stack size is about 8 Megabytes for the main
         stack and 256 Kilobytes for each thread stack. The limit
         command (with no parameters) shows the current main stack
         size.
    
         You can set the main stack size to 64 Megabytes, for exam-
         ple, with the
            limit stacksize 65536
         command. See the Fortran User's Guide.
    
         -stop_status={yes|no}
         Permit STOP statement to return an integer status value.
    
         The default is no.
    
         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 available as
         $status for the C shell or $? for the Bourne and Korn
         shells.
    
         The value must be in the range 0 to 255.
    
         -temp=dir
         Define directory for temporary files.
    
         Set the directory for temporary files used by f77 to be dir
         instead of the /tmp directory.
    
         -time
         Show execution time each compilation phase.
    
    
    
         -U
         Recognize upper and lower case in source files.
    
         Do not treat uppercase letters as equivalent to lowercase.
         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. However, use of -U may prevent intermix-
         ing of Fortran 77 with Fortran 90 programs, which does not
         have a comparable option.
    
         Calls to intrinsic functions, Fortran library functions, and
         routines explicitly declared EXTERNAL are not affected by
         this option.
    
         -u
         Report undeclared variables.
    
         Make the default type of variables undeclared rather than
         using FORTRAN implicit typing. This option does not override
         any 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.
    
         -V
         Show name and version of each compilation phase.
    
         -v
         Verbose mode - show compilation details
    
         Like -V but also show detail of options and environment
         variables used by the driver.
    
         -vax=v
         Specify choice of VMS Fortran extensions enabled.
    
         v must be one of align, misalign, or no.
         See -xl for a summary of the features involved.
         align:    Provide all language features of -xl.  Retain old
                   (release 3.0 and earlier) -xl alignment behavior;
                   that is, structures are not padded by the com-
                   piler.  If your program contains misaligned struc-
                   tures, it will not run.
         misalign: Provide all language features of -xl, including:
                   allow structures to be misaligned. This is a
                   synonym for -xl.
    
         Sub-options can be individually selected or turned off (by
         preceeding with no%).
         blank_zero:
                   Interpret blanks in formatted input as zeros.
         bslash:   Allow backslash in character constants.
         debug:    Allow VMS Fortran 'D' debugging statements.
         logical_name:
                   Allow VMS Fortran style logical file names.
         oct_const:
                   Allow double quote character to signify octal con-
                   stants.
         param:    Allow non-standard form of PARAMETER statement.
         rsize:    Allow unformatted record size in words rather than
                   bytes.
         struct_align:
                   Align structures as in VMS Fortran.
    
         Specifying -vax=misalign selects all these suboptions.
         Specifying -vax=align selects all these suboptions except
         does not allow misaligned data. Specifying -vax=%all is
         equivalent to -vax=misalign.
    
         Specifying -vax=misalign,no%rsize selects all the features
         of -xl except rsize.
    
         Similarly, -vax=%all,no%blank_zero selects all these
         features except blanks in input are treated as "nulls" and
         ignored.
    
    
         -vpara
         Show verbose parallelization messages (SPARC Only).
    
         Parallelization options require a WorkShop license.
    
         As the compiler detects each explicitly parallelized loop
         that has dependencies, it issues a warning message but the
         loop is parallelized.
    
         Use with -explictpar and a C$PAR DOALL parallel pragma.
    
         Example:  demo% f77 -explicitpar -vpara any.f
         -w
         Suppress warning messages.
    
         This option suppresses most warnings. However, if you
         specify two options, and the second one overrides all or
         part of the first one, the compiler issues a warning.
    
         -xa
         Synonym for -a.
    
         -xarch=a
         Specify the target architecture instruction set.
    
         a must be one of the following depending on platform.
    
         On SPARC:  generic, v7, v8a, v8, v8plus, v8plusa, v9, v9a.
    
         Note that v9 and v9a are only available on 64-bit Solaris 7.
    
         On x86:  generic, 386, pentium_pro.
    
         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.
    
         This option limits the instructions generated to those of
         the specified architecture, and allows the specified set of
         instructions. It does not guarantee an instruction is used;
         however, under optimization, it is usually used.
    
         If this option is used with optimization, the appropriate
         choice can provide good performance of the executable on the
         specified architecture. An inappropriate choice can result
         in serious degradation of performance.
    
         v7, v8, and v8a are all binary compatible. v8plus and
         v8plusa are binary compatible with each other and forward,
         but not backward.
    
         For any particular choice, the generated executable can run
         much more slowly on earlier architectures (to the left in
         the above list).
    
         v9, and v9a are binary compatible with each other, but not
         backward compatible with the earlier architectures.
    
         The -xarch values on SPARC are:
    
         generic Get good performance on most SPARCs, and major
                 degradation on none. This is the default.
    
         v7      Limit the instruction set to V7 architecture.
         v8a     Limit the instruction set to the V8a version of the
                 V8 architecture.
    
         v8      Limit the instruction set to V8 architecture.
    
         v8plus  Limit the instruction set to the V8plus version of
                 the V9 architecture.
    
         v8plusa Limit the instruction set to the V8plusa version of
                 the V9 architecture with version 1.0 of the Visual
                 Instruction Set (VIS).
    
         v9      Limits instruction set to the SPARC-V9 architecture.
                 The resulting .o object files are in 64-bit ELF for-
                 mat and can only be linked with other object files
                 in the same format. The resulting executable can
                 only be run on a 64-bit SPARC processor running 64-
                 bit Solaris 7 with the 64-bit kernel.  Compiling
                 with this option uses the best instruction set for
                 good performance on the V9 SPARC architecture, but
                 without the use of quad-precision floating-point
                 instructions.
                 (Available only on 64-bit Solaris 7)
    
         v9a     Limits instruction set to the SPARC-V9 architecture,
                 adding the Visual Instruction Set (VIS) and exten-
                 sions specific to UltraSPARC processors.
                 The resulting .o object files are in 64-bit ELF for-
                 mat and can only be linked with other object files
                 in the same format. The resulting executable can
                 only be run on a 64-bit SPARC processor running 64-
                 bit Solaris 7 with the 64-bit kernel.  Compiling
                 with this option uses the best instruction set for
                 good performance on the V9 UltraSPARC architecture,
                 but without the use of quad-precision floating-point
                 instructions.
                 (Available only on 64-bit Solaris 7)
    
         Use of -xarch=v8plus or v8plusa causes the .o file to be
         marked as a V8plus binary; such binaries will not run on a
         V7 or V8 machine.
    
         See the Fortran User's Guide for more complete definitions.
    
         -xautopar
         Synonym for -autopar
    
    
    
         -xcache=c
         Define cache for optimizer (SPARC Only).
    
         Define cache properties for use by optimizer.
    
         c must be one of the following:
            o generic
            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 optim-
         izer can use. It does not guarantee that any particular
         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 SPARCs. This is the default.
         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.
    
         -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:  generic, old, super, super2, micro, micro2,
         hyper, hyper2, powerup, ultra, ultra2, ultra2i.
    
         On x86:  generic, 386, 486, pentium, pentium_pro.
    
         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 SPARCs.
         old     Optimize for pre-SuperSPARC(TM) processors.
         super   Optimize for the SuperSPARC chip.
         super2  Optimize for the SuperSPARC II(TM) chip.
         micro   Optimize for the MicroSPARC(TM) chip.
         micro2  Optimize for the MicroSPARC II(TM) chip.
         hyper   Optimize for the HyperSPARC(TM) chip.
         hyper2  Optimize for the HyperSPARC II(TM) chip.
         powerup Optimize for the Weitek(R) PowerUp(TM) chip.
         ultra   Optimize for the UltraSPARC(TM) chip.
         ultra2  Optimize for the UltraSPARC II(TM) chip.
         ultra2i Optimize for the UltraSPARC IIi(TM) chip.
         For complete information, see the Fortran User's Guide
    
         -xcommonchk[={yes|no}]
         Enable runtime checking of common block inconsistencies.
         (SPARC Only).
    
         This option is provided as a debugging aid for programs
         using task common and parallelization (-explicitpar or
         -parallel). (See the task common pragma.)
    
         By default, runtime checking for inconsistent task common
         declarations is disabled. Compiling with -xcommonchk=yes
         will enable this runtime check when the program is executed.
         If a common block is declared in one source module as a reg-
         ular common block, and somewhere else appears in a task com-
         mon pragma, the program will stop and a message pointing to
         the first such inconsistency issued.
    
         Because the runtime check invoked by this option will
         degrade program performance, it should only be used during
         program development and debugging.
    
         Specifying -xcommoncheck alone is equivalent to
         -xcommoncheck=yes
    
         -xcode=v
         Specify code address space (SPARC Only).
    
         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 architectures:
                 arch=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
    
         abs64   Generate 64-bit absolute addresses.
                 Available only on 64-bit architectures:
                 -xarch=v9,v9a
    
         pic13   Generate position-independent code (small model).
                 Equivalent to -pic.  Permits references to at most
                 2**11 unique external symbols on 32-bit architec-
                 tures, 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 architec-
                 tures, 2**29 on 64-bit.
    
         The default is -xcode=abs32 for SPARC V8 and V7.  The
         default is -xcode=abs64 for SPARC and UltraSPARC V9 (with
         -xarch=v9|v9a).
    
         When building shared dynamic libraries with -xarch=v9 or v9a
         on 64-bit Solaris 7, a -xcode=pic13 or pic32 (or -pic or
         -PIC) option MUST be specified.
    
    
         -xcrossfile[=n]
         Enable optimization and inlining across source files (SPARC
         Only).
    
         If specified, n may be 0, or 1.
    
         Normally, the scope of the compiler's analysis is limited to
         each separate file on the command line. For example, -O4's
         automatic inlining is limited to subprograms 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 concatenated into a
         single source file.
    
         -xcrossfile is only effective when used with -O4 or -O5.
    
         The files produced from this compilation are interdependent
         (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 performed.
         -xcrossfile is equivalent to -xcrossfile=1.
    
    
         -xdepend
         Synonym for -depend
    
         -xexplicitpar
         Synonym for -explicitpar
    
         -xF
         Allow function-level reordering by WorkShop 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 optimizes 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 per-
         centage of the application time. Otherwise, reordering may
         not improve the overall performance of the application. The
         Analyzer is part of the Sun WorkShop. See the Analyzing Pro-
         gram Performance With Sun WorkShop manual for further infor-
         mation on the Analyzer.
    
    
         -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.
    
         -xildoff
         Turn off Incremental Linker (SPARC Only).
    
         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 (SPARC Only).
         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.
    
         -xl[d]
         Extend the language with more VMS features.
         You get most of the VMS FORTRAN features automatically, with
         no special option needed.  However, where the same source
         code can mean two different behaviors (one behavior for VMS
         FORTRAN and another behavior for f77), -xl makes the com-
         piler choose VMS FORTRAN.
    
         -xl is a macro that is translated to -vax=misalign.
    
         -xl provides the following language features:
         o Unformatted record size in words, not bytes
         o VMS-style logical file names
         o Quote (") character that introduces octal constants
         o Backslash (\) as ordinary normal in constants
         o Nonstandard form of the PARAMETER statement
         o Alignment of structures as in VMS FORTRAN
    
         -xld Besides what -xl does, this option allows VMS debugging
              statements. If there is a D or d in column one, then
              -xld causes them to be compiled; otherwise, they are
              treated as comments.
    
         -xlibmil
         Synonym for -libmil.
    
         -xlibmopt
         Use library of optimized math routines (SPARC Only).
    
         Use a library of selected math routines optimized for per-
         formance.  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 significant.
    
         -xlicinfo
         Show license server user IDs.
    
         Return license information about the licensing system. In
         particular, return the name of the license server and the
         IDs of users who have obtained licenses.
    
         Generally, with this option, no compilation is done, and a
         license is not checked out. If a conflicting option is used,
         then the latest one on the command line takes precedence,
         and a warning is issued.
    
         -xlic_lib=libs
         Link with specified Sun licensed libraries.
    
         libs is a comma-delimited list of libraries.
    
         Example: linking with the Sun Performance Library:
            f77 -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.
    
         -Xlist
         Produce lisitings and do global program checking.
    
         Check across routines for consistency.  This option helps
         find a variety of bugs. In general, -Xlist also makes a
         line-numbered listing of the source and a cross reference
         table of the identifiers. The errors that are found do not
         prevent the program from being compiled and linked.
    
         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% f77 -Xlist file1.f file2.f
    
         Use the -Xlist options to check for interprocedural prob-
         lems, but only after all other compiler errors and warnings
         have been resolved.
    
    
    
         Summary of -Xlist Suboptions
    
         -Xlist         Default: listings, errors, xref
         -Xlistc        Show only global errors, call graph
         -XlistE        Errors only (no xref or listings)
         -Xlisterr      Suppress all -Xlist error messages
         -Xlisterr[n]   Suppress -Xlist error message n.
         -Xlistf        Show errors, listing, cross reference; no
                        compilation
         -Xlistflndir   Put .fln files in directory dir
         -Xlisth        Halt compilation if global errors detected
         -XlistI        Check include files also
         -XlistL        Listings only (no xref)
         -Xlistl[n]     Page length is n lines
         -Xlistonm      Output to nm instead of to file.lst
         -Xlists        Suppress unreferenced names from cross-
                        reference
         -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)
    
    
    
         -xloopinfo
         Synonym for -loopinfo
    
    
         -xmaxopt[=n]
         Enable optimization pragma and set maximum optimization
         level.
    
         If a
    
         C$PRAGMA SUN OPT=n
    
         directive appears specifying a level greater than the level
         specified by the -xmaxopt flag, the optimization level used
         is the one specified by -xmaxopt.
    
         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 speci-
         fied by other options. So, for example:
    
                f77 ... -O3 -xmaxopt=4
    
         would be appropriate.
    
         The flag  -xmaxopt   by itself defaults to -xmaxopt=5
         -xnolib
         Synonym for -nolib.
    
    
         -xnolibmil
         Synonym for -nolibmil.
    
    
         -xnolibmopt
         Cancel -xlibmopt (SPARC Only).
    
         Use with -fast to cancel linking with the optimized math
         library.
    
    
         -xO[n]
         Synonym for -O[n].
    
    
         -xparallel
         Synonym for -parallel
    
    
         -xpg
         Synonym for -pg.
    
    
         -xpp=p
         Select source file preprocessor.
    
         p is either fpp or cpp.  Selects the source file preproces-
         sor to be used with .F files. The default is fpp, which is
         appropriate for Fortran. Previous versions of the compiler
         used cpp, the standard C language preprocessor. To select
         cpp, specify -xpp=cpp.
    
    
         -xprefetch[={yes|no}]
         Use prefetch instructions on UltraSPARC II processors.
         (SPARC Only).
    
         With -xprefetch=yes, the compiler is free to insert prefetch
         instructions into the code it generates. This may result in
         a performance improvement on UltraSPARC II processors.
    
         The default if not specified is -xprefetch=no. Specifying
         -xprefetch alone is equivalent to -xprefetch=yes.
    
         -xprofile=p
         Collect or optimize with runtime profiling data
    
         Collect and save execution frequency data during execution;
         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 com-
                  piler generates code to measure statement execution
                  frequency.
    
                  The nm is the name of the program that is being
                  analyzed. This name is optional. If not specified,
                  a.out is assumed to be the name of the executable.
    
                  At runtime a program compiled with -
                  xprofile=collect:nm will create the subdirectory
                  nm.profile to hold the runtime feedback informa-
                  tion. Data is written to the file feedback in this
                  subdirectory. If you run the program several times,
                  the execution frequency data accumulates in the
                  feedback file; that is, output from prior runs is
                  not lost.
    
         use[:nm] Use execution frequency data to optimize strategi-
                  cally.
    
                  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 execution
                  frequency data previously generated and saved in
                  the feedback files written by a previous execution
                  of the program compiled with -xprofile=collect.
    
                  The source files and other compiler options must be
                  exactly the same as used for the compilation 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 compilation:
                  -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 generated, 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 output.
    
                  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.
    
    
         -xreduction
         Synonym for -reduction
    
    
         -xregs=r
         Specify register usage (SPARC Only).
    
         Specify usage of registers in generated code.
    
         r is a comma-separated list of one or more of the following:
         [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, g4, and g5.  (v8plus,
                  v8plusa)
                  Allow using registers g2, g3.  (v9, v9a)
    
         no%appl  Do not use appl registers.
    
         float    Allow using floating-point registers as specified
                  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
             Assume no memory-based traps (SPARC Only).
    
             Allow the compiler to assume no memory-based traps occur
             This option grants permission to use the speculative
             load instruction on V9 machines. It is only effective
             when used with -O5 optimization, and
             -xarch=v8plus|v8plusa|v9|v9a is specified.
    
    
         -xsb
             Synonym for -sb.
    
    
         -xsbfast
             Synonym for -sbfast.
    
    
         -xspace
             Do not increase code size (SPARC Only).
    
             Do no optimizations that increase the code size.
             Example: Do not unroll loops.
    
    
         -xtarget=t
             Specify system for optimization
    
             Specify the target system for the instruction set and
             optimization.
    
             t must be one of: native, generic, system-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.
    
             generic:  Get the best performance for generic architec-
             ture, chip, and cache. This is the default.
    
             system-name:  Get the best performance for the specified
             system.
    
             Valid system 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,
             ss5, 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/hs11, ss20/hs12, ss20/hs14, ss20/hs21, ss20/hs22,
             ss20/51, ss20/61, ss20/71, ss20/502, ss20/512, ss20/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, ultra1/200,
             ultra2/1170, ultra2/1200, ultra2/1300, ultra2/2170,
             ultra2/2200, ultra2/2300, entr2, entr2/1170, entr2/2170,
             entr2/1200, entr2/2200, entr150, entr3000, entr4000,
             entr5000, entr6000.
    
             Compiling for 64-bit Solaris 7 on SPARC or UltraSPARC V9
             is indicated by the -xarch=v9 or -xarch=v9a flag. Set-
             ting -xtarget=ultra or ultra2 is not necessary or suffi-
             cient.  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.
    
             On the x86 platform, valid system names are:  generic,
             native, 386, 486, pentium, pentium_pro.
    
             See the appendix in the Fortran User's Guide that lists
             the -xtarget expansions.
    
             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
    
             fpversion(1) can be used to see the -xtarget or
             -xarch, -xchip, and -xcache options equivalent to
             -xtarget=native on any 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. Compare with -dbl and -r8.
    
             The syntax of the string spec is:
    
             real:size,double:size,integer:size
    
             The data sizes accepted are
             64 (real, double, and integer),
             128 (double),
             and mixed (integer).
    
             All three type specifications must appear, in the order
             shown.
    
             This option applies to all variables declared without
             explicit byte sizes, as in REAL XYZ.
    
             The allowable size values are:
    
                On SPARC:
                  real:64,
                  double:64, double:128,
                  integer:64, integer:mixed.
    
                On x86:
                  real:64,
                  double:64,
                  integer:64, integer:mixed.
    
             The mapping integer:mixed indicates 8-byte integers but
             only 4-byte arithmetic.  Use
             -xtypemap=real:64,double:64,integer:64 in 64-bit
             environments instead of -dbl or -r8.
    
             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. (SPARC Only).
    
             -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 f77 command.
    
    
         -xvpara
             Synonym for -vpara
    
    
         -Zlp
             Compile for loop profiling by looptool.  (SPARC Only).
    
             Prepare object files for the loop profiler looptool,
             part of the Sun WorkShop.  This option requires a
             WorkShop license.
    
             If you compile and link in separate steps, and you com-
             pile with -Zlp, then be sure to link with -Zlp.
    
             If you compile one subprogram with -Zlp, you need not
             compile all subprograms of that program with -Zlp.  How-
             ever, you get loop information only for the files com-
             piled with -Zlp, and no indication that the program
             includes other files.
    
    
         -ztext
             Make no library with relocations (SPARC Only)
    
             Do not make the library if relocations remain.  The gen-
             eral purpose of -ztext is to ask if 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 f77-compatible object programs, typically
         produced by an earlier run, or libraries of routines that
         are f77-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.
    
    DIRECTIVES
         General Directives:  f77 allows general compiler directive
         lines starting with C$PRAGMA, !$PRAGMA, or *$PRAGMA, and any
         uppercase or lowercase is allowed.  Examples:
    
           C$PRAGMA C( suba, subz)
           C$PRAGMA SUN UNROLL 2
           C$PRAGMA WEAK funk
           C$PRAGMA SUN OPT=4
    
         Parallel Directives:  f77 allows parallel compiler directive
         lines starting with C$PAR, !$PAR, or *$PAR, and any upper-
         case or lowercase is allowed.  Examples:
    
           C$PAR DOALL
           C$PAR DOSERIAL
           C$PAR DOSERIAL*
           C$PAR TASK COMMON
    
         See the Fortran User's Guide for details and variations.
    
    
    
    ENVIRONMENT
         The paths shown below assume a standard installation of the
         Sun WorkShop Compilers to /opt/SUNWspro/.  Contact your sys-
         tem administrator if your compilers were custom installed to
         some other directory path.
    
      PATH
         To use f77, add the following to the start of the search
         path:
    
         /opt/SUNWspro/bin/
    
    
      MANPATH
         To access the f77 man pages, add the following to the MAN-
         PATH environment variable:
    
         /opt/SUNWspro/man/
    
    
      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
         On Solaris 7, this environment variable is similar to
         LD_LIBRARY_PATH but overrides it when searching for 64-bit
         dependencies.
    
         When running Solaris 7 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 f77, LD_RUN_PATH is
         not identical with -R.  (For ld.so, they are identical.)
         See -R, in the Fortran User's Guide, for details.
    
    FILES
         Selected major files used by the compiler
         a.out                Executable output file
         file.a               Library of object files
         file.d               Test coverage input file for tcov(1)
         file.f               FORTRAN source file
         file.F               FORTRAN source file for cpp(1)
         file.for             FORTRAN source file
         file.il              In-line expansion file
         file.o               Object file
         file.r               Ratfor source file
         file.s               Assembler source file
         file.S               Assembler source for cpp(1)
         file.tcov            Output from tcov(1)
    
         /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/SC5.0/
    
         The `SC5.0' varies with each release of the Sun WorkShop
         Compilers.
    
         bin/fpp
              Fortran preprocessor
         bin/cpp
              C preprocessor
         include/f77
              Path searched for f77 INCLUDE statement
         include/f77/f77_floatingpoint.h
              f77 IEEE arithmetic type definitions
         lib/libF77.a
              f77 lib, includes I/O and UNIX interface
         lib/libp/libF77.a
              f77 profile lib
         lib/libM77.a
              f77 math library
         lib/libp/libM77.a
              f77 profiled math library
    
         /usr/lib/libm.a
              Math lib
         /usr/lib/libp/libm.a
              Math profile lib
         lib/libsunmath.a
              Sun value-added math lib
         lib/libp/libsunmath.a
              Sun value-added math profile lib
    
         lib/libV77.a
              VMS routines in conflict with Sun f77
         lib/libp/libV77.a
              VMS FORTRAN 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_77
              o   math_libraries
              o   64bit_Compilers
    
         The path to the READMEs directory is:
           <install_path>/SUNWspro/READMEs/
         where <install_path> is usually /opt in a standard install.
    
    SEE ALSO
         asa(1),  cc(1),  dbx(1),  fpp(1),  fpr(1),  fsplit(1),
         gprof(1),  ild(1),  ld(1),  perror(3f),  prof(1),  tcov(1)
    
         Fortran User's Guide
         Fortran Programming Guide
         FORTRAN 77 Language Reference
         Numerical Computation Guide
         Analyzing Program Performance with Sun WorkShop
         Fortran Library Reference
         Linker and Libraries Guide (ld)
         Debugging a Program With dbx
    
         Sun Performance Library:  See the performance_library infor-
         mation file and the libsunperf Reference Manual PostScript
         files in the READMEs/ directory. This library is part of the
         Sun Performance WorkShop and contains subroutines and func-
         tions for operations in computational linear algebra and
         Fourier transforms.
    
         POSIX bindings:  The POSIX bindings provided are for IEEE
         Standard 1003.9-1992.  IEEE 1003.9 is a binding of 1003.1-
         1990 to FORTRAN (X3.8-1978).
    
         POSIX.1 documents:
              o    ISO/IEC 9945-1:1990
              o    IEEE Standard 1003.1-1990
              o    IEEE Order number SH13680
              o    IEEE CS Catalog number 1019
    
         To find out precisely what POSIX Fortran bindings are, you
         need both the 1003.9 and the POSIX.1 documents.
    
         For information on ordering these documents, see the chapter
         on libraries in the Fortran Programming Guide.
    
    DIAGNOSTICS
         The diagnostics produced by f77 itself are intended to be
         self-explanatory. Occasional messages may be produced by the
         linker.  The error messages are listed in perror(3f).
    
    
    
    


    Поиск по тексту MAN-ов: 




    Спонсоры:
    Inferno Solutions
    Hosting by Hoster.ru
    Хостинг:

    Закладки на сайте
    Проследить за страницей
    Created 1996-2021 by Maxim Chirkov
    Добавить, Поддержать, Вебмастеру