Compiling & Running HP C Programs

NOTE: See the Optimizing HP C Programs section of the HP C Online Help for a more detailed description of HP compiler optimization options.

Compiling HP C Programs
Controlling Code Scheduling
Using Pragmas
Running HP C Programs

Compiling HP C Programs

• Compatibility Mode vs. ANSI C Mode
• The cc(1) Command
• Specifying Files to the cc Command
• Specifying Options to the cc Command
• Concatenating Options
• HP C General Use Compiler Options
• Examples of Compiler Commands
• Environment Variables
• CCOPTS Environment Variable
• TMPDIR Environment Variable

• Preprocessor: This phase examines all lines beginning with a # and performs the corresponding actions and macro replacements.
• Compilation Process: This phase takes the output of the preprocessor and generates object code.
• Optimization: This optional phase optimizes the generated object code.
• Linking: In this phase, the linker is invoked to produce an executable program. External references in shared and archived libraries are resolved as required. The startup routines in /opt/langtools/lib/crt0.o are copied in, and the C library in /lib/libc.sl or /lib/libc.a is referenced. (By default, shared libraries take precedence over archived libraries if both versions are available. However, if you use the LPATH environment variable, you should make sure that all shared libraries come before any archive library directories. See the HP-UX Linker and Libraries Online User Guide for information on LPATH or on creating and linking with shared libraries.) Object modules are combined into an executable program file.
• If you are referencing 64-bit binaries on the compile-line you must specify the +DD64 option, or the compiler will pass the 32-bit crt0.o to the linker, producing a Mismatched ABI error message from the linker.

Compatibility Mode vs. ANSI C Mode

The cc(1) Command

cc [options] files

where:

• options is one or more compiler options and their arguments, if any. Options can be grouped together under one minus sign.
• files is one or more file names, separated by blanks. Each file is either a source or an object file.

Specifying Files to the cc Command

Files with names ending in .i are assumed to be preprocessor output files (see the -P compiler option in Table 5: HP C Compiler Option Details in This section). Files ending in .i are processed the same as .c files, except that the preprocessor is not run on the .i file before the file is compiled.

Files with names ending in .s are assumed to be assembly source files; the compiler invokes the assembler to produce .o files from these.

Files with .o extensions are assumed to be relocatable object files that are included in the linking. All other files are passed directly to the linker by the compiler.

Specifying Options to the cc Command

     -optionname [optionarg]

• optionname is the name of a standard compiler option.
• optionarg is the argument to optionname.

An Example of Using a Compiler Option

cc demo.c

You can use the -o option to override the default name of the executable file produced by cc. For example, suppose my_source.c contains C source code and you want to create an executable file name my_executable. Then you would use the following command line:

cc -o my_executable my_source.c

Concatenating Options

For example, suppose you want to compile my_file.c using the -v, -g, and -DPROG=sub compiler options. There are several ways to do this:

cc my_file.c -v -g -DPROG=sub
cc my_file.c -vg -D PROG=sub

cc my_file.c -vgDPROG=sub
cc -vgDPROG=sub my_file.c

Table 7: HP C Compiler Option Details describes in detail the options that HP C workstations and servers support.

Table 7: HP C Compiler Option Details

Option	What It Does
-Aa	Requests a compilation in ANSI C mode, based on the ANSI programming language C standard ISO 9899:1990. ANSI C specifies which names are available in the standard libraries and headers, which are reserved for the implementation, and which must be left available for your use. HP C in ANSI mode conforms to these restrictions. Only names permitted by ANSI C are defined or declared in the standard libraries and headers. Macro definitions can be used to access names that are normally defined in other standards (POSIX and XOPEN, for example), and in HP C Version 3.1 compatibility mode. To gain access to all variables and functions defined by POSIX, include the following line at the start of your source file before including any system headers:  #define _POSIX_SOURCE or define this macro by using the -D name option:  cc -D _POSIX_SOURCE  myfile.c To gain access to all the names defined by XOPEN, include the following line at the start of your source file before including any system headers:  #define _XOPEN_SOURCE or define the macro on the command line:  cc -D _XOPEN_SOURCE myfile.c To gain access to all the names normally available in compatibility mode, include the following line at the start of your source file before including any system headers:  #define _HPUX_SOURCE or define the macro on the command line:  cc -D _HPUX_SOURCE myfile.c _HPUX_SOURCE defines a superset of names defined by _XOPEN_SOURCE. _XOPEN_SOURCE defines a superset of names defined by _POSIX_SOURCE.
-Ac	Requests compatibility with version 3.1. This was the default at the HP-UX 10.20 operating system release. It is a non-ANSI implementation.
-Ae	Requests a compilation in ANSI C mode with HP C extensions. This option is the same as specifying -Aa, -D_HPUX_SOURCE, and +e.
-b	Cause the linker ld(1) to create a shared library rather than a normal executable file. Object files processed with this option must contain position independent code (PIC). -b has no effect on the -E, -P, and -S options.
-B options	The following new -B options are recognized by HP C to specify whether references to global symbols may be resolved to symbols defined in the current translation unit, or whether they must by assumed to be resolved to symbols defined in another load module. All -B options are applied in a 'left to right' order so that options at the end of a string may supercede those that appear earlier in the string. -Bdefault=symbol[,symbol...] - The named symbols are assigned the default export class. These symbols may be imported or exported outside of the current load module. The compiler will access tentative symbols through the linkage table. Any symbol that is not assigned to another export class through use of another -B option (or the deprecated +O[no]extern option) will be assigned the default export class. The -Bdefault option may also may also be used on a per-symbol basis to specify exceptions to global -Bprotected, -Bhidden, or -Bextern options. -Bdefault:filename - The file indicated by filename contains a list of symbols, separated by spaces or newlines. These symbols are assigned the default export class. -Bextern:filename - Perform the same operation as -Bdefault:filename but fetch the symbols from a text file in a separate load module. Symbols referenced in the text file must be separated by white space within the file. -Bextern[=symbol[,symbol...]*]* - Perform the same operation as -Bdefault[=symbol[,symbol...]]. Specifying symbols with this option will cause the compiler to mark that symbol with the default export class, and to avoid compile-time binding. NOTE: When specifying a symbol list or file, all symbols are affected. Specifying no list or file affects only undefined symbols. -Bhidden[=symbol[,symbol...]*] - The named symbols, or all symbols if no symbols are specified, are assigned the hidden export class. The hidden export class is similar to the protected export class. These symbols will not be pre-empted by symbols from other load modules. The compiler may bypass the linkage table for both code and data references and bind them to locally defined code and data symbols. In addition, hidden symbols will not be exported outside the current load module. The linker may eliminate them from a shared library, but in an executable, they remain accessible to the debugger unless +Oprocelim is also specified. NOTE: Specifying -Bhidden with no symbol list implies the usage of the -W1, -aarchive_shared options. This causes the linker to prefer an archive library to a shared library if one is available. This can be overriden on the command line by using a a subsequent -W1, -a option. -Bhidden:filename - The file indicated by filename contains a list of symbols, separated by spaces or newlines. These symbols are assigned the hidden export class. -Bprotected[=symbol[,symbol...]*] - The named symbols, or all symbols if no symbols are specified, are assigned the protected export class. That means these symbols will not be pre-empted by symbols from other load modules. The compiler may bypass the linkage table for both code and data references and bind them to locally defined code and data symbols. NOTE: Specifying -Bprotected with no symbol list implies the usage of the -W1, -aarchive_shared options. This causes the linker to prefer an archive library to a shared library if one is available. This can be overriden on the command line by using a a subsequent -W1, -a option. -Bprotected:filename - The file indicated by filename contains a list of symbols, separated by spaces or newlines. These symbols are assigned the protected export class. -Bprotected_data - Same as -Bprotected, but only data symbols are marked as having a protected export class. -Bprotected_def - Same as -Bprotected, but only locally defined (nontentative) symbols are assigned the protected export class. -Bsymbolic - All symbols are assigned the protected export class. Equivalent to -Bprotected with no symbol list.
-c	Compile one or more source files but do not link. The compiler produces the object file (a file ending with .o by default) for each source file (a file ending with .c, .s, or .i). Object files must be linked before they can be executed. Overrides the -r and -b options. Is overridden by the -E, -P, and -S options.
-C	Prevent the preprocessor from stripping comments. See the description of cpp(1) in the HP-UX Reference Manual or the cpp(1) manpage for details.
-Dname -Dname=def	Define name to the preprocessor cpp as if defined by the preprocessing directive #define. If =def is not given, name is "1". Macros should be assigned integer values when they will be used in constant expressions that are to be evaluated by the conditional compilation directives #if and #else. See Conditional Compilation (#if, #ifdef,..#endif) for more information.
-dynamic	Produce dynamically-bound executables. These support shared libraries and use the features of the dynamic loader. Theshl_load and dlopen APIs are fully supported. The linker links in shared libraries first and then archive libraries. See -minshared for instructions on how to produce statically-bound executables. HP C's default behavior is -dynamic.
-E	Run only cpp on the named C or assembly files, and send the result, including the full path name of the include, to the standard output. Overrides the -b, -c, -o, -r, and -S options.
-eepsym	Set the default entry point address for the output file to be that of the symbol epsym. This option only applies to executable files. It does not work if epsym=xec.
-exec	Indicate that any object files created will be used to create an executable file. Constants with a protected or hidden export class are placed in the read-only data section. This option also implies -Bprotected_def.
-fast	The -fast compiler option expands into an existing set of compiler options which, used together, result in optimum speed and application run-times. This option is also provided for compatibility in porting other C compiler applications to HP-UX. -fast expands to the following HP C/ANSI C options: +O2 +Olibcalls +Onolimit +Ofltacc=relaxed +FPD +DSnative +Oshortdata NOTE: Do not use this option for programs that depend on IEEE standard floating-point denormalized numbers. Otherwise, different numerical results may occur. +O2 optimizations include all +O1 optimizations as well as global optimizations. This is the compiler optimization default. +Olibcalls increases the runtime performance of code which calls the standard library routines. +Onolimit removes optimization time restrictions at +O2 and above. This lets you perform full optimization of large procedures, but may incur significant compile time increases for very large procedures. +Ofltacc=relaxed enables the most aggressive floating-point optimizations. +FPD enables a fast underflow mode where denormalized floating-point operands are flushed to zero. +DSnative allows you to schedule code in the fastest manner possible for your system's Itanium implementation. +Oshortdata controls the size of objects placed in the short data area. All objects of size n=bytes will be placed in the short data area. Valid values of n are 0, or a decimal number between 8 and 4,191,304 bytes (4MB).
-fpeval=[float|double|extended]	Specify the minimum precision to use for floating point expression evaluation. Does not affect the precision of parameters, return types, or assignments, and does not impact the floating point constant type or floating point expression type. Values for -fpeval include: float - Evaluates floating point expressions and constants in their semantic type. This is the default when used with -Aa or -Ae. double - Evaluates float operations and constants using the range and precision of double, and evaluates all other floating point expressions and constants in their semantic type. extended - Utilizes hardware support of these floating point registers for optimum speed in floating point computations. Evaluates float and double constants and expressions using the range and precision of the extended type, and evaluates all other floating point expressions in their semantic type. This option, while providing greater precision than double, does not provide greater speed than double or float.
-[no]fpwidetypes	Enable extended and quad floating point data types. quad is a synonym for longdouble. Without this option, the user still has the longdouble type and all of the functions for longdouble. The default is -nofpwidetypes.
-g	Inserts information for the symbolic debugger in the object file. In conjunction with the HP Distributed Debugging Environment (DDE), the C compiler now provides support for debugging optimized code. This support includes:  Tracebacks with line-number annotation Setting breakpoints and single-stepping at the source statement level Mapping between source statements and machine instructions Viewing and modifying global variables at procedure call boundaries Viewing and modifying parameters on procedure entry To enable debugging of optimized code, specify the -g compile-line option together with the -0, +01, or +02 option. Currently, debugging is supported at optimization levels 2 and below. If you try to use -g with the +03 or +04 option, the compiler will issue a warning stating that the options are incompatible, and will ignore the -g option.
-G	Prepares the object file for profiling with gprof. See the gprof(1) description in the HP-UX Reference Manual for details.
-Idir	Adds dir to the list of directories that are searched for include files by the preprocessor. For include files that are enclosed in double quotes and do not begin with a /, the preprocessor first searches the current directory, then the directory named in the -I option, and finally, the standard include directory /usr/include. For include files that are enclosed in < and > symbols, the search path begins with the directory named in the -I option and is completed in the standard include directory, /usr/include. The current directory is not searched.
-lx	Cause the linker to search the libraries /usr/lib/libx.a or /usr/lib/libx.sl (searched first) and /opt/langtools/lib/libx.a or /opt/langtools/lib/libx.sl (searched second). The -a linker option determines whether the archive (.a) or shared (.sl) version of a library is searched. The linker searches the shared version of a library by default. Libraries are searched when their names are encountered. Therefore 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. See the description of ld(1) in the HP-UX Reference Manual for details.
-Ldir	Cause the linker to search for libraries in the directory dir before using the default search path. The default search path is the directory /usr/lib followed by /opt/langtools/lib. -Ldir must precede -lx on the command line; otherwise -Ldir is ignored. This option is passed directly to the linker. For example:  cc -L/project/libs prog.c -lfoo -lbar Compiles and links prog.c and directs the linker to search the directories /project/libs, /usr/lib, then /opt/langtools/lib for libfoo.a, libfoo.sl, libbar.a, and libbar.sl libraries.
-minshared	Indicates that the result of the current compilation is going into an executable file that will make minimal use of shared libraries. Equivalent to -exec and -Bprotected.
-n	Cause the program file produced by the linker to be marked as shareable. For details and system defaults see the description of ld(1) in the HP-UX Reference Manual.
-N	Cause the program file produced by the linker to be marked as unshareable. For details and system defaults see the ld(1) description in the HP-UX Reference Manual.
-ooutfile	Cause the output of the compilation sequence to be placed in outfile. The default name is a.out. When compiling a single source file with the -c option, you can also use the -o option to specify the name and location of the object file.
-O	Invoke the optimizer to perform level 2 optimization. Other optimization levels can be set. Refer to a summary of major HP C optimization options for details on HP C optimization levels.
-P	Only perform preprocessing. Runs the preprocessor with the -P option only on the named HP C source files and leaves the result in the corresponding files with .i as the suffix.
-q	Cause the output file from the linker to be marked as demand loadable. For details and system defaults, see the ld(1) description in the HP-UX Reference Manual.
-Q	Cause the program file created by the linker to be marked as not demand loadable. For details and system defaults, see the ld(1) description in the HP-UX Reference Manual.
-s	Strip the executable. Causes the program file created by the linker to be stripped of symbol table information. Specifying this option prevents using a symbolic debugger on the resulting program. See the ld(1) description in the HP-UX Reference Manual for more details.
-S	Compile the named HP C program and leave the assembly language output in a corresponding file with .s as the suffix. Overrides the -c, -r, and -b options. Is overridden by the -E and -Poptions.
-t x,name	Substitute or inserts subprocess x with name, where x is one or more of a set of identifiers indicating the subprocesses. This option works in two modes: 1) if x is a single identifier, name represents the full pathname of the new subprocess; 2) if x is a set of identifiers, name represents a prefix to which the standard suffixes are concatenated to construct the full pathnames of the new subprocesses. x can be one or more of the following values:  p-Preprocessor (standard suffix is cpp). c-Compiler (standard suffix is ccom). 0-Same as c. a-Assembler (standard suffix is as). l-Linker (standard suffix is ldr).
-Uname	Undefines or removes any initial definition of name in the preprocessor. See the cpp(1) description in the HP-UX Reference Manual for details.
-usymbol	Enter symbol as an undefined symbol in ld's symbol table. The resulting unresolved reference is useful for linking a program solely from object files in a library. More than one symbol can be specified, but each must be preceded by -u.
-v	Enables the verbose mode sending a step-by-step description of the compilation process to standard error (stderr.)
-V	Prints version information on each invoked subprocess to standard error (stderr.)
-w	Suppresses warning messages.
-Wx, arg1 [,arg2,..,argn]	Passes the arguments arg1 through argn to the subprocess x.
-Wd,-a	When processing files which have been written in assembly language, does not assemble with the prefix file which sets up the space and subspace structure required by the linker.
-Wx,arglist	Pass the comma-separated argument[s] in arglist to subprocess x.
-W c,-e or +e	Enables the following HP value added features while compiling in ANSI C mode: sized enum, long long, long pointers, compiler supplied defaults for missing arguments to intrinsic calls, and $ in identifier HP C extensions.
-W c,-L or +L	Enable any #pragma listing directives and the listing facility. A straight listing prints the following:  A banner on the top of each page. Line numbers. The nesting level of each statement or declaration. The postprocessed source file with expanded macros, include files, and no user comments (unless the -C option is used). Under ANSI mode, -Wc,-L causes the compiler to generate an output list of the source without the cpp macro replacements. The -Wc,-Lp option causes the compiler to generate an output list of the source with the cpp macro replacements.
-W c,-m	Cause the identifier maps to be printed. First, all global identifiers are listed, then all the other identifiers are listed by function at the end of the listing. For struct and union members, the address column contains B@b, where B is the byte offset and b is the bit offset. Both B and b are in hexadecimal.
-W c,-o	Cause the code offsets to be printed in hexadecimal grouped by function at the end of the listing.
-W c,or -Rnum	Allow only the first num register variables to actually have the register class. Use this option when the register allocator issues an out of general registers message.
-W c,-wn or +wn	Specify the level of the warnings messages. The value of n can be one of the following: 1-All warnings are issued. This includes low level warnings that may not indicate anything wrong with the program. 2-Only warnings indicating that code generation might be affected are issued. This is equivalent to the compiler default without the -w options. 3-No warnings are issued. This is equivalent to the -w option.
-W d,-a	When processing files written in assembly language, this option specifies that the compiler should not assemble with the prefix file that sets up the space and subspace structure required by the linker. Programs assembled with this option may not link unless they contain the equivalent information. You can then optimize the program based on this profile data by re-linking with the +P command line option. The +I command line option is incompatible with the -g, -s, and -S options. The +I option does not affect the default optimization level or the optimization level specified by the -O or +O options.
-Y	Enable Native Language Support (NLS) of 8-bit and 16-bit characters in comments, string literals, and character constants. See hpnls(5), long(5), and environ(5) in the HP-UX Reference Manual for a description of the NLS model. The language value is used to initialize the correct tables for interpreting comments, string literals, and character constants. It is also used to build the pathname to the proper message catalog.
-z	Disallow run-time dereferencing of null pointers. Fatal errors result if null pointers are dereferenced.
-Z	Allow dereferencing of null pointers at run-time. This is the default. The value of a dereferenced null pointer is zero.
+DDdata_model	Generate 32-bit or 64-code. 32 - Use the ILP32 data model. The sizes of the int, long and pointer data types are 32-bits. 64 - Use the LP64 data model. The size of the int data type is 32-bits, and the sizes of the long and pointer data types are 64-bits. Defines __LP64__ and __LP64 to the preprocessor. The default is +DD32.
+dfname	Specify the path name of the profile database to use with profile-based optimization. This option can be used with the +P command line option. 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.
+DSmodel	Use the code instruction scheduler tuned to the IPF specified model. The defined values for model are shown below. For this release of HP C the default is blended. blended - Tune for best performance on a combination of processors (i.e., Itanium or McKinley processors). itanium - Tune for best performance on an Itanium processor. This is the only valid option for HP-UX 11i v1.5. mckinley - Tune for best performance on a McKinley processor. native - Tune for best performance on the processor on which the compiler is running.
+e	Enable HP value-added features while compiling in ANSI C mode, -Aa. This option is ignored with -Ac and -Ae because these features are already provided. Features enabled include: Integral type specifiers can appear in enum declarations. The $ character can appear in identifier names. Missing parameters on intrinsic calls
+f	Inhibit the automatic promotion of float to double when evaluating expressions. This differs from the +r option in that both parameters and function return values are still promoted to double. In ANSI mode, this option is ignored and a warning is issued.
+FP flags	Specify what floating-point traps to enable and also enables or disables fast underflow mode. flags is a series of upper case or lower case letters from the set [VvZzOoUuIiDd] with no spaces, tabs, or other characters between them. If the upper-case letter is selected, that behavior is enabled. If the lower-case letter is selected or if the letter is not present in the flags, the behavior is disabled. By default, all traps are disabled. The values for flags are: V enables traps on invalid floating-point operations. v disables traps on invalid floating-point operations. Z enables traps on divide by zero. (If your program must conform to the POSIX standard, do not enable this trap.) z disables traps on divide by zero. O enables traps on floating-point overflow. o disables traps on floating-point overflow. U enables traps on floating-point underflow. u disables traps on floating-point underflow. I enables traps on floating-point operations that produce inexact results. i disables traps on floating-point operations that produce inexact results. D enables fast underflow (flush to zero) of denormalized values. d disables fast underflow (flush to zero) of denormalized values. To dynamically change these settings at run time, refer to fpgetround(3M).
+help	Launch a web browser displaying an html version of the HP C/HP-UX online help, and then processes any other arguments.
+I	Instruct the compiler to instrument the object code for collecting run-time profile data. The profiling information can then be used by the linker to perform profile-based optimization. Code generation and optimization phases are delayed until link time by this option. After compiling and linking with +I, run the resultant program using representative input data to collect execution profile data. 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. Note that this option is incompatible with the -G, +P, and -S options. It is incompatible with the -g option only during runtime.
+ild	Specify incremental linking. If the output file does not exist, or if it was created without the +ild option, the linker performs an initial incremental link. The output file produced is suitable for subsequent incremental links. The incremental link option is valid for both executable and shared library links. It is not valid for relocatable links, options (or tools) that strip the output module, and certain optimization options. See the ld(1) manpage for more information.
+ildrelink	Perform an initial incremental link, regardless of the output load module. In certain situations during incremental linking (for example, internal padding space is exhausted), the incremental linker is forced to perform an initial incremental link. The +ildrelink option allows you to avoid such unexpected initial incremental links by periodically rebuilding the output file.
+L	See -W c,-L
+M0	Cause migration warnings to be emitted. Defined values for level are: 0 (Default) - ANSI migration warnings. These warnings alert the programmer to the so- called Quiet Changes between the K&R behavior ( -Ac) and the ANSI behavior ( -Aa). For details on the Quiet Changes, refer to the Rationale Document which is available with the ANSI Programming Language C Standard ISO 9899:1990. 1 - Platform migration warning when migrating from a PA processer application to an IPF processer application. 2 - Data model migration warnings. These warnings alert the programmer to code that may work differently in the LP64 data model than in the ILP32 data model.
+[no]objdebug	This option, when used with any of the -g options, will cause the debug information to be left in the object files instead of being placed in the a.out. Available only for wdb(1) or gdb(1). +objdebug is the default. +noobjdebug can be used at link time to place the debug info into the a.out, even if some objects were compiled with +objdebug. NOTE: Object files and archive libraries must be accessible to the debugger if the +objdebug method of storing debug information is used. .
+Oopt	Invokes the level of optimization selected by opt. opt can have any of the following values.  These can be preceded by either +O or -O . Defined values for level are: 0 - Perform no optimizations. 1 - Perform optimizations within basic blocks only. 2 - Perform level 1 and global optimizations. Same as -O and +O. 3 - Perform level 2 as well as interprocedural global optimizations. 4 - Perform level 3 as well as doing link time optimizations. NOTE: +Oprocelim is the general default at all levels, unless the users says +ild +ildrelink or -b. NOTE: +O4 is only supported with +P. Otherwise, attempts to activate +O4 will cause the compiler to automatically drop to +O3.
+opts filename	Process options contained in the file as if they were specified on the command line at the point of the +opts option.
+P	Use profile information to guide code generation and profile-based optimization. This option causes the compiler to generate intermediate compiler code instead of compiled object code. The application is optimized based on profile data found in the database file flow.data, produced by compilation with +I. +P is equivalent to +Oprofile=use or +Oprofile=use:filename. The actual code generation is done at link time. This option does not affect the default optimization level, or the optimization level specified by the -O or +Oopt 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 command line option is incompatible with the +I, -g, -s, and -S options. Also refer to the +I, and +df command line options.
+r	Inhibit the automatic promotion of float to double when evaluating expressions and passing arguments. This option is ignored and a warning produced if the ANSI mode is in effect (see also +f).
+[no]srcpos	Control the generation of source position information for the Caliper and CXperf performance analysis tools. When +srcpos is in effect (the default), the compiler generates this information. When +nosrcpos is in effect, the compiler does not generate this information, and the compiler will instruct the linker to discard any of this information encountered in object files.
+uc	Make unqualified char data types unsigned. By default, the HP C compiler converts all unqualified char data types to signed. Use this option to help port applications from other C compilers, where the default behavior for unqualified char types is unsigned. Be careful when using this option. Your application may have problems interfacing with HP-UX system libraries and other libraries that do not use this option.
+wn	Specifies the level of the warnings messages. The value of n can be one of the following: 1-All warnings are issued. This includes low level warnings that may not indicate anything wrong with the program. 2-Only warnings indicating that code generation might be affected are issued. This is equivalent to the compiler default without the -w options. 3-No warnings are issued. This is equivalent to the -w option. This option is the same as -W c,-wn.
+W n1[,n2[,...nN]]	Suppresses the specified warnings, where n1 through nN are valid compiler warning message numbers. See the file /opt/ansic/lib/nls/msg/C/cc.msgs for a list of error and warning messages.
+We arg1[,arg2,...argn]	Selectively interpret any specified warning or future error messages as errors. arg1 through argn are valid compiler message numbers.
+Ww arg1[,arg2,...argn]	Selectively treats compiler warnings as warning. arg1 through argn are valid compiler message numbers. Conflicts between +W, +Ww and +We are resolved based on their severity. +We is the highest and +W is the lowest.

NOTE: Any option not described above will generate a warning to standard error (stderr.) (Options not recognized by cc are not passed on to ld. Use the -Wl,arg option to pass options to ld.).

Examples of Compiler Commands

• cc -Aa prog.c requests a strict ANSI C compilation of prog.c.
• cc -tp,/users/devel/cpp prog.c uses /users/devel/cpp as the pathname for the preprocessing phase.
• cc -tpca,/users/devel/x prog.s uses /users/devel/x/cpp for cpp, /users/devel/x/ccom for ccom, and /users/devel/x/as for as; the assembly file prog.s is processed by the specified assembler.
• cc -Aa prog.c procedure.o -o prog compiles and links the file prog.c, creating the executable program file prog. The compiler produces prog.o. The linker ld(1) links prog.o and procedure.o with all of the HP C startup routines in /lib/crt0.o and the library routines from the HP C library /lib/libc.a.
• cc prog.c -co /users/my/prog.o compiles the source file prog.c and places the object file prog.o in /users/my/prog.o. cc -Wp,-H150000 p1.c p2.c p3.c -o p compiles the source files in the option -H150000 to the preprocessor cpp to increase the define table size from the default.
• cc -Wl,-vt *.c -o vmh compiles all files in the working directory ending with .c, passes the -vt option to the linker, and causes the resulting program file to be named vmh.
• cc -vg prog.c compiles prog.c, adds debug information, and displays the steps in the compilation process.
• cc -S prog.c compiles the file prog.c into an assembly output file called prog.s.
• cc -Wc,-R15 prog.c compiles prog.c placing no more than the first fifteen declared register variables in each function into registers.
• cc -Wc,-L,-m,-o prog.c compiles prog.c and produces a source listing, local and global identifier maps, and local code offsets on the standard output device.
• cc -OAa prog.c compiles prog.c in ANSI mode and requests level 2 optimization.
• cc +O1 prog.c compiles prog.c and requests level 1 optimization.
• cc +w1 prog.c -c compiles prog.c with low-level warnings emitted and suppresses linking.
• cc -D BUFFER_SIZE=1024 prog.c passes the option -D BUFFER_SIZE=1024 to the preprocessor, setting the value of the macro for the compilation of prog.c.
• cc -lm prog.c compiles prog.c requests the linker to link the library /lib/libm.a with the object file prog.o to create the executable a.out.
• cc -L/users/devel/lib -lme prog.c compiles prog.c and causes the linker to search the directory /users/devel/lib for the library libme.a, before searching in /lib or /usr/lib for it.

Environment Variables

• CCOPTS
• TMPDIR

CCOPTS Environment Variable

The syntax for the CCOPTS environment variable in C shell notation is:

setenv CCOPTS [options]
[ | [options]]

Options that appear after the vertical bar in the CCOPTS variable override and take precedence over options supplied on the cc command line.

If the vertical bar is omitted, the compiler gets the value of CCOPTS and places its contents before any arguments on the command line.

For example, the following in C shell notation

setenv CCOPTS -v
cc -g prog.c

cc -v -g prog.c

setenv CCOPTS "-v | +O1"
cc +O2 prog.c

cc -v +O2 prog.c +O1

TMPDIR Environment Variable

setenv TMPDIR altdir

where altdir is the name of the alternative directory for temporary files.

Controlling Code Scheduling

For example, you can schedule code to run best on each of these implementations by using either +DSitanium or +DSmckinley, respectively. However, users may also want to optimize their code once, and have it run reasonably well on both implementations. The default setting, +DSblended, attempts to do this.

In particular, code is scheduled such that floating point code is biased to run best on Itanium, with only moderate degradations on McKinley, and integer (or non-floating point) code is biased to run somewhat better on McKinley. For example, +DSblended will schedule for the longer floating-point latencies from Itanium, since this will minimize the stalls incurred on Itanium. Since floating-point code is often contained within loops which can be "modulo-scheduled", these longer latencies can be tolerated on McKinley, with reasonably small degradations due to additional stages in the modulo-scheduled loops.

To schedule code in the fastest manner possible for your system's IPF implementation, use +DSnative.

As new implementations of IPF are released, additional targets will be added, and the schedule resulting from +DSblended will change.

Using HP C Pragmas

• C99 Standard Pragmas
• STDC CX_LIMITED_RANGE
• STDC FP_CONTRACT
• STDC FENV_ACCESS
• Copyright Notice and Identification Pragmas
• COPYRIGHT Pragma
• COPYRIGHT_DATEPragma
• LOCALITY Pragma
• LOCALITY_ALL Pragma
• VERSIONID Pragma
• Data Alignment Pragmas
• HP_ALIGN Pragma
• Data Alignment Stack
• Alignment Modes
• Accessing Data with the HP_ALIGN Pragma
• PACK Pragma
• FastCall Pragmas
• HP_DEFINED_EXTERNAL Pragma
• Initialization and Termination Pragmas
• INIT Pragma
• FINI Pragma
• The Linker +I Option
• Listing Pragmas
• AUTOPAGE Pragma
• LINES Pragma
• LIST Pragma
• PAGE Pragma
• SIGNAL Pragma
• SUBTITLE Pragma
• TITLE Pragma
• WIDTH Pragma
• Optimization Pragmas
• FLOAT_TRAPS_ON Pragma
• If_Convert Pragma
• no_inline Pragma
• [NO]INLINE_CALL Pragma
• OPT_LEVEL
• OPTIMIZE
• Unroll_Factor Pragma
• Profile-Based Optimization (PBO) Pragmas
• ESTIMATED_FREQUENCY Pragma
• FREQUENTLY_CALLED Pragma
• RARELY_CALLED Pragma
• Symbol Binding Pragmas
• DEFAULT_BINDING Pragma
• EXTERN Pragma
• HIDDEN Pragma
• PROTECTED Pragma

Introduction

This section introduces the following groups of HP C compiler pragmas:

• C99 standard pragmas
• copyright notice and identification pragmas
• data alignment pragmas
• fast libcall pragmas
• initialization and termination pragmas
• (program) listing pragmas
• optimization pragmas

C99 Standard Pragmas

STDC CX_LIMITED_RANGE

#pragma STDC CX_LIMITED_RANGE on-off-switch

Toggling the switch on results in faster complex arithmatic sequences, for example.

The default is off.

STDC CX_LIMITED can occur:

• outside an external declaration (STDC CX_LIMITED takes effect from its occurrence until another STDC CX_LIMITED pragma is encountered, or until the end of the translation unit.)
• inside a compound statement (STDC CX_LIMITED takes effect from its occurrence until another STDC CX_LIMITED pragma is encountered, including within a nested compound statement.)

If this pragma is used in any other context, it's behavior is undefined.

STDC FP_CONTRACT

#pragma STDC FP_CONTRACT on-off-switch

By default the only optimizations allowed that change values are floating-point multiply add (fma) instructions. While these instructions may change the resulting value over a two-instruction multiply add sequence, the resulting value is actually more accurate, since it has not been subject to an intermediate rounding.

On IPF systems, the benefit from forming these contractions can be significant. Contractions can be enabled and disabled in different blocks of code using the STDC FP_CONTRACT pragma. The default (either ON or OFF is defined by how this pragma is implemented:

• Outside external declarations (STDC FP_CONTRACT takes affect until another STDC FP_CONTRACT pragma is encountered)
• Preciding all explicit declarations
• Within a compound statement (FP_CONTRACT takes effect from its occurrence until another STDC FP_CONTRACT pragma is encountered, or until the end of the compound statement.)

If STDC FP_CONTRACT is used in any other context, it's behavior is undefined.

STDC FENV_ACCESS

#pragma STDC FENV_ACCESS on-off-switch

Using the STDC FENV_ACCESS pragma prevents dead code elimination of instructions which may raise exceptions; result in longer floating-point-to-integer conversion sequences which explicitely check for out-of-range results; and result in longer floating-point division sequences.

STDC FENV_ACCESS can occur:

• outside external declarations (STDC FENV_ACCESS takes effect from its occurrence until another STDC FENV_ACCESS pragma is encountered, or until the end of the translation unit.)
• preceding all explicit declarations and statements inside a compound statement (STDC FENV_ACCESS takes effect from its occurrence until another STDC FENV_ACCESS pragma is encountered, including within a nested compound statement).

If STDC FENV_ACCESS is used in any other context, it's behavior is undefined.

Copyright Notice and Identification Pragmas

#pragma COPYRIGHT string

(C) Copyright Acme Software, 2000. All rights reserved. No part
of this program may be photocopied, reproduced, or transmitted
without prior written consent of Acme Software.

#pragma COPYRIGHT_DATE string

#pragma LOCALITY string

Code that is not headed by a LOCALITY pragma is associated with the name $CODE$. An empty string causes the code name to revert to the default name of $CODE$.

LOCALITY_ALL Pragma

#pragma LOCALITY_ALL string

The LOCALITY_ALL pragma specifies a name to be associated with the linker procedures and global variables that should be grouped together at program binding or load time. These are written to a relocatable object module. All procedures and global variables following the LOCALITY_ALL pragma are associated with the name specified in string.

VERSIONID Pragma

#pragma VERSIONID string

HP_ALIGN Pragma

#pragma HP_ALIGN align_mode [PUSH]
 
#pragma HP_ALIGN POP

The HP_ALIGN pragma must have a global scope (outside of any function, enclosing structure, or union).

#pragma HP_ALIGN POP

#pragma HP_ALIGN align_mode PUSH

#pragma HP_ALIGN HPUX_WORD

#pragma HP_ALIGN HPUX_NATURAL_S500

#pragma HP_ALIGN HPUX_NATURAL

#pragma HP_ALIGN NATURAL

#pragma HP_ALIGN DOMAIN_NATURAL

#pragma HP_ALIGN DOMAIN_WORD

#pragma HP_ALIGN NOPADDING

References to non-natively aligned data often results in poorer run-time performance than references to natively aligned data. Natively aligned data is often accessed with a single load or store instruction. Non-natively aligned data must be accessed with one or more load and store instructions.

The HP_ALIGN pragma differs from the +ubytes compiler option. When you use the HP_ALIGN pragma, the compiler localizes inefficient code generation to accesses of data declared with structures or unions under the HP_ALIGN pragma. The +ubytes option assumes that all references to pointer objects are misaligned and performs worst case code generation for all loads and stores of dereferenced data.

The HP_ALIGN pragma offers better run-time performance than the +unumber option. However, the HP_ALIGN pragma requires careful pointer assignment and dereferencing. The following example shows how the pragma is often misused, and what can be done to correct the mistake.

#pragma HP_ALIGN HPUX_WORD
 
struct {
   char chardata;
   int intdata;
} stvar;
 
 
 
main()
{
   int *localptr;
   int localint;
   localptr = &stvar.intdata;
   localint = *localptr;   /* invalid dereference */
}

The error occurs after the address of stvar.intdata is assigned to localptr. localptr is not affected by the HP_ALIGN HPUX_WORD pragma. When localptr is used to access the data, it is treated as a pointer to four-byte aligned data rather than as a pointer to two-byte aligned data and a run-time error can occur.

Two solutions help to work around this problem. First, the recommended solution is to access non-natively aligned data through structures or unions that are declared under the HP_ALIGN pragma.

For example, the above program can be transformed to:

#pragma HP_ALIGN HPUX_WORD
 
struct {
    char chardata;
    int intdata;
} stvar;   /* stvar is declared under the HP_ALIGN pragma */
 
 
 
main()
{
   int *localptr;
   int localint;
   localint = stvar.intdata; /* Valid access of non-naturally */
                             /* aligned data through a struct */
}

For complete details about the +ubytes option, see Table 6: HP C Compiler Option Details .

PACK Pragma

#pragma PACK n

The PACK pragma is not intended to be an "extension" of the HP_ALIGN pragma. It is, instead, a simple and highly portable way of controlling the alignment of aggregates. It has some significant differences with the HP_ALIGN pragma, including uniform bitfield alignment, uniform struct and union alignment, and the lack of PUSH and POP functionality.

FastCall Pragmas

#pragma HP_DEFINED_EXTERNAL sym1, sym2, ...

#pragma INIT string

For example:

#pragma INIT "my_init"void my_init() { ... do some initializations ... }

FINI Pragma

#pragma FINI string

For example:

#pragma FINI "my_fini"void my_fini() { ... do some clean up ... }

The function returns nothing but takes two arguments. The first is a handle to the shared library being initialized. This handle can be used in calling shl_load API routines. The second is set to non-zero at startup and zero at program termination.

$ ld -b foo.o +I my_10x_init -o libfoo.slfont=*

#include <dl.h>
void my_10x_init(shl_t handle, int loading)
{
/* handle is the shl_load API handle for the shared library being initialized. 
/* loading is non-zero at startup and zero at termination. 
*/ if (loading) 
{
... do some initializations ... 
} else 
{... do some clean up ...
}
}

#pragma AUTOPAGE { ON }

#pragma AUTOPAGE { OFF }

LINES Pragma

#pragma LINES linenum

#pragma LIST { ON }

#pragma LIST { OFF }

MSTATS Pragma

#pragma MSTATS

#pragma PAGE

SIGNAL Pragma

#pragma SIGNAL int

Once the signal has been received, the signal function would typically interpret the signal based upon how it is defined (i.e., abort termination, invalid function range, termination request sent to program, etc.).

SUBTITLE Pragma

#pragma SUBTITLE string

TITLE Pragma

#pragma TITLE string

WIDTH Pragma

#pragma WIDTH pagewidth

FLOAT_TRAPS_ON Pragma

#pragma FLOAT_TRAPS_ON { functionname,...functionname }

#pragma FLOAT_TRAPS_ON {_ALL }

The _ALL parameter specifies that loop invariant code motion should be disabled for all functions within the compilation unit.

IF_CONVERT Pragma

#pragma IF_CONVERT

By default at +O2 and higher, the compiler uses heuristics to determine when it is beneficial to apply if-conversion to eliminate a conditional branch. This pragma overrides those heuristics and causes the compiler to eliminate all non-loop control flow within the scope of the pragma

You can specify this pragma to facilitate software pipelining of inner loops that contain conditional code, since the compiler can only software pipeline loops that do not contain control flow. When placed within the scope of an inner loop, this pragma will cause the compiler to eliminate all branches except for the loop back branch.

NO_INLINE Pragma

#pragma NO_INLINE [functionname1,...,functionnamen]

#pragma INLINE_CALL

unroll_factor Pragma

#pragma unroll_facgtor n

A user-specified unroll factor will override the unroll factor computed by the compiler. Specifying n=1 will prevent the compiler from unrolling the loop. Specifiying n=0 will cause the compiler to use its own heuristics to determine the best unroll factor; this is the same as not specifying the pragma. unroll_factor will be ignored if it is placed in a loop other than the innermost loop.

Profile-Based Optimization (PBO) Pragmas

Profile-based optimization (PBO) pragmas correspond to similar command-line options for IPF systems, described in the Optimizing C Programs section of the HP C online help.

The pragmas described in this section allow you to:

• Estimate the execution frequency of the current block compared with the surrounding block.
• Identify functions that are frequently executed
• Identify functions that are infrequently executed

ESTIMATED_FREQUENCY Pragma

#pragma ESTIMATED FREQUENCY f

FREQUENTLY_CALLED Pragma

#pragma FREQUENTLY_CALLED symbol[,symbol]*

RARELY_CALLED Pragma

#pragma RARELY_CALLED symbol[,symbol]*

Symbol Binding Pragmas

DEFAULT_BINDING Pragma

#pragma DEFAULT_BINDING [symbol{,symbol}]

EXTERN Pragma

#pragma EXTERN symbol[,symbol]*

By default, the compiler may bind references to symbols defined in the same translation unit. The only way to override this default is to use the EXTERN pragma or the (analogous) -B general use options. This adds specified symbols to the extern or undefined list, and removes all other lists. The EXTERN pragma works the same as the -Bextern symbol binding option.

NOTE: When specifying a symbol list, all symbols are affected. Specifying no symbol list affects only undefined symbols.

HIDDEN Pragma

#pragma HIDDEN symbol[,symbol]*

The compiler may bypass thelinkage table for both code and data references and bind them to locally defined code and data symbols. In addition, hidden symbols will not be exported outside the current load module. The linker may eliminate them from a shared library, but in an executable, they remain accessible to the debugger unless the +Oprocelim is specified from the command line.

The HIDDEN pragma works the same as the -Bhidden symbol binding option.

NOTE: Using the HIDDEN pragma with no symbol list implies the usage of the -W1, -aarchive_shared options. This causes the linker to prefer an archive library to a shared library if one is available. This can be overriden on the command line by using a a subsequent -W1, -a option.

PROTECTED Pragma

#pragma PROTECTED symbol[,symbol]*

The PROTECTED pragma works the same as the -Bprotected symbol binding option.

NOTE: Specifying PROTECTED with no symbol list implies the usage of the -W1, -aarchive_shared options. This causes the linker to prefer an archive library to a shared library if one is available. This can be overriden on the command line by using a a subsequent -W1, -a option.

Running HP C Programs