InnerhalbNach weiteren Dokumenten suchenSupport-Ressourcen |  Dieses Buch im PDF-Format herunterladen (315 KB)
Option ReferenceThe following section alphabetically lists all the C++ compiler options and indicates any platform restrictions. -386x86: Use -xtarget=386. This option is provided for backward compatibility only. -486x86: Use -xtarget=486. This option is provided for backward compatibility only. -aUse -xa. -BbindingAllows dynamic or requires static library linking. This option specifies whether the linker should look for dynamic (shared) libraries or for static (archive) libraries. You can use the -B option to toggle several times on a command line. This option is passed to the linker, ld. Note - On the Solaris 7 platform, not all libraries available as static libraries. Valuesbinding must be one of the following:
(No space is allowed between -B and dynamic or static.) DefaultsIf -B is not specified, -Bdynamic is assumed. InteractionsTo link the C++ default libraries statically, use the -staticlib option. This option affects the linking of libraries provided by default. To ensure that default libraries are linked dynamically, the last use of -B should be -Bdynamic. ExamplesThe following compiler command links libfoo.a even if libfoo.so exists; all other libraries are linked dynamically: demo% CC a.o -Bstatic -lfoo -Bdynamic See also-nolib, -staticlib, ld(1), "Statically Linking Standard Libraries", Linker and Libraries Guide -cCompile only; produce object .o files, but suppress linking. This option directs the CC driver to suppress linking with ld and produce a .o file for each source file. If you specify only one source file on the command line, then you can explicitly name the object file with the -o option. ExamplesIf you enter CC -c x.cc, the x.o object file is generated. If you enter CC -c x.cc -o y.o, the y.o object file is generated. See also-o filename -cg[89|92]Use -xcg[89|92]. -compat[=(4|5)]Sets the major release compatibility mode of the compiler. This option controls the __SUNPRO_CC_COMPAT and __cplusplus macros. The C++ compiler has two principal modes. The compatibility mode accepts ARM semantics and language defined by the 4.2 compiler. The standard mode accepts constructs according to the ANSI/ISO standard. These two modes are incompatible with each other because the ANSI/ISO standard forces significant, incompatible changes in name mangling, vtable layout, and other ABI details. These two modes are differentiated by the -compat option as shown in the following values. Values
DefaultsIf the -compat option is not specified, -compat=5 is assumed. If only -compat is specified, -compat=4 is assumed. Regardless of the -compat setting, _ _SUNPRO_CC is set to 0x500. InteractionsThis option controls the preprocessor __SUNPRO_CC_COMPAT=(4|5) macro. The -xarch=v9 and the -compat[=4] options are not supported when used together. See alsoC++ Migration Guide +dDoes not expand C++ inline functions. InteractionsThis option is automatically turned on when you specify -g, the debugging option. The -g0 debugging option does not turn on +d. WarningsFor large programs that rely heavily on inline functions, the amount of additional code generated can be substantial. See also-g0, -g -Dname[=def]Defines the macro symbol name to the preprocessor. Using this option is equivalent to including a #define directive at the beginning of the source. You can use multiple -D options. ValuesThe following values are predefined for SPARC and x86: __BUILTIN_VA_ARG_INCR (for the __builtin_alloca, __builtin_va_alist, and __builtin_va_arg_incr keywords in varargs.h, stdarg.h, and sys/varargs.h) _ _cplusplus _ _DATE_ _ _ _FILE_ _ __LINE_ _ _ _STDC_ _ _ _TIME_ _ __sun The following values are predefined for sun _ _SUNPRO_CC=0x500 (The value of _ _SUNPRO_CC indicates the release number of the compiler) _ _SUNPRO_CC_COMPAT=(4|5) _ _SVR4 _ _'uname -s'_'uname -r'(Where uname is the output of uname -s with invalid characters replaced by underscores, as in -D__SunOS_5_3; -D__SunOS_5_4) _ _unix The following values are predefined for UNIX _WCHAR_T The following values are predefined for SPARC only: _ _sparc (32-bit compilation modes only) The following values are predefined for SPARC v9 only: _ _sparcv9 (64-bit compilation modes only) The following values are predefined for x86 only: _ _i386 You can use these values in such preprocessor conditionals as #ifdef. DefaultsIf you do not use =def, name is defined as 1. See also-U -d(y|n)Allows or disallows dynamic libraries for the entire executable. This option is passed to ld. This option can appear only once on the command line. Values
DefaultsIf no -d option is specified, -dy is assumed. See alsold(1), Linker and Libraries Guide -dalignSPARC: Generates double-word load and store instructions whenever possible for improved performance. This option assumes that all double type data are double-word aligned. WarningsIf you compile one program unit with -dalign, compile all units of a program with -dalign, or you might get unexpected results. -dryrunShows commands built by driver, but does not compile. This option directs the driver CC to show, but not execute, the subcommands constructed by the compilation driver. -ERuns the preprocessor on source files; does not compile. Directs the CC driver to run only the preprocessor on C++ source files, and to send the result to stdout (standard output). No compilation is done; no .o files are generated. Output from this option is not supported as input to the C++ compiler when templates are used. See also-P +e(0|1)Controls virtual table generation when -compat=4. Invalid and ignored when -compat=5. Values
InteractionsWhen you compile with this option, also use the -features=no%except option. Otherwise, the compiler generates virtual tables for internal types used in exception handling. See alsoC++ Migration Guide -fastOptimizes for speed of execution using a selection of options. This option is a macro that selects a combination of compilation options for optimum execution speed. The criteria for the -fast option vary with the C, C++, FORTRAN 77, and Pascal compilers. See the appropriate compiler documentation for specifics. ExpansionsThis option provides near maximum performance for many applications by expanding to the following compilation options:
InteractionsThe -fast option expands into options that may affect options that are specified after -fast. The code generation option, optimization level, and use of inline template files can be overridden by subsequent options. The optimization level that you specify overrides a previously set optimization level. The -fast option includes -fns -ftrap=%none; that is, this option turns off all trapping. ExamplesThe following compiler command results in an optimization level of -xO3: demo% CC -fast -xO3 The following compiler command results in an optimization level of -xO4: demo% CC -xO3 -fast WarningsDo not use this option for programs that depend on IEEE standard floating-point arithmetic; different numerical results, premature program termination, or unexpected SIGFPE signals can occur. Note - In previous SPARC releases, the -fast macro option included -fnonstd; now it does not. Nonstandard floating-point mode is not initialized by -fast. See the Numerical Computation Guide, ieee_sun(3M). See also-dalign, -fns, -fsimple, -ftrap=%none, -libmil, -nofstore, -xO4, -xlibmopt, -xtarget=native -features=a[,...a]Enables/disables various C++ language features named in a comma-separated list. ValuesFor compat=4 only, a can be one of the following values:
For compat=4 and compat=5, a can be one of the following values:
Note - [no%]castop is allowed for compatibility with makefiles written for the C++ 4.2 compiler, but has no affect on the 5.0 compiler. The new style casts (const_cast, dynamic_cast, reinterpret_cast, and static_cast) are always recognized and cannot be disabled. When -features=arraynew is enabled, the macro _ARRAYNEW=1 is defined; when disabled, the macro is not defined. When -features=bool is enabled, the macro _BOOL=1 is defined; when disabled, the macro is not defined. When -features=no%anachronisms is enabled, no anachronistic constructs are allowed. When -features=except is disabled, a throw-specification on a function is accepted but ignored. The keywords try, throw, and catch are always reserved. DefaultsIf -features is not specified, the following is assumed:
See alsoC++ Migration Guide -flagsSame as -help. The -flags option displays a brief description of each compiler option. See also-help, -readme, -migration. -fnonstdx86: Causes nonstandard initialization of floating-point hardware. In addition, the -fnonstd option causes hardware traps to be enabled for floating-point overflow, division by zero, and invalid operations exceptions. These results are converted into SIGFPE signals; if the program has no SIGFPE handler, it terminates with a memory dump (unless you limit the core dump size to 0). DefaultsIf -fnonstd is not specified, IEEE 754 floating-point arithmetic exceptions do not abort the program, and underflows are gradual. See also-fns, -ftrap=common, Numerical Computation Guide. -fns[=(yes|no)]SPARC: Enables/disables the SPARC nonstandard floating-point mode. -fns=yes (or -fns) causes the nonstandard floating point mode to be enabled when a program begins execution. This option provides a way of toggling the use of nonstandard or standard floating-point mode following some other macro option that includes -fns, such as -fast. (See "Examples.") On some SPARC devices, the nonstandard floating-point mode disables "gradual underflow," causing tiny results to be flushed to zero rather than to produce subnormal numbers. It also causes subnormal operands to be silently replaced by zero. On those SPARC devices that do not support gradual underflow and subnormal numbers in hardware, -fns=yes (or -fns) can significantly improve the performance of some programs. Values
DefaultsIf -fns is not specified, the nonstandard floating point mode is not enabled automatically. Standard IEEE 754 floating-point computation takes place--that is, underflows are gradual. If only -fns is specified, -fns=yes is assumed. ExamplesTo use the -fns option following some other macro option that includes -fns, such as -fast: demo% CC foo.cc -fast -fns=no WarningsWhen nonstandard mode is enabled, floating-point arithmetic can produce results that do not conform to the requirements of the IEEE 754 standard. If you compile one routine with the -fns option, then compile all routines of the program with the -fns option; otherwise, you might get unexpected results. This option is effective only on SPARC devices, and only if used when compiling the main program. On x86 devices, the option is ignored. Use of the -fns=yes (or -fns) option might generate the following message if your program experiences a floating-point error normally managed by the IEEE floating-point trap handlers: Note: Nonstandard floating-point mode enabled See the Numerical Computation Guide, ieee_sun(3M) See alsoNumerical Computation Guide -fprecision=px86: Sets the non-default floating-point precision mode. The -fprecision option sets the rounding precision mode bits in the Floating Point Control Word. These bits control the precision to which the results of basic arithmetic operations (add, subtract, multiply, divide, and square root) are rounded. Valuesp must be one of the following:
If p is single or double, this option causes the rounding precision mode to be set to single or double precision, respectively, when a program begins execution. If p is extended or the -fprecision option is not used, the rounding precision mode remains at the extended precision. The single precision rounding mode causes results to be rounded to 24 significant bits, and double precision rounding mode causes results to be rounded to 53 significant bits. In the default extended precision mode, results are rounded to 64 significant bits. This mode controls only the precision to which results in registers are rounded, and it does not affect the range. All results in register are rounded using the full range of the extended double format. Results that are stored in memory are rounded to both the range and precision of the destination format, however. The nominal precision of the float type is single. The nominal precision of the long double type is extended. DefaultsWhen the -fprecision option is not specified, the rounding precision mode defaults to extended. WarningsThis option is effective only on x86 devices and only if used when compiling the main program. On SPARC devices, this option is ignored. -fround=rSets the IEEE rounding mode in effect at start-up. This option sets the IEEE 754 rounding mode that:
The meanings are the same as those for the ieee_flags subroutine, which can be used to change the mode at runtime. Valuesr must be one of the following:
DefaultsWhen the -fround option is not specified, the rounding mode defaults to -fround=nearest. WarningsIf you compile one routine with -fround=r, compile all routines of the program with the same -fround=r option; otherwise, you might get unexpected results. This option is effective only if used when compiling the main program. -fsimple[=n]Selects floating-point optimization preferences. This option allows the optimizer to make simplifying assumptions concerning floating-point arithmetic. ValuesIf n is present, it must be 0, 1, or 2.
DefaultsIf -fsimple is not designated, the compiler uses -fsimple=0. If -fsimple is designated but no value is given for n, the compiler uses -fsimple=1. Interactions-fast implies -fsimple=1. WarningsThis option can break IEEE 754 conformance. See also-fast -fstorex86: Forces precision of floating-point expressions. This option causes the compiler to convert the value of a floating-point expression or function to the type on the left side of an assignment rather than leave the value in a register when the following is true:
To turn off this option, use the -nofstore option. WarningsDue to roundoffs and truncation, the results can be different from those that are generated from the register values. See also-nofstore -ftrap=tSets the IEEE trapping mode in effect at start-up. This option sets the IEEE 754 trapping modes that are established at program initialization, but does not install a SIGFPE handler. You can use ieee_handler to simultaneously enable traps and install a SIGFPE handler. When more than one value is used, the list is processed sequentially from left to right. Valuest is a comma-separated list that consists of one or more of the following:
Note that the [no%] form of the option is used only to modify the meaning of the %all and common values, and must be used with one of these values, as shown in the example. The [no%] form of the option by itself does not explicitly cause a particular trap to be disabled. If you wish to enable the IEEE traps, -ftrap=common is the recommended setting. DefaultsIf -ftrap is not specified, the -ftrap=%none value is assumed. (Traps are not enabled automatically.) ExamplesWhen one or more terms are given, the list is processed sequentially from left to right, thus -ftrap=%all,no%inexact means to set all traps except inexact. InteractionsThe mode can be changed at runtime with ieee_handler(3M). WarningsIf you compile one routine with -ftrap=t, compile all routines of the program with the same -ftrap=t option; otherwise, you might get unexpected results. Use the -ftrap=inexact trap with caution. Use of -ftrap=inexact results in the trap being issued whenever a floating-point value cannot be represented exactly. For example, the following statement generates this condition: x = 1.0 / 3.0; This option is effective only if used when compiling the main program. Be cautious when using this option. If you wish to enable the IEEE traps, use -ftrap=common. See alsoieee_handler(3M) man page -GBuild a dynamic shared library instead of an executable file. All source files specified in the command line are compiled with -Kpic by default. When building a shared library that uses templates, it is necessary in most cases to include in the shared library those template functions that are instantiated in the template data base. Using this option automatically adds those templates to the shared library as needed. InteractionsThe following options are passed to ld if -c (the compile-only option) is not specified:
WarningsDo not use ld -G to build shared libraries; use CC-G. The CC driver automatically passes several options to ld that are needed for C++. See also-dy, -Kpic, -xcode=pic13, -xildoff, -ztext, ld(1) man page, C++ Library Reference. -gInstructs both the compiler and the linker to prepare the file or program for debugging. The tasks include:
InteractionsYou can use this option with -xO to get the optimization level that you desire. If you use this option with -xO, you will get limited debugging information. When you specify this option, the +d option is specified automatically. This option makes -xildon the default incremental linker option in order to speed up the compile-edit-debug cycle. This option invokes ild in place of ld unless any of the following are true:
See also+d, -g0, -xildoff, -xildon, -xs, ld(1) man page, Debugging a Program With dbx (for details about stabs) -g0Compiles and links for debugging, but doesn't disable inlining. This option is the same as -g, except that +d is disabled. See also+d, -g, -xildon, Debugging a Program With dbx -HPrints path names of included files. On the standard error output (stderr), this option prints, one per line, the path name of each #include file contained in the current compilation. -helpDisplays a summary list of compiler options. This option displays a brief description of each compiler option. See also-flags, -readme, C++ Migration Guide -hnameAssigns the name name to the generated dynamic shared library. This is a loader option, passed to ld. In general, the name after -h should be exactly the same as the one after -o. A space between the -h and name is optional. The compile-time loader assigns the specified name to the shared dynamic library you are creating. It records the name in the library file as the intrinsic name of the library. If there is no -hname option, then no intrinsic name is recorded in the library file. Every executable file has a list of shared library files that are needed. When the runtime linker links the library into an executable file, the linker copies the intrinsic name from the library into that list of needed shared library files. If there is no intrinsic name of a shared library, then the linker copies the path of the shared library file instead. Examplesdemo% CC -G -o libx.so.1 -h libx.so.1 a.o b.o c.o -iTells the linker, ld, to ignore any LD_LIBRARY_PATH setting. -IpathnameAdd pathname to the #include file search path. This option adds pathname to the list of directories that are searched for #include files with relative file names (those that do not begin with a slash). The preprocessor searches for #include files in the following order:
InteractionsIf -ptipath is not used, the compiler looks for template files in -Ipathname. Use -Ipathname instead of -ptipath. -inline=rlstUse -xinline=rlst. -instances=aControls the placement and linkage of template instances. Valuesa must be one of the following:
DefaultsIf -instances is not specified, -instances=extern is assumed. WarningsFor all values other than extern, the template definitions must be included (directly or indirectly) within the current compilation unit. The compiler silently skips the instantiation if the definition is not available. See alsoChapter 4, Compiling Templates -keeptmpRetains temporary files created during compilation. Along with -verbose=diags, this option is useful for debugging. See also-v, -verbose -KPICSPARC: Same as -xcode=pic32. x86: Same as -Kpic. -KpicSPARC: Same as -xcode=pic13. x86: Compiles with position-independent code. Use this option to compile source files when building a shared library. 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 pc-relative addressing mode through a procedure linkage table. -LdirAdds dir to list of directories to search for libraries. This option is passed to ld. The directory, dir, is searched before compiler-provided directories. -llibAdds library liblib.a or liblib.so to the linker's list of search libraries. This option is passed to ld. Normal libraries have names such as liblib.a or liblib.so, where the lib and .a or .so parts are required. You should specify the lib part with this option. Put as many libraries as you want on a single command line; they are searched in the order specified with -Ldir. Use this option after your object file name. InteractionsIt is always safer to put -lx after the list of sources and objects to insure that libraries are searched in the correct order. See also-Ldir, C++ Library Reference, and Tools.h++ Class Library Reference -libmieeeUse -xlibmieee. -libmilUse -xlibmil. -library=l[,...l]Incorporates specified CC-provided libraries into compilation and linking. ValuesFor -compat=4, l must be one of the following:
For -compat=5, l must be one of the following:
DefaultsFor -compat=4, if -library is not specified, -library=%none,libC.The libC library always is included unless specifically excluded using -library=%none or -library=no%libC. For -compat=5, if -library is not specified, -library=%none,Cstd,Crun.The libCstd library always is included unless specifically excluded using -library=%none or -library=no%Cstd. The libCrun library always is included unless specifically excluded using -library=no%Crun. ExamplesTo link in standard mode without any C++ libraries (except libCrun), use: demo% CC -library=%none To include the Rogue Wave tools.h++ v7 and iostream libraries in standard mode: demo% CC -library=rwtools7,iostream InteractionsIf a library is specified with -library, the proper -I paths are set during compilation. The proper -L,-Y P, -R paths and -l options are set during linking. Use of the -library option ensures that the -l options for the specified libraries are emitted in the right order. For example, the -l options are passed to ld in the order -lrwtool -liostream for both -library=rwtools7,iostream and -library=iostream,rwtools7. The specified libraries are linked before system support libraries. Only one Rogue Wave tools library can be used at a time. The Rogue Wave Tools.h++ version 7 library is built with classic iostreams. Therefore, when you include the Rogue Wave tools library in standard mode, you must also include libiostream. If you include both libCstd and libiostream, you must be careful to not use the old and new forms of iostreams (for example, cout and std::cout) within a program to access the same file. Mixing standard iostreams and classic iostreams in the same program is likely to cause problems if the same file is accessed from both classic and standard iostream code. Programs linking neither libC nor libCrun might not use all features of the C++ language. If -xnolib is specified, -library is ignored. WarningsThe set of libraries is not stable and might change from release to release. See also-I, -l, -R, -staticlib, -xnolib, "Using make With iostreams", C++ Library Reference, Tools.h++ User's Guide, Tools.h++ Class Library Reference, Standard C++ Library Reference -migrationExplains where to get information about migrating source code to C++ 5.0. See AlsoC++ Migration Guide: C++ 4.2 to C++ 5.0 contains information about incompatibilities between versions 4.0.1, 4.1, and 4.2 of the compiler and the 5.0 compiler. -misalignSPARC: Permits misaligned data, which would otherwise generate an error, in memory. This is shown in the following code: char b[100];
int f(int * ar) {
return *(int *) (b +2) + *ar;
}
Very conservative loads and stores must be used for the data, that is, one byte at a time. Using this option can cause significant degradation in performance when you run the program. WarningsIf possible, do not link aligned and misaligned parts of the program. -mtCompiles and links for multithreaded code. This option compiles source files with -D_REENTRANT and augments the set of support libraries to include -lthread in the required order. WarningsTo ensure proper library linking order, use this option, rather than -lthread, to link with libthread. If you compile and link in separate steps and you compile with -mt, be sure to link with -mt, as shown in the following example, or you might get unexpected results. demo% CC -c -mt myprog.cc demo% CC -mt myprog.o See also-xnolib, Multithreaded Programming Guide, Linker and Libraries Guide, C++ Library Reference -nativeUse -xtarget=native. -noexUse -features=no%except. -nofstorex86: Disables forced precision of an expression. This option does not force the value of a floating-point expression or function to the type on the left side of an assignment, but leaves the value in a register when either of the following are true:
See also-fstore -nolibUse -xnolib. -nolibmilUse -xnolibmil. -noqueueDisables license queueing. If no license is available, this option returns without queuing your request and without compiling. A nonzero status is returned for testing makefiles. -norunpathDoes not build a runtime search path for shared libraries into the executable. If an executable file uses shared libraries, then the compiler normally builds in a path that points the runtime linker to those shared libraries. To do so, the compiler passes the -R option to ld. The path depends on the directory where you have installed the compiler. This option is helpful if you have installed the compiler in some nonstandard location, and you ship an executable file to your customers. Your customers don't have to work with that nonstandard location. InteractionsIf you use any shared libraries under the compiler installed area (default location /opt/SUNWspro/lib) and you also use -norunpath, then you should either use the -R option at link time or set the environment variable LD_LIBRARY_PATH at runtime to specify the location of the shared libraries. Doing so allows the runtime linker to find the shared libraries. -OSame as -xO2. -OlevelUse -xOlevel. -o filenameSets the name of the output file or the executable file to filename. WarningsThe filename must have the appropriate suffix for the type of file to be produced by the compilation. It cannot be the same file as the source file, since the CC driver does not overwrite the source file. +pDisallows preprocessor asserts. DefaultsIf +p is not present, preprocessor asserts are allowed. -POnly preprocesses source; does not compile. (Outputs a file with a .i suffix) This option does not include preprocessor-type line number information in the output. See also-E -pPrepares object code to collect data for profiling with prof. This option invokes a runtime recording mechanism that produces a mon.out file at normal termination. See also-xpg, analyzer(1) man page. -pentiumx86: Replace with -xtarget=pentium. -pgUse -xpg. -PICUse -KPIC. -picUse -Kpic. -ptaUse -template=wholeclass. -ptipathSpecifies an additional search directory for template source. This option is an alternative to the normal search path set by -Ipathname. If the -ptipath option is used, the compiler looks for template definition files on this path and ignores the -Ipathname option. Using the -Ipathname option instead of -ptipath produces less confusion. See also-Ipathname -ptoUse -instances=static. -ptrdatabase-pathSpecifies the directory of the template repository. The template repository is contained within the SunWS_config or SunWS_cache subdirectory of the given directory. The template repository cache files are stored in directory/SunWS_cache. The template repository configuration files are stored in directory/SunWS_config. You cannot use multiple -ptr options. Examples-ptr/tmp/Foo specifies the repository subdirectories /tmp/Foo/SunWS_cache and /tmp/Foo/SunWS_config. InteractionsThe subdirectory names can be changed with the environment variables SUNWS_CACHE_NAME and SUNWS_CONFIG_NAME. WarningsIf you compile and link in separate steps, and use -ptr to compile, you must also use -ptr to link. -ptvUse -verbose=template. -Qoption phase option[,...option]Passes option to the compilation phase. To pass multiple options, specify them in order as a comma-separated list. Valuesphase must have one of the following values:
ExamplesIn the following command line, when ld is invoked by the CC driver, -Qoption passes the -i and -m options to ld: demo% CC -Qoption ld -i,-m test.c -qoption phase optionUse -Qoption. -qpSame as -p. -Qproduce sourcetypeCauses the CC driver to produce output of the type sourcetype. Sourcetype suffixes are defined below.
-qproduce sourcetypeUse -Qproduce. -RpathnameBuilds dynamic library search paths into the executable file. Multiple instances of -Rpathname are concatenated, with each pathname separated by a colon. This option is passed to ld. DefaultsIf the -R option is not present, the library search path that is that is recorded in the output object and passed to the runtime linker depends upon the target architecture instruction specified by the -xarch option (when -xarch is not present, -xarch=generic is assumed).
With a standard install, install-path is /opt. InteractionsIf the LD_RUN_PATH environment variable is defined and the -R option is specified, then the path from -R is scanned and the path from LD_RUN_PATH is ignored. See also-norunpath, Linker and Libraries Guide -readmeDisplays the content of the README file. The README file is paged by the command specified in the environment variable, PAGER. If PAGER is not set, the default paging command is more. -SCompiles and generates only assembly code. This option causes the CC driver to compile the program and output an assembly source file, without assembling the program. The assembly source file is named with a .s suffix. -sStrips the symbol table from the executable file. This option removes all symbol information from output executable files. This option is passed to ld. -sbReplace with -xsb. -sbfastUse -xsbfast. -staticlib=l[,...l]Indicates which C++ libraries are to be linked statically. Valuesl must be one of the following:
DefaultsIf -staticlib is not specified, -staticlib=%none is assumed. ExamplesThe following command line links libCrun statically because Crun is a default value for -library: demo% CC -staticlib=Crun However, the following command line does not link libgc because libgc is not linked unless explicitly specified with the -library option: demo% CC -staticlib=gc To link libgc statically, use the following command: demo% CC -library=gc -staticlib=gc InteractionsIf you select C++ libraries explicitly with the -library option or implicitly through its defaults, you must also specify -staticlib to link these libraries statically. If a you specify a library with -staticlib but have not selected it with -library or its defaults, the library is not linked. Refer to the examples. In the Solaris 7 operating environment, some C++ libraries are not available as static libraries. WarningsThis set of libraries is not stable and might change from release to release. See also-library, "Statically Linking Standard Libraries" -temp=dirDefines directory for temporary files. This option sets the name of the directory for temporary files, generated during the compilation process, to dir. See also-keeptmp -template=wEnables/disables various template options. Valuesw must be wholeclass or no%wholeclass.
-timeUse -xtime. -UnameDeletes initial definition of the preprocessor symbol name. This option removes any initial definition of the macro symbol name created by -D on the command line including those implicitly placed there by the CC driver. It has no effect on any other predefined macros, nor any macro definitions in source files. You can specify multiple -U options on the command line. WarningsThis option is order-sensitive if used with the -D option, and is processed after all -D options are processed. -unroll=nSame as -xunroll=n. -VSame as -verbose=version. -vSame as -verbose=diags. -vdelxFor expressions using delete[], this option generates a call to the runtime library function _vector_deletex_ instead of generating a call to _vector_delete_. The function _vector_delete_ takes two arguments: the pointer to be deleted and the size of each array element. The function _vector_deletex_ behaves the same as _vector_delete_ except that it takes a third argument: the address of the destructor for the class. This third argument is not used by the function, but is provided to be used by third-party vendors. DefaultThe compiler generates a call to _vector_delete_ for expressions using delete[]. WarningsThis is an obsolete option that will be removed in future releases. This option is available only for -compat=4. Don't use this option unless you have bought some software from a third-party vendor and the vendor recommends using this option. -verbose=v[,...v]Controls compiler verbosity. Valuesv must be one of the following values.
You can specify more than one option, for example, -verbose=template,diags. DefaultsIf -verbose is not specified, -verbose=%none is assumed. +wPrints extra warnings where necessary. This option generates additional warnings about questionable constructs that are:
DefaultsIf +w is not specified, the compiler warns about constructs that are almost certainly problems. See also-w, +w2 +w2Prints even more warnings. See also+w -wSuppresses warning messages. This option causes the compiler not to print warning messages. However, some warnings, particularly warnings regarding serious anachronisms cannot be suppressed. See also+w -xaGenerates code for profiling. If set at compile time, the TCOVDIR environment variable specifies the directory where the coverage (.d) files are located. If this variable is not set, then the coverage (.d) files remain in the same directory as the source files. Use this option only for backward compatibility with old coverage files. InteractionsThe -xprofile=tcov and the -xa options are compatible in a single executable. That is, you can link a program that contains some files that have been compiled with -xprofile=tcov, and others that have been compiled with -xa. You cannot compile a single file with both options. -xa is incompatible with -g. WarningsIf you compile and link in separate steps and you compile with -xa, be sure to link with -xa, or you might get unexpected results. See also-xprofile=tcov, tcov(1) man page, Analyzing Program Performance With Sun WorkShop -xarCreates archive libraries. When building a C++ archive that uses templates, it is necessary in most cases to include in the archive those template functions that are instantiated in the template database. Using this option automatically adds those templates to the archive as needed. ExamplesThe following command line archives the template functions contained in the library and object files. demo% CC -xar -o libmain.a a.o b.o c.o WarningsDo not add .o files from the template data base on the command line. Do not use the ar command directly for building archives. Use CC -xar to ensure that template instantiations are automatically included in the archive. See alsoChapter 6 -xarch=aSpecifies the target architecture instruction set. Although this option can be used alone, its primary use is to override a value supplied by the -xtarget option. This option limits the instructions generated to those appropriate to the specified architecture, and it allows the specified set of instructions. The option does not guarantee an instruction will be used; however, under optimization, it is usually used. Valuesa must be one of the following:
For SPARCSPARC architectures v7, v8a, and v8 are all binary compatible. v8plus and v8plusa are binary compatible with each other, and they are forward, but not backward, compatible. For any particular choice, the generated executable might run much more slowly on earlier architectures.
For x86generic and 386 are equivalent in this release. 486, pentium, or pentium_pro directs the compiler to issue instructions for the Intel PentiumPro chip. DefaultsIf -xarch=a is not specified, -xarch=generic is assumed. InteractionsThe -xarch=v9 option and the -compat[=4] options are not supported when used together. WarningsIf this option is used with optimization, the appropriate choice can provide good performance of the executable on the specified architecture. An inappropriate choice, however, might result in serious degradation of performance. -xcache=cSPARC: Defines cache properties for use by the optimizer. This option specifies the cache properties that the optimizer can use. It does not guarantee that any particular cache property is used. Note - 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. Values
The definitions of the cache properties, si/li/ai, are as follows:
For example, i=1 designates level 1 cache properties, s1/l1/a1. DefaultsIf -xcache is not specified, the default -xcache=generic is assumed. This value directs the compiler to use cache properties for good performance on most SPARC processors, without major performance degradation on any of them. Examples-xcache=16/32/4:1024/32/1 specifies the following:
See also-xtarget=t -xcg(89|92)SPARC: Compiles for generic SPARC or SPARC V8 architecture. This option specifies the code generator for floating-point hardware in SPARC devices released in 1989 or 1992. Use the fpversion command to determine which floating-point hardware you have. If you compile one procedure of a program with this option, it does not mean that you must compile all the procedures of that program in the same way. -xg89 generates code to run on generic SPARC architecture. -xg92 generates code to run on SPARC V8 architecture. ExpansionsThe option -xcg89 is a macro for -xtarget=ss2, which is equivalent to -xarch=v7 -xchip=old -xcache=64/32/1. The option -xcg92 is a macro for -xtarget=ss1000, which is equivalent to -xarch=v8 -xchip=super -xcache=16/64/4:1024/64/1. WarningsIf you compile and link in separate steps and you compile with -xcg89 or -xcg92, be sure to link with the same option, or you might get unexpected results. -xchip=cSpecifies target processor for use by the optimizer. The -xchip option specifies timing properties by specifying the target processor. This option affects:
ValuesThe following table lists the valid values for c.
DefaultsOn most SPARC processors, generic is the default value that directs the compiler to use the best timing properties for good performance without major performance degradation on any of them. -xcode=aSPARC: Specifies the code address space. Valuesa must be one of the following:
DefaultsFor SPARC V8 and V7 processors, the default is -xcode=abs32. For SPARC and UltraSPARC processors (with -xarch=(v9|v9a)), the default is -xcode=abs64. InteractionsWhen building shared dynamic libraries with -xarch=v9 or -xarch=v9a using 64-bit Solaris 7 software, the -xcode=pic13 or -xcode=pic32 (or -pic or -PIC) option must be specified. -xFEnables reordering of functions by the linker. If you compile with the -xF option and then run the Analyzer, you can generate a map file that shows an optimized order for the functions. A subsequent link to build the executable file can be directed to use that map by using the linker -Mmapfile option. It places each function from the executable file into a separate section. Reordering the subprograms in memory is useful only when the application text page fault time is consuming a large percentage of the application time. Otherwise, reordering might not improve the overall performance of the application. InteractionsThe -xF option is only supported with -features=no%except (-noex). See alsoanalyzer(1), debugger(1), ld(1) man pages -xhelp=flagsSame as -help. Displays list of compiler options. -xhelp=readmeSame as -readme. Displays contents of online readme file. -xildoffTurns off the incremental linker. DefaultsThis option is assumed if you do not use the -g option. It is also assumed if you do use the -G option, or name any source file on the command line. Override this default by using the -xildon option. See also-xildon, ild(1) man page, ld(1) man page, Incremental Link Editor Guide -xildonTurns on the incremental linker. This option is assumed if you use -g and not -G, and you do not name any source file on the command line. Override this default by using the -xildoff option. See also-xildoff, ild(1) man page, ld(1) man page, Incremental Link Editor Guide -xinline=f[,...f]Inlines specified routines. Note - This option does not affect C++ inline functions and is not related to the +d option. This option instructs the optimizer to inline the user-written functions and subroutines specified in a comma-separated list. Inlining is an optimization technique whereby the compiler effectively replaces a function call with the actual subprogram code itself. Inlining often provides the optimizer more opportunities to produce efficient code. The following restrictions apply--no warning is issued:
Examplesdemo% cat example.cc
static int twice ( int i ) { return 2*i; }
int main() {return twice( 3 ); }
demo% CC -compat=4 -O example.cc
demo% nm -C a.out | grep twice[37] | 68068| 8|FUNC |LOCL |0 |7 |twice(int) [__0FFtwicei]
demo% CC -compat=4 -O -xinline=__0FFtwicei example.cc
InteractionsIf a function specified in the list is not declared as extern "C", the function name should be mangled. You can use the nm command on the executable file to find the mangled function names. For functions declared as extern "C", the names are not mangled by the compiler. The -xinline option has no effect for optimization levels below -xO3. At -xO4, the optimizer decides which functions should be inlined, and does so without the -xinline option being specified. At -xO4, the compiler also attempts to determine which functions will improve performance if they are inlined. If you force inlining of a function with -xinline, you might actually diminish performance. See alsonm(1), +d -xlibmieeeCauses libm to return IEEE 754 values for math routines in exceptional cases. The default behavior of libm is XPG-compliant. See alsoNumerical Computation Guide -xlibmilInlines selected libm library routines for optimization. Note - This option does not affect C++ inline functions. There are inline templates for some of the libm library routines. This option selects those inline templates that produce the fastest executables for the floating-point option and platform currently being used. See alsoNumerical Computation Guide -xlibmoptUses library of optimized math routines. This option uses a math routine library optimized for performance and usually generates faster code. The results might be slightly different from those produced by the normal math library; if so, they usually differ in the last bit. The order on the command line for this library option is not significant. InteractionsThis option is implied by the -fast option. See also-fast, -xnolibmopt -xlic_lib=l[,...l]Links with the Sun-supplied, licensed library specified by l. This option, like -l, should appear at the end of the command line, after source or object files. ExamplesTo link with the Sun(TM) Performance Library(TM): demo% CC program.cc -xlic_lib=sunperf See alsoperformance_library README -xlicinfoShows license server information. This option returns the license-server name and the user ID for each user who has a license checked out. When you use this option, the compiler is not invoked, and a license is not checked out. If a conflicting option is used, the latest one on the command line takes precedence, and a warning is issued. ExamplesDo not compile; report license information: CC -c -xlicinfo any.cc Compile; do not report license information: CC -xlicinfo -c any.cc -XmUse -features=iddollar. -xMOutputs makefile dependency information. ExamplesWhen you compile the following code, hello.c, #include <cstdio>
using std::printf;
int main () {
printf ("Hello World!\n");
}
with this option: demo% CC -xM hello.c the output shows the dependencies: hello.o : hello.c hello.o : /opt/SUNWspro/SC5.0/include/CC/cstdio hello.o : /usr/include/sys/va_list.h See alsomake(1) (for details about makefiles and dependencies) -xM1Generates dependency information, but excludes /usr/include. This is the same as -xM, except that this option does not report dependencies for the /usr/include header files. ExamplesWhen you compile the code sample shown for the -xM option: % CC -xM1 hello.c the output is: hello.o: hello.c -xMergeMerges the data segment with the text segment. The data in the object file is read-only and is shared between processes, unless you link with ld -N. See alsold(1) man page -xnolibDisables linking with default system libraries. Normally (without this option) the C++ compiler links with several system libraries to support C++ programs. With this option, the -llib options to link the default system support libraries are not passed to ld. Normally, the compiler links with the following libraries in the following order: For compat=4: -lC -lC_mtstubs -lm -lw -lcx -lc For compat=5: -lCstd -lCrun -lC_mtstubs -lm -lw -lcx -lc The order of the -l options is significant. The -lm, -lw,and -lcx options must appear before -lc. Note - If the -mt compiler option is specified, then -lthread is passed instead of -lC_mtstubs. ExamplesFor minimal compilation to meet the C application binary interface (that is, a C++ program with only C support required) use: demo% CC -xnolib test.cc -lc To link libm statically into a single-threaded application on SPARC V8 architecure, use: demo% CC -xnolib -Bstatic -lm -Bdynamic -lC_mtstubs -lw -lcx -lc To link libm and libw statically, and link others dynamically: demo% CC -xnolib -Bstatic -lm -lw -Bdynamic -lcx -lc InteractionsIf you specify -xnolib, you must manually link all required system support libraries in the given order. You must link the system support libraries last. If -xnolib is specified, -library is ignored. WarningsThis set of libraries is not stable and might change from release to release. -lcx is not present in 64-bit compilation modes. See also-library, -staticlib, -l -xnolibmilCancels -xlibmil on the command line. Use this option with -fast to override linking with the optimized math library. -xnolibmoptDoes not use the math routine library. ExamplesUse this option after the -fast option on the command line, as in: demo% CC -fast -xnolibmopt -xO[level]Specifies optimization level. In general, program execution speed depends on level of optimization. The higher the level of optimization, the faster the speed. If -xO[level] is not specified, only a very basic level of optimization (limited to local common subexpression elimination and dead code analysis) is performed. A program's performance might be significantly improved when it is compiled with an optimization level. Use of -O (which implies -xO2) is recommended for most programs. Generally, the higher the level of optimization with which a program is compiled, the better the runtime performance. However, higher optimization levels can result in increased compilation time and larger executable files. In a few cases, -xO2 might perform better than the others, and -xO3 might outperform -xO4. Try compiling with each level to see if you have one of these rare cases. If the optimizer runs out of memory, it tries to recover by retrying the current procedure at a lower level of optimization. The optimizer resumes subsequent procedures at the original level specified in the -xO option. There are five levels that you can use with -xO. The following sections describe how they operate on the SPARC platform and the x86 platform. ValuesOn the SPARC Platform: -xO is equivalent to -xO2. -xO1 does only the minimum amount of optimization (peephole), which is postpass, assembly-level optimization. Do not use -xO1 unless using -xO2 or -xO3 results in excessive compilation time, or you are running out of swap space. -xO2 does basic local and global optimization, which includes:
This level does not optimize references or definitions for external or indirect variables. In general, this level results in minimum code size. -xO3, in addition to optimizations performed at the -xO2 level, also optimizes references and definitions for external variables. This level does not trace the effects of pointer assignments. When compiling either device drivers that are not properly protected by volatile or programs that modify external variables from within signal handlers, use -xO2. In general, -xO3 results in increased code size. If you are running out of swap space, use -xO2. -xO4 does automatic inlining of functions contained in the same file in addition to performing -xO3 optimizations. This automatic inlining usually improves execution speed but sometimes makes it worse. In general, this level results in increased code size. -xO5 generates the highest level of optimization. It is suitable only for the small fraction of a program that uses the largest fraction of computer time. This level uses optimization algorithms that take more compilation time or that do not have as high a certainty of improving execution time. Optimization at this level is more likely to improve performance if it is done with profile feedback. See "-xprofile=p". On the x86 Platform: -xO1 preloads arguments from memory and causes cross jumping (tail merging), as well as the single pass of the default optimization. -xO2 schedules both high- and low-level instructions and performs improved spill analysis, loop memory-reference elimination, register lifetime analysis, enhanced register allocation, global common subexpression elimination, as well as the optimization done by level 1. -xO3 performs loop strength reduction and inlining, as well as the optimization done by level 2. -xO4 performs architecture-specific optimization, as well as the optimization done by level 3. -xO5 generates the highest level of optimization. It uses optimization algorithms that take more compilation time or that do not have as high a certainty of improving execution time. InteractionsDebugging with -g does not suppress -xO[level], but -xO[level] limits -g in certain ways. The -xO3 and -xO4 options reduce the utility of debugging so that you cannot display variables from dbx, but you can still use the dbx where command to get a symbolic traceback. The -xinline option has no effect for optimization levels below -xO3. At -xO4, the optimizer decides which functions should be inlined, and does so without the -xinline option being specified. At -xO4, the compiler also attempts to determine which functions will improve performance if they are inlined. If you force inlining of a function with -xinline, you might actually diminish performance. WarningsIf you optimize at -xO3 or -xO4 with very large procedures (thousands of lines of code in a single procedure), the optimizer might require an unreasonable amount of memory. In such cases, machine performance can be degraded. To prevent this degradation from taking place, use the limit command to limit the amount of virtual memory available to a single process (see the csh(1) man page). For example, to limit virtual memory to 16 megabytes: demo% limit datasize 16M This command causes the optimizer to try to recover if it reaches 16 megabytes of data space. The limit cannot be greater than the total available swap space of the machine, and should be small enough to permit normal use of the machine while a large compilation is in progress. The best setting for data size depends on the degree of optimization requested, the amount of real memory, and virtual memory available. To find the actual swap space, type: swap -l To find the actual real memory, type: dmesg | grep mem See also-fast, -xprofile=p, csh(1) man page -xpgCompiles for profiling with the gprof profiler. The -xpg option compiles self-profiling code to collect data for profiling with gprof. This option invokes a runtime recording mechanism that produces a gmon.out file when the program normally terminates. WarningsIf you compile and link separately, and you compile with -xpg, be sure to link with -xpg. See also-xprofile=p, analyzer(1) man page -xprefetch[=(yes|no)]SPARC: Uses prefetch instructions on UltraSPARC II processors. With -xprefetch=yes, the compiler is free to insert prefetch instructions into the code it generates. This can result in a performance improvement on UltraSPARC II processors. DefaultsIf the -xprefetch option is not specified, the default is -xprefetch=no. Specifying -xprefetch alone is equivalent to -xprefetch=yes. -xprofile=pCollects or optimizes with runtime profiling data. This option causes execution frequency data to be collected and saved during the execution. The data can then be used in subsequent runs to improve performance. This option is valid only when a level of optimization is specified. Valuesp must be one of the following:
InteractionsThe -xprofile=tcov and the -xa options are compatible in a single executable. That is, you can link a program that contains some files that have been compiled with -xprofile=tcov and other files compiled with -xa. You cannot compile a single file with both options. -xprofile=tcov is incompatible with -g. WarningsIf compilation and linking are performed in separate steps, the same -xprofile option must appear in the compile as well as the link step. See also-xa, tcov(1) man page, Analyzing Program Performance With Sun WorkShop -xregs=r[,...r]SPARC: Controls scratch register usage. The compiler can generate faster code if it has more registers available for temporary storage (scratch registers). This option makes available additional scratch registers that might not always be appropriate. Valuesr must be one of the following (meaning depends upon the -xarch setting):
DefaultsIf -xregs is not specified, -xregs=appl,float is assumed. ExamplesTo compile an application program using all available scratch registers, use: -xregs=appl,float To compile non-floating-point code sensitive to context switch, use: -xregs=no%appl,no%float See alsoSPARC V7/V8 ABI, SPARC V9 ABI -xsAllows debugging by dbx without object (.o) files. This option disables Auto-Read for dbx. Use this option if you cannot keep the .o files around. This option passes the -s option to the assembler. No Auto-Read is the older way of loading symbol tables. It places all symbol tables for dbx in the executable file. The linker links more slowly, and dbx initializes more slowly. Auto-Read is the newer and default way of loading symbol tables. With Auto-Read the information is placed in the .o files, so that dbx loads the symbol table information only if it is needed. Hence the linker links faster, and dbx initializes faster. With -xs, if you move executables to another directory, you do not have to move the object (.o) files to use dbx. Without -xs, if you move the executables to another directory, you must move both the source files and the object (.o) files to use dbx. -xsafe=memSPARC: Allows no memory-based traps to occur. This option grants permission to use the speculative load instruction on V9 machines. InteractionsThis option is only effective if used with -xO5 optimization when -xarch=v8plus, v8plusa, v9, or v9a is specified. WarningsYou should use this option only if you can safely assert that no memory-based traps occur in your program. For most programs, this assertion is appropriate and can be safely made. For a program that explicitly forces memory-based traps to handle exceptional conditions, this assertion is not safe. -xsbProduces information for the Sun WorkShop source browser. This option causes the CC driver to generate extra symbol table information in the SunWS_cache subdirectory for the source browser. See also-xsbfast -xsbfastProduces only source browser information, no compilation. This option runs only the ccfe phase to generate extra symbol table information in the SunWS_cache subdirectory for the source browser. No object file is generated. See also-xsb -xspaceSPARC: Does not allow optimizations that increase code size. -xtarget=tSpecifies the target platform for instruction set and optimization. The performance of some programs can benefit by providing the compiler with an accurate description of the target computer hardware. When program performance is critical, the proper specification of the target hardware could be very important. This is especially true when running on the newer SPARC processors. However, for most programs and older SPARC processors, the performance gain is negligible and a generic specification is sufficient. Values (SPARC)t must be one of the following:
Values (x86)For the x86 platform, -xtarget accepts the following values:
For SPARC devices, -xtarget accepts the following expansion values: DefaultsOn both SPARC and x86 devices, if -xtarget is not specified, -xtarget=generic is assumed. ExpansionsThe -xtarget option is a macro that permits a quick and easy specification of the -xarch, -xchip, and -xcache combinations that occur on commercially purchased platforms. The only meaning of -xtarget is in its expansion. Examples-xtarget=sun4/15 means -xarch=v8a -xchip=micro -xcache=2/16/1 InteractionsCompiling for 64-bit Solaris 7 on SPARC or UltraSPARC V9 devices is indicated by the -xarch=v9|v9a option. Setting -xtarget=ultra or ultra2 is not necessary or sufficient. If -xtarget is specified, the -xarch=v9 or v9a option must appear after the -xtarget, as in: -xtarget=ultra -xarch=v9 Otherwise, the -xtarget setting reverts the -xarch value to v8. -xtimeCauses the CC driver to report execution time for the various compilation passes. -xunroll=nEnables unrolling of loops where possible. This option specifies whether or not the compiler optimizes (unrolls) loops. ValuesWhen n is 1, it is a suggestion to the compiler to not unroll loops. When n is an integer greater than 1, -unroll=n causes the compiler to unroll loops n times. -xweConverts all warnings to errors by returning nonzero exit status. -ztextForces a fatal error if any relocations remain against nonwritable, allocatable sections. This option is passed to the linker. |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
|