gh-41171: Speedup and proper fix for gap conversion from sage/python integer
    
follow up to #41057

My machine has `sizeof(mp_limb_t) == sizeof(UInt)` true, but I've tested
both branches by changing the `if ...` to `if False` and see that the
tests pass.

the expression `num_gmp_limbs * sizeof(mp_limb_t)` cannot overflow
(because there's a buffer in memory with that size), so as long as
`sizeof(mp_limb_t) > 1` (which must be the case, see below),
`-num_gmp_limbs` cannot overflow `UInt`.

## note on word size

From `gmp-h.in`:

```
#ifdef __GMP_SHORT_LIMB
typedef unsigned int            mp_limb_t;
typedef int                     mp_limb_signed_t;
#else
#ifdef _LONG_LONG_LIMB
typedef unsigned long long int  mp_limb_t;
typedef long long int           mp_limb_signed_t;
#else
typedef unsigned long int       mp_limb_t;
typedef long int                mp_limb_signed_t;
#endif
#endif
typedef unsigned long int       mp_bitcnt_t;

/* For reference, note that the name __mpz_struct gets into C++ mangled
   function names, which means although the "__" suggests an internal,
we
   must leave this name for binary compatibility.  */
typedef struct
{
  int _mp_alloc;                /* Number of *limbs* allocated and
pointed
                                   to by the _mp_d field.  */
  int _mp_size;                 /* abs(_mp_size) is the number of limbs
the
                                   last field points to.  If _mp_size is
                                   negative this is a negative number.
*/
  mp_limb_t *_mp_d;             /* Pointer to the limbs.  */
} __mpz_struct;
```

From `gap/src/common.h`:

```
typedef intptr_t  Int;
typedef uintptr_t UInt;
```

so their sizes need not always be equal.

## note on gap internal implementation of integer

That said, `gap/src/integer.c` contains this

```
GAP_STATIC_ASSERT( sizeof(mp_limb_t) == sizeof(UInt), "gmp limb size
incompatible with GAP word size");
```

maybe we're safe...? On the other hand it's entirely possible that gap
and sage are compared with different settings of gmp, they're distinct
shared libraries.

also there's this

```
/***********************************************************************
*****
**
**  'ADDR_INT' returns a pointer to the limbs of the large integer
'obj'.
**  'CONST_ADDR_INT' does the same, but returns a const pointer.
*/
EXPORT_INLINE UInt * ADDR_INT(Obj obj)
{
    GAP_ASSERT(IS_LARGEINT(obj));
    return (UInt *)ADDR_OBJ(obj);
}


static Obj GMPorINTOBJ_MPZ( mpz_t v )
{
    return MakeObjInt((const UInt *)v->_mp_d, v->_mp_size);
}
```

the former is actually exported. If we're fine with using more
internals, we could call `NewBag` directly with the correct size, but I
think that's unnecessary.

### 📝 Checklist

<!-- Put an `x` in all the boxes that apply. -->

- [ ] The title is concise and informative.
- [ ] The description explains in detail what this PR is about.
- [ ] I have linked a relevant issue or discussion.
- [ ] I have created tests covering the changes.
- [ ] I have updated the documentation and checked the documentation
preview.

### ⌛ Dependencies

<!-- List all open PRs that this PR logically depends on. For example,
-->
<!-- - #12345: short description why this is a dependency -->
<!-- - #34567: ... -->
    
URL: #41171
Reported by: user202729
Reviewer(s): Chenxin Zhong, Tobias Diez, user202729

Author: Release Manager

src/sage/libs/gap/element.pxd

@@ -15,7 +15,7 @@ from sage.structure.element cimport Element, ModuleElement, RingElement
 cdef Obj make_gap_list(sage_list) except NULL
 cdef Obj make_gap_matrix(sage_list, gap_ring) except NULL
 cdef Obj make_gap_record(sage_dict) except NULL
-cdef Obj make_gap_integer(sage_int) except NULL
+cdef Obj make_gap_integer(x) except NULL
 cdef Obj make_gap_string(sage_string) except NULL
 
 cdef GapElement make_any_gap_element(parent, Obj obj)

src/sage/libs/gap/element.pyx

@@ -16,7 +16,7 @@ elements. For general information about GAP, you should read the
 # ****************************************************************************
 
 from cpython.object cimport Py_EQ, Py_NE, Py_LE, Py_GE, Py_LT, Py_GT
-from cpython.mem cimport PyMem_Malloc, PyMem_Free
+from libc.stdlib cimport free
 
 from sage.libs.gap.gap_includes cimport *
 from sage.libs.gap.libgap import libgap
@@ -25,6 +25,7 @@ from sage.libs.gap.util import GAPError, gap_sig_on, gap_sig_off
 from sage.libs.gmp.mpz cimport *
 from sage.libs.gmp.pylong cimport mpz_get_pylong, mpz_set_pylong
 from sage.cpython.string cimport str_to_bytes, char_to_str
+from sage.rings.integer cimport Integer
 from sage.rings.integer_ring import ZZ
 from sage.rings.rational_field import QQ
 from sage.rings.real_double import RDF
@@ -213,135 +214,79 @@ cdef Obj make_gap_record(sage_dict) except NULL:
         GAP_Leave()
 
 
-cdef Obj make_gap_integer(sage_int) except NULL:
+cdef extern from *:
+    long __BYTE_ORDER__, __ORDER_LITTLE_ENDIAN__
+
+
+cdef Obj make_gap_integer_from_mpz(mpz_srcptr z) except NULL:
+    """
+    Internal helper to convert ``mpz`` integer into ``Gap`` integer.
+    """
+    cdef size_t num_gmp_limbs = mpz_size(z)
+    cdef void* temp
+    cdef size_t num_gap_words
+    if sizeof(mp_limb_t) == sizeof(UInt) or (
+            __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ and sizeof(mp_limb_t) * num_gmp_limbs % sizeof(UInt) == 0):
+        # use GMP internal to avoid memory allocation
+        num_gap_words = num_gmp_limbs * sizeof(mp_limb_t) / sizeof(UInt) if sizeof(mp_limb_t) != sizeof(UInt) else num_gmp_limbs
+        try:
+            GAP_Enter()
+            return GAP_MakeObjInt(<const UInt*>z._mp_d, -num_gap_words if mpz_sgn(z) < 0 else num_gap_words)
+        finally:
+            GAP_Leave()
+    else:
+        temp = mpz_export(NULL, &num_gap_words, -1, sizeof(UInt), 0, 0, z)  # because of sage.ext.memory, this uses sage_sig_malloc
+        try:
+            GAP_Enter()
+            return GAP_MakeObjInt(<const UInt*>temp, -num_gap_words if mpz_sgn(z) < 0 else num_gap_words)
+        finally:
+            GAP_Leave()
+            free(temp)
+
+
+def make_GapElement_Integer_from_sage_integer(parent, Integer x):
+    """
+    Internal helper to convert Sage :class:`~sage.rings.integer.Integer` into GapElement objects.
+    Not to be used directly, use ``libgap(x)`` instead.
+
+    TESTS::
+
+        sage: for x in [0, 1, 2**31, 2**32, 2**63, 2**64, 2**128]:
+        ....:     for y in [x, -x, x-1]:
+        ....:         assert str(libgap(y)) == str(y), y
+
+    Check that the following is fast (i.e. no conversion to decimal is performed)::
+
+        sage: ignore = libgap(1<<500000000)
     """
-    Convert Sage integer or Python integer into Gap integer
+    return make_GapElement_Integer(parent, make_gap_integer_from_mpz(x.value))
+
+
+cdef Obj make_gap_integer(x) except NULL:
+    """
+    Convert Python integer into Gap integer. Not to be used directly, use ``libgap(x)`` instead.
 
     INPUT:
 
-    - ``sage_int`` -- Sage integer or Python int
+    - ``x`` -- Python ``int`` object
 
     OUTPUT: the integer as a GAP ``Obj``
 
-    TESTS:
+    TESTS::
 
-    Test with Sage integers::
+        sage: for x in [0, 1, 2**31, 2**32, 2**63, 2**64, 2**128]:
+        ....:     for y in [x, -x, x-1]:
+        ....:         assert str(libgap(int(y))) == str(y), y
 
-        sage: libgap(0)   # indirect doctest
-        0
-        sage: libgap(1)
-        1
-        sage: libgap(-1)
-        -1
-        sage: libgap(2**31)
-        2147483648
-        sage: libgap(-2**63)
-        -9223372036854775808
-        sage: libgap(2**64)
-        18446744073709551616
-        sage: libgap(-(2**256))
-        -115792089237316195423570985008687907853269984665640564039457584007913129639936
-
-    Test with Python int (not Sage Integer)::
-
-        sage: libgap(int(0))
-        0
-        sage: libgap(int(1))
-        1
-        sage: libgap(int(-1))
-        -1
-        sage: libgap(int(10**30))
-        1000000000000000000000000000000
-        sage: libgap(-int(10**30))
-        -1000000000000000000000000000000
-        sage: libgap(int(2**100))
-        1267650600228229401496703205376
-
-    Test round-trip conversion::
-
-        sage: n = int(123456789012345678901234567890)
-        sage: gap_n = libgap(n)
-        sage: gap_n.sage() == n
-        True
+    Check that the following is fast (i.e. no conversion to decimal is performed)::
 
-        sage: n = factorial(100)
-        sage: gap_n = libgap(n)
-        sage: gap_n.sage() == n
-        True
+        sage: ignore = libgap(int(1<<500000000))
     """
     cdef mpz_t temp
-    cdef Obj result
-    cdef Int size
-    cdef Int sign
-    cdef UInt* limbs = NULL
-    cdef size_t limb_count
-    cdef size_t i
-    
-    # We need to handle this carefully to avoid accessing GMP internals
     mpz_init(temp)
     try:
-        # Convert Python int to GMP mpz_t
-        mpz_set_pylong(temp, sage_int)
-        
-        # Handle zero specially (mpz_size returns 0 for zero)
-        size = mpz_size(temp)
-        if size == 0:
-            return GAP_NewObjIntFromInt(0)
-        
-        # Get the sign: mpz_sgn returns -1, 0, or 1
-        sign = <Int>mpz_sgn(temp)
-        
-        # Allocate limb buffer for export
-        # sizeof(mp_limb_t) may differ from sizeof(UInt), so we need to handle this
-        if sizeof(mp_limb_t) == sizeof(UInt):
-            # Direct case: limb sizes match, we can use mpz_export directly
-            # into a UInt buffer
-            limbs = <UInt*>PyMem_Malloc(size * sizeof(UInt))
-            if limbs == NULL:
-                raise MemoryError("Failed to allocate limb buffer")
-            
-            # Export limbs: order=-1 (least significant first, native GMP/GAP order),
-            # size=sizeof(UInt), endian=0 (native), nails=0 (use full limbs)
-            mpz_export(limbs, &limb_count, -1, sizeof(UInt), 0, 0, temp)
-            
-            # GAP_MakeObjInt expects signed size (negative for negative numbers)
-            if sign < 0:
-                size = -<Int>limb_count
-            else:
-                size = <Int>limb_count
-            
-            try:
-                GAP_Enter()
-                result = GAP_MakeObjInt(<const UInt*>limbs, size)
-            finally:
-                GAP_Leave()
-                PyMem_Free(limbs)
-            
-            return result
-        else:
-            # Fallback case: limb sizes don't match
-            # We need to copy limb-by-limb using mpz_getlimbn
-            # This is slower but portable
-            limbs = <UInt*>PyMem_Malloc(size * sizeof(UInt))
-            if limbs == NULL:
-                raise MemoryError("Failed to allocate limb buffer")
-            
-            # Copy each limb individually
-            for i in range(size):
-                limbs[i] = <UInt>mpz_getlimbn(temp, i)
-            
-            # GAP_MakeObjInt expects signed size
-            if sign < 0:
-                size = -size
-            
-            try:
-                GAP_Enter()
-                result = GAP_MakeObjInt(<const UInt*>limbs, size)
-            finally:
-                GAP_Leave()
-                PyMem_Free(limbs)
-            
-            return result
+        mpz_set_pylong(temp, x)
+        return make_gap_integer_from_mpz(temp)
     finally:
         mpz_clear(temp)
 

src/sage/rings/integer.pyx

@@ -6365,6 +6365,19 @@ cdef class Integer(sage.structure.element.EuclideanDomainElement):
         """
         return str(self)
 
+    def _libgap_(self):
+        """
+        Convert this integer to ``libgap``. Not to be used directly, use ``libgap(x)``.
+
+        EXAMPLES::
+
+            sage: libgap(1)
+            1
+        """
+        from sage.libs.gap.element import make_GapElement_Integer_from_sage_integer  # avoid compile-time dependency
+        from sage.libs.gap.libgap import libgap
+        return make_GapElement_Integer_from_sage_integer(libgap, self)
+
     @property
     def __array_interface__(self):
         """