- or a + sign.
Any number of options can be interspersed anywhere in the aCC
command and they are typically separated by blanks.
-c Command Line Option Syntax |
-c
The compiler produces an object file (a file ending with
.o) for each source file (a file ending with .c, .C, .s,
or .i). Note that you must eventually link object files before they
can be executed.
aCC -c sub.C prog.C
Compiles sub.C and prog.C and puts the relocatable object code in the
files sub.o and prog.o, respectively.
+DAarchitecture Command Line Option Syntax |
+DAarchitecturearchitecture can be one of the following:
2.0 or 1.1)
+DAportable to generate code compatible
across 1.1 and 2.0 workstations and servers.)
/opt/langtools/lib/sched.models file for a list of
model numbers and their PA-RISC architecture designations.
-lm.
(See the HP-UX Floating-Point Guide for more information about using math libraries.)
NOTE: Object code generated for PA-RISC 2.0 will not execute on PA-RISC 1.1 systems.
To generate code compatible across PA-RISC 1.1 and 2.0 workstations
and servers, use the +DAportable option.
For best
performance use +DA with the model number or architecture where you plan
to execute the program.
If you do not specify a +DA option, the default code generation is based on that of the system on which you compile.
If you specify neither a +DA nor a +DS option, default instruction scheduling is based on that of the system on which you compile. If you do specify a +DA option and do not specify a +DS option, default instruction scheduling is based on what you specify in +DA, and not based on that of the system on which you compile.
For example, specify +DA1.1 and do not specify +DS, and instruction scheduling will be for 1.1. Specify +DAportable and do not specify +DS, and instruction scheduling will be for 1.1. (+DAportable is currently equivalent to +DA1.1.)
/opt/langtools/lib/sched.models for model numbers and their
architectures. Use the command uname -m to determine the model number
of your system.
The instruction set on PA-RISC 2.0 is a superset of the instruction set on PA-RISC 1.1. Code generated for HP 9000 PA-RISC 1.1 systems will run on HP 9000 PA-RISC 2.0 systems, though possibly less efficiently than if it were specifically generated for PA-RISC 2.0.
Code generated for PA-RISC 2.0 will not run on PA-RISC 1.1 systems.
When you use the +DA option depends on your particular circumstances.
+DA.
+DAarchitecture with the model number of the target system.
For example, if you are compiling on a 720 and your program will run on an
855, use +DA855.
+DAportable.
+DSmodel Command Line Option Syntax |
+DSmodelmodel can be either a model number of an HP 9000 system (such as 725, 890, or G40), PA-RISC architecture designation 1.1 or 2.0, or one of the PA-RISC processor names such as PA7000, PA7100, PA7100LC, or PA8000. See the file
/opt/langtools/lib/sched.models for model numbers and
processor names.
Object code with scheduling tuned for a particular model will execute on other HP 9000 systems, although possibly less efficiently.
If you specify neither a +DA nor a +DS option, default instruction scheduling is based on that of the system on which you compile. If you do specify a +DA option and do not specify a +DS option, default instruction scheduling is based on what you specify in +DA, and not based on that of the system on which you compile.
For example, specify +DA1.1 and do not specify +DS, and instruction scheduling will be for 1.1. Specify +DAportable and do not specify +DS, and instruction scheduling will be for 1.1. (+DAportable is currently equivalent to +DA1.1.)
If you plan to run your program on both PA-RISC 1.1 and 2.0 systems, use the +DS2.0 designation.
+DS720
+DS745
+DSPA8000
/opt/langtools/lib/sched.models for model numbers and their processor
names. Use the command uname -m to determine the model number of
your system.
By default, the compiler performs scheduling tuned for the system on which you
are compiling, or, if specified, tuned for the setting of the
+DA option.
Use the +DS option to change this default behavior and
to specify instruction scheduling tuned to a particular
implementation of PA-RISC. For example, to specify instruction scheduling
for the model 867, use +DS867. To specify instruction scheduling for the
PA-RISC 8000 processor, use +DSPA8000. See the file
/opt/langtools/lib/sched.models for model numbers and processor names.
When you use the +DS option depends on your particular circumstances.
+DS option. The compiler
generates code tuned for your system.
+DSmodel with either the model number of the target system or
the processor name of the target system.
For example, if you are compiling on a system with a PA7100 processor and your
program will run on a system with a PA7100LC processor, you can use
+DSPA7100LC. This will give you the best performance on the PA7100LC
system.
+k Command Line Option Syntax |
+k
If your program references a large amount of global data in shared libraries,
the default code generation for referencing that global data may not be
sufficient. If this is the case, when you link your program the linker
gives an error message indicating that you need to recompile with the +k
option. The +k option generates long-displacement code sequences so
a program can reference large amounts of global data in shared libraries.
Use +k only when the linker generates a message indicating you need to
do so.
aCC +k prog.C mylib.sl
Compiles prog.C, generates code for accessing a large number of global
data items in the shared library mylib.sl, and links with mylib.sl.
+tmtarget Command Line Option Syntax |
+tmtarget
+tm target option implies
+DAarchitecture and
+DSmodel
settings as described in the following table.
| specified target value | +DAarchitecture implied | +DSmodel implied |
|---|---|---|
| K7200 | 1.1 |
1.1 |
| K8000 | 2.0 | 2.0 |
| V2200 | 2.0 | 2.0 |
NOTE:
If you specify +DA or +DS on the aCC
command line, your setting takes precedence over the setting implied by
+tm target.
+tm target at
optimization levels 0, 1, 2, 3, and 4.
The default target
value corresponds to the machine on which you invoke the compiler.
-S Command Line Option Syntax |
-S
.s suffix.
CAUTION:
The -S option is informational only. Generated output is not
meant to be used as input to the assembler (as).
aCC -S prog.C
Compiles prog.C to assembly code rather than to object code, and puts the
assembly code in the file prog.s.
+u Command Line Option Syntax |
+unum
The +u option allows pointers to access non-natively aligned data. This option alters the way that the compiler accesses dereferenced data. Use of this option may reduce the efficiency of generated code. num can be specified as:
aCC +u1 app.C
Data storage refers to the size of data types, such as bool, short,
int, float, and char*.
Data alignment refers to the way the HP aC++ compiler
aligns data structures in memory. Data type alignment and storage differences
can cause problems when moving data between systems that have different
alignment and storage schemes. These differences become apparent when
a structure is exchanged between systems using files or inter-process
communication. In addition, misaligned data addresses can cause bus errors
when an attempt is made to dereference the address.
The following lists the sizes and alignments of HP aC++ data types:
Data Type Size (bytes) Alignmentbool 1 1-byte
char, unsigned char, 1 1-byte signed char
wchar_t 2 2-byte
short, unsigned short, 2 2-byte signed short
int, unsigned int 4 4-byte
long, unsigned long 4 4-byte
float 4 4-byte
double 8 8-byte
long double 16 8-byte
long long, 64 8-byte unsigned long long
enum 4 4-byte
arrays Size and alignment of array element type.
struct (*) 1-, 2-, 4- or 8-byte (*)
union (*) 1-, 2-, 4- or 8-byte (*)
bit-fields Size and alignment of declared type.
pointer 4 4-byte
(*) Alignment is the same as the strictest alignment of any member. Padding is done to a multiple of the alignment size.
+d Command Line Option Syntax |
+d
This option is useful when you are debugging your code because you cannot set breakpoints at inline functions. This option defeats inlining thereby allowing you to set breakpoints at functions specified as inline.
-g Command Line Option Syntax |
-g
-g causes the compiler to
generate minimal information for the debugger.
It uses an algorithm that attempts to reduce duplication of debug information.
To suppress expansion of inline functions use the +d option.
-g0 Command Line Option Syntax |
-g0
To suppress expansion of inline functions use the +d option.
-g1 Command Line Option Syntax |
-g1
-g1 causes the compiler to
generate minimal information for the debugger.
It uses an algorithm that attempts to reduce
duplication of debug information.
To suppress expansion of inline functions use the +d option.
-g0 option emits full debug information about every
class referenced in a file, which can result in some redundant information.
The -g and -g1 options, on the other hand, emit a subset of this debug information, thereby decreasing the size of your object file. If you compile your entire application with -g or -g1 no debugger functionality is lost.
NOTE: If you compile part of an application with -g or -g1 and part with debug off, (that is, with neither the -g, the -g0, nor the -g1 option) the resulting executable may not contain complete debug information. You will still be able to run the executable, but in the debugger, some classes may appear to have no members.
Use -g0 when either of the following is true:
NOTE: If you compile part of an application with -g or -g1 and part with debug off, (that is, with neither the -g, the -g0, nor the -g1 option) the resulting executable may not contain complete debug information. You will still be able to run the executable, but in the debugger, some classes may appear to have no members.
If there are no virtual member functions, the compiler looks for the first non-inline member function.
If there are no non-inline member functions, debug information is always generated.
A problem occurs if all functions are inline;
in this case, no debug information is generated.
+p Command Line Option Syntax |
+p
Ordinarily, the compiler gives warnings about anachronistic constructs. Using
the +p option, the compiler gives errors for anachronistic constructs.
aCC +p file.CCompiles
file.C and gives errors for all anachronistic constructs rather
than just giving warnings.
-w Command Line Option Syntax |
-w
By default, HP aC++ reports all errors and warnings.
aCC -w file.CCompiles
file.C and reports errors but does not report any warnings.
+w Command Line Option Syntax |
+w
The default is to warn only about constructs that are almost certainly problems.
For example, this option warns you when calls to inline functions cannot be expanded inline.
aCC +w file.CCompiles
file.C and warns about both questionable constructs and
constructs almost certainly problematic.
+Wargs Command Line Option Syntax |
+Warg1[,arg2,..argn]
aCC +W600 app.C
+Weargs Command Line Option Syntax |
+Wearg1[,arg2,..argn]
aCC +We600,829 app.C
+noeh Command Line Option Syntax |
+noeh
Disables exception handling.
By default, exception handling is on. To turn off exception handling, you must use this option. With exception handling disabled, the keywords throw and try elicit an error.
Note that if your application throws no exceptions, code compiled with and without +noeh can be mixed freely. However, the mixing of code compiled with and without +noeh in an application which throws exceptions is unsupported.
aCC +noeh progex.CCompiles and links
progex.C, which does not use exception handling.
-ext Command Line Option Syntax |
-ext
long long and unsigned long long
data types.
Use this option for 64-bit integer literals and for input and output of 64-bit integers.
If you use the -ext option, use it at both compile and link time.
aCC -ext foo.C
Compiles foo.C which contains a long long declaration.
#include <iostream.h>void main(){ long long ll = 1; cout << ll << endl; }
#include files.
-Idirectory Command Line Option Syntax |
-I directory
directory is the HP-UX directory where HP aC++ looks for header files.
#include files during preprocessing.
During the link phase, adds directory to the directories to be
searched for #include files by the link-time template processor.
For #include files that are enclosed in double quotes
(" ")
within a source file and do not begin with a /, the preprocessor searches in
the following order:
#include.
-I option.
For #include files that are enclosed in angle brackets (< >), the
preprocessor searches in the following order:
-I option.
(The current directory is not searched when angle brackets (< >)
are used with #include.)
aCC -I /opt/aCC/include/SC file.C
This example directs HP aC++ to search in the directory
/opt/aCC/include/SC for #include files.
-I- Command Line Option Syntax |
[-Idirs] -I- [-Idirs][-Idirs] indicates an optional list of -Idirectory specifications in which a directory name cannot begin with a hyphen (-) character.
Specifying -I- serves a dual purpose, as follows:
(" ")
file names in a #include directive to the following order:
-I option.
The preprocessor does not search the directory of the including file.
Angle-bracket enclosed file names in a #include directive are searched for only in the -I directories specified after -I- on the command-line. Quoted includes are searched for in the directories that both precede and succeed the -I- option.
Without view-pathing, there is no way to completely replace the default -Idirectory search-path with one customized specifically for project development.
With view-pathing, you can designate and separate official directories from development directories and enforce an unconventional search-path order. For quote enclosed headers, the preprocessor can include any header files located in development directories and, in the absence of these, include headers located in the official directories.
If -I- is not specified view-pathing is turned off. This is the default.
aCC -Idir1 -Idir2 -c a.CWith view-pathing on, the following example searches for quoted include files in dir1 first and dir2 next, followed by the standard include directories, ignoring the directory of a.C. Angle-bracketed includes are searched for in dir2 first, followed by the standard include directories.
aCC -Idir1 -I- -Idir2 -c a.CCAUTION: Some of the compiler's header files are included using double quotes. Since the -I- option redefines the search order of such includes, if any standard headers are used, it is your responsibility to supply the standard include directories (/opt/aCC/include and /usr/include) in the correct order in your -I- command line.
For example, when using -I- on the aCC command line, any specified -I directory containing a quoted include file having the same name as an HP-UX system header file, may cause the following possible conflict. (In general, if your application includes no header having the same name as an HP-UX system header, there is no chance of a conflict.)
Suppose you are compiling program a.C with view-pathing on. a.C includes the file a.out.h which is a system header in /usr/include:
aCC -IDevelopmentDir -I- -IOfficialDir a.CIf a.C contains:
// This is the file a.C #include <a.out.h> // ...When a.out.h is preprocessed from the /usr/include directory, it includes other files that are quote included (like #include "filehdr.h").
Since with view-pathing, quote enclosed headers are not searched for in the including file's directory, filehdr.h which is included by a.out.h will not be searched for in a.out.h's directory (/usr/include). Instead, for the above command line, it is first searched for in DevelopmentDir, then in OfficialDir and if it is found in neither, it is finally searched for in the standard include directories (/opt/aCC/include and /usr/include) in the latter of which it will be found.
However, if you have a file named filehdr.h in DevelopmentDir or OfficialDir, that file (the wrong file) will be found.
+help Command Line Option Syntax |
+help
If +help is used on any command line, the compiler displays the online programmer's guide with the default web browser and then processes any other arguments.
If $DISPLAY is set, the default web browser is displayed.
If the display variable is not set, a message so indicates.
Set your $DISPLAY variable as follows:
export DISPLAY=YourDisplayAddress (ksh shell notation) setenv DISPLAY YourDisplayAddress (csh shell notation)
aCC +help
To use a browser other than the default, first set the BROWSER environment variable to the alternate browser's location:
export BROWSER=AlternateBrowserLocation aCC +help
+inline_levelnum Command Line Option Syntax |
+inline_levelnum
This option controls how C++ inlining hints influence HP aC++. Specify num as 0, 1, 2, or 3.
| num | Meaning |
|---|---|
| 0 | No inlining is done (same effect as the +d option). |
| 1 | Only small functions are inlined. |
| 2 | Only large functions are not inlined. |
| 3 | Inlining hints are respected in all cases, except when the called function is recursive or when it has a variable number of arguments. |
The default level depends on +Oopt as shown in the following table:
| opt | num |
|---|---|
| 0 | 1 |
| 1 | 1 |
| 2 | 2 |
| 3 | 2 |
| 4 | 2 |
NOTE: This option controls functions declared with the inline keyword or within the class declaration and is effective at all optimization levels.
The options +O[no]inline and +Oinlinebudget control the high level optimizer that recognizes other opportunities in the same source file (+O3) or amongst all source files (+O4).
aCC +inline_level3 app.C
+A Command Line Option Syntax |
+A
The -a,archive linker
option also links archive libraries but it links the shared library
/usr/lib/libdld.sl. +A links in
/opt/aCC/lib/cxxshl.o instead of /usr/lib/libdld.sl.
aCC +A file.o -lmLinks
file.o and links in the archived version of the math library,
/lib/libm.a, rather than the shared version,
/lib/libm.sl,
and does not link in /usr/lib/libdld.sl.
-a linker option
-b Command Line Option Syntax |
-b
The object files must have been created with the +z or +Z option to generate position-independent code (PIC).
aCC -b utils.o -o utils.sl
Links utils.o (which must have been created using the +z option)
and creates the shared library utils.sl.
-lname Command Line Option Syntax |
-lnameThe name parameter forms part of the name of the library the linker searchs when looking for routines called by your program.
/usr/lib/libname.sl
/usr/lib/libname.a
/opt/langtools/lib/libname.sl
/opt/langtools/lib/libname.a
.sl) or the archive
library (.a) depends on the value of the
-a linker option or the
+A compiler option.
NOTE:
Because a library is searched when its name is encountered, placement of a
-l is significant. If a file contains an unresolved external reference,
the library containing the definition must be placed after the file
on the command line. For details refer to the description of ld
in the HP-UX Reference Manual or the ld(1) man page if it is installed
on your system. (If you see the message "Man page could not be formatted,"
ensure the man page is installed.)
aCC file.o -lnumeric
This example directs the linker to link file.o and (by default)
search the library /usr/lib/libnumeric.sl.
-Ldirectory Command Line Option Syntax |
-LdirectoryThe directory parameter is the HP-UX directory where you want the linker to search for libraries your program uses before searching the default directories.
The default search path is the directory /opt/aCC/lib.
The -L option must precede any -lname
option entry on the command line; otherwise -L is ignored.
This option is passed directly to the linker.
aCC -L/project/libs prog.C -lmylib1 -lmylib2
Compiles and links prog.C and directs the linker to search the directories
/opt/aCC/lib and /project/libs for any libraries that prog.C uses
(in this case, mylib1 and mylib2).
+z Command Line Option Syntax |
+z
Use -b to create a shared library.
+z is similar to the +Z option.
Use +z
unless the linker generates an error message indicating that you should
use +Z.
The -G option is ignored if either +z or
+Z is used.
aCC -c +z utils.C
Compiles utils.C and generates position-independent code in utils.o.
utils.o can be placed into a shared library with the -b option.
+Z Command Line Option Syntax |
+Z
Use -b to create a shared library.
+Z is the same as the +z option except that it allows
for more imported symbols than does +z.
Use the +Z option only if errors are generated when you use +z.
The -G option is ignored if either +z
or +Z is used.
In addition, you can use the -Wl,args compiler option to specify any linker option on the compiler command line.
-n Command Line Option Syntax |
-n
ld in the
HP-UX Reference Manual or the ld(1) man page if it is installed
on your system. (If you see the message "Man page could not be formatted,"
ensure the man page is installed.) See also the -N
option.
-N Command Line Option Syntax |
-N
Unsharable executable files generated with the -N option cannot
be executed with exec.
ld description in the
HP-UX Reference Manual or the ld(1) man page if it is installed
on your system. (If you see the message "Man page could not be formatted,"
ensure the man page is installed.)
-q Command Line Option Syntax |
-q
ld in the
HP-UX Reference Manual or the ld(1) man page if it is installed
on your system. (If you see the message "Man page could not be formatted,"
ensure the man page is installed.)
-Q Command Line Option Syntax |
-Q
-s Command Line Option Syntax |
-s
Specifying this option prevents using a symbolic debugger on the resulting program.
ld in the HP-UX Reference Manual or
the ld(1) man page if it is installed on your system.
(If you see the message "Man page could not be formatted," ensure the man page
is installed.)
-o Command Line Option Syntax |
-o outfile
The outfile parameter is the name of the file containing the
output of the compilation.
Without this option the default name is a.out.
When compiling a single source file with the -c
option, you can use the -o option to specify the name and location of the
object file.
-.suffix Command Line Option Syntax |
-.suffixThe suffix parameter represents the character or characters to be used as the output file name suffix.
suffix cannot be the same as the original source file name suffix.
.c file.
aCC -E -.Pfile prog.C
Preprocesses the C++ code in prog.C and puts the resulting code
in the file prog.Pfile.
-Y Command Line Option Syntax |
-Y
The language value (refer to environ(5) for the LANG environment
variable) is used to initialize the correct tables for interpreting
comments, string literals, and character constants. The language value
is also used to build the path name to the proper message catalog.
hpnls, lang, and environ in the
HP-UX Reference Manual for a description of the NLS model.
-z Command Line Option Syntax |
-z
Fatal errors result if null pointers are dereferenced.
If you attempt to dereference a null pointer, a SIGSEGV
error occurs at run time.
aCC -z file.CCompiles
file.C and generates code to disallow dereferencing of null
pointers.
To use optimization, first specify the appropriate basic optimization level
(+O1, +O2, +O3, or +O4)
on the aCC command line followed by one or more
finer or more precise options when necessary.
For an introduction with examples, refer to
Optimizing HP aC++ Programs.
Categories of options are listed below.
-O Command Line Option Syntax |
-O
aCC -O prog.CCompiles
prog.C and optimizes at level 2.
+O1 Command Line Option Syntax |
+O1
aCC +O1 prog.CCompiles
prog.C and optimizes at level 1.
+O2 Command Line Option Syntax |
+O2
aCC +O2 prog.CCompiles
prog.C and optimizes at level 2.
+O3 Command Line Option Syntax |
+O3
aCC +O3 prog.CCompiles
prog.C and optimizes at level 3.
+O4 Command Line Option Syntax |
+O4
When you link a program, the compiler brings all modules that were
compiled at optimization level 4 into virtual memory at the same time.
Depending on the size and number of the modules, compiling at +O4 can
consume a large amount of virtual memory. If you are linking a
large program that was compiled with the +O4 option,
you may notice a system slow down. In the worst case,
you may see an error indicating that you have run out of memory.
If you run out of memory when compiling at +04 optimization, there
are several things you can do:
+O4 only those
modules that need to be compiled at optimization level 4, and compile
the remaining modules at a lower level.
maxdsiz process parameter from 64 MB to 128 MB.
This procedure provides the process with additional data space.
Refer to the System Administration Tasks manual, Chapter 11,
"Reconfiguring the HP-UX Kernel." See Appendix A for full
descriptions of the different process parameters, including
maxdsiz.
For a complete discussion of swap space, refer to How HP-UX Works: Concepts for the System Administrator.
aCC +O4 prog.CCompiles
prog.C and optimizes at level 4.
+ESfic Command Line Option Syntax |
+ESfic
Replaces millicode calls with inline fast indirect calls.
The +ESfic compiler option affects how function
pointers are dereferenced in generated code. The default is to generate
low-level millicode calls for function pointer calls.
The +ESfic option generates code that calls function pointers
directly, by branching through them.
NOTE:
The +ESfic option should only be used in an environment where there
are no dependencies on shared libraries. The application must be linked
with archive libraries only. Using this option can improve
run-time performance.
+ESsfc Command Line Option Syntax |
+ESsfc
Replaces millicode calls with inline code when performing simple function
pointer comparisons. The +ESsfc compiler option affects how function
pointers are compared in generated code. The default is to generate
low-level millicode calls for function pointer comparisons.
The +ESsfc option generates code that compares function pointers
directly, as if they were simple integers.
NOTE:
The +ESsfc option should only be used in an environment where there
are no dependencies on shared libraries. The application must be linked
with archive libraries only. Using this option can improve run-time
performance.
Following is an example of a code fragment that performs function pointer comparisons:
int (*g)( );
int (*f)( );
int foo ( );
{
. . .
}
. . .
if (f == g)
. . .
if (f == foo)
. . .
if (f == SIG_ERR) /* SIG_ERR is defined in signal.h */
. . .
+O[no]all Command Line Option Syntax |
+O[no]all
+Oall to obtain the best possible performance.
This option should be used with stable, well-structured code. These optimizations give you the fastest code, but are riskier than the default optimizations.
You can use +Oall at optimization levels 2, 3, and 4.
The default is +Onoall.
aCC +Oall prog.CCompiles
prog.C and optimizes for best performance.
aCC -O +Oall prog.CCompiles
prog.C and optimizes at level 2 with aggressive optimizations
and unrestricted compile time.
+Oall option without +O2, +O3, or +O4 combines the following options:
+O[no]aggressive Command Line Option Syntax |
+O[no]aggressive
The +Oaggressive option enables aggressive optimizations.
The +Onoaggressive option disables aggressive optimizations.
Aggressive optimizations can result in significant performance improvement, but can change program behavior. They can:
Use +Oaggressive with optimization levels 2, 3, or 4.
By default, aggressive optimizations are turned off.
aCC +O2 +Oaggressive sourcefile.Cor:
aCC +O3 +Oaggressive sourcefile.Cor:
aCC +O4 +Oaggressive sourcefile.C
+Oaggressive option invokes the following advanced optimization
options:
+O[no]conservative Command Line Option Syntax |
+O[no]conservative
+Oconservative option causes the optimizer to make conservative
assumptions about application code and enable only
conservative optimizations, a subset of basic optimizations.
Use +Oconservative at optimization levels 2, 3, or 4 when your source code
is unstructured or you are unfamiliar with the source code being optimized.
The default is +Onoconservative.
+Oconservative option as follows:
aCC +O2 +Oconservative sourcefile.Cor:
aCC +O3 +Oconservative sourcefile.Cor:
aCC +O4 +Oconservative sourcefile.C
+O[no]limit Command Line Option Syntax |
+O[no]limit
+Olimit option suppresses optimizations that significantly
increase compile-time or that consume a lot of memory.
The +Onolimit option enables optimizations regardless of their effect
on compile time or memory consumption.
Use +Onolimit with optimization levels 2, 3, or 4.
The default is +Olimit.
+Onolimit as follows:
aCC +O2 +Onolimit sourcefile.Cor:
aCC +O3 +Onolimit sourcefile.Cor:
aCC +O4 +Onolimit sourcefile.C
+O[no]size Command Line Option Syntax |
+O[no]size
+Osize option suppresses
those few optimizations that significantly increase code size.
The +Onosize option enables code-expanding optimizations.
Use +Osize at optimization levels 2, 3, or 4. The default is +Onosize.
+Osize as follows:
aCC +O2 +Osize sourcefile.Cor:
aCC +O3 +Osize sourcefile.Cor:
aCC +O4 +Osize sourcefile.C
Advanced optimization options provide additional control for special situations.
+O[no]dataprefetch Command Line Option Syntax |
+O[no]dataprefetch
+Odataprefetch is enabled, the optimizer inserts instructions within
innermost loops to explicitly prefetch data from memory into the data cache.
Data prefetch instructions are inserted only for data structures referenced
within innermost loops using simple loop varying addresses (that is,
in a simple arithmetic progression). It is only available for PA-RISC 2.0
targets.
Use this option for applications that have high data cache miss overhead.
You can use +Odataprefetch at optimization levels 2, 3, and 4.
The default is +Onodataprefetch.
+O[no]entrysched Command Line Option Syntax |
+O[no]entrysched
+Oentrysched option optimizes instruction scheduling on a procedure's
entry and exit sequences.
Enabling this option can speed up an
application. The option has undefined behavior for applications which
handle asynchronous interrupts. The option affects unwinding in the entry
and exit regions.
At optimization level +O2 and higher (using dataflow information), save and restore operations become more efficient.
This option can change the behavior of programs that perform
error handling or that handle asynchronous interrupts.
The behavior of setjmp() and longjmp() is not affected.
Use +Oentrysched at optimization levels 2, 3, or 4.
The default is +Onoentrysched.
+O[no]failsafe Command Line Option Syntax |
+O[no]failsafe
+Ofailsafe option allows compilations with internal optimization
errors to continue by issuing a warning message and restarting
the compilation at +O0.
You can use +Onofailsafe at optimization levels 1, 2, 3, or 4
when you want the internal optimization errors to abort your build.
The default is +Ofailsafe at levels 1, 2, 3, 4.
+O[no]fastaccess Command Line Option Syntax |
+O[no]fastaccess
+Ofastaccess option optimizes for fast access to global data items.
Use +Ofastaccess to improve execution speed at the expense of longer
compile times.
Use +Ofastaccess at optimization levels 0, 1, 2, 3, or 4.
The default is +Onofastaccess at optimization levels 0, 1, 2, and 3, and
+Ofastaccess at optimization level 4.
+O[no]fltacc Command Line Option Syntax |
+O[no]fltacc
+Ofltacc option allows the compiler to make transformations which are
algebraically correct, but which may affect the result of computations
slightly due to the inherent imperfection of computer floating-point
arithmetic. These transformations typically exceed those allowed by
relevant language standards.
For many programs, the results obtained under +Onofltacc are as
valid as those obtained without the optimization. They may be
slightly different, but not obviously better or worse. For applications
in which roundoff error has been carefully studied, and the order of
computation carefully crafted to control error, +Onofltacc
may be unsatisfactory.
Use +Onofltacc at optimization levels 2, 3, or 4.
The default is +Ofltacc.
CAUTION: The sophistication of this optimization is likely to change over time. You should review the performance of your code with subsequent releases of the HP aC++ compiler.
+Onofltacc allows the compiler to substitute division by a multiplication
using the reciprocal. For example, the following code
for (int j=1;j<5;j++)
a[j] = b[j] / x;
is transformed as follows (note that x is invariant in the loop):
x_inv = 1.0/x;
for (int j=1;j<5;j++)
a[j] = b[j] * x_inv;
Since multiplication is considerably faster than division, the optimized program runs faster.
+O[no]initcheck Command Line Option Syntax |
+O[no]initcheck
+Oinitcheck), the optimizer initializes to zero any local,
scalar, non-static variables that are uninitialized with respect to at least
one path leading to a use of the variable.
+Onoinitcheck), the optimizer does not initialize uninitialized
variables, but issues warning messages when it discovers them.
Use +Oinitcheck to look for program variables that may not be
initialized.
Use +Oinitcheck at any optimization level and +Onoinitcheck at
optimization levels 2, 3, or 4.
+O[no]inline Command Line Option Syntax |
+O[no]inline
+Oinline option indicates that any function can be inlined by the
optimizer. +Onoinline disables inlining of functions by the optimizer.
(This option does not affect functions inlined at the source code level.
Use +Onoinline at optimization levels 3 or 4.
The default is +Onoinline at optimization levels 1 and 2 and
+Oinline at levels 3 and 4.
+Oinlinebudget Command Line Option Syntax |
+Oinlinebudget=n
The +Oinlinebudget option controls the aggressiveness of
inlining
according to the value you specify for n
where n is an integer in the range 1 - 1000000 that specifies the
level of aggressiveness, as follows:
The +Onolimit and
+Osize
options also affect inlining.
Specifying the +Onolimit option has the same effect
as specifying +Oinlinebudget=200.
The +Osize option has the same effect as
+Oinlinebudget=1.
Note, however, that the +Oinlinebudget option takes
precedence over both of these options.
This means that
you can override the effect of +Onolimit
or +Osize option on inlining
by specifying the +Oinlinebudget option on the same compile line.
Use this option at optimization level 3 or higher.
The default is +Oinlinebudget=100.
See also the
+O[no]inline option.
+O[no]libcalls Command Line Option Syntax |
+O[no]libcalls
errno and do not give an error
message in the event of an exception.
The +Olibcalls option provides access to millicode routines
for the following math library calls:
sin cos tan atan2 pow log10 asin acos atan exp log
Use +Olibcalls to improve the performance of these library routines
only when you do not want standard error checking. For example, you
might use +Olibcalls with code that has already been debugged and runs
without error.
The default is +Onolibcalls.
Use +O[no]libcalls at any optimization level.
+O[no]looptransform Command Line Option Syntax |
+O[no]looptransform
The +O[no]looptransform option enables [disables] transformation of
eligible loops for improved cache performance. The most important
transformation is the reordering of nested loops to make the inner loop
unit stride, resulting in fewer cache misses.
The default is +Olooptransform at optimization levels 3 and 4.
You cannot use the option at levels 0-2.
+O[no]loopunroll Command Line Option Syntax |
+O[no]loopunroll[=unroll factor]
+Oloopunroll option turns on loop unrolling.
When you use +Oloopunroll, you can also use the unroll factor
to control the code expansion. The default unroll factor is 4,
that is, four copies of the loop body. By experimenting with different
factors, you may
improve the performance of your program.
You can use +Oloopunroll at optimization levels 2, 3, and 4.
The default is +Oloopunroll.
+O[no]moveflops Command Line Option Syntax |
+O[no]moveflops
+Omoveflops option allows moving conditional floating point
instructions out of loops. The behavior of floating-point error handling may
be altered by this option.
This option also allows you to enable or disable replacing integer divide by a floating point multiply. This may cause SIGFPE if IEEE inexact is enabled (+FPI).
+Onomoveflops if floating-point traps are enabled and you do not
want the behavior of floating-point errors to be altered by the relocation
of floating-point instructions.
Use +Onomoveflops at optimization levels 2, 3, and 4.
The default is +Omoveflops.
+O[no]parmsoverlap Command Line Option Syntax |
+O[no]parmsoverlap
+Oparmsoverlap option optimizes with the assumption that the actual
arguments of function calls overlap in memory.
Use +Onoparmsoverlap if C++ programs have been literally translated
from FORTRAN programs.
Use +Onoparmsoverlap at optimization levels 2, 3, and 4.
The default is +Oparmsoverlap.
+O[no]pipeline Command Line Option Syntax |
+O[no]pipeline
+Opipeline option enables software pipelining.
Use +Onopipeline to conserve code space.
Use +Onopipeline at optimization levels 2, 3, and 4.
The default is +Onopipeline at optimization level 1 and +Opipeline at
levels 2, 3, and 4.
+O[no]procelim Command Line Option Syntax |
+O[no]procelim
Used when linking an executable file, +Oprocelim removes functions not
referenced by the application.
Used when building a shared library, +Oprocelim removes functions not
exported and not referenced from within the shared library.
This may be especially useful when functions have been inlined.
Note that any function having symbolic debug information associated with it is not removed.
The default is +Onoprocelim at optimization levels 1 through 3 and
+Oprocelim at level 4.
Use +O[no]procelim at any optimization level.
+O[no]regionsched Command Line Option Syntax |
+O[no]regionsched
+Oregionsched option applies aggressive scheduling techniques to move
instructions across branches.
NOTE:
This option is incompatible with the -z option.
Using this option with -z may cause a SIGSEGV error at run-time.
See signal(2) and signal(5) for more information.
(If you see the message "Man page could not be formatted," ensure
the man page is installed.)
Use +Oregionsched to improve application run-time speed.
Use +Oregionsched at optimization levels 2, 3, and 4.
The default is +Onoregionsched.
+O[no]regreassoc Command Line Option Syntax |
+O[no]regreassoc
+Onoregreassoc option turns off register reassociation.
Use +Onoregreassoc to disable register reassociation
if this optimization hinders application performance.
Use +Onoregreassoc at optimization levels 2, 3, and 4.
The default is +Oregreassoc.
+O[no]signedpointers Command Line Option Syntax |
+O[no]signedpointers
+Osignedpointers option performs optimizations related to treating
pointers in Boolean comparisons (for example, <, <=, >, >=) as signed
quantities.
Applications that allocate shared memory and that compare a pointer to shared
memory with a pointer to private memory may run incorrectly if this
optimization is enabled.
Use+Osignedpointers to improve application run-time speed.
Use +Osignedpointers at optimization levels 2, 3, and 4.
The default is +Onosignedpointers.
+O[no]volatile Command Line Option Syntax |
+O[no]volatile
+Ovolatile option implies that memory references to global
variables are volatile and cannot be removed during optimization.
The +Onovolatile option implies that all globals are not of
volatile class. This means that references to global variables can be
removed during optimization.
Use this option to control the "volatile" semantics for all global variables.
Use +Ovolatile at optimization levels 1, 2, 3, or 4.
The default is +Onovolatile.
Profile-based optimization is a set of performance-improving code transformations based on the run-time characteristics of your application.
+dfname Command Line Option Syntax |
+dfname
The profile database by default is named flow.data. This file stores
profile information for one or more executables.
Use +df when the flow.data file has been renamed or is in a different
directory than where you are linking.
You can also use the FLOW_DATA environment variable to specify a different
path and file name for the profile database file. The +dfname
command line option takes precedence over the FLOW_DATA environment
variable.
NOTE:
The +dfname option cannot be used to redirect the
instrumentation output (with the +I option). It is only compatible
with the +P option.
aCC +P +dfpbo.data prog.o -o myapp
Relinks the object file prog.o, optimizes using the run-time profile
data in the file pbo.data, and puts the executable code in the file
myapp.
+I Command Line Option Syntax |
+I
After compiling and linking with +I, run the resultant program
using representative input data to collect execution profile data.
Finally, relink with the +P option
to perform profile-based optimization.
Profile data is stored in flow.data by default. See the
+dfname option for information on controlling
the name and location of this data file.
The +I option is incompatible with exception handling. To turn off
exception handling, use the +noeh option.
The +I option is incompatible with the
-g0, -g1,
-G, +P,
and -S options.
aCC +I -O -c prog.C aCC +I -O -o prog.pbo prog.o
Compiles prog.C with optimization, prepares the object code for data
collection, and creates the executable file prog.pbo. Running prog.pbo
collects run-time information in the file flow.data in preparation for
optimization with +P.
+P Command Line Option Syntax |
+P
The +P option does not affect the default optimization level, or the
optimization level specified by the +O1,
+O2, +O3, or
+O4 options.
NOTE:
Source files that are compiled with the +I option
do not need to be recompiled with +P in order to use profile-based
optimization. You only need to relink the object files
with the +P option after running the instrumented version of the
program.
The +P option is incompatible with exception handling. To turn off
exception handling, use the +noeh option.
The +P option is incompatible with the
+noeh,
-g0,
-g1,
+I,
and -S options.
aCC +P -o myapp prog.o
Relinks the object file prog.o and optimizes using the run-time profile
data.
+pgmname Command Line Option Syntax |
+pgmname
Specifies a program name to look up in the flow.data file to use with
profile-based optimization and the +P option.
The +pgmname option should be used when the name of the
profiled executable differs from the name of the current executable
specified by the -o option.
In the following example, the instrumented program file name
is sample.inst. The optimized program file name is sample.opt.
The +pgmname option is used to pass the instrumented program name,
sample.inst, to the optimizer:
aCC -c +I sample.C aCC -o sample.inst +I -O sample.o sample.inst < input.file1 aCC -o sample.opt +P +pgm sample.inst sample.o
+O[no]info Command Line Option Syntax |
+O[no]info
+Oinfo displays informational messages about the optimization process.
This option may be helpful in understanding what optimizations are occurring.
You can use the option at levels 0-4.
The default is +Onoinfo at levels 0-4.
+hdr_create Command Line Option Syntax |
+hdr_create
You can reduce compilation time by precompiling common include (header) files into a precompiled header file.
aCC headers.C -c +hdr_create precompFrom headers.C, creates a precompiled header file named precomp.
Note that the -c option is needed to suppress the link step.
+hdr_use Command Line Option Syntax |
+hdr_use
This is known as a load compile.
aCC main.C +hdr_use precompCompiles main.C, including a precompiled header file named precomp.
+hdr_v Command Line Option Syntax |
+hdr_v
aCC headers.C -c +hdr_create precomp +hdr_vCreates a precompiled header file named precomp and displays what is going into the precompiled header file.
aCC main.C +hdr_use precomp +hdr_vCompiles main.C and displays what is being used from the precompiled header file.
stdout.
.i file.
.suffix.
-Dname Command Line Option Syntax |
-Dname[=def]
name is the symbol name that is defined for the preprocessor.
def is the definition of the symbol name (name).
#define.
If no definition (def) is given, the name is defined as "1".
aCC -DDEBUGFLAG file.C
Defines the preprocessor symbol DEBUGFLAG and gives it the value 1.
Following is a program that uses this symbol.
#include <iostream.h>
void main(){
int i, j;
#ifdef DEBUGFLAG
int call_count=0;
#endif
...
}
-E Command Line Option Syntax |
-E
stdout).
Unlike the -P option, the output of -E contains #line entries indicating the original file and line numbers.
+m[d] Command Line Option Syntax |
+m[d]
If +md is specified, the list is directed to a .d file. The .d file name prefix is the same as that of the object file. The .d file is created in the same directory as the object file.
| command line specified | .d file name | .d file location |
|---|---|---|
| aCC -c +m a.C | none | output to stdout |
| aCC -c -E -.i +md a.C | a.d | current directory |
| aCC -c -P +md a.C -o b.o | b.d | current directory |
| aCC -c -P +md a.C -o /tmp/c | c.d | /tmp directory |
+M[d] Command Line Option Syntax |
+M[d]
If +Md is specified, the list is directed to a .d file. The .d file name prefix is the same as that of the object file. The .d file is created in the same directory as the object file.
| command line specified | .d file name | .d file location |
|---|---|---|
| aCC -c +M a.C | none | output to stdout |
| aCC -c -E -.i +Md a.C | a.d | current directory |
| aCC -c -P +Md a.C -o b.o | b.d | current directory |
| aCC -c -P +Md a.C -o /tmp/c | c.d | /tmp directory |
-P Command Line Option Syntax |
-P
.i.
aCC -P prog.CPreprocesses the file
prog.C leaving the output in the file prog.i.
Does not compile the program.
-Uname Command Line Option Syntax |
-Unamename is the symbol name whose definition is removed from the preprocessor.
A name can be a definition set by HP aC++; these are displayed when you specify the -v option. Or a name can be a definition you have specified with the -D option on the aCC command line.
The -D option has lower precedence than the -U option. Thus, if the same name is used in both a -U option and a -D option, the name is undefined regardless of the order of the options on the command line.
-G Command Line Option Syntax |
-G
gprof (to get an execution
profile).
aCC -G file.CCompiles
file.C and creates the executable file a.out instrumented for
use with gprof.
Argument-dependent Lookup Rules Command Line Option Syntax |
-Wc,-koenig_lookup,[on]
[off]
namespace N {
struct S {};
void f(S const&, int); // (1)
}
void f(N::S const&, long); // (2)
int main() {
N::S x;
f(x, 1);
}
-tx,name Command Line Option Syntax |
-tx,name
This option works in two modes:
aCC -ta,/users/sjs/myasmb file.sInvokes the assembler
/users/sjs/myasmb instead of the default assembler
/usr/ccs/bin/as to assemble and link file.s.
-t.
-W allows you to pass
options to subprocesses.)
aCC -tf,/new/bin/c++filt file.CCompiles
file.C and specifies that
/new/bin/c++filt should be used rather than the default
/opt/aCC/bin/c++filt.
aCC -tC,/users/proj/ctcom file.CCompiles
file.C and specifies that /users/proj/ctcom
should be used instead of the default /opt/aCC/lbin/ctcom.
aCC -tx,/new/&driver; file.CCompiles
file.C and specifies that the characters /new/aCC should
be used as a prefix to all the subprocesses of HP aC++ For example,
/new/aCC/ctcom runs rather than the default /opt/aCC/lbin/ctcom.
a
as).
b
C (upper case)
ctcom).
f
c++filt).
l
ld).
u
ucomp).
x
If x is a single identifier, name represents the full path
name of the new subprocess. If x is a set of
identifiers, name represents a prefix to which the
standard suffixes are concatenated to construct the
full path names of the new subprocesses.
-Wx,args Command Line Option Syntax |
-Wx,arg1[,arg2,..,argn]
-argoption[,argvalue]
aCC -Wl,-v file.CCompiles
file.C and passes the option -v to the linker.
-t allows you to substitute
subprocesses in place of the defaults.)
aCC file.o -Wl,-a,archive -lmLinks
file.o and passes the option -a archive to the linker,
indicating that the archive version of the math library
(indicated by -lm)
and all other driver supplied libraries
should be used rather than the default shared library.
aCC -Wl,-a,archive,-m,-v file.o -lmLinks
file.o and passes the options -a archive, -m, and -v to
the linker.
This case is similar to the previous example, with additional options.
-m indicates that a load map should be produced.
-v requests verbose messages from the linker.
-W option takes
the form:
-argoption[,argvalue]
where:
a
as).
b
C (either upper or lower case)
ctcom).
d
f
c++filt).
l
ld).
Template Usage:
+inst_all Command Line Option Syntax |
+inst_all
Causes the compiler to instantiate all template functions and all static data members and member functions of template classes defined in a translation unit, regardless of whether or not they are used, and to place these instantiations in the resulting object file.
This option allows existing instantiations in a translation unit to be used by the assigner to satisfy instantiation requests in other translation units.
NOTE: Because +inst_all instantiates all templates, it is essential to have a thorough understanding of your application and its template usage in order to use +inst_all effectively. Otherwise, duplicate symbols may result.
file1.C and places instantiations
in file1.o.
aCC -c +inst_all file1.C
Migration Note: Note that the +inst_all option differs from the HP C++ -pta option which instantiates all members of used template classes and all needed template functions.
+inst_auto Command Line Option Syntax |
+inst_auto
When you link or create a shared library, if there is more than one object file on the command line, the assigner determines which object file is to contain a given instantiation.
To use +inst_auto, you must specify it at both compile-time and when creating an executable or a shared library.
Note the use of the +inst_close option to satisfy all needed template instantiations.
+inst_close Command Line Option Syntax |
+inst_close
Use +inst_close along with the +inst_auto option to specify that automatic instantiation be used to close a set of link units. This option prevents reinstantiation of any already instantiated templates in the .o files or libraries on the command line.
Note that the -c option must be used with +inst_close, otherwise an executable file or (with -b) a shared library is created.
If you want to create a template library that uses templates, unlike a non-template library, you must instantiate the templates before linking the library.
NOTE: If a library is dependent on another template library, that template library must be on the command line when you close the dependent library. If you build an application with the dependent library, the dependee libr