HP-UX 64-bit compiler and linker changes

Overview

HP C

To compile in 64-bit mode, use the +DD64 command line option, or for PA platforms you can use +DA2.0W.

Note
If you are porting from a previous release of HP-UX, be aware that extended ANSI mode (-Ae) is the default compilation mode since the HP-UX 10.30 release. See the HP C/HP-UX Programmer's Guide (HP part number 92434-90013) or HP aC++ Transition Guide (PDF, 1.1 MB) for information on how to port to ANSI mode.

Porting C programs to the HP-UX 64-bit data model may require some source code changes because longs and pointers change size. In the 64-bit data model, longs and pointers are 64 bits, and ints are 32 bits.

The differences in C data type sizes and alignments are shown:

In general, source code changes are only needed when transitioning to the HP-UX 64-bit data model to correct assumptions made about the size and relationship of int, long, and pointer data types. Examples of programs that require change include:

• Programs that assume that an int is the same size as a long.
• Programs that assume that an int is the same size as a pointer.
• Programs that perform arithmetic or comparison operations between ints, longs and pointers, and between signed numeric types and unsigned numeric types.
• Programs that make assumptions about data item sizes and alignment in structures.
• Programs that use hard-coded constants.

The following new or changed HP C features support 64-bit development:

HP aC++

To compile in 64-bit mode, use the +DD64 command line option. Alternatively, for PA 2.0 platforms you can use +DA2.0W.

Note
Applications written in HP C++ (cfront) must be migrated to ac++ prior to compiling in 64-bit mode. For information on migrating to ac++, see the HP ac++ Transition Guide (PDF, 1.1 MB).

The ac++ compiler on HP-UX 11.x includes support for both the 32-bit data model and the 64-bit data model. In 32-bit mode, integer, long, and pointer types are 32 bits in size. In 64-bit mode, long and pointer types are 64 bits in size, and integers are 32 bits.

The following new HP ac++ features support 64-bit development:

HP Fortran 90

To compile in 64-bit mode, use the +DD64 command line option. Alternatively, on PA 2.0 platforms, you can use +DA2.0W.

HP Fortran and HP C data types

The following table shows the differences between the corresponding data types in HP Fortran and C when compiling in 32-bit mode and in 64-bit mode.

Size differences between HP Fortran 90 and C data Types
HP Fortran data types	C data types
	32-bit mode	64-bit mode	Sizes (in bits)
INTEGER	int or long	int	32
INTEGER*4	int or long	int	32
INTEGER*8	long long	long or long long	64
REAL	float	float	32
DOUBLE PRECISION	double	double	64
REAL*16	long double	long double	128

The following table shows the difference when the Fortran program is compiled with the +autodbl option. (The +autodbl option increases the default size of integer, logical, and real items to 8 bytes, and double precision and complex items to 16 bytes.)

Size differences after compiling with +autodbl
HP Fortran data types	C data types
	32-bit mode	64-bit mode	Sizes (in bits)
INTEGER	long long	long	64
INTEGER*4	int or long	int	32
INTEGER*8	long long	long	64
REAL	double	double	64
DOUBLE PRECISION	long double	long double	128
REAL*16	long double	long double	128

HP Fortran features

Programming toolset

(1) Bundled with compilers. Tools that are not footnoted are bundled with the OS.

Linker toolset

Unsupported linker features for 64-bit PA

Run-time differences

There are two main areas where program startup changes in 64-bit mode on PA platforms:

• Dynamic path searching for shared libraries
• Symbol searching in dependent libraries

It is recommended that you use the standard SVR4 linking option (+std, which is on by default) when linking 64-bit applications. Use the +compat option when linking 64-bit applications to force the linker to use 32-bit linking and dynamic loading behavior. +compat can be used for 32-bit applications for Itanium-based systems to force the 32-bit PA-mode behavior, though we recommend that you avoid using this non-standard behavior.

The following table summarizes the dynamic loader differences between 32-bit and 64-bit mode on PA platforms:

Dynamic path searching for shared libraries

In 32-bit mode, you can enable run-time dynamic path searching of shared libraries in two ways:

• by linking the program with +s, enabling the program to use the path list defined by the SHLIB_PATH environment variable at run time.
• by storing a directory path list in the program with the linker option +b path_list.

If +s or +b path_list is enabled, all shared libraries specified with the -llibrary or l:library linker options are subject to a dynamic path lookup at run time.

In 64-bit mode, the dynamic path searching behavior has changed:

• The +s dynamic path searching option is enabled by default. It is not enabled by default in 32-bit mode.
• The LD_LIBRARY_PATH environment variable is available in addition to the SHLIB_PATH environment variable.
• An embedded run-time path list called RPATH may be stored in the executable.
• If +b path_list is specified, these directories are added to RPATH. If +b path_list is not specified, the linker creates a default RPATH consisting of:
  1. directories in the -L option (if specified), followed by
  2. directories in the LPATH environment variable (if specified)
• By default, in 64-bit mode, the linker ignores the ordering of the +b path_list and +s options.
• At run time, the dynamic loader searches directory paths in the following order:
  1. LD_LIBRARY_PATH (if set), followed by
  2. SHLIB_PATH (if set), followed by
  3. RPATH, followed by
  4. the default locations /lib/pa20_64 and /usr/lib/pa20_64.

Examples

• Linking to libraries by fully qualifying paths:

  In this example, the program is linked with /opt/myapp/mylib.sl:

  $ cc main.o /opt/myapp/mylib.sl 
  
  Perform 32-bit link.
  
  $ cc +DD64 main.o /opt/myapp/mylib.sl 
  
  Perform 64-bit link.
  

  At run-time, in both 32-bit and 64-bit mode, the dynamic loader only looks in /opt/myapp to find mylib.sl.

• Linking to libraries using the -llibrary or -l:library options:

  In this example, the +s option is not explicitly enabled at link time. Two versions of a shared library called libfoo.sl exist; a 32-bit version in /usr/lib and a 64-bit version in /usr/lib/pa20_64:

  $ cc main.o -lfoo -o main 
  
  Perform 32-bit link.
  

  When linked in 32-bit mode, main will abort at run time if libfoo.sl is moved from /usr/lib. This is because the absolute path name of the shared library /usr/lib/libfoo.sl is stored in the executable.

  $ cc +DD64 main.o -lfoo -o main 
  
  Perform 64-bit link.
  

  When linked in 64-bit mode, main will not abort at run time if libfoo.sl is moved, as long as SHLIB_PATH or LD_LIBRARY_PATH is set and point to libfoo.sl.

• Linking to libraries using -L and +b path_list:

  The -L option is used by the linker to locate libraries at link time. The +b option is used to embed a library path list in the executable for use at run time.

  Here is the 32-bit mode example:

  $ cc main.o -L. -Wl,+b/var/tmp -lme  
  
  Link the program.
  $ mv libme.sl /var/tmp/libme.sl      
  
  Move libme.sl.
  $ a.out                             
  
  Run the program.
  

  In 32-bit mode, the dynamic loader searches paths to resolve external references in the following order:

  1. /var/tmp to find libme.sl found
  2. /var/tmp to find libc.sl not found
  3. /usr/lib/libc.sl found

  Here is the 64-bit mode example:

  $ cc +DD64 main.o -L. \
  -Wl,+b/var/tmp -lme 
  
  Link the program.
  
  $ mv libme.sl /var/tmp/libme.sl        
  
  Move libme.sl.
  
  $ a.out                                  
  
  Run the program.
  

  In 64-bit mode, the dynamic loader searches paths to resolve external references in the following order:

  1. LD_LIBRARY_PATH (if set) to find libme.sl
     not found
  2. SHLIB_PATH (if set) to find libme.sl
     not found
  3. /var/tmp to find libme.sl
     found
  4. LD_LIBRARY_PATH (if set) to find libc.sl
     not found
  5. SHLIB_PATH (if set) to find libc.sl
     not found
  6. /var/tmp to find libc.sl not found
  7. /usr/lib/pa20_64/libc.sl
     found

Symbol searching in dependent libraries

In 32-bit mode, the dynamic loader searches shared libraries using a depth-first search order. On Itanium-based platforms, 32-bit and 64-bit native applications both use breadth-first symbol searching.

The following figure shows an example program with shared libraries and compares the two search methods:

Figure 1: Search order of dependent libraries

The commands to build the libraries and the executable in the previous figure are shown:

ld -b lib2.o -o lib2.sl
ld -b lib3.o -o lib3.sl
ld -b lib1.o -L. -l3 -o lib1.sl
cc main.o -Wl,-L. -l1 -l2 -o main

64-bit PA system libraries

The 64-bit file system layout leaves the current 32-bit directory structure intact. This helps preserve binary compatibility with 32-bit versions of shared libraries whose paths are embedded in executables.

The following figure shows the new directory structure:

Figure 2: New subdirectory for 64-bit PA libraries (pa20_64)

The linker automatically finds the correct set of system libraries depending on whether the application is compiled in 32-bit or 64-bit mode.

32-bit and 64-bit PA libraries on Itanium-based platforms

32-bit and 64-bit application interoperability

This table summarizes topics described in Interoperability of 32- and 64-Bit Applications.

pstat_getdynamic(2)
pstat_getipc(2)
pstat_getproc(2)
pstat_getprocvm(2)
pstat_getshm(2)
pstat_getfile(2)

See also

For additional information on Fortran, see:
» HP Fortran 90 Release Notes
» HP Fortran 90 Programmer's Reference

For additional information on linkers and libraries, see:
» HP-UX Linker and Libraries User's Guide

For addition information on 64-bit porting concepts, see:
» HP-UX 64-Bit Porting Concepts