| United States |
|
|
|
cxx(1)Name
cxx - the C++ compilerSyntax
/usr/bin/cxx [ option ] ... file ... An option is an optional list of compile-time options. A file is one or more file specifications separated by white space. You cannot group multiple options after a single hyphen; that is, `-pg' is different than `-p -g'. Supply complete relative or absolute path information when the source file is not in your current directory.Description
The cxx command compiles C++ code into machine-readable instructions. The desired output is specified with an option on the command line, and can be object files or symbolic assembly language. For additional information about this release, see the online release notes in: /usr/lib/cmplrs/cxx/cxxnnn_release.ps/txt HTML files are provided for the release notes and some of the product manu- als for use with a web browser. These files are installed by selecting the following subset: Compaq C++ HTML documentation To view this documentation, open the following file using your web browser: /usr/share/doclib/cplusplus/index.htm The compiler produces one object files for each file compiled. Additional files can be written to the repository for template instantiations. If the linker is called, and only one source file is specified on the command line, the single object file is deleted after the linking operation. The cxx command invokes the C++ compiler, and possibly other com- ponents of the compiler system, depending on the specified command options and files. When you start the cxx compiler, it normally performs the fol- lowing tasks: + Preprocessing + Compiling + Linking Use the -c option to stop compiler operation before linking, resulting in one or more output files with the .o suffix. Use the -E option to run only the preprocessor. The detection of an error in one source file does not affect compilation of other source files specified on the same command line. If the -x cxx option has been specified then the compiler treats all files as C++ source files regardless of their suffixes, unless the file has an .a or .o suffix. If the -x cxx has not been specified, or if the -x none option has been specified, then the compiler recognizes the following file name suffixes as having special significance: .cxx, .CXX, .cpp, .CPP, .cc, .CC, or .C C++ source code. .hxx C++ header file .ixx C++ source code already processed by the preprocessor. .a Linker library. -x cxx has no effect on files with this extension. .c C source code, to be compiled with the DEC C compiler. .i C source code already processed by the preprocessor. .o Linker object module. -x cxx has no effect on files with this extension. .so Shared object (shared library). Command options recognized by the cxx compiler are described in the Options section. Some of the options affect the behavior of the preprocessor. The preprocessor is invoked through the cxx command for C++ files, and is not invoked with a separate command. Any options not recognized by the cxx com- piler are assumed to be linker options, and are passed through to the linker. See the ld(1) reference page for linker options. To facilitate setting default compiler flags, you can create an optional configuration file named comp.config or an environment variable named DEC_CXX. + The comp.config file allows system administrators to establish a set of compilation flags that are applied to compilations on a system-wide basis. The compiler flags in comp.config must be specified on a sin- gle line, and the comp.config file should be stored in the compiler target directory, /usr/lib/cmplrs/cxx. + The DEC_CXX environment variable allows users to establish a set of compilation flags that are applied to subsequent compilation on a per user basis. The DEC_CXX environment variable can contain two distinct sets of com- pilation flags separated by a single vertical bar (|). The flags before the vertical bar are known as prologue flags and the flags after the bar are know as epilogue flags. The DEC_CXX environment variable can begin or end with a vertical bar, or have no vertical bar at all. If no vertical bar is present, the flags are treated as prologue flags by default. Any vertical bar found after the first vertical bar is treated as whitespace and a warning is issued. Compiler flags are processed in the following order during a compilation: 1. comp.config flags 2. DEC_CXX prologue flags 3. command line flags 4. DEC_CXX epilogue flags If -v is specified on the command line, the contents of DEC_CXX and comp.config, if present, are displayed. Macro Names The following standard macro names are understood by the preprocessor. These names cannot be redefined or undefined. __LINE__ The current line number (a decimal integer). __FILE__ The current file name (a character string). __DATE__ The source file's compilation date (a character string literal of the form "Mmm dd yyyy", where the month names are the same as those generated by the asctime function, and the first character of "dd" is a space character if the value is less than 10). __TIME__ The source file's compilation time (a character string literal of the form "hh:mm:ss"), as in the time generated by the asctime function). __cplusplus Defined by the C++ compiler when compiling source code. In addition, the following macro names are predefined for C++. These names can be undefined or redefined. Note that some macros are defined only if the corresponding command-line option is specified. __alpha __arch64__ _BOOL_EXISTS __BOOL_IS_A_RESERVED_KEYWORD __CFRONT __DECCXX __DECCXX_VER __digital__ __EXCEPTIONS __FLT_ROUNDS __GLOBAL_ARRAY_NEW __IEEE_FLOAT _IEEE_FP __IMPLICIT_INCLUDE_ENABLED __IMPLICIT_USING_STD __INITIAL_POINTER_SIZE __MS __osf__ __PCH_ENABLED __PRAGMA_ENVIRONMENT _PTHREAD_USED_D4 _REENTRANT __RTTI __STDNEW __STD_ANSI __STD_ARM __STD_CFRONT __STD_MS __STD_STRICT_ANSI __STD_STRICT_ANSI_ERRORS __unix __unix__ _WCHAR_T __X_FLOAT These names are useful in preprocessor #ifdef and #if defined directives to isolate code intended for one of the particular cases. The names can be used anywhere you use other defined names, including within macros.Options
The following sections describe the cxx command options, which are grouped as follows: + General options + Preprocessor options + Language Mode options + Message Information and Control options + Standard Library options + Precompiled Header options + Template options The notation "cxx -newcxx only" indicates that an option works only with the default compiler and is ignored by the old compiler. The notation "cxx -oldcxx only" indicates that an option works only with the old com- piler and is ignored by the default compiler. Otherwise, the option works with both compilers.General Options
The cxx command supports the following general options: -alternative_tokens (cxx -newcxx only) -noalternative_tokens (cxx -newcxx only) Enables use of the following operator keywords and digraphs to generate tokens: __________________________ Operator Keyword Token and && and_eq &= bitand & bitor | compl ~ not ! not_eq != or || or_eq |= xor ^ xor_eq ^= __________________________ Digraph Token :> ] <: [ %> } <% { %: # The default is -noalternative_tokens when compiling -std arm, -std cfront, -std ms, and -std ansi. The default is -alternative_tokens when compiling -std strict_ansi and -std strict_ansi_errors. -[no]ansi_alias (cxx -newcxx only) Directs the compiler to assume the ANSI C aliasing rules. By so doing, the compiler has the freedom to generate better optimized code. If a program does not access the same data through pointers of a different type (and for this purpose, signed and quali- fied versions of an otherwise same type are considered to be the same type), then assuming ANSI C aliasing rules allows the compiler to generate better optimized code. If a program does access the same data through pointers of a different type (for example, by a "pointer to int" and a "pointer to float", you must not allow the compiler to assume ANSI C aliasing rules, because these rules can result in the generation of incorrect code. The default is ansi_alias. -arch option Specifies the version of the Alpha architecture for which to generate instructions. All Alpha processors implement a core set of instructions and, in some cases, the following extensions: BWX (byte- and word-manipulation instructions) and MAX (multimedia instructions). (The Alpha Architecture Reference Manual describes the extensions in detail.) The option specified by the -arch flag determines which instructions the compiler can generate: generic Generate instructions that are appropriate for all Alpha processors. This option is the default. host Generate instructions for the processor on which the compiler is running (for example, EV56 instructions on an EV56 processor, and EV4 instructions on an EV4 processor). ev4,ev5 Generate instructions for the EV4 processor (21064, 20164A, 21066, and 21068 chips) and EV5 processor (some 21164 chips). (Note that the EV5 and EV56 processors both have the same chip number - 21164.) Applications compiled with this option do not incur incur any emulation overhead on any Alpha processor. ev56 Generate instructions for EV56 processors (some 21164 chips). This option permits the compiler to generate any EV4 instruction, plus any instructions contained in the BWX extension. Applications compiled with this option can incur emulation overhead on EV4 and EV5 processors. ev6 Generate instuctions for EV6 processors (21264 chips). This option permits the compiler to generate any EV6 instruction, plus any instructions contained in the following extensions: BWX, MVI, FIX, and SIX. pca56 Generate instructions for PCA56 processors (21164PC chips). This option permits the compiler to generate any EV4 instruction, plus any instructions contained in the BWX or MAX extensions. Applications compiled with this option can incur emulation overhead on EV4, EV5, and EV56 processors. A program compiled with any of the options runs on any Alpha processor. Beginning with Version 4.0 of the operating system and continuing with subsequent versions, the operating system kernel includes an instruction emulator. This capability allows any Alpha chip to execute and produce correct results from Alpha instructions -- even if some of the instructions are not implemented on the chip. Applications using emulated instructions run correctly, but can incur significant emulation overhead at run time. The psrinfo -v command can be used to determine which type of processor is installed on any given Alpha system. -assume option Allow the compiler to make assumptions regarding certain alignments or code transformations. The following options are supported: [no]accuracy_sensitive Specify whether certain code transformations that affect floating-point operations are allowed. These changes may affect the accuracy of the program's results. The accuracy_sensitive option directs the compiler to use only certain scalar rules for calculations. This setting can prevent some optimizations. This is the default. The noaccuracy_sensitive option frees the compiler to reorder floating-point operations based on algebraic identities (inverses, associativity, and distribution). This allows the compiler to move divide operations out side of loops, which may improve performance. [no]aligned_objects The aligned_objects option causes the compiler to assume that a dereferenced object's alignment matches or exceeds the alignment indicated by the pointer to the object. This is the default. On Tru64 UNIX systems, dereferencing a pointer to a longword- or quadword-aligned object is more efficient than dereferencing a pointer to a byte- or word-aligned object. Therefore, when the compiler assumes that a pointer object of an aligned pointer type does point to an aligned object, it can generate better code for pointer dereferences of aligned pointer types. The noaligned_objects option flag causes the compiler to generate longer code sequences to perform indirect load and store operations in order to avoid hardware alignment faults for arbitrarily aligned addresses. Although this flag may generate less efficient code than the aligned_objects option, by avoiding hardware alignment faults, it speeds the execution of programs that reference unaligned data. [no]trusted_short_alignment Control the alignment assumptions for code generated for indirect load and store instructions. The trusted_short_alignment option indicates that the compiler should assume any short accessed through a pointer is naturally aligned. This generates the fastest code, but can silently generate the wrong results when an unaligned short object crosses a quadword boundary. The notrusted_short_alignment option tells the compiler that short objects might not be naturally aligned. The compiler generates slightly larger (and slower) code that will give the correct result, regardless of the actual alignment of the data. This is the default. The notrusted_short_alignment option does not override the __unaligned type qualifier, the -misalign flag, or the -assume noaligned_objects flag. [no]ptrs_to_globals (cxx -newcxx only) Controls whether the compiler can safely assume that global variables have not had their addresses taken in code that is not visible to the current compilation. The default is ptrs_to_globals, which directs the compiler to assume that global variables have had their addresses taken in separately compiled modules and that a pointer dereference in the module could be accessing the same memory as a global variable. This is often a significant barrier to optimization. While the ansi_alias option allows some resolution based on data type, ptrs_to_globals provides significant cant additional resolution and improved optimization in many cases. noptrs_to_globals tells the compiler that any global variable accessed through a pointer in the compilation unit must have had its address taken within that compilation unit. The compiler can see any code that takes the address of an extern variable. If it does not see the address of the variable being taken, the compiler can assume that no pointer within this compilation unit points to the variable. [no]whole_program (cxx -newcxx only) Asserts to the compiler that except for "well-behaved library routines", the whole program consists only of the single object module being produced by this compilation. The optimizations enabled by whole_program include all those enabled by nopointer_to_globals, and possibly other optimizations. The default is nowhole_program. -Bstring Append string to all names specified by the -t flag. If no -t flag has been processed before the -B option, then a -Bstring flag is passed to the loader to use with its -lx arguments and the -t flag is assumed to be hpfjusmocablyzrntL. This list designates all names. Invoking the compiler with a name of the form cxxstring has the same effect as using -Bstring flag on the command line. -c Suppress the linking phase of the compilation and force production of one or more object file(s) with the .o suffix. If the file name argument already has the .o suffix, do nothing at all. -call_shared Produce a dynamic executable file that uses shareable objects during run-time. This is the default. The loader uses shareable objects to resolve undefined symbols. The run-time loader (/sbin/loader) is invoked to bring in all required shareable objects and to resolve any symbols that remained undefined during static link time. -cfront Interpret source programs according to some language conventions followed by AT&T's "cfront" implementation. This option also defines the macro __CFRONT. -check (cxx -oldcxx only) This option has no effect when -newcxx is specified. Per- form compile-time code checking. With this option, the com- piler checks for code that exhibits nonportable behavior, represents a possible unintended code sequence, or possibly affects program operation because of a quiet change in the language standard. Some of these checks traditionally have been associated with the lint utility. -[no]compress Cause the output object file or instantiated object file to be produced in compressed object file format, resulting in a substantially smaller object file. To produce uncompressed files, specify -nocompress. The default is -compress. -cord Run the procedure rearranger on the resulting file after linking. Rearrangement is performed to reduce the cache conflicts of the program's text. At least one -feedback file must be specified. -denorm Force denormalized constant numbers to zero when IEEE support is enabled. -distinguish_nested_enums Change the compiler's name mangling scheme to include the name of any class, if any, that an enum type is nested within. This allows functions to be overloaded when the only difference in the parameter types is one parameter is an enum with a particular name and the other parameter is an enum with the same name nested within a class (or nested within a different class). In general, if you compile one module of your program with this switch, you should compile all modules with this switch. Using this switch might make it difficult to link with libraries or old object files because of differences in mangled names. -error_limit n Specify the number of errors allowed before compilation stops. -feedback file This option is used with the -cord option to specify a feedback file. The feedback file is produced by the prof command with its -feedback option from an execution of the program produced by the pixie command. -fprm option Specify rounding mode. The following options are supported: c Round toward 0 (chop). d Set rounding mode for IEEE floating-point instructions dynamically, as determined from the contents of the floating-point control register. The dynamic rounding mode can be changed or read at execution time by a call to write_rnd(3) or read_rnd(3). If you specify this option, the IEEE floating-point rounding mode defaults to round to nearest. m Round toward minus infinity. n Set normal rounding mode (unbiased round to nearest). This is the default. -fptm option Specify trapping mode. Only one option can be used on a command line. The following options are supported: n Generate instructions that do not trigger floating- point underflow or inexact trapping modes. Any float- ing point overflow, divide-by-zero, or invalid opera- tion will unconditionally generate a trap. This is the default. u Generate intstructions that trap floating-point underflow, overflow, divide-by-zero, and invalid operations. -fp_reorder Same as -assume noaccuracy_sensitive. -g Produce symbol table information for full symbolic debugging, but do not perform optimizations that limit full symbolic debugging. Same as -g2. If the debugger describes a class asor lacks debugging information, you may need to compile particular files using the -gall option. -g0 Do not produce symbol table information for symbolic debugging. This is the default. -g1 Produce symbol table information for accurate, but limited, symbolic debugging of partially optimized code. -g2 Produce symbol table information for full symbolic debugging, but do not perform optimizations that limit full symbolic debugging. Same as -g. -g3 Produce symbol table information for full symbolic debugging of fully optimized code. This option can affect debugger accuracy. -gall Generate full symbol table information for all classes, structs, and unions. If you specify -gall, -g is assumed. For more information, See the Release Notes (/usr/lib/cmplrs/cxx/cxxnnn_release.ps/txt). -gall_pattern Generate full symbol table information for all classes, structs, and unions if the name of the file being compiled matches the pattern. The pattern can be a list of file names (with each file name separated by a comma or colon), filename patterns, or a combination of a file name list and filename patterns. The -gall_pattern option is ignored unless -g, -g2, or -g3 is also specified. See fnmatch(3) for valid filename patterns. -G num Specify the maximum size, in bytes, of a data item that is to be accessed from the global pointer. The num argument is interpreted as a decimal number. If num is zero, data is not accessed from the global pointer. The default value for num is 8 bytes. -gen_feedback Generate accurate profile information to be used with -feedback optimizations. Such optimizations should be used in the compiling and linking phases. When compiling a program for profiling, add -gen_feedback to your existing set of command line flags. The -gen_feedback flag should not be used when generating profile information. -[no]global_array_new (cxx -newcxx only) Controls whether calls to global array new and delete are generated as specified by ANSI. Pre-ANSI global array new generated calls to operator new(). According to ANSI, use of global array new generate calls to operator new()[]. This option also defines the macro __GLOBAL_ARRAY_NEW. -global_array_new generates calls to operator new()[] for global array new expressions such as new int[4]; this is the default when compiling -std ansi, -std strict_ansi, -std strict_ansi_errors, and -std ms. -noglobal_array_new generates calls to operator new() for global array new expressions such as new int[4] and preserves compatibility with V5.n; this is the default when compiling -std arm and -std cfront. Note that 'arm' refers to The Annotated C++ Reference Manual by Ellis and Stroustrup, 1990 edition. -h dir Use the specified directory instead of the directory where the name specified by the -t flag is normally found. -Hc Halt compiling after the stage specified by the character c, producing an intermediate file for the next stage. The c argument can be any one of the following: f C++ compiling and template instantiating a as0 b as1 l ld y ftoc z cord -ieee Support all portable features of the IEEE Standard for Binary Floating-Point Arithmetic (ANSI/IEEE Standard 754- 1985), including the treatment of denormalized numbers, NaNs, infinities, and the handling of error cases. This flag also sets the _IEEE_FP macro. -inline keyword Specifies whether to provide inline expansion of functions. The -no_inline flag disables the inlining optimization that would otherwise be performed by default under the following compiler optimization -O[n] flags: - When -O2, -O3, or -O4 is specified. You can specify one of the following as the keyword to control inlining: all Inline every call that can be inlined while still generating correct code. Recursive routines, however, does not cause an infinite loop at compile time. manual Inline only those function calls explicitly requested for inlining by an inline keyword. This is the default when compiling with the -O1 flag. none Do not do any inlining. This is the default when compiling with the -O0 optimization level. size Inline all of the function calls in the manual category, plus any additional calls that the compiler determines would improve run-time performance without significantly increasing the size of the program. This is the default when compiling with either the -O2 or the -O3 flag. speed Inline all of the function calls in the manual category, plus any additional calls that the compiler determines would improve run-time performance, even where it may significantly increase the size of the program. For optimization level 0 (-O0), the -inline flag is ignored and no inlining is done. -K Build and use intermediate files, producing a file with the conventional extension for the type of file. These intermediate files are not removed, even when a stage encounters a fatal error. Extensions are appended to the output if the output file does not already have an extension. -machine_code List the generated machine code in the listing file. To produce the listing file, you must also specify the -source_listing option. The default is not to list the generated machine code. -misalign Specify that code generated for indirect load instructions and store instructions not generate alignment faults for arbitrarily aligned addresses. Using this flag increases the size of generated code and might have a negative impact on performance. The default condition is for code generated for indirect load instructions and store instructions to generate alignment faults for arbitrarily aligned addresses. -ms Interpret source programs according to some language conventions followed by Microsoft's Visual C++ implementation. This option also defines the macro __MS. -newcxx Invoke the version 6.1 compiler. This is the default. -no_misalign Negate the -misalign flag. -no_pg Selectively disable profiling for individual modules when using the -pg graph profiling option. -nocleanup Disable generation of implicit exception handlers. Procedures without explicit handlers may have implicit handlers. For example, the compiler creates a handler for each automatic object that has a destructor. The compiler also creates handlers for constructors that initialize subobjects that have destructors. In such a constructor, the compiler creates a handler for each member with a destructor, and a handler for each base class with a destructor. The -nocleanup option suppresses generation of such implicit handlers, which results in a slightly smaller executable. The -nocleanup option results in smaller and faster programs by suppressing all runtime invocation of destructors during transfer of control out of a scope by way of throw or longjmp. You should not use the -nocleanup option to build programs that expect destructors to be invoked for local variables when the stack is unwound by a thrown exception, or a call to exc_longjmp. -nodemangle Do not pipe linker messages through the demangler. This causes linker messages to contain mangled names. By default, cxx pipes linker messages through the demangler so that demangled names are displayed. -[no]exceptions Specify -noexceptions to disable C++ exceptions as follows: + The compiler diagnoses warnings for throw expressions, try blocks, and catch statements, but might generate code for these constructs. + The compiler does not generate cleanup code for automatic objects. + The compiler does not generate special code for main programs so that the terminate() function is called for unhandled exceptions. Specify -exceptions to reenable normal exception handling. -noinline Do not compile any function calls as inline code. -noinline_auto Compile only inline functions that are explicitly declared to be inline. -[no]intrinsics The -intrinsics option causes the compiler to recognize intrinsic functions wherever it can automatically, based only on name and call signature. Unlike -D_INTRINSICS, this option can treat library function calls as intrinsic even when the appropriate header file is not included. Any function declaration or call site (in the case of implicit declaration) with a name matching the name of an intrinsic function is examined to see if its parameters and return result are consistent with the intrinsic function of that name. If so, calls are treated as being intrinsic. If not, a diagnostic is issued and calls are treated as ordinary external function calls. When the compiler identifies a function as an intrinsic function, it is then free to make code optimizations (transformations) based on what it knows about the operations performed by the standardized version of that function--given an optimization level (-On) that enables the intrinsic treatment of that particular function. The optimization level determines which functions can be treated as intrinsics: -O0 or -O1 No intrinsic functions. The -intrinsics option has no effect at this optimization level. -O2 (or -O) Memory and string functions: alloca, bcopy, bzero, memcpy, memmove, memset, strcpy, strlen Math functions: abs, fabs, labs, atan, atan2, atan2f, atand, atand2, atanf, ceil, ceilf, cos, cosd, cosf, floor, floorf, sin, sind, sinf -O3 fprintf, printf, snprintf, sprintf -fast (due to its supplying -assume nomath_errno and -O3) acos, acosf, asin, asinf, cosh,coshf, exp, expf, log, log10, log10f, logf, log2, pow, powf, sqrt, sqrtf, sinh, sinhf, tan, tand, tanf, tanh The effects of the various optimization levels are cumulative; for example, -fast causes the functions at the -02 (or -O) and -O3 optimization levels to be treated as intrinsics--in addition to the intrinsic function treatment that is triggered by -fast itself. The -intrinsics option is in effect by default. To disable the default, specify the -nointrinsics option. To disable the intrinsic treatment of individual functions, specify the function names in a pragma function directive in either your source code or a file associated with a -FI option ("file include" option). Although -intrinsics is the default (and it generally treats calls to [f]printf as intrinsic), to have the low-level support routines for intrinsic [f]printf inlined, the compilation must include and also specify both -D_INTRINSICS and -D_INLINE_INTRINSICS on the command line. -nomember_alignment Direct the compiler to byte-align data structure members, except for bit-field members. By default, data structure members are aligned on natural boundaries (that is, the next boundary appropriate to the member type) rather than the next byte. Using any of the #pragma [no]member_alignment or #pragma pack directives in the source code overrides the setting established by this flag. -non_shared Do not produce a dynamic executable file. The loader uses regular archives to resolve undefined symbols and object files (.o suffix) from archives that are included in the executable produced. -noobject Do not produce an object file. -oldcxx Invoke a bug fix update to the Version 5.7 compiler. This option is provided for cases where the Version 6.0 compiler requires excessive source changes or for problems in using the Version 6.0 compiler. If extensive source changes are required to correct errors, try using the -std arm option. For excessive warnings, try the -msg_quiet option. If you want -oldcxx to be the default, define the DEC_CXX environ- ment variable as follows: setenv DEC_CXX "-oldcxx" -no_vtable_info Tell the demangler to suppress the display of information concerning internal symbols (specifically __vtbl and __btbl) -o file Name the final output file, rather than use the default a.out. The given name is used regardless of the type of file (executable, object, or other type). -O[n] Determine the level of optimization. _____________________________________ Option Optimization _____________________________________ -O0 No optimization. -O1 Optimization with space as the primary criterion. This is the default if no optimization option is specified. -O2 Optimization with time as the primary criterion. This is the default if you specify -O without a level number. -O3 Same as -O2 for C++. If you use the cxx command to compile C source files, -O3 enables inline expansion of C global functions. -O4, -O5 Additional global optimi- zations that improve speed at the cost of extra code size. -O4 and -O5 have the same effect. _____________________________________ In addition to affecting the generated code, the -O level is passed on to ld and is used by both ld and -om (if -om is specified). The general guidelines for optimization are as follows: + If the speed of the generated code is more important than code size, specify -O (same as -O2). In some cases, -O4 may produce faster code. Using inline all at -O or -O4 can inline more calls (particularly calls to constructors) and improve speed, but this option may increase the code size for some programs beyond an acceptable limit. If you are potentially interested in this option, you should build your program both with and without the option and compare the code size. + If the size of the generated code is more important than speed, some experimentation may be necessary to determine the best optimization option. Whereas -O1 (default if an optimization level is not specified) is intended to optimize for code size, in some cases code that is compiled with -O (or -O2) to optimize for speed may actually be smaller. Also try -O -unroll 1 to see whether a smaller size is generated. Using -unroll 1 disables a loop unrolling optimization and generally reduces the code size when -O is used. You might also try compiling with the -noinline option both with and without -O to see whether a reduction in code size occurs. Other switches that can possibly affect run-time size and speed are as follows: compiler -fp_reorder, -misalign, -nocleanup, -noinline, -tune, -assume trusted_short_alignment, -unroll linker -non_shared, -om When you use -g for best debugging, optimizations are suppressed. Thus, when comparing the effects of different optimization levels, you should not specify -g or -g2. For such comparisons, you specify -g0, which suppresses debug- ging information. -om Perform code optimization after linking, including nop (No Operation) removal, .lita removal, and reallocation of com- mon symbols. This flag also positions the global pointer register so the maximum addresses fall in the global pointer-accessible window. The -om flag is supported only for programs compiled with the -non_shared flag. The fol- lowing options can be passed directly to -om by using the -WL compiler flag: -WL,-om_compress_lita Remove unused .lita entries after optimization, and then compress the .lita section. -WL,-om_dead_code Remove dead code (unreachable instructions) generated after applying optimizations. The .lita section is not compressed by this flag. -WL,-om_ireorg_feedback,file Use the pixie-produced information in file.Counts and file.Addrs to reorganize the instructions to reduce cache thrashing. -WL,-om_no_inst_sched Disable instruction scheduling. -WL,-om_no_align_labels Disable alignment of labels. Normally, the -om flag quadword-aligns the targets of all branches to improve loop performance. -WL,-om_Gcommon,num Set size threshold of "common" symbols. Every "common" symbol whose size is less than or equal to num will be allocated close to each other. This flag can be used to improve the probability that the symbol can be accessed directly from the global pointer register. Normally, the -om flag causes the compiler to try to collect all "common" symbols together. -p Perform profiling by periodically sampling the value of the program counter. This option affects only linking. When linking is done, this option replaces the standard run-time startup routine with the profiling run-time startup routine (mcrt0.o) and searches the level 1 profiling library (libprof1.a). When profiling is completed, the startup rou- tine calls the monstartup routine and produces a mon.out file that contains execution-profiling data for use with the postprocessor prof. Same as -p1. -p0 Do not perform profiling. This is the default. -p1 Perform profiling by periodically sampling the value of the program counter. This option affects only linking. When linking is done, this option replaces the standard run-time startup routine with the profiling run-time startup routine (mcrt0.o) and searches the level 1 profiling library (libprof1.a). When profiling is completed, the startup rou- tine calls the monstartup routine and produces a mon.out file that contains execution-profiling data for use with the postprocessor prof. Same as -p. -pg Perform call graph profiling using the gprof tool. For more information on profiling C++ code, see the DIGITAL UNIX Programmer's Guide and the gprof(1) reference page. -preempt_module Provide module preemption, but not full symbol preemption. Module preemption allows the replacement of the definitions of all of the symbols corresponding to a compilation unit (that is, a single object file generated from a .cxx file). Module preemption would take effect if you modified and recompiled a .cxx file, and linked the new .o file into the main object, thus "replacing" all of the .cxx file's exter- nal symbols from the shared library. Unlike full symbol preemption, module preemption does not support replacing individual symbols because the compiler may perform optimi- zations that take advantage of information about symbols defined within a module. This is the default behavior at all optimization levels. You can use -preempt_symbol to provide full symbol preemption. -preempt_symbol Provide full symbol preemption. Full symbol preemption allows the replacement of the definition of an individual external symbol (function or data) in a shared library. This "replacement" occurs at runtime when the dynamic loader uses a definition of the symbol from the main object or some other shared library in preference to the definition in the original shared library. This behavior may be important when a particular symbol is defined in both the main object and in a shared library (or in multiple shared libraries). -protect_headers [all | none] Enables the protection of system header files as described in Protecting System Header Files in Using Compaq C++ for Tru64 UNIX. Specifying none disables protection. -pthread Direct the linker to use the threadsafe version of any library specified with the -l flag when linking programs. This flag also tells the linker to include the POSIX 1003.1c-conformant DECthreads interfaces in libpthread when linking the program. -r Retain relocation entries in the output file. Relocation entries must be saved if the output file is to become an input file in a subsequent linker run. This option prevents final definitions from being given to common symbols; it also suppresses the diagnosis of undefined symbols. -readonly_strings Make all string literals readable only. This is the default. -[no]rtti (cxx -newcxx only) Enable or disable support for RTTI (runtime type identifica- tion) features: dynamic_cast and typeid. Disabling runtime type identification may also save space in your object file because static information to describe polymorphic C++ types is not generated. The default is to enable runtime type information features and generate static information in the object file. Specifying -nortti does not disable exception handling. -rpath string Set the rpath to the specified string. This option is meaningful for shared linkage only. -S Compile the specified source programs and produce symbolic assembly language in corresponding files with a .s suffix. Do not assemble these files. If the file name argument already has a .s suffix, do nothing at all. -SD[directory] Suppress certain warning- and informational-level diagnostic messages that are inappropriate for system header files. The suppressed messages relate to non-portable constructs in header files whose pathnames are prefixed by string directory. The default is -SD/usr/include. Specifying -SD without a directory string cancels the effect of any previous SD flags on the command line (including the default, -SD/usr/include). It also disables the -protect_headers feature's suppression of diagnostic messages by defining the macro __DECC_EMPTY_SD_OPTIONS. (The -protect-headers feature provides message suppression in the file __DECC_include_prologue.h.) -shared Produce a shared object. This includes creating all of the tables for run-time linking, and resolving references to other specified shared objects. The object created can be used by the linker to make dynamic executables. Using dlopen()dlclose() guarantees that the appropriate constructors/destructors are called. -show keyword[,keyword,...] Specify one or more items to be included in the listing file. When specifying multiple keywords, separate them by commas (with no intervening blanks). To use any of the -show keywords, you must also specify the -source_listing option. The -show keywords are as follows: all Enable all options. [no]header Specify whether to produce header lines at top of each page of listing. [no]include Specify whether to place contents of #include files in the program listing. none Negate all options. [no]source Specify whether to place source program statements in the program listing. The default is -show header,source. -show_mangled_name Tell demangler to display encoded name in parentheses after demangled name. -signed Cause all char declarations to have the same machine representation and value set as signed char declarations. This is the default. -source_listing Produce a source code listing file of the same name as the source file, but with the suffix .lis. -[no]stdnew Controls whether calls are generated to the ANSI or pre-ANSI implementation of the operator new(). On memory allocation failure, the ANSI implementation throws std::bad_alloc while the pre-ANSI implementation returns 0. This option also defines the macro __STDNEW. -stdnew generates calls to the ANSI new() implementation; this is the default when compiling -std ansi, -std strict_ansi and -std strict_ansi_errors. -nostdnew generates calls to the pre-ANSI new() implementa- tion; this is the default when compiling -std arm, -std cfront and -std ms. For information about overriding ANSI new(),pre-ANSI new(), or both, see the discussion in the C++ Standard Library chapter of Using C++ for Compaq TGru64 UNIX Systems. -strong_volatile Allow byte and word access of data at byte granularity by using a load-locked instruction sequence for byte and word stores. This means that, for assignments to objects that are less than or equal to 16 bits in size and have been declared as volatile, assignments to adjacent volatile small objects by different threads in a multithreaded program will not cause one of the objects to receive an incorrect value. The generated code includes a load-locked instruction for the enclosing longword or quadword, an insertion of the new value of the object, and a store-conditional instruction for the enclosing longword or quadword. -t Select a name to use for a particular pass, startup routine, or Standard Library from the set of -t [fablyzrnLM], -h path, and -Bstring flags. These arguments are processed from left to right so their order is significant. When the -B flag is encountered, the selection of names takes place using the last -h and -t flags. Therefore, the -B flag is always required when using -h or -t. You can use sets of these flags to select any combination of names. The -p[01] flags must precede all -B flags because they can affect the location of run times and what run times are used. Use the -t [fablyzrnLM] suboptions to select the names. The names selected are those designated by the characters following the -t flag according to the following table: f C++ compiling and template instantiating a as0 b as1 l ld y ftoc z cord r [m]crt0.o n libprof1.a L om M _main.o -taso Tell the linker that the executable file should be loaded in the lower 31-bit addressable virtual address range. You can also use the -T and -D options to the ld command to ensure that the addresses of text and data segments are loaded into low memory. Besides setting default addresses for text and data seg- ments, the -taso option also causes shared libraries linked outside the 31-bit address space to be appropriately relo- cated by the loader. If you specify -taso and also specify text and data segment addresses with -T and -D, those addresses override the -taso default addresses. The -taso option is useful for porting 32-bit programs to Tru64 UNIX. -threads Direct the linker to use the thread-safe version of any library specified with the -l flag when linking programs. This flag also tells the linker to include both the DEC- thread interfaces that are conformant with POSIX 1003.4a Draft 4. The flag is supported only for compatability with earlier releases of the operating system. New designs should use the -pthread flag. -trapuv Forces all uninitialized stack variables to be initialized with 0xfff58005fff58005. When this value is used as a floating-point variable, it is treated as a floating-point NaN and causes a floating-point trap. When it is used as a pointer, an address or segmentation violation usually occurs. For programs compiled without the -trapuv switch, the debugger stops only on executable statements in which the value of a specified variable changes. With the -trapuv switch, the debugger stops on these statements and also stops on all local variable declarations. (The debugger treats the local variable declarations as assignment state- ments because the variables are initialized by the com- piler.) -tune option Select processor-specific instruction tuning for implementa- tions of the operating system architecture. Using the -tune option causes the generated code to run correctly on all implementations of the architecture. Tuning for a specific implementation may improve run-time performance; however, code tuned for a specific target may run slower on another target. The options are: generic (tune appropriate to all architec- tures), host (tune appropriate to the machine compiling the code), ev4 (tune for the 21064, 21064A, 21066, and 21068), ev5 (tune for the 21164), and ev6 (tune for the 21264). The default is -tune generic. In addition to affecting the generated code, -tune is passed on to ld and is used by both ld and -om (if -om is speci- fied). -unroll n Control loop unrolling done by the optimizer. n signifies the number of times to unroll loop bodies. Specifying zero for n tells the optimizer to use its own default unroll amount. This is the default. -unsigned Cause all char declarations to have the same machine representation and value set as unsigned char declarations. The -unsigned option overrides -signed if both are specified on the command line. -[no]use_ld_input=filespec use_ld_input directs the compiler to record the names of requested automatic template instantiation object files in a linker options file. By default, the compiler creates the linker options file with an appropriate name in the repository. If you specify the filespec parameter, the compiler uses that file specification and does not delete the file after compilation. On subsequent calls, the compiler begins linking with all all objects listed in the options file. To prevent inclusion of these objects, you can delete the options file. The compiler then adds the linker options file to the ld command line using the ld -input option. The default behavior is use_ld_input. -nouse_ld_input directs the compiler to record the names of requested requested automatic template instantiation object files on the command line so that you can determine the objects with which you are linking. However, if there are many object files, you might receive Arg list too long messages. -v Print the names of compiler phases as they execute, along with their arguments and input and output files. This option also prints resource usage in the following format: user time, system time, total elapsed time, percentage use of CPU cycles. -V Enable printing of the version of the compiler and its phases. -verbose Include identifiers with diagnostic messages. These identifiers can be used with #pragma message directives. -volatile Compile all variables as volatile. -vptr_size Make 64-bits the default size of virtual function and vir- tual base pointers in a C++ class object (64-bits is the normal default). This option also enables #pragma pointer_size and passes -taso to the linker. -vptr_size_short Make 32-bits the default size of virtual function and vir- tual base pointers in a C++ class object. This option also enables #pragma pointer_size and passes -taso to the linker. -w Suppress warning and informational level compiler messages, but not back-end messages. Same as -w2. -w0 Display all levels of compiler messages. -w1 Suppress information-level compiler messages. This is the default. -w2 Suppress warning- and informational-level compiler messages, but not back-end messages. Same as -w. -Wc[c...],arg1[,arg2...] Pass the arguments arg1 to the compiler stages c[c..]. Use this option to pass arguments through to a particular stage, which otherwise would be consumed by an earlier stage. The c argument selects the compiler stage in the same way as it does in the -H option. Valid characters for c are: a, b, f, l, L, n, r, t, y, z. -weak_volatile Do not generate load-locked instructions for a sequence of byte or word stores for assignments to objects that are less than or equal to 16 bits in size and have been declared as volatile. This allows byte or word access to memory-like I/O devices for which larger access will not cause read or write side effects. Because the sequence does not access byte or word data independently directly in memory (that is, ensure byte granularity), adjacent volatile data can be corrupted when such byte or word accesses are performed in a multithreaded environment (for example, two volatile shorts stored in a longword and accessed asynchronously). -writable_strings Make string literals writable. -x cxx Cause all subsequent file names to be compiled as C++ source files, regardless of their suffixes. This option applies to all following file names up to the next -x option, except for files with the .a or .o suffix. -x none Cause all subsequent file names to be treated according to their file name suffixes. This option is the reverse of the -x cxx option. It applies to all following file names until the next -x option. In the following example, files one.cxx and two.c will be compiled as C++ source files, and file three.c will compiled as a C source file: cxx one.cxx -x cxx two.c -x none three.c The -x none option is the default. -xref -xref_stdout Direct the compiler to generate a data file that the DEC FUSE Database Manager uses to create a cross-reference data- base file. This database file is used by the DEC FUSE C++ Class Browser, Call Graph Browser, and Cross-Referencer. Specifying the -xref_stdout option directs the compiler to output the data file to standard output. -xtaso Enable #pragma pointer_size and pass -taso to the linker. Note that if -xtaso_short has set the default pointer size of the compilation unit to 32-bits (64-bits is the normal default), subsequently specifying -xtaso on the command line will not reset the pointer size. -xtaso_short Set the default pointer size of the compilation unit to 32- bits (for all pointers except virtual function and virtual base pointers). This option also enables #pragma pointer_size and passes -taso to the linker. The this pointer is unaffected by this option, it remains the system default pointer size, which is 64 bits. -Zpn Align structure members as specified by the value of n, which can be 1, 2 or 4. This flag specifies packing so that each structure member after the first is stored on the n byte boundaries specified. Specifying Zp without any integer value causes structure members to be packed on 1-byte boundaries. Preprocessor Options The following cxx command options control the action of the preprocessing phase: -cpp Run the preprocessor on the source files before compiling. This is the default. If both -cpp and -nocpp are included on the command line, the option specified last is in effect. -nocpp (cxx -oldcxx only) Do not run the preprocessor on the source files before com- piling. If both -nocpp and -cpp are included on the command line, the option specified last is in effect. If -P or -E is specified, -nocpp has no effect. -C Prohibit the preprocessor from removing comments in the source file. (Use with the -E or -Em option.) -Dname=def -Dname Define name to the preprocessor, as if the line #define name def were prepended to the C++ source file. There can be a space between the option and name. If name or def contains a dollar sign ($), they must be surrounded by apostrophes ('). If no =def is given, the name is defined as 1. -E Run only the preprocessor on the source files (regardless of whether a suffix exists), and send the result to the stan- dard output. This sets the -cpp option. -Em Run only the preprocessor on the source files (regardless of whether a suffix exists), and produce makefile dependencies instead of the usual output. For each source file, the preprocessor creates one makefile entry naming the object file and listing all included files as dependencies. Same as -M. -I Do not search for #include files in the standard direc- tories, /usr/include/cxx and /usr/include. Because -I can be followed by a directory, do not place a nondirectory file name on the command line immediately following -I. If -I is being used without a directory, follow it with another option or place it at the end of the command line to avoid misinterpretation. -Idir Define the directory name dir to the preprocessor for use in searching for quoted and angle-bracketed include files. There can be a space between the option and dir. The prepro- cessor searches for include file names that do not begin with a slash (/) in the following order: + Quoted file names: 1. In the directory containing the source file with the #include directive. 2. In the directories specified by the -I option. 3. In the /usr/include/cxx and /usr/include directories. + Angle-bracketed files are searched for in the list of directories specified on the command line, then in the /usr/include/cxx directory, and finally, in the /usr/include directory. If -nocurrent_include is specified, the preprocessor does not search in the directory containing the source file (#1 above). -M Run only the compiler on the source files (regardless of whether a suffix exists), and produce makefile dependencies instead of the usual output. For each source file, the preprocessor creates one makefile entry naming the object file and listing all included files as dependencies. To identify correctly the template implementations on which source depends, the compiler parses and analyzes the source; the source must be a valid C++ program. To disable this analysis, specify the -noimplicit_include switch. Same as -Em. -MD Produce a dependency file, which has the suffix .d appended to the object file name. This dependency file is created even if the object file is not. The information and the format in the dependency file is identical to that produced by the -M flag. The -MD flag allows dependency information to be generated at the same time that a compilation is occurring. -nocurrent_include Do not search for quoted include files in the directory con- taining the source file with the #include line. The prepro- cessor will searches the directories specified by the -I option and in the standard directory (/usr/include). See also the -Idir option. -oldcomment Remove comments from preprocessor output files and replace the comments with nothing. -P Run only the preprocessor and put the result for each source file in a corresponding .ixx file, without including line numbers. The -P option has no effect if specified after -E or -Em. If specified before -E, it overrides -E. If speci- fied before -Em, it writes the makefile dependencies to .ixx files. -Uname Cancel any command-line definition of name to the preproces- sor, as if the line #undef name were prepended to the C++ source file. There can be a space between the option and name. If name contains a dollar sign ($), name must be sur- rounded by apostrophes ('). The undefine operation occurs after any definitions produced by the -D options. Symbols defined by default are listed in the Description section. If the environment variable COMP_HOST_ROOT is set, the value is used as the root directory for all stage names rather than the default slash (/). If the environment variable COMP_TARGET_ROOT is set, the value is used as the root directory for all include and library names rather than the default slash (/). COMP_TARGET_ROOT affects the standard directory for include files, /usr/include, and the standard library, /usr/lib/libc.a. If COMP_TARGET_ROOT is set, COMP_TARGET_ROOT/usr/lib is the only directory that is searched for libraries using the -lx option. If the environment variable TMPDIR is set, the value is used as the direc- tory to hold any temporary files rather than the default /tmp directory. If the environment variable RLS_ID_OBJECT is set and a link occurs, the value is used as the name of an object to link. The RLS_ID_OBJECT variable is always the last object specified to the linker. Language Mode Options The cxx command supports the following Language Mode options. For detailed information about language modes, see Porting to Compaq C++ in Using Compaq C++ for Tru64 UNIX. -std ansi (cxx -newcxx only) Use this option if you want an ANSI C++ compiler that sup- ports some commonly used extensions and is somewhat less strict than the standard. This is the default compiler mode. If you find that the compiler generates too many diagnostics in this mode, you can use the -msg_quiet option to relax error checking. This option also defines the macro __STD_ANSI. -std arm (cxx -newcxx only) Use this mode if you want to compile programs developed Using Compaq C++ Version 5.n and want to minimize source changes. This option also defines the macro __STD_ARM. If you usually want your compilations done in this mode and don't want to specify -std arm on each cxx command, define the environment variable DEC_CXX as follows: setenv DEC_CXX "-std arm" -std cfront (cxx -newcxx only) Use this option if you want to compile programs developed using cfront or a compiler based on cfront. This option also defines the macro __STD_CFRONT. -std ms (cxx -newcxx only) Use this option if you want the compiler to accept addi- tional Microsoft Visual C++ extensions. This option also defines the macro __STD_MS. -std strict_ansi (cxx -newcxx only) Use this option if you want the compiler to enforce the ANSI C++ standard strictly. The default ANSI mode permits some common extensions and provides less strict error checking than the STRICT_ANSI mode. This option also defines the macro __STD_STRICT_ANSI. -std strict_ansi_errors (cxx -newcxx only) Use this option if you want STRICT_ANSI and also want errors to be issued for all ANSI violations. -std strict_ansi reports warnings for some ANSI violations. This option also defines the macro __STD_STRICT_ANSI_ERRORS. Message Information and Control Options The cxx command supports the following message control options.The options apply only to discretionary, warning, and informational messages. The tag variable can be the keyword all, a tag obtained from the -msg_display_tag option, or a number obtained from the -msg_display_number option. -msg_inform tag,... (cxx -newcxx only) Alter message(s) severity to informational. -msg_warn tag,... (cxx -newcxx only) Alter message(s) severity to warning. -msg_error tag,... (cxx -newcxx only) Alter message(s) severity to error. -msg_enable tag,... (cxx -newcxx only) Enable specific messages that would normally not be issued when using -msg_quiet. This option can also be used to enable messages disabled with -msg_disable. -msg_disable tag,... (cxx -newcxx only) Disable message. Can be used for any non-error message. -msg_quiet (cxx -newcxx only) Be more like C++ V5.n error reporting. Fewer messages are issued using this option. This is the default in arm mode (-std arm). All other modes default to -nomsg_quiet. The msg_enable option can be used with this option to enable specific messages normally disabled using -msg_quiet. The cxx command supports the following message information options. Both are off by default. -msg_display_number (cxx -newcxx only) Displays the error number at the beginning of each message. Note that "D" (meaning discretionary) indicates that the severity of the message can be controlled from the command line. The message number can be used as the tag in the mes- sage control options. If "D" is not displayed with the mes- sage number, any attempt to control the message is ignored. -msg_display_tag (cxx -newcxx only) Displays a more descriptive tag at the end of each message. D" indicates the severity of the message can be controlled from the command line. The tag displayed can be used as the tag in the above message control options. Note that you can also change the severity of a diagnostic message if the message is discretionary. For example, -msg_inform 110 changes the severity of message 110 to an informational. These options interact with -w0, -w1, and -w2. Standard Library Options
The following are Standard Library options. For detailed information abdout the Standard Library, see The C++ Standard Library in Using Compaq C++ for Tru64 UNIX. -nocxxstd (cxx -newcxx only) Tells the driver not to include libcxxstd.a when linking. -norpath (cxx -newcxx only) Instructs the driver not to add an rpath for the location of the C++ libraries. An application produced with this option uses the installed C++ libraries when run. This is the default for Tru64 UNIX 4.0F or higher. -[no]use_system_libcxx (cxx -newcxx only) Instructs the driver to link with the C++ libraries installed on the system. Implies -norpath. This is the default for Tru64 UNIX 4.0F and higher. -[no]using_std (cxx -newcxx only) Controls whether standard library header files are processed as if the compiled code were written: #include <header> using namespace std; This option is provided for compatibility for users who do not want to qualify use of each standard library name with std:: or put "using namespace std" at the top of their sources. -using_std turns implicit using namespace std on; this is the default when compiling -std arm, -std cfront, -std ms, or -std ansi. -nousing_std turns implicit using namespace std off; this is the default when compiling -std strict_ansi or -std strict_ansi_errors. To access the Standard Library reference pages, type man cxxstdlib_intro. To access the Class Library reference pages, type man cxxlib_intro.Precompiled Header Options
The cxx command supports the following precompiled header options. For detailed information about precompiled headers, see Using Compaq C++ for Compaq Tru64 Systems. -create_pch file-name (cxx -newcxx only) If other conditions are satisfied, create a precompiled header file with the specified name. If -pch (automatic PCH mode) or -use_pch appears on the command line following this option, the last option is used. This option also defines the macro __PCH_ENABLED. -pch (cxx -newcxx only) Automatically use and/or create a precompiled header file. If -use_pch or -create_pch (manual PCH mode) appears on the command line following this option, the last option is used. This option also defines the macro __PCH_ENABLED. -pch_dir dir (cxx -newcxx only) Specifies the directory in which to search for and/or create a precompiled header file. This option can be used with automatic PCH mode (-pch) or manual PCH mode (-create_pch) or -use_pch. -[no]pch_messages (cxx -newcxx only) Enable or disable the display of a message indicating that a precompiled header file was created or used in the current compilation. The default is -pch_messages. -use_pch file-name (cxx -newcxx only) Use a precompiled header file of the specified name as part of the current compilation. If -pch (automatic PCH mode) or -create_pch appears on the command line following this option, the last option is used. This option also defines the macro __PCH_ENABLED.Template Options
The cxx command supports the following options for the instantiation of templates. For detailed information about templates, see Using Compaq C++ for Tru64 UNIX. -define_templates, -tall Instantiate all template entities declared or referenced in the compilation unit. For each fully instantiated template class, all its member functions and static data members are instantiated even if they were not used. Nonmember template functions are instantiated even if the only reference was a declaration. Instantiations are created with external link- age. Overrides -pt at compile time. Instantiations are placed in the user's .o file. -Hf Stops the cxx command after the prelinker runs and before the final link. Provided for compatibility with previous versions of C++. This option has no effect with the Version 6.n compiler. -[no]implicit_include (cxx -newcxx only) Effective only with Version 6.0 and later. Enable or disable inclusion of source files as a method of finding definitions of template entities. Implicit inclusion is enabled by default, and it and disabled when compiling with -E or -P. The search rules for finding template definition files are the same as for include files. This option also defines the macro __IMPLICIT_INCLUDE_ENABLED. You might want to disable implicit inclusion with the -ms and -std ms options to match the behavior on Microsoft C++ more closely. -nopt Directs the compiler not to instantiate templates automati- cally. -nopragma_template Directs the compiler to ignore any #pragma define_template directives. This option is provided for users who want to migrate quickly to automatic instantiation without having to remove all the pragma directives from their code base. -pt Directs the compiler to instantiate templates automatically. This option is the default. Instantiations are placed in the repository. -ptr dir Specifies a repository, with ./cxx_repository as the default. If you specify several repositories, only the first is writable, and the rest are read only. Read-only reposi- tories are used only at link time. Specifying this option at link time enables C++ to recognize and use the template instantiation information files within the specified repository. If you use this option, make sure that the repository specified at compile time is the same one specified at link time. -ptsuf Specifies a list of file name suffixes that are valid for template definition files. Items in the list must be separated by commas and each suffix preceded by a period. A suffix may have no more than eight characters excluding the beginning period. The default is ".cxx,.CXX,.C,.cc,.CC,.cpp,.c". -ptv Turns on verbose or verify mode to display each phase of instantiation as it occurs. During the compilation phase, informational level diagnostics are generated to indicate which templates are automatically being instantiated into the repository. This option is useful as a debugging aid. -tlocal Similar to -tused except that the functions are given internal linkage. This option provides a simple mechanism for getting started with templates. The compiler instantiates as local functions the functions used in each compilation unit, and the program links and run correctly (barring problems resulting from multiple copies of local static variables). However, because many copies of the instantiated functions can be generated, this option might not be not suitable for production use. Note that -tlocal cannot be used in conjunction with automatic template instantiation. If automatic instantiation is enabled by default, it is disabled by the -tlocal option. If automatic instantiation is not enabled by default, use of -tlocal and -pt is an error. -ttimestamp (cxx -newcxx only) Used with automatic instantiation. Templates are instantiated only if they are not already in the repository, or if the existing instantiations in the repository are older than the timestamp in the repository -tused Instantiate those template entities that were used in the compilation, including all static data members for which template definitions exist. Overrides -pt at compile time.Examples
This section provides usage examples. % cxx -g -DUSE_CONCENTRATOR -o netmud netmud.cxx This example creates an executable file named netmud with symbol table information for full symbolic debugging (-g). The -D option defines the macro name USE_CONCENTRATOR for the preprocessor. % cxx -o gfview -I/usr/kafka/src:/usr/barnes/include gfview.cxx The above command line creates an executable file from the gfview.cxx source file. The -o option names the output file gfview. The -I option directs the preprocessing phase to search the specified directories for include files not found in the current working directory. % cxx -c io_module.cxx This example preprocesses and compiles the source file io_module.cxx and produces an object file named io_module.o. Processing stops after creating the object file. % cxx -o newsreader io_module.o ui.cxx -L/users/dave -lnews This example creates an executable file, and the -o option names the file newsreader. The source file ui.cxx is preprocessed and compiled, and then linked with the object file io_module.o. The link operation uses the library specified by -l (libnews.a). The linker first looks for the library in the current working directory, then in the directory specified by -L (/users/dave), and finally in $PATH. % cxx -pg a.cxx b.cxx -no_pg c.cxx This command line enables gprof profiling for files a.cxx and b.cxx and disables profiling for file c.cxx.Diagnostics
The error messages produced by the cxx compiler are self-explanatory. The line number and file name where the error occurred are printed along with the diagnostic. Files file.cxx C++ source code input file file.o Object file a.out Default output file /usr/include /usr/include/cxx Standard directories for include files See Also asctime(3), cxxlib_intro(3), cxxstdlib_intro(3), demangle(1), ladebug(1), ld(1), pixie(1), prof(1), what(1), and the DIGITAL UNIX Programmer's Guide.
|
