- 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.)
2.0N (Use +DA2.0N to specify 32-bit narrow mode
for the PA-RISC 2.0 architecture.
This is the new name for 2.0 on 64-bit systems.
This is the default on 64-bit systems.)
2.0W (Use +DA2.0W to specify 64-bit wide mode for the PA-RISC 2.0
architecture. This option is specific to the PA-RISC 2.0 architecture.)
When +DA2.0W is specified:
__LP64__ is defined.
/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.
+DOosname Command Line Option Syntax |
+DOosnameosname can be one of the following:
If +DO11.0EP9806 and +Olibcalls are both specified on an HP-UX 11.0EP9806 system, the compiler enables the fusing of libcalls where applicable. This promotes instruction level parallelism in library routines which can improve performance by computing the same function (such as sin) of two values concurrently. This becomes particularly significant in the presense of loop unrolling.
+DO can be used at any level of optimization.
CAUTION: Use of +DO makes the resulting code binary incompatible with earlier versions of HP-UX.
aCC +DO11.0EP9806 +Olibcalls app.CThe following examples generate code for any HP-UX operating system and do not enable the fusing of libcalls:
aCC +DO11.0 +Olibcalls app.C aCC app.C
+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.
+hugesize=n Command Line Option Syntax |
+hugesize=n[M][K]
In order for the compiler to qualify a data object as huge, its size must equal or exceed the current setting of the hugesize threshold. The threshold is initially set to .5 gigabytes (2^29 bytes). A data object whose size equals or exceeds the threshold is allocated in huge data subspace.
The number of elements that can be declared in an array depends on the data type of the array. The following table lists current object size limits in 32-bit (narrow) mode:
| Data Structure | Maximum Number of Elements in an Array of this Type |
|---|---|
| char arrays | 2^28 |
| float and 32-bit integer arrays | (2^28)/4 |
| double and 64-bit integer arrays | (2^28)/8 |
| long double arrays | (2^28)/16 |
| structs/unions | based on element size |
Refer also to Default Data Storage and Alignment
aCC +DA2.0W +hugesize=8 app1.C app2.C
+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.
+[no]objdebug Command Line Option Syntax |
+[no]objdebug
CAUTION: With +objdebug, the object files or archive libraries must not be removed.
+noobjdebug is the default at compile time and is the same as versions of the compiler prior to A.01.15. +objdebug is the default at link time.
If +noobjdebug is used at link time (not the default), all debug information goes into the executable, even if some objects were compiled with +objdebug. This can be used to enforce the debugging paradigm prior to HP aC++ version A.01.15.
If +objdebug is used at compile time, extra debug information is placed into each object file to help the debugger locate the object file and to quickly find global types and constants.
Use +[no]objdebug with the -g, -g0, or -g1 option.
+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.
+W args Command Line Option Syntax |
+W arg1[,arg2,..argn]
aCC +W600 app.C
+We args Command Line Option Syntax |
+We arg1[,arg2,..argn]
aCC +We 600,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)
export BROWSER=AlternateBrowserLocation
To invoke the online guide:
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.
In 64-bit mode, &prefix:/lib/cxxshl.o is not used.
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.
64-bit Mode Only: +Z is the default when +DA2.0W is specified.
In addition, you can use the -Wl,args compiler option to specify any linker option on the compiler command line. For more information on linker options, see the ld(1) man page or the HP-UX Reference Manual.
CAUTION: You must use the aCC command to link your HP aC++ programs and libraries. This ensures that all libraries and other files needed by the linker are available.
-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]extern Command Line Option Syntax |
+O[no]extern
64-bit Mode Only: Use +Onoextern only with the 64-bit runtime model.
NOTE: Use of +Onoextern creates code that cannot be included in a shared library. Use +Onoextern only to build executables.
Only internal symbols (defined in the load module) can be optimized. If +Onoextern is specified, the compiler assumes that no symbols are external to the load module being compiled, and any symbol can be optimized. If +Oextern is specified, the compiler assumes that all symbols are external to the load module being compiled and thus cannot be optimized; this is the default.
Use +O[no]extern at optimization levels 0, 1, 2, 3, or 4.
The default is +Oextern with no name list.
+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.
+Olevel=name1[,name2,...,nameN] Command Line Option Syntax |
+Olevel=name1[,name2,...,nameN]
This option works as does the OPT_LEVEL pragma. The option overrides the pragma for the specified functions. As with the pragma, you can only lower the level of optimization; you cannot raise it above the level specified by a basic +Olevel or -O option. To avoid confusion, it is best to use either this option or the OPT_LEVEL pragma rather than both.
You can use this option at optimization levels 1, 2, 3, and 4. The default is to optimize all functions at the level specified by the basic +Olevel or -O option.
aCC +O3 +O1=myfunc1,myfunc2 funcs.c main.cThe following command optimizes all functions at level 2, except for the functions myfunc1 and myfunc2, which it optimizes at level 0.
aCC -O +O0=myfunc1,myfunc2 funcs.c main.c
+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]multiprocessor Command Line Option Syntax |
+O[no]multiprocessor
Use +O[no]multiprocessor at optimization levels 2, 3, and 4. The default is +Onomultiprocessor.
+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]promote_indirect_calls
+O[no]promote_indirect_calls Command Line Option Syntax |
+O[no]promote_indirect_calls
In all cases the optimized code tests to
make sure the direct call is being taken and if not, executes the indirect
call. If +Oinline is in effect,
the optimizer may also inline the promoted calls.
+Opromote_indirect_calls is only effective with
profile-based optimization.
NOTE: The optimizer tries to determine the most likely target of indirect calls. If the profile data is incomplete or ambiguous, the optimizer may not select the best target. If this happens, your code's performance may decrease.
This option can be used at optimization levels 3 and 4. At +O3, it is only effective if indirect calls from functions within a file are mostly to target functions within the same file. This is because +O3 optimizes only within a file whereas, +O4 optimizes across files.
The default is +Onopromote_indirect_calls.
+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.
+Oreusedir=DirectoryPath Command Line Option Syntax |
+Oreusedir=DirectoryPath
When you compile with +I, +P, or +O4, the compiler generates intermediate code in the object file. Otherwise, the compiler generates regular object code in the object file. When you link, the linker first compiles the intermediate object code to regular object code, then links the object code. With this option you can reduce link time on subsequent links by not recompiling intermediate object files that have already been compiled to regular object code and have not changed.
NOTE: When you do change a source file or command line options and recompile, a new intermediate object file will be created and compiled to regular object code in the specified directory. The previous object file in the directory will not be removed. You should periodically remove this directory or the old object files since the old object files cannot be reused and will not be automatically removed.
Use +Oreusedir=DirectoryPath at optimization
level 4 or with profile-based optimization.
The default is to use TMPDIR and remove the temporary objects after each link.
+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.
+O[no]autopar Command Line Option Syntax |
+O[no]autopar
+Oparallel
option, +Oautopar
causes the compiler to parallelize loops that are safe to parallelize.
When used with +Oparallel, +Onoautopar causes
the compiler not to parallelize any loops.
A loop is safe to parallelize if it has an iteration count that can be determined at runtime before loop invocation; it must contain no loop-carried dependences, procedure calls, or I/O operations. A loop-carried dependence exists when one iteration of a loop assigns a value to an address that is referenced or assigned on another iteration.
+Oautopar is the default for all optimization levels but is useful only at levels 3 and 4.
+O[no]dynsel Command Line Option Syntax |
+O[no]dynsel
+Oparallel,
the +Odynsel option
enables workload-based dynamic selection of parallelizable loops.
+Odynsel causes the compiler to generate either a
parallel or a serial version of the loop.
The loop's workload is compared to parallelization overhead,
and the parallel version is run only if it is profitable to do so.
The +Onodynsel option disables dynamic selection
and tells the compiler that it is profitable
to parallelize all parallelizable loops.
If a loop's iteration count is known at compile time, this optimization is performed at compile time. If a loop's iteration count is not known until runtime, the optimization is performed at runtime.
The default is +Odynsel if +Oparallel is enabled
at optimization level(s) 3 and 4.
+O[no]loop_block Command Line Option Syntax |
+O[no]loop_block
+O[no]loop_block option enables [disables] blocking
of eligible loops for improved cache performance.
The default is +Onoloop_block at optimization level(s) 3 and 4.
+O[no]loop_unroll_jam Command Line Option Syntax |
+O[no]loop_unroll_jam
+O[no]loop_unroll_jam option enables [disables]
loop unrolling and jamming.
Loop unrolling and jamming increase register exploitation.
The default is +Onoloop_unroll_jam
at optimization level(s) 3 and 4.
+O[no]parallel Command Line Option Syntax |
+O[no]parallel
The default is +Onoparallel at optimization level(s) 3 and 4.
NOTE: If you compile one or more files in an application using +Oparallel, the application must be linked (using the aCC compiler driver) with the +Oparallel option in order to link in the proper start-up files and runtime support.
Use the MP_NUMBER_OF_THREADS environment variable, to specify the number of processors used in executing your parallel programs. This variable is read by your program at runtime. If set to a positive integer n, your program executes on n processors. n must be less than or equal to the number of processors on the system where the program is executing.
For introductory examples, see Setting the Number of Threads Used in Parallel and Transforming Loops for Parallel Execution (+Oparallel).
NOTE: +Oparallel disables the +Ofailsafe option.
+O[no]report[=report_type] Command Line Option Syntax |
+O[no]report[=report_type]
This option causes the compiler to display various optimization reports. The value of report_type determines which report is displayed, as described below:
+Oreport=loop produces the Loop Report which gives
information on optimizations performed on loops and calls.
+Oreport (without = report_type) also
produces the Loop Report.
+Oreport=private produces the Loop Report and the
Privatization Table, which provides information on loop
variables that are privatized by the compiler.
+Oreport=all produces all reports.
The +Onoreport option does not accept any of
the report_type values.
The +Oreport[=report_type] option is active only
at optimization levels 3 and above.
The default is +Onoreport.
+O[no]sharedgra Command Line Option Syntax |
+O[no]sharedgra
+Onosharedgra option enables [disables] global register
allocation for shared-memory variables that are visible to multiple
threads. This option may help if a variable shared among
parallel threads is causing wrong answers.
The default is +Osharedgra. This option is available at optimization levels 2 and above.
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 unde