ABI (Application Binary Interface) refers to the calling conventions between functions, meaning what registers are used and what sizes the various C data types are. ISA (Instruction Set Architecture) refers to the instructions and registers a CPU has available.
Some 64-bit ISA CPUs have both a 64-bit ABI and a 32-bit ABI defined, the
latter for compatibility with older CPUs in the family. GMP supports some
CPUs like this in both ABIs. In fact within GMP ‘ABI’ means a
combination of chip ABI, plus how GMP chooses to use it. For example in some
32-bit ABIs, GMP may support a limb as either a 32-bit long or a 64-bit
long long.
By default GMP chooses the best ABI available for a given system, and this generally gives significantly greater speed. But an ABI can be chosen explicitly to make GMP compatible with other libraries, or particular application requirements. For example,
./configure ABI=32
In all cases it's vital that all object code used in a given program is compiled for the same ABI.
Usually a limb is implemented as a long. When a long long limb
is used this is encoded in the generated gmp.h. This is convenient for
applications, but it does mean that gmp.h will vary, and can't be just
copied around. gmp.h remains compiler independent though, since all
compilers for a particular ABI will be expected to use the same limb type.
Currently no attempt is made to follow whatever conventions a system has for installing library or header files built for a particular ABI. This will probably only matter when installing multiple builds of GMP, and it might be as simple as configuring with a special ‘libdir’, or it might require more than that. Note that builds for different ABIs need to done separately, with a fresh ./configure and make each.
gcc -m64
gcc -m32
(In GCC 2.95 and earlier there's no ‘-m32’ option, it's the only mode.)
gcc -mx32
gcc [built for 2.0w]
cc +DD64
long long for a limb. This ABI is available on hppa64
GNU/Linux and on HP-UX 10 or higher. Applications must be compiled with
gcc [built for 2.0n]
cc +DA2.0 +e
Note that current versions of GCC (eg. 3.2) don't generate 64-bit
instructions for long long operations and so may be slower than for
2.0w. (The GMP assembly code is the same though.)
All three ABIs are available for CPU types ‘hppa2.0w’, ‘hppa2.0’ and ‘hppa64’, but for CPU type ‘hppa2.0n’ only 2.0n or 1.0 are considered.
Note that GCC on HP-UX has no options to choose between 2.0n and 2.0w modes, unlike HP cc. Instead it must be built for one or the other ABI. GMP will detect how it was built, and skip to the corresponding ‘ABI’.
ints and longs are 32 bits and GMP
uses a 64 bit long long for a limb. Applications can be compiled
without any special flags since this ABI is the default in both HP C and GCC,
but for reference the flags are
gcc -milp32
cc +DD32
longs and pointers are 64 bits and GMP uses a
long for a limb. Applications must be compiled with
gcc -mlp64
cc +DD64
On other IA-64 systems, GNU/Linux for instance, ‘ABI=64’ is the only choice.
gcc -mabi=32
cc -32
long long. Applications must be compiled with
gcc -mabi=n32
cc -n32
gcc -mabi=64
cc -64
Note that MIPS GNU/Linux, as of kernel version 2.2, doesn't have the necessary support for n32 or 64 and so only gets a 32-bit limb and the MIPS 2 code.
gcc -maix64
xlc -q64
On 64-bit GNU/Linux, BSD, and Mac OS X/Darwin systems, the applications must be compiled with
gcc -m64
long long limb but with the chip
still in 32-bit mode and using 32-bit calling conventions. This is the default
for systems where the true 64-bit ABI is unavailable. No special compiler
options are typically needed for applications. This ABI is not available under
AIX.
GMP's speed is greatest for the ‘mode64’ ABI, the ‘mode32’ ABI is 2nd best. In ‘ABI=32’ only the 32-bit ISA is used and this doesn't make full use of a 64-bit chip.
gcc -m64
On Solaris applications must be compiled with
gcc -m64 -mptr64 -Wa,-xarch=v9 -mcpu=v9
cc -xarch=v9
On the BSD sparc64 systems no special options are required, since 64-bits is
the only ABI available.
gcc -m32
On Solaris, no special compiler options are required for applications, though using something like the following is recommended. (gcc 2.8 and earlier only support ‘-mv8’ though.)
gcc -mv8plus
cc -xarch=v8plus
GMP speed is greatest in ‘ABI=64’, so it's the default where available. The speed is partly because there are extra registers available and partly because 64-bits is considered the more important case and has therefore had better code written for it.
Don't be confused by the names of the ‘-m’ and ‘-x’ compiler options, they're called ‘arch’ but effectively control both ABI and ISA.
On Solaris 2.6 and earlier, only ‘ABI=32’ is available since the kernel doesn't save all registers.
On Solaris 2.7 with the kernel in 32-bit mode, a normal native build will reject ‘ABI=64’ because the resulting executables won't run. ‘ABI=64’ can still be built if desired by making it look like a cross-compile, for example
./configure --build=none --host=sparcv9-sun-solaris2.7 ABI=64