[haiku-commits] r43010 - in buildtools/trunk/gcc: gmp/doc mpfr

  • From: zooey@xxxxxxxxxxxxxxx
  • To: haiku-commits@xxxxxxxxxxxxx
  • Date: Sun, 30 Oct 2011 20:29:15 +0100 (CET)

Author: zooey
Date: 2011-10-30 20:29:14 +0100 (Sun, 30 Oct 2011)
New Revision: 43010
Changeset: https://dev.haiku-os.org/changeset/43010

Cleanup gcc4 buildtools a bit:
* replace gmp.info-? in gcc/gmp/doc by gmp.info, since the latter
  is the makeinfo target that will otherwise have to be generated
  each time gcc4 is built
* add autom4te.cache to svn:ignore

Added: buildtools/trunk/gcc/gmp/doc/gmp.info
--- buildtools/trunk/gcc/gmp/doc/gmp.info                               (rev 0)
+++ buildtools/trunk/gcc/gmp/doc/gmp.info       2011-10-30 19:29:14 UTC (rev 
@@ -0,0 +1,10703 @@
+This is /home/zooey/Sources/haiku/buildtools/gcc/gmp/doc/gmp.info,
+produced by makeinfo version 4.13 from
+This manual describes how to install and use the GNU multiple precision
+arithmetic library, version 5.0.1.
+   Copyright 1991, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
+2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 Free
+Software Foundation, Inc.
+   Permission is granted to copy, distribute and/or modify this
+document under the terms of the GNU Free Documentation License, Version
+1.3 or any later version published by the Free Software Foundation;
+with no Invariant Sections, with the Front-Cover Texts being "A GNU
+Manual", and with the Back-Cover Texts being "You have freedom to copy
+and modify this GNU Manual, like GNU software".  A copy of the license
+is included in *note GNU Free Documentation License::.
+* gmp: (gmp).                   GNU Multiple Precision Arithmetic Library.
+File: gmp.info,  Node: Top,  Next: Copying,  Prev: (dir),  Up: (dir)
+   This manual describes how to install and use the GNU multiple
+precision arithmetic library, version 5.0.1.
+   Copyright 1991, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
+2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 Free
+Software Foundation, Inc.
+   Permission is granted to copy, distribute and/or modify this
+document under the terms of the GNU Free Documentation License, Version
+1.3 or any later version published by the Free Software Foundation;
+with no Invariant Sections, with the Front-Cover Texts being "A GNU
+Manual", and with the Back-Cover Texts being "You have freedom to copy
+and modify this GNU Manual, like GNU software".  A copy of the license
+is included in *note GNU Free Documentation License::.
+* Menu:
+* Copying::                    GMP Copying Conditions (LGPL).
+* Introduction to GMP::        Brief introduction to GNU MP.
+* Installing GMP::             How to configure and compile the GMP library.
+* GMP Basics::                 What every GMP user should know.
+* Reporting Bugs::             How to usefully report bugs.
+* Integer Functions::          Functions for arithmetic on signed integers.
+* Rational Number Functions::  Functions for arithmetic on rational numbers.
+* Floating-point Functions::   Functions for arithmetic on floats.
+* Low-level Functions::        Fast functions for natural numbers.
+* Random Number Functions::    Functions for generating random numbers.
+* Formatted Output::           `printf' style output.
+* Formatted Input::            `scanf' style input.
+* C++ Class Interface::        Class wrappers around GMP types.
+* BSD Compatible Functions::   All functions found in BSD MP.
+* Custom Allocation::          How to customize the internal allocation.
+* Language Bindings::          Using GMP from other languages.
+* Algorithms::                 What happens behind the scenes.
+* Internals::                  How values are represented behind the scenes.
+* Contributors::               Who brings you this library?
+* References::                 Some useful papers and books to read.
+* GNU Free Documentation License::
+* Concept Index::
+* Function Index::
+File: gmp.info,  Node: Copying,  Next: Introduction to GMP,  Prev: Top,  Up: 
+GNU MP Copying Conditions
+This library is "free"; this means that everyone is free to use it and
+free to redistribute it on a free basis.  The library is not in the
+public domain; it is copyrighted and there are restrictions on its
+distribution, but these restrictions are designed to permit everything
+that a good cooperating citizen would want to do.  What is not allowed
+is to try to prevent others from further sharing any version of this
+library that they might get from you.
+   Specifically, we want to make sure that you have the right to give
+away copies of the library, that you receive source code or else can
+get it if you want it, that you can change this library or use pieces
+of it in new free programs, and that you know you can do these things.
+   To make sure that everyone has such rights, we have to forbid you to
+deprive anyone else of these rights.  For example, if you distribute
+copies of the GNU MP library, you must give the recipients all the
+rights that you have.  You must make sure that they, too, receive or
+can get the source code.  And you must tell them their rights.
+   Also, for our own protection, we must make certain that everyone
+finds out that there is no warranty for the GNU MP library.  If it is
+modified by someone else and passed on, we want their recipients to
+know that what they have is not what we distributed, so that any
+problems introduced by others will not reflect on our reputation.
+   The precise conditions of the license for the GNU MP library are
+found in the Lesser General Public License version 3 that accompanies
+the source code, see `COPYING.LIB'.  Certain demonstration programs are
+provided under the terms of the plain General Public License version 3,
+see `COPYING'.
+File: gmp.info,  Node: Introduction to GMP,  Next: Installing GMP,  Prev: 
Copying,  Up: Top
+1 Introduction to GNU MP
+GNU MP is a portable library written in C for arbitrary precision
+arithmetic on integers, rational numbers, and floating-point numbers.
+It aims to provide the fastest possible arithmetic for all applications
+that need higher precision than is directly supported by the basic C
+   Many applications use just a few hundred bits of precision; but some
+applications may need thousands or even millions of bits.  GMP is
+designed to give good performance for both, by choosing algorithms
+based on the sizes of the operands, and by carefully keeping the
+overhead at a minimum.
+   The speed of GMP is achieved by using fullwords as the basic
+arithmetic type, by using sophisticated algorithms, by including
+carefully optimized assembly code for the most common inner loops for
+many different CPUs, and by a general emphasis on speed (as opposed to
+simplicity or elegance).
+   There is assembly code for these CPUs: ARM, DEC Alpha 21064, 21164,
+and 21264, AMD 29000, AMD K6, K6-2, Athlon, and Athlon64, Hitachi
+SuperH and SH-2, HPPA 1.0, 1.1 and 2.0, Intel Pentium, Pentium
+Pro/II/III, Pentium 4, generic x86, Intel IA-64, i960, Motorola
+MC68000, MC68020, MC88100, and MC88110, Motorola/IBM PowerPC 32 and 64,
+National NS32000, IBM POWER, MIPS R3000, R4000, SPARCv7, SuperSPARC,
+generic SPARCv8, UltraSPARC, DEC VAX, and Zilog Z8000.  Some
+optimizations also for Cray vector systems, Clipper, IBM ROMP (RT), and
+Pyramid AP/XP.
+For up-to-date information on GMP, please see the GMP web pages at
+     `http://gmplib.org/'
+The latest version of the library is available at
+     `ftp://ftp.gnu.org/gnu/gmp/'
+   Many sites around the world mirror `ftp.gnu.org', please use a mirror
+near you, see `http://www.gnu.org/order/ftp.html' for a full list.
+   There are three public mailing lists of interest.  One for release
+announcements, one for general questions and discussions about usage of
+the GMP library and one for bug reports.  For more information, see
+     `http://gmplib.org/mailman/listinfo/'.
+   The proper place for bug reports is <gmp-bugs@xxxxxxxxxx>.  See
+*note Reporting Bugs:: for information about reporting bugs.
+1.1 How to use this Manual
+Everyone should read *note GMP Basics::.  If you need to install the
+library yourself, then read *note Installing GMP::.  If you have a
+system with multiple ABIs, then read *note ABI and ISA::, for the
+compiler options that must be used on applications.
+   The rest of the manual can be used for later reference, although it
+is probably a good idea to glance through it.
+File: gmp.info,  Node: Installing GMP,  Next: GMP Basics,  Prev: Introduction 
to GMP,  Up: Top
+2 Installing GMP
+GMP has an autoconf/automake/libtool based configuration system.  On a
+Unix-like system a basic build can be done with
+     ./configure
+     make
+Some self-tests can be run with
+     make check
+And you can install (under `/usr/local' by default) with
+     make install
+   If you experience problems, please report them to
+<gmp-bugs@xxxxxxxxxx>.  See *note Reporting Bugs::, for information on
+what to include in useful bug reports.
+* Menu:
+* Build Options::
+* ABI and ISA::
+* Notes for Package Builds::
+* Notes for Particular Systems::
+* Known Build Problems::
+* Performance optimization::
+File: gmp.info,  Node: Build Options,  Next: ABI and ISA,  Prev: Installing 
GMP,  Up: Installing GMP
+2.1 Build Options
+All the usual autoconf configure options are available, run `./configure
+--help' for a summary.  The file `INSTALL.autoconf' has some generic
+installation information too.
+     `configure' requires various Unix-like tools.  See *note Notes for
+     Particular Systems::, for some options on non-Unix systems.
+     It might be possible to build without the help of `configure',
+     certainly all the code is there, but unfortunately you'll be on
+     your own.
+Build Directory
+     To compile in a separate build directory, `cd' to that directory,
+     and prefix the configure command with the path to the GMP source
+     directory.  For example
+          cd /my/build/dir
+          /my/sources/gmp-5.0.1/configure
+     Not all `make' programs have the necessary features (`VPATH') to
+     support this.  In particular, SunOS and Slowaris `make' have bugs
+     that make them unable to build in a separate directory.  Use GNU
+     `make' instead.
+`--prefix' and `--exec-prefix'
+     The `--prefix' option can be used in the normal way to direct GMP
+     to install under a particular tree.  The default is `/usr/local'.
+     `--exec-prefix' can be used to direct architecture-dependent files
+     like `libgmp.a' to a different location.  This can be used to share
+     architecture-independent parts like the documentation, but
+     separate the dependent parts.  Note however that `gmp.h' and
+     `mp.h' are architecture-dependent since they encode certain
+     aspects of `libgmp', so it will be necessary to ensure both
+     `$prefix/include' and `$exec_prefix/include' are available to the
+     compiler.
+`--disable-shared', `--disable-static'
+     By default both shared and static libraries are built (where
+     possible), but one or other can be disabled.  Shared libraries
+     result in smaller executables and permit code sharing between
+     separate running processes, but on some CPUs are slightly slower,
+     having a small cost on each function call.
+Native Compilation, `--build=CPU-VENDOR-OS'
+     For normal native compilation, the system can be specified with
+     `--build'.  By default `./configure' uses the output from running
+     `./config.guess'.  On some systems `./config.guess' can determine
+     the exact CPU type, on others it will be necessary to give it
+     explicitly.  For example,
+          ./configure --build=ultrasparc-sun-solaris2.7
+     In all cases the `OS' part is important, since it controls how
+     libtool generates shared libraries.  Running `./config.guess' is
+     the simplest way to see what it should be, if you don't know
+     already.
+Cross Compilation, `--host=CPU-VENDOR-OS'
+     When cross-compiling, the system used for compiling is given by
+     `--build' and the system where the library will run is given by
+     `--host'.  For example when using a FreeBSD Athlon system to build
+     GNU/Linux m68k binaries,
+          ./configure --build=athlon-pc-freebsd3.5 --host=m68k-mac-linux-gnu
+     Compiler tools are sought first with the host system type as a
+     prefix.  For example `m68k-mac-linux-gnu-ranlib' is tried, then
+     plain `ranlib'.  This makes it possible for a set of
+     cross-compiling tools to co-exist with native tools.  The prefix
+     is the argument to `--host', and this can be an alias, such as
+     `m68k-linux'.  But note that tools don't have to be setup this
+     way, it's enough to just have a `PATH' with a suitable
+     cross-compiling `cc' etc.
+     Compiling for a different CPU in the same family as the build
+     system is a form of cross-compilation, though very possibly this
+     would merely be special options on a native compiler.  In any case
+     `./configure' avoids depending on being able to run code on the
+     build system, which is important when creating binaries for a
+     newer CPU since they very possibly won't run on the build system.
+     In all cases the compiler must be able to produce an executable
+     (of whatever format) from a standard C `main'.  Although only
+     object files will go to make up `libgmp', `./configure' uses
+     linking tests for various purposes, such as determining what
+     functions are available on the host system.
+     Currently a warning is given unless an explicit `--build' is used
+     when cross-compiling, because it may not be possible to correctly
+     guess the build system type if the `PATH' has only a
+     cross-compiling `cc'.
+     Note that the `--target' option is not appropriate for GMP.  It's
+     for use when building compiler tools, with `--host' being where
+     they will run, and `--target' what they'll produce code for.
+     Ordinary programs or libraries like GMP are only interested in the
+     `--host' part, being where they'll run.  (Some past versions of
+     GMP used `--target' incorrectly.)
+CPU types
+     In general, if you want a library that runs as fast as possible,
+     you should configure GMP for the exact CPU type your system uses.
+     However, this may mean the binaries won't run on older members of
+     the family, and might run slower on other members, older or newer.
+     The best idea is always to build GMP for the exact machine type
+     you intend to run it on.
+     The following CPUs have specific support.  See `configure.in' for
+     details of what code and compiler options they select.
+        * Alpha: alpha, alphaev5, alphaev56, alphapca56, alphapca57,
+          alphaev6, alphaev67, alphaev68 alphaev7
+        * Cray: c90, j90, t90, sv1
+        * HPPA: hppa1.0, hppa1.1, hppa2.0, hppa2.0n, hppa2.0w, hppa64
+        * IA-64: ia64, itanium, itanium2
+        * MIPS: mips, mips3, mips64
+        * Motorola: m68k, m68000, m68010, m68020, m68030, m68040,
+          m68060, m68302, m68360, m88k, m88110
+        * POWER: power, power1, power2, power2sc
+        * PowerPC: powerpc, powerpc64, powerpc401, powerpc403,
+          powerpc405, powerpc505, powerpc601, powerpc602, powerpc603,
+          powerpc603e, powerpc604, powerpc604e, powerpc620, powerpc630,
+          powerpc740, powerpc7400, powerpc7450, powerpc750, powerpc801,
+          powerpc821, powerpc823, powerpc860, powerpc970
+        * SPARC: sparc, sparcv8, microsparc, supersparc, sparcv9,
+          ultrasparc, ultrasparc2, ultrasparc2i, ultrasparc3, sparc64
+        * x86 family: i386, i486, i586, pentium, pentiummmx, pentiumpro,
+          pentium2, pentium3, pentium4, k6, k62, k63, athlon, amd64,
+          viac3, viac32
+        * Other: a29k, arm, clipper, i960, ns32k, pyramid, sh, sh2, vax,
+          z8k
+     CPUs not listed will use generic C code.
+Generic C Build
+     If some of the assembly code causes problems, or if otherwise
+     desired, the generic C code can be selected with CPU `none'.  For
+     example,
+          ./configure --host=none-unknown-freebsd3.5
+     Note that this will run quite slowly, but it should be portable
+     and should at least make it possible to get something running if
+     all else fails.
+Fat binary, `--enable-fat'
+     Using `--enable-fat' selects a "fat binary" build on x86, where
+     optimized low level subroutines are chosen at runtime according to
+     the CPU detected.  This means more code, but gives good
+     performance on all x86 chips.  (This option might become available
+     for more architectures in the future.)
+     On some systems GMP supports multiple ABIs (application binary
+     interfaces), meaning data type sizes and calling conventions.  By
+     default GMP chooses the best ABI available, but a particular ABI
+     can be selected.  For example
+          ./configure --host=mips64-sgi-irix6 ABI=n32
+     See *note ABI and ISA::, for the available choices on relevant
+     CPUs, and what applications need to do.
+     By default the C compiler used is chosen from among some likely
+     candidates, with `gcc' normally preferred if it's present.  The
+     usual `CC=whatever' can be passed to `./configure' to choose
+     something different.
+     For various systems, default compiler flags are set based on the
+     CPU and compiler.  The usual `CFLAGS="-whatever"' can be passed to
+     `./configure' to use something different or to set good flags for
+     systems GMP doesn't otherwise know.
+     The `CC' and `CFLAGS' used are printed during `./configure', and
+     can be found in each generated `Makefile'.  This is the easiest way
+     to check the defaults when considering changing or adding
+     something.
+     Note that when `CC' and `CFLAGS' are specified on a system
+     supporting multiple ABIs it's important to give an explicit
+     `ABI=whatever', since GMP can't determine the ABI just from the
+     flags and won't be able to select the correct assembly code.
+     If just `CC' is selected then normal default `CFLAGS' for that
+     compiler will be used (if GMP recognises it).  For example
+     `CC=gcc' can be used to force the use of GCC, with default flags
+     (and default ABI).
+     Any flags like `-D' defines or `-I' includes required by the
+     preprocessor should be set in `CPPFLAGS' rather than `CFLAGS'.
+     Compiling is done with both `CPPFLAGS' and `CFLAGS', but
+     preprocessing uses just `CPPFLAGS'.  This distinction is because
+     most preprocessors won't accept all the flags the compiler does.
+     Preprocessing is done separately in some configure tests, and in
+     the `ansi2knr' support for K&R compilers.
+     Some build-time programs are compiled and run to generate
+     host-specific data tables.  `CC_FOR_BUILD' is the compiler used
+     for this.  It doesn't need to be in any particular ABI or mode, it
+     merely needs to generate executables that can run.  The default is
+     to try the selected `CC' and some likely candidates such as `cc'
+     and `gcc', looking for something that works.
+     No flags are used with `CC_FOR_BUILD' because a simple invocation
+     like `cc foo.c' should be enough.  If some particular options are
+     required they can be included as for instance `CC_FOR_BUILD="cc
+     -whatever"'.
+C++ Support, `--enable-cxx'
+     C++ support in GMP can be enabled with `--enable-cxx', in which
+     case a C++ compiler will be required.  As a convenience
+     `--enable-cxx=detect' can be used to enable C++ support only if a
+     compiler can be found.  The C++ support consists of a library
+     `libgmpxx.la' and header file `gmpxx.h' (*note Headers and
+     Libraries::).
+     A separate `libgmpxx.la' has been adopted rather than having C++
+     objects within `libgmp.la' in order to ensure dynamic linked C
+     programs aren't bloated by a dependency on the C++ standard
+     library, and to avoid any chance that the C++ compiler could be
+     required when linking plain C programs.
+     `libgmpxx.la' will use certain internals from `libgmp.la' and can
+     only be expected to work with `libgmp.la' from the same GMP
+     version.  Future changes to the relevant internals will be
+     accompanied by renaming, so a mismatch will cause unresolved
+     symbols rather than perhaps mysterious misbehaviour.
+     In general `libgmpxx.la' will be usable only with the C++ compiler
+     that built it, since name mangling and runtime support are usually
+     incompatible between different compilers.
+     When C++ support is enabled, the C++ compiler and its flags can be
+     set with variables `CXX' and `CXXFLAGS' in the usual way.  The
+     default for `CXX' is the first compiler that works from a list of
+     likely candidates, with `g++' normally preferred when available.
+     The default for `CXXFLAGS' is to try `CFLAGS', `CFLAGS' without
+     `-g', then for `g++' either `-g -O2' or `-O2', or for other
+     compilers `-g' or nothing.  Trying `CFLAGS' this way is convenient
+     when using `gcc' and `g++' together, since the flags for `gcc' will
+     usually suit `g++'.
+     It's important that the C and C++ compilers match, meaning their
+     startup and runtime support routines are compatible and that they
+     generate code in the same ABI (if there's a choice of ABIs on the
+     system).  `./configure' isn't currently able to check these things
+     very well itself, so for that reason `--disable-cxx' is the
+     default, to avoid a build failure due to a compiler mismatch.
+     Perhaps this will change in the future.
+     Incidentally, it's normally not good enough to set `CXX' to the
+     same as `CC'.  Although `gcc' for instance recognises `foo.cc' as
+     C++ code, only `g++' will invoke the linker the right way when
+     building an executable or shared library from C++ object files.
+Temporary Memory, `--enable-alloca=<choice>'
+     GMP allocates temporary workspace using one of the following three
+     methods, which can be selected with for instance
+     `--enable-alloca=malloc-reentrant'.
+        * `alloca' - C library or compiler builtin.
+        * `malloc-reentrant' - the heap, in a re-entrant fashion.
+        * `malloc-notreentrant' - the heap, with global variables.
+     For convenience, the following choices are also available.
+     `--disable-alloca' is the same as `no'.
+        * `yes' - a synonym for `alloca'.
+        * `no' - a synonym for `malloc-reentrant'.
+        * `reentrant' - `alloca' if available, otherwise
+          `malloc-reentrant'.  This is the default.
+        * `notreentrant' - `alloca' if available, otherwise
+          `malloc-notreentrant'.
+     `alloca' is reentrant and fast, and is recommended.  It actually
+     allocates just small blocks on the stack; larger ones use
+     malloc-reentrant.
+     `malloc-reentrant' is, as the name suggests, reentrant and thread
+     safe, but `malloc-notreentrant' is faster and should be used if
+     reentrancy is not required.
+     The two malloc methods in fact use the memory allocation functions
+     selected by `mp_set_memory_functions', these being `malloc' and
+     friends by default.  *Note Custom Allocation::.
+     An additional choice `--enable-alloca=debug' is available, to help
+     when debugging memory related problems (*note Debugging::).
+FFT Multiplication, `--disable-fft'
+     By default multiplications are done using Karatsuba, 3-way Toom,
+     and Fermat FFT.  The FFT is only used on large to very large
+     operands and can be disabled to save code size if desired.
+Berkeley MP, `--enable-mpbsd'
+     The Berkeley MP compatibility library (`libmp') and header file
+     (`mp.h') are built and installed only if `--enable-mpbsd' is used.
+     *Note BSD Compatible Functions::.
+Assertion Checking, `--enable-assert'
+     This option enables some consistency checking within the library.
+     This can be of use while debugging, *note Debugging::.
+Execution Profiling, `--enable-profiling=prof/gprof/instrument'
+     Enable profiling support, in one of various styles, *note
+     Profiling::.
+     Various assembly versions of each mpn subroutines are provided.
+     For a given CPU, a search is made though a path to choose a
+     version of each.  For example `sparcv8' has
+          MPN_PATH="sparc32/v8 sparc32 generic"
+     which means look first for v8 code, then plain sparc32 (which is
+     v7), and finally fall back on generic C.  Knowledgeable users with
+     special requirements can specify a different path.  Normally this
+     is completely unnecessary.
+     The source for the document you're now reading is `doc/gmp.texi',
+     in Texinfo format, see *note Texinfo: (texinfo)Top.
+     Info format `doc/gmp.info' is included in the distribution.  The
+     usual automake targets are available to make PostScript, DVI, PDF
+     and HTML (these will require various TeX and Texinfo tools).
+     DocBook and XML can be generated by the Texinfo `makeinfo' program
+     too, see *note Options for `makeinfo': (texinfo)makeinfo options.
+     Some supplementary notes can also be found in the `doc'
+     subdirectory.
+File: gmp.info,  Node: ABI and ISA,  Next: Notes for Package Builds,  Prev: 
Build Options,  Up: Installing GMP
+2.2 ABI and ISA
+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.
+AMD64 (`x86_64')
+     On AMD64 systems supporting both 32-bit and 64-bit modes for
+     applications, the following ABI choices are available.
+    `ABI=64'
+          The 64-bit ABI uses 64-bit limbs and pointers and makes full
+          use of the chip architecture.  This is the default.
+          Applications will usually not need special compiler flags,
+          but for reference the option is
+               gcc  -m64
+    `ABI=32'
+          The 32-bit ABI is the usual i386 conventions.  This will be
+          slower, and is not recommended except for inter-operating
+          with other code not yet 64-bit capable.  Applications must be
+          compiled with
+               gcc  -m32
+          (In GCC 2.95 and earlier there's no `-m32' option, it's the
+          only mode.)
+HPPA 2.0 (`hppa2.0*', `hppa64')
+    `ABI=2.0w'
+          The 2.0w ABI uses 64-bit limbs and pointers and is available
+          on HP-UX 11 or up.  Applications must be compiled with
+               gcc [built for 2.0w]
+               cc  +DD64
+    `ABI=2.0n'
+          The 2.0n ABI means the 32-bit HPPA 1.0 ABI and all its normal
+          calling conventions, but with 64-bit instructions permitted
+          within functions.  GMP uses a 64-bit `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.)
+    `ABI=1.0'
+          HPPA 2.0 CPUs can run all HPPA 1.0 and 1.1 code in the 32-bit
+          HPPA 1.0 ABI.  No special compiler options are needed for
+          applications.
+     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'.
+IA-64 under HP-UX (`ia64*-*-hpux*', `itanium*-*-hpux*')
+     HP-UX supports two ABIs for IA-64.  GMP performance is the same in
+     both.
+    `ABI=32'
+          In the 32-bit ABI, pointers, `int's and `long's 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
+    `ABI=64'
+          In the 64-bit ABI, `long's 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.
+MIPS under IRIX 6 (`mips*-*-irix[6789]')
+     IRIX 6 always has a 64-bit MIPS 3 or better CPU, and supports ABIs
+     o32, n32, and 64.  n32 or 64 are recommended, and GMP performance
+     will be the same in each.  The default is n32.
+    `ABI=o32'
+          The o32 ABI is 32-bit pointers and integers, and no 64-bit
+          operations.  GMP will be slower than in n32 or 64, this
+          option only exists to support old compilers, eg. GCC 2.7.2.
+          Applications can be compiled with no special flags on an old
+          compiler, or on a newer compiler with
+               gcc  -mabi=32
+               cc   -32
+    `ABI=n32'
+          The n32 ABI is 32-bit pointers and integers, but with a
+          64-bit limb using a `long long'.  Applications must be
+          compiled with
+               gcc  -mabi=n32
+               cc   -n32
+    `ABI=64'
+          The 64-bit ABI is 64-bit pointers and integers.  Applications
+          must be compiled with
+               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.
+PowerPC 64 (`powerpc64', `powerpc620', `powerpc630', `powerpc970', `power4', 
+    `ABI=aix64'
+          The AIX 64 ABI uses 64-bit limbs and pointers and is the
+          default on PowerPC 64 `*-*-aix*' systems.  Applications must
+          be compiled with
+               gcc  -maix64
+               xlc  -q64
+    `ABI=mode64'
+          The `mode64' ABI uses 64-bit limbs and pointers, and is the
+          default on 64-bit GNU/Linux, BSD, and Mac OS X/Darwin
+          systems.  Applications must be compiled with
+               gcc  -m64
+    `ABI=mode32'
+          The `mode32' ABI uses a 64-bit `long long' limb but with the
+          chip still in 32-bit mode and using 32-bit calling
+          conventions.  This is the default on for systems where the
+          true 64-bit ABIs are unavailable.  No special compiler
+          options are needed for applications.
+    `ABI=32'
+          This is the basic 32-bit PowerPC ABI, with a 32-bit limb.  No
+          special compiler options are needed for applications.
+     GMP speed is greatest in `aix64' and `mode32'.  In `ABI=32' only
+     the 32-bit ISA is used and this doesn't make full use of a 64-bit
+     chip.  On a suitable system we could perhaps use more of the ISA,
+     but there are no plans to do so.
+Sparc V9 (`sparc64', `sparcv9', `ultrasparc*')
+    `ABI=64'
+          The 64-bit V9 ABI is available on the various BSD sparc64
+          ports, recent versions of Sparc64 GNU/Linux, and Solaris 2.7
+          and up (when the kernel is in 64-bit mode).  GCC 3.2 or
+          higher, or Sun `cc' is required.  On GNU/Linux, depending on
+          the default `gcc' mode, applications must be compiled with
+               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.
+    `ABI=32'
+          For the basic 32-bit ABI, GMP still uses as much of the V9
+          ISA as it can.  In the Sun documentation this combination is
+          known as "v8plus".  On GNU/Linux, depending on the default
+          `gcc' mode, applications may need to be compiled with
+               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
+File: gmp.info,  Node: Notes for Package Builds,  Next: Notes for Particular 
Systems,  Prev: ABI and ISA,  Up: Installing GMP
+2.3 Notes for Package Builds
+GMP should present no great difficulties for packaging in a binary
+   Libtool is used to build the library and `-version-info' is set
+appropriately, having started from `3:0:0' in GMP 3.0 (*note Library
+interface versions: (libtool)Versioning.).
+   The GMP 4 series will be upwardly binary compatible in each release
+and will be upwardly binary compatible with all of the GMP 3 series.
+Additional function interfaces may be added in each release, so on
+systems where libtool versioning is not fully checked by the loader an
+auxiliary mechanism may be needed to express that a dynamic linked
+application depends on a new enough GMP.
+   An auxiliary mechanism may also be needed to express that
+`libgmpxx.la' (from `--enable-cxx', *note Build Options::) requires
+`libgmp.la' from the same GMP version, since this is not done by the
+libtool versioning, nor otherwise.  A mismatch will result in
+unresolved symbols from the linker, or perhaps the loader.
+   When building a package for a CPU family, care should be taken to use
+`--host' (or `--build') to choose the least common denominator among
+the CPUs which might use the package.  For example this might mean plain
+`sparc' (meaning V7) for SPARCs.
+   For x86s, `--enable-fat' sets things up for a fat binary build,
+making a runtime selection of optimized low level routines.  This is a
+good choice for packaging to run on a range of x86 chips.
+   Users who care about speed will want GMP built for their exact CPU
+type, to make best use of the available optimizations.  Providing a way
+to suitably rebuild a package may be useful.  This could be as simple
+as making it possible for a user to omit `--build' (and `--host') so
+`./config.guess' will detect the CPU.  But a way to manually specify a
+`--build' will be wanted for systems where `./config.guess' is inexact.
+   On systems with multiple ABIs, a packaged build will need to decide
+which among the choices is to be provided, see *note ABI and ISA::.  A
+given run of `./configure' etc will only build one ABI.  If a second
+ABI is also required then a second run of `./configure' etc must be
+made, starting from a clean directory tree (`make distclean').
+   As noted under "ABI and ISA", currently no attempt is made to follow
+system conventions for install locations that vary with ABI, such as
+`/usr/lib/sparcv9' for `ABI=64' as opposed to `/usr/lib' for `ABI=32'.
+A package build can override `libdir' and other standard variables as
+   Note that `gmp.h' is a generated file, and will be architecture and
+ABI dependent.  When attempting to install two ABIs simultaneously it
+will be important that an application compile gets the correct `gmp.h'
+for its desired ABI.  If compiler include paths don't vary with ABI
+options then it might be necessary to create a `/usr/include/gmp.h'
+which tests preprocessor symbols and chooses the correct actual `gmp.h'.
+File: gmp.info,  Node: Notes for Particular Systems,  Next: Known Build 
Problems,  Prev: Notes for Package Builds,  Up: Installing GMP
+2.4 Notes for Particular Systems
+AIX 3 and 4
+     On systems `*-*-aix[34]*' shared libraries are disabled by
+     default, since some versions of the native `ar' fail on the
+     convenience libraries used.  A shared build can be attempted with
+          ./configure --enable-shared --disable-static
+     Note that the `--disable-static' is necessary because in a shared
+     build libtool makes `libgmp.a' a symlink to `libgmp.so',
+     apparently for the benefit of old versions of `ld' which only
+     recognise `.a', but unfortunately this is done even if a fully
+     functional `ld' is available.
+     On systems `arm*-*-*', versions of GCC up to and including 2.95.3
+     have a bug in unsigned division, giving wrong results for some
+     operands.  GMP `./configure' will demand GCC 2.95.4 or later.
+Compaq C++
+     Compaq C++ on OSF 5.1 has two flavours of `iostream', a standard
+     one and an old pre-standard one (see `man iostream_intro').  GMP
+     can only use the standard one, which unfortunately is not the
+     default but must be selected by defining `__USE_STD_IOSTREAM'.
+     Configure with for instance
+          ./configure --enable-cxx CPPFLAGS=-D__USE_STD_IOSTREAM
+Floating Point Mode
+     On some systems, the hardware floating point has a control mode
+     which can set all operations to be done in a particular precision,
+     for instance single, double or extended on x86 systems (x87
+     floating point).  The GMP functions involving a `double' cannot be
+     expected to operate to their full precision when the hardware is
+     in single precision mode.  Of course this affects all code,
+     including application code, not just GMP.
+MS-DOS and MS Windows
+     On an MS-DOS system DJGPP can be used to build GMP, and on an MS
+     Windows system Cygwin, DJGPP and MINGW can be used.  All three are
+     excellent ports of GCC and the various GNU tools.
+          `http://www.cygwin.com/'
+          `http://www.delorie.com/djgpp/'
+          `http://www.mingw.org/'
+     Microsoft also publishes an Interix "Services for Unix" which can
+     be used to build GMP on Windows (with a normal `./configure'), but
+     it's not free software.
+MS Windows DLLs
+     On systems `*-*-cygwin*', `*-*-mingw*' and `*-*-pw32*' by default
+     GMP builds only a static library, but a DLL can be built instead
+     using
+          ./configure --disable-static --enable-shared
+     Static and DLL libraries can't both be built, since certain export
+     directives in `gmp.h' must be different.
+     A MINGW DLL build of GMP can be used with Microsoft C.  Libtool
+     doesn't install a `.lib' format import library, but it can be
+     created with MS `lib' as follows, and copied to the install
+     directory.  Similarly for `libmp' and `libgmpxx'.
+          cd .libs
+          lib /def:libgmp-3.dll.def /out:libgmp-3.lib
+     MINGW uses the C runtime library `msvcrt.dll' for I/O, so
+     applications wanting to use the GMP I/O routines must be compiled
+     with `cl /MD' to do the same.  If one of the other C runtime
+     library choices provided by MS C is desired then the suggestion is
+     to use the GMP string functions and confine I/O to the application.
+Motorola 68k CPU Types
+     `m68k' is taken to mean 68000.  `m68020' or higher will give a
+     performance boost on applicable CPUs.  `m68360' can be used for
+     CPU32 series chips.  `m68302' can be used for "Dragonball" series
+     chips, though this is merely a synonym for `m68000'.
+OpenBSD 2.6
+     `m4' in this release of OpenBSD has a bug in `eval' that makes it
+     unsuitable for `.asm' file processing.  `./configure' will detect
+     the problem and either abort or choose another m4 in the `PATH'.
+     The bug is fixed in OpenBSD 2.7, so either upgrade or use GNU m4.
+Power CPU Types
+     In GMP, CPU types `power*' and `powerpc*' will each use
+     instructions not available on the other, so it's important to
+     choose the right one for the CPU that will be used.  Currently GMP
+     has no assembly code support for using just the common instruction
+     subset.  To get executables that run on both, the current
+     suggestion is to use the generic C code (CPU `none'), possibly
+     with appropriate compiler options (like `-mcpu=common' for `gcc').
+     CPU `rs6000' (which is not a CPU but a family of workstations) is
+     accepted by `config.sub', but is currently equivalent to `none'.
+Sparc CPU Types
+     `sparcv8' or `supersparc' on relevant systems will give a
+     significant performance increase over the V7 code selected by plain
+     `sparc'.
+Sparc App Regs
+     The GMP assembly code for both 32-bit and 64-bit Sparc clobbers the
+     "application registers" `g2', `g3' and `g4', the same way that the

[... truncated: 9716 lines follow ...]

Other related posts:

  • » [haiku-commits] r43010 - in buildtools/trunk/gcc: gmp/doc mpfr - zooey