This one is better when the result is converted to an Int

In particular, the gcd rule now uses smallInteger rather than S#, which
means that it actually fires.

Also fixed a bug when the result is minBound :: Int.

The GMP docs say:

    Counts of bits of a multi-precision number are represented in the C
    type mp_bitcnt_t. Currently this is always an unsigned long, but on
    some systems it will be an unsigned long long in the future.

Now that divModInteger isn't inlined, we were getting allocations for
both results even if we're just going to throw one away.

Recent change means ul is truncate to an int, not a long anymore.

I didn't diagnose the problem, but with the newer GMP the problem seems
fixed. There are a couple of things that look like candidates for the
bug:
* A few minor bugs related to portability fixed.
* A bug in division code possibly causing incorrect computation was fixed.

We now have rules for
    integerToInt    (smallInteger    x) = x
    integerToWord   (wordToInteger   x) = x
    integerToInt64  (int64ToInteger  x) = x
    integerToWord64 (word64ToInteger x) = x

Now used by GHC to generate Integer literals.

We don't need them to be inlined at all, following changes in how
GHC handles Integers.

integer-simple doesn't export them

The GMP primitives are now in GHC.Integer.GMP.Prim instead.

* GMP uses m4 scripts to pre-process hand coded assembly routines
* These didn't properly account for OS X/i86_64 always using PIC

The type and implementation are now in the same module, so the orphan
instances are no longer orphaned.

This caused an odd dependency in the module hierarchy.

We get lots of code, and the simplifier generally can't do much with
it. We'll instead use builtin rules to do constant folding where
possible.

From daniel.is.fischer.

We were doing
    echo $(HOSTPLATFORM) | sed 's/i[567]86/i486/g'
but the only x86 value HOSTPLATFORM can have is i386.

We now also tell GMP that its build platform is $(BUILDPLATFORM)
rather than $(HOSTPLATFORM).