o32(5)

o32 - Describes the options for the o32 ABI for the MIPSpro compilers

As shipped in IRIX 6.5.22. Last changed in IRIX 6.5.19.

NAME
     o32 - Describes the options for the o32 ABI for the MIPSpro compilers

SYNOPSIS
     -o32 | -32 [options]

DESCRIPTION
     This man page describes the function of the -o32 or -32 option, which
     generates a 32-bit object when specified on the cc(1), CC(1), or
     f77(1) command line.  It defaults to -mips2 if -mips1 has not also
     been specified.  Unless specified in the description, options apply to
     all three compilers.

OPTIONS
     -mips1
          Generates code using the instruction set of the R2000/R3000 RISC
          architecture, and searches for mips1 libraries/objects at link-
          time.  Defaults to -o32.

     -mips2
          Generates code using the MIPS II instruction set (MIPS I + R4000
          specific extensions), and searches for mips2 libraries/objects at
          link-time.  Defaults to -o32.

     --   In XPG4 mode, standard utilities that accept operands but do not
          accept options, recognize the -- characters as the first argument
          to be discarded.  This lets portable applications shield their
          operands from arbitrary options that the implementation may
          provide as an extension.

          For example, if the standard utility foo is listed as taking no
          options, and the application needed to give it a pathname with a
          leading hypen, it could safely do it as foo -- -myfile and avoid
          any problems with -m used as an extension.

     -66  (f77 only) Suppresses extensions that enhance FORTRAN 66
          compatibility.

     -ansiE
          (CC only) Issues error messages for use of non-standard features
          in ANSI/ISO C.

     -ansiW
          (CC only) Issues warning messages for use of non-standard
          features in ANSI/ISO C.  This is the default with the -ansi flag.

     -ansi
          (ANSI/ISO C only) Pure ANSI/ISO C.  The symbols _MIPS_FPSET,
          _MIPS_ISA, _MIPS_SIM, _MIPS_SZINT, _MIPS_SZLONG, _MIPS_SZPTR,
          _LANGUAGE_C, __sgi, __unix, __host_mips, _MODERN_C, __DSO__,
          _SYSTYPE_SVR4, __mips, _MIPSEB, __STDC__, and _CFE are defined to
          the preprocessor.  The symbol __ANSI_CPP__ is defined, and
          ANSI/ISO trigraphs are processed by default.

          NOTE: When compiling in pure ANSI/ISO mode (-ansi), several
          standard UNIX symbols (such as environ and end) may only be
          referenced by their ANSI/ISO compliant counterparts (such as
          _environ and _end).  The type long long is allowed, but results
          in a warning in -ansi mode.  To take advantage of this type in
          libraries that refer to __int64_t and __uint64_t, you must define
          the macro __LONGLONG on the command line; otherwise, __int64_t
          and __uint64_t are defined as structs.  See the ANSI C Transition
          Guide for more information.

     -ansiposix
          (ANSI/ISO C only) Specifies the same compilation environment as
          -ansi with the additional preprocessor definition of
          _POSIX_SOURCE.  This is a pure ANSI/ISO environment, and __STDC__
          is defined with this option as well as with the -ansi option.

          WARNING:  This option is obsolete and will be removed in future
          releases.

     -automatic
          (f77 only) Places local variables on the runtime stack.  The same
          restrictions apply for this option as they do for the automatic
          keyword.  This is the default.

     -avoid_gp_overflow
          Asserts assorted flags that are intended to avoid GOT overflow.

     -backslash
          (f77 only) Treats the backslash character as a normal character
          instead of an escape sequence character.  For example, when this
          option is specified, the sequence \t is treated as two separate
          characters instead of a single <TAB> character.

     -bytereclen
          (f77 only) Record lengths used for unformatted direct I/O are
          specified as the number of bytes in a record.  By default, record
          length specifications are interpreted as the number of 4-byte
          words in a record.  If the main routine for a mixed C and Fortran
          program is written in C, and Fortran unformatted direct I/O will
          be performed by the program, the /usr/include/cmplrs/fioflags.h
          header file must be included by the C main program and the OLD_RL
          flag must be set as directed by the header file.

     -c   Suppresses the loading phase of the compilation, and produces an
          object file.

     -cckr
          (CC only) Specifies the traditional K&R/Version7 C with SGI (and
          some like ANSI/ISO C) extensions, including function prototypes,
          void, void*.  The following symbols are defined to the
          preprocessor:
          _MIPS_FPSET
          _MIPS_ISA
          _MIPS_SIM
          _MIPS_SZINT
          _MIPS_SZLONG
          _MIPS_SZPTR
          __EXTENSIONS__
          LANGUAGE_C
          _LANGUAGE_C
          __INLINE_INTRINSICS
          sgi
          __sgi
          unix
          mips
          host_mips
          __unix
          __host_mips
          _SVR4_SOURCE
          _MODERN_C
          _SGI_SOURCE
          __DSO__
          SYSTYPE_SVR4
          _SYSTYPE_SVR4
          _LONGLONG
          __mips
          _MIPSEB
          MIPSEB
          _CFE

     -cfront
          (CC only) Causes the compiler to accept constructs that were
          accepted by previous cfront-based compilers, such as OCC, but
          which are not accepted in the ANSI/ISO standard.

     -chararg1
          (f77 only) Counts each character argument as only one argument.
          For subroutines accepting a variable number of arguments, the
          default is to count all arguments on the argument stack.  This
          means that for each character argument, the count is two because
          both the address of the character argument and its length are put
          on the argument stack.

     -common
          (CC only) The declaration int i; in multiple files at file level
          is merged.  Without it, ANSI/ISO C generates a warning (from
          ld(1)) about duplicate definitions.  When C and Fortran compiled
          objects are linked together and an ANSI C defined variable should
          be located at the same address as a Fortran common block, you
          must compile the C source with the -common flag.  When specifying
          traditional K&R/Version7 C (for example, -cckr), this option is
          ignored.

          The ANSI/ISO C Strict-Ref/Def-initialization model is relaxed to
          the traditional IRIX Relaxed Ref/Def model (see the ANSI/ISO C
          Standard for information on this model).

     -cord
          Runs the procedure rearranger, cord(1), on the file created after
          linking.  This improves the paging and caching performance of the
          program's text.  The output of cord(1) is left in the file
          specified by the -o output option or a.out by default.  Use the
          -feedback option to specify the feedback file.  If no -feedback
          file is specified, then outfile.fb is the default.

     +d   (CC only) Suppresses expansion of inline functions.  Copies of
          inline functions are emitted as external out-of-line functions in
          each compilation unit where they are called.

          These are marked so that the linker silently accepts duplicate
          symbols and resolves all of the calls to one copy of the
          function, and removes all other copies from the executable.

     -ddopt
          (f77 only) Specifies the data dependence optimization pass.  An
          option indicating that the global optimizer is to be run (-O,
          -O2, -O3) must also be specified.  This optimization pass is
          experimental and may not be supported.

     -dollar
          (CC only) Allows the dollar sign ($) as a character in C
          identifiers, including the leading character of an identifier.
          This option is provided for compatibility purposes, and its use
          is not recommended.

     -expand_include
          (f77 only) Expands all include statements in the FORTRAN listing
          file.  This option must be specified with the -listing option.

     -exceptions
          (CC only) Invokes an exception handling compiler with a different
          front end than the standard 32-bit compiler.  If this option is
          not specified on the command line, the CC driver continues to
          invoke the standard 32-bit compiler.  If you want to use
          exception handling, it is recommended that you recompile all of
          your code using the -exceptions option.  Generally, code with
          exception handling and code without exception handling cannot be
          mixed.  See the release notes for the actual restrictions.  This
          option should be used with caution.

     -feedback <file>
          Specifies the feedback file(s) to be used with the -cord option.
          This file can be produced by using prof(1) with its -feedback
          option from an execution of the instrumented program produced by
          pixie(1).  Multiple feedback files can be specified with multiple
          -feedback options.

     -float
          Uses single-precision floating-point except when specified in
          function arguments.  In the following example, a and b are
          promoted to double and a double-precision multiply is done,
          followed by a conversion back to single-precision for the
          assignment to c:


          float a; int b; float c;
          c = a * b;

          The -float option is ignored in all ANSI/ISO C conformance modes
          and has effect only in -cckr mode.  ANSI/ISO C uses single
          precision floating-point operations where allowed by the
          standard.  If the -float option is specified, b is promoted to
          single-precision, and a single-precision multiply is done.  This
          option does not affect float and double argument passing; float
          function arguments are promoted to double unless function
          prototypes are used.  Unappended floating-point constants are
          cast to single precision values in subexpressions with no double
          (or long double) operands.

     -framepointer
          (f77 only) Asserts the requirement of frame pointer for all
          procedures defined in the source file.

     -fullwarn
          Executes various extra checks and produces additional warnings
          that are suppressed by default.  This option is recommended for
          all compiles during software development.

     -gn  Specifies options for producing debugging information.  n can be
          one of the following:

             0    Does not produce debugging information for symbolic
                  debugging.  This is the default.

             2    Produces additional debugging information for full
                  symbolic debugging and does not perform optimizations
                  that limit full symbolic debugging.  These options
                  override the following optimization options:  -O, -O1,
                  -O2, -O3.

             3    Produces additional debugging information for symbolic
                  debugging of fully optimized code.  This option makes the
                  debugger inaccurate.  This option can be used with the
                  following optimization options:  -O, -O1, -O2, -O3.

          Specifying -g without a debug level is equivalent to specifying
          -g2.

     -h path
          Specifies the directory (path) where the name is found.

     -j   Compiles the specified source programs, and creates ucode object
          files in corresponding files appended with .u.

     -k   (f77 only) Passes options that start with a -k to the ucode
          loader.  This is used to specify ucode libraries (with -kl x) and
          other ucode loader options.

     -keep
          Builds intermediate compilation files named after the
          corresponding source files.  The file is appended by a letter
          appropriate for the type of intermediate file (for example, the
          front end generates a binary intermediate .B file).  These
          intermediate files are never removed even when a compilation pass
          encounters a fatal error.

     -ko output
          Specifies the output file created by the ucode loader (output).
          This file is not removed.  If this file is compiled, the object
          file is named output appended with .o.

     -kpicopt
          (f77 only) Requests uopt to perform the special treatment for
          global variables to optimize their program accesses regardless of
          the shared/nonshared compilation mode.

     -l library
          In XPG4 mode, searches the library named lib.IRlibrary.a.  A
          library is searched when its name is encountered, so the
          placement of the -l operand is significant.

     -m   (f77 only) Applies the M4 preprocessor, m4(1), to each RATFOR
          source file before transforming it with the ratfor(1)
          preprocessor.  The temporary file created for the output is
          appended with .p.  This temporary file is removed unless the -K
          option is specified.

     -mp  (CC only) Enables the multiprocessing directives.  (Requires
          Power C.)

     -nocpp
          (CC only) The C macro preprocessor is not run on C and assembly
          source files before compiling.  This option is ignored when
          compiling a .i file.

     -noexpopt
          (f77 only) Exponential operation is not optimized.  This option
          achieves the same precision as releases prior to 4D1-4.0 without
          using the exponentiation optimization.  The new optimization
          might present some precision differences (which do not
          necessarily mean less accuracy) in double precision exponential
          operations.

     -nofilt
          (CC only) Disables filtering of back end and linker error
          messages through a filter that demangles C++ external names.

     -nokpicopt
          Specifies that uopt does not perform the special treatment for
          global variables to optimize their program accesses under shared
          compilation.

     -non_shared
          (CC only) Specifies that the compiler build a non-shared object.
          This is the opposite of specifying -KPIC.  Using the -non_shared
          option causes the linker to search the nonshared subdirectory of
          each default library search directory (see the ld(1) man page).
          The linker defaults the archive extensions to .a instead of .so.
          The appropriate non-shared library images must be installed.
          Programs built with the -non_shared option are not portable
          across platforms.

     -nostdinc
          (CC only) Does not search for #include files in the standard
          directory (/usr/include).

     -old_rl
          (f77 only) Same functionality as the -bytereclen option which
          should be used instead of -old_rl.

     -o output
          (CC only) Specifies the final output file, output.  The file
          a.out is undisturbed.

     +p
     +pp  (CC only) The 32-bit compiler enables anachronisms and cfront
          bug-compatibility support by default (see the -anach and -cfront
          options).  The +p option turns off support for C++ anachronisms.
          The +pp option turns off support for both anachronisms and cfront
          bug-compatibility.

     -pca [list][keep]
          (CC only) Runs the pca(1) preprocessor to automatically discover
          parallelism in the source code.  This also enables the
          multiprocessing (-mp) directive.  There are two optional
          arguments:

          list Runs pca and produces a .L listing file.  It explains which
               loops were parallelized and if not, why.

          keep Runs pca and produces the listing file.  Creates a
               transformed multiprocessed C intermediate file appended with
               a .M.  (Power C only.)

     -pedantic
          (CC only) In ANSI/ISO preprocessing mode, warns that the #ident
          preprocessor directive is non-standard except in -cckr mode when
          the directive is silently ignored.  This directive is a System V
          extension, which by default is silently ignored.

     -show
          (CC only) Prints the passes as they execute, their arguments, and
          their input and output files.

     -signed
          (CC only) Causes all char declarations to be signed char
          declarations.  By default they are treated as unsigned char
          declarations.

     -sopt[,option][,option]...
          (cc and f77 only) Invokes the source-to-source optimizer, copt(1)
          or fopt(1), on the indicated source file(s).  This is distinct
          from the standard global optimizer which is invoked with one of
          the following options:  -O, -O2, or -O3.  Additional options can
          be passed to -sopt by using a comma-separated list, but the
          options passed by default cannot be changed (use cc -sopt -show
          or f77 -sopt -show to see what is passed by default).  See the
          copt(1) and fopt(1) man pages for more details.

     -t [options]
          Select a name to use for a particular pass, startup routine, or
          standard library.  These arguments are processed from left to
          right so their order is significant.

          The following table lists the possible options:

          Name                Character

          include             h

          ujoin               j

          uld                 u

          usplit              s

          umerge              m

          uopt                o

          ugen                c

          as0                 a

          as1                 b

          ld                  l

          [m]crt[1n].o        r

          The following are available for C only:

          preprocessor        p

          pca                 K (Power C only)

          mpc                 M (Power C only)

          cfe                 f

          The following are available for Fortran only:

          cpp                 p

          pfa                 K

          fcom                f

          libF77.a            F

          libI77.a            I

          libU77.a            U

          libisam.a           S

          libm.a              M

          cord                z

          Although cc or f77 can be used to compile source files in other
          languages (such as Pascal), only the name used for the front end
          of the C or Fortran compiler is selected by the -tf option.

          f77 Usage notes: When the -B option is encountered, the selection
          of names takes place using the last -h and -t options.  You must
          use all three options together.  For example, -tc -h. -B directs
          the compiler to use the ugen executable in the current directory.

          Any of the -g options must precede all -B options because they
          can affect the location of runtimes and what runtimes are used.

          If no -t argument has been processed before the -B argument, then
          a -B string is passed to the loader to use with its -l x
          arguments.

          For example, to use /tmp/libI77.a.patch instead of the standard
          runtime I/O library /usr/lib/nonshared/libI77.a, the program must
          be linked using the -t I -h /tmp -B .patch options.

          The F, U, I, S, M, and n options affect compiling with the
          -non_shared option.

     -trapuv
          Forces all uninitialized stack, automatic and dynamically
          allocated variables to be initialized with 0xFFFA5A5A.  When this
          value is used as a floating point variable, it is treated as a
          floating point NaN and it will cause a floating point trap.  When
          it is used as a pointer, an address or segmentation violation
          will likely occur.  Default OFF.

     -u   (f77 only) Makes the default type of a variable undefined, rather
          than using the default FORTRAN rules.

     -use_readwrite_const
          Puts const qualified variables and string literals in a readable
          and writable data section.

     -use_readonly_const
          (CC only) Puts string literals and file-level (static, common, or
          external) const qualified initialized variables into a .rodata
          section to separate these objects from data likely to be
          modified.  This is the default.  However, if you really want
          constants to not be writable, then in addition to specifying
          -use_readonly_const you must also specify -G0 -rdata_shared,
          because by default the linker will make .rodata and gp-relative
          sections be writable.

     -usefpidx
          (f77 only) Forces the compiler to use the floating point DO loop
          variable as the loop counter.  This is contrary to the ANSI
          standard but maintains backward compatibility with the 4D1-3.3
          release.

     -v   (CC) Same as -fullwarn (verbose warnings).  The old definition of
          -v (prints the compiler passes) is invoked with the -show option.

          (F77) Print the passes as they execute and their input and
          output.

     -version
          Displays the version number of the compiler.  The compiler will
          not be run if this flag is used.

     -vms_cc
          (f77 only) Uses VMS FORTRAN carriage control interpretation on
          unit 6.  See the /usr/include/cmplrs/fioflags.h file when the
          main program is written in C.

     -vms_endfile
          (f77 only) Writes a VMS endfile record to the output file when
          ENDFILE statement is executed and allows subsequent reading from
          an input file after an endfile record is encountered.  See the
          /usr/include/cmplrs/fioflags.h file when the main program is
          written in C.

     -vms_library
          (f77 only) Treats subroutines and functions starting with LIB$,
          OTS$, and SMG$ as VMS runtime library routines which take a
          variable number of arguments.  This is accomplished by adding an
          argument count as the hidden first argument in the actual
          argument list.  Normal FORTRAN routines that do not take a
          variable number of arguments and do not have an argument count as
          the first argument in the formal argument list, should not be
          named as above when used with this compilation option.

     -vms_stdin
          (f77 only) Allows rereading from stdin after EOF has been
          encountered.  See the /usr/include/cmplrs/fioflags.h file when
          the main program is written in C instead.

     -w[n]
          Suppresses warning messages.  n can be one of the following:

          0    (f77 only) Does not suppress the warning message for unused
               variables.

          1    (f77 only) Suppresses the warning message for unused
               variables (but permits other warnings unless -w is
               specified.  This is the default.

          2    Warnings are counted as errors.

          66   (f77 only) Suppresses only FORTRAN 66 compatibility warnings
               messages.

     -woff all
          (CC only) Suppresses warning messages.

     -woff numberlist
          (CC only) Suppresses warnings in ANSI/ISO C.  All warnings have
          been given a number: the number appears immediately after the
          word Warning in the warning text, and is larger than 1000 (to
          make warning numbers different from those in an earlier version
          of the compiler).  The numberlist is a comma-separated set of 1
          or more numbersets.  A numberset is either a simple integer or a
          pair of integers separated by a hyphen.

          Examples:  -woff " 1527" suppresses warning 1527.  -woff " 1527-
          1570" suppresses warnings 1527 through 1570.  -woff 1600-
          1700,1705-1790 suppresses numbers 1600 through 1700 and 1705
          through 1790.

     -xansi
          (ANSI/ISO C only) Specifies ANSI/ISO C.  See the symbol
          definitions in the -cckr option description.  Note that __STDC__
          is defined, __EXTENSIONS__ is defined and adds many symbols into
          the namespace, and __INLINE_INTRINSICS is defined and may cause
          some intrinsic <math.h>, <stdio.h>, <string.h>, and <curses.h>
          library routines to be inlined.  Such inlined routines may not
          set errno in accordance with the strict ANSI/ISO C standard
          requirements.  -xansi is the default used by the compiler unless
          the environment variable SGI_CC is set (see the introductory
          remarks of this man page).

     -xgot
          Specifies a 32-bit offset in the Global Symbol Table (GOT).  By
          default, addresses are loaded out of the GOT using a 16-bit
          offset from a context pointer.  The default size of the GOT is
          limited to 64K bytes or about 8K worth of symbols, 16K for -o32
          compiled objects.  This can sometimes result in a GOT overflow
          message.  Use of the -xgot option allows the GOT to contain up to
          1G of entries; however, the resulting executable will be somewhat
          larger and slower.  -xgot is a synonym for -TENV:large_GOT.

          A better solution for "GOT overflow" problems is to compile the
          objects without the -xgot option and to link using the -multigot
          option, described in ld(1).

          For more information about the GOT, the -xgot option and some
          important notes about its use, see the dso(5) man page (the FAQ
          section, "What should I do about a GOT overflow?").

     -B string
          Appends string to all names specified by the -t option.  If no -t
          option has been processed before the -B option, the -t option is
          assumed to be hpKfjusmocablrnyz.  This list designates all names.
          If no -t argument has been processed before the -B then a -B
          string is passed to the loader to use with its -l x arguments.
          Sometimes a more convenient way to get a string appended to all
          archive library names is to use the ld -Bstring option, which may
          be passed via the -Wl,-Bstring option.  Invoking the compiler
          with a name of the form cc string has the same effect as
          specifying a -B string option on the command line.

     -C   (f77 only) See the -DEBUG:subscript_check option description in
          the DEBUG_group(5) man page.

     -D name=def
     -D name
          Define the name to the C macro preprocessor, as if by #define.
          If no definition is given, the name is defined as "1".

     -E   Runs only the C macro preprocessor files (without considering
          suffixes), and sends the result to the standard output.  The
          resultant output will contain line directives.  This option
          overrides the -nocpp option.

     -F   (f77 only) Applies the RATFOR preprocessor to relevant files and
          puts the result in files appended by .f.  (No .o files are
          created.)

     -G num
          Specifies the maximum size, in bytes, of a data item that is to
          be accessed from the global pointer.  num is assumed to be a
          decimal number.  If num is zero, no data is accessed from the
          global pointer.  The default value for num is 0 for shared
          compiles and 8 for non-shared compiles.

          Data stored relative to the global pointer can be accessed by the
          program quickly, but this space is limited.  Large programs may
          overflow the space accessed by the global pointer at load time.
          If the loader gives the error message Bad -G num value, recompile
          with -G 0.  One must usually use the same value of this switch
          for compiling all files that comprise a program executable or
          DSO.

     -H c (f77 only) Halts compiling after the pass specified by the
          character c, producing an intermediate file for the next pass.  c
          can be fjusmoca (see the -t option for argument definitions).  It
          selects the compiler pass in the same way as the the -t option.
          If this option is used, the symbol table file produced and used
          by the passes is the last component of the source file appended
          with .T and is not removed.

     -I   The /usr/include file is not searched for #include files.

          This option will be phased out in a future release; specify
          -nostdinc instead.

     -I dir
          #include files whose names do not begin with / are sought first
          in the file directory, then in directories specified in -I
          options, and finally in the standard directory (/usr/include).

     -K   (f77 only) Uses the standard algorithm for generating file names
          with the conventional suffix for the type of file (for example,
          .B for binary ucode produced by the front end) instead of putting
          intermediate files in /tmp or TMPDIR.  These intermediate files
          are never removed even when a pass encounters a fatal error.

          When ucode linking is performed and the -K option is specified,
          the basename of the files created after the ucode link is u.out
          by default.  If -ko output is specified, the basename of the
          object file is output with the appropriate suffix appended at the
          end if output has no suffix.

     -KPIC
          Generates position-independent code (PIC).  This is the default
          and is needed for programs linking with dynamic shared libraries.
          If you do not want to generate PIC code, specify -non_shared on
          the command line.

     -L directory
          In XPG4 mode, searches for libraries named in directory before
          searching the default location.  Directories are searched in the
          specified order.  Multiple instances of -L options can be
          specified.

     -MDupdate filename
          While compiling, updates filename to contain header, library, and
          runtime make(1) dependencies for the cc output file.  cc
          -MDupdate updates only lines that end with a distinctive make
          comment and begin with the name of the output file followed by a
          colon.  The standard option used with make(1) is the following:


          -MDupdate Makedepend

     -M   Runs only the macro preprocessor on the named C programs,
          requesting it to generate make dependencies and sends the result
          to standard output.

     -N[qxscelnC]nnn
          (f77 only) Increases size of static tables in the compiler.  The
          compiler displays a warning message if tables overflow and will
          recommend that you specify one or more of the following flags:

          q    Maximum number of equivalenced variables.  Default is 2000.

          x    Maximum number of external names (common block names,
               subroutine and function names).  Default is 3000.

          s    Maximum number of statement numbers.  Default is 1000.

          c    Maximum depth of nesting for control statements (such as DO
               loops).  Default is 50.

          e    Maximum expression tree depth.  Default is 400.

          l    Maximum number of labels.  Default is 125.

          n    Maximum number of local names.  Default is 8191.

          C    Maximum number of continuation lines.  Default is 99.

     -O3  Creates a ucode object file for each C, FORTRAN 77, or RATFOR
          source file appended with .u.  The newly created ucode object
          files, the ucode object files specified on the command line, the
          runtime startup routine, and all of the runtime libraries are
          ucode linked.  Optimization is done on the resulting ucode linked
          file and then it is linked as normal producing an a.out file.  No
          resulting .o file is left from the ucode linked result.  You
          cannot specify -c with the -O3 option.  Instead, specify the -j
          option.

     -Olimit num
          Specify the maximum size, in basic blocks, of a routine to be
          optimized by the global optimizer.  If a routine has more than
          this number of basic blocks, it is not optimized and a message is
          printed.  An option specifying that the global optimizer is to be
          run (-O, -O2, -O3) must also be specified.  num is assumed to be
          a decimal number.  The default value for num is 1000 basic
          blocks.

     -O n The main optimization level, specifying the basic level of
          optimization desired.  n can be one of the following:

          0    Turns off all optimizations.  This is the default.

          1    Turns on local optimizations that can be done quickly.

          2    Turns on extensive optimization.  The optimizations at this
               level are generally conservative, in the sense that they (1)
               are virtually always beneficial, (2) provide improvements
               commensurate to the compile time spent to achieve them, and
               (3) avoid changes which affect such things as floating point
               accuracy.

          3    Turns on aggressive optimization.  The optimizations at this
               level are distinguished from -O2 by their aggressiveness,
               generally seeking highest-quality generated code even if it
               requires extensive compile time.  They may include
               optimizations that are generally beneficial but occasionally
               hurt performance.

          If no value is specified for n, 2 is assumed.

     -P   Runs only the C macro preprocessor.  Puts the result for each
          source file (by suffix convention, i.e., .c and .s) in a
          corresponding .i file.  The .i file has no # lines in it.

     -R   (f77 only) Uses any remaining characters in the argument as
          RATFOR options whenever processing a .r file.  The temporary file
          used as the output of the RATFOR preprocessor is that of the last
          component of the source file with a .f substituted for the .r.
          This temporary file is removed unless the -K option is specified.

     -S   Compiles the specified source programs and leaves the symbolic
          assembly language output in corresponding files appended with .s.

     -U   (f77 only) Does not fold cases.  f77 is usually a case-
          insensitive language (for example, a is equivalent to A).  The -U
          option causes f77 to treat uppercase and lowercase separately.
          The compiler only recognizes keywords in lowercase when this flag
          is used.

     -U name
          Removes any initial definition of name.

     -Wc,arg1[,arg2]...
          (f77 only) Passes the argument(s) argi to the compiler pass c.  c
          is one of pfjusmocablKyz.  c selects the compiler pass in the
          same way as the -t option (see the -t option decription).  This
          switch is not standard and may not be supported across product
          lines.

     -Wf, -Yc
          (CC only) Removes calls to empty user-defined constructors and
          destructors.  This option improves the quality of code generated
          and the runtime performance.  This option could have undesirable
          side effects on code compiled with the -exceptions option and
          should be used with extreme caution.

     -Wx,[-G [num],-v, -A, -K]
          Treats any argument following -Wx, as if it were an svr3 cc
          option.

     -Xcpluscomm
          Processes C++ style comments (// ).  By default, // is not
          treated as a comment introduction.  With this option, C++ comment
          rules are applied.

FILES
     /tmp/ctm*            Temporaries

     /usr/lib/driver      Compiler driver

     /usr/lib/cpp         C macro preprocessor

     /usr/lib/acpp        ANSI/ISO C macro preprocessor

     /usr/lib/pca         Multiprocessing analyzer (Power C only)

     /usr/lib/mpc         Multiprocessing C translator (Power C only)

     /usr/lib/copt        C source-to-source optimizer

     /usr/lib/cfe         C front end

     /usr/lib/ujoin       Binary ucode and symbol table joiner

     /usr/bin/uld         ucode loader

     /usr/lib/usplit      Binary ucode and symbol table splitter

     /usr/lib/umerge      Procedure intergrator

     /usr/lib/uopt        Optional global ucode optimizer

     /usr/lib/ugen        Code generator

     /usr/lib/as0         Symbolic to binary assembly language translator

     /usr/lib/as1         Binary assembly language assembler and
                          reorganizer

     /usr/lib/mcrt1.o     Startup for profiling

     /usr/lib/crt1.o      Runtime startup

     /usr/lib/crtn.o      Runtime startup

     /usr/lib/libc_mp.a   Multiprocessing library (Power C only)

     /usr/lib/libc.so.1   Shared standard library

     /usr/lib/libfpe.so   Floating point exception handler library, see
                          sigfpe (3c)

     /usr/lib/libm.so     Shared math library

SEE ALSO
     cc(1), CC(1), f77(1)

     MIPSpro Compiling and Performance Tuning Guide