gccrs: Fix 128-bit non-decimal integer literal saturation

This patch replaces std::strtol with GNU MP (GMP) for arbitrary-precision
parsing. Additionally, the hex literal dispatcher was corrected to
avoid prepending "0x" to the internal string, ensuring compatibility
with mpz_set_str.

gcc/rust/ChangeLog:

	* lex/rust-lex.cc (Lexer::parse_non_decimal_int_literal): Use GMP
	for base conversion to support 128-bit literals.
	(Lexer::parse_non_decimal_int_literals): Fix hex prefix inconsistency
	by passing pure string.

gcc/testsuite/ChangeLog:

	* rust/execute/non_decimal_128_saturation.rs: New test.

Signed-off-by: Enes Cevik <nsvke@proton.me>

Author: nsvke

gcc/rust/lex/rust-lex.cc

@@ -2271,9 +2271,13 @@ Lexer::parse_non_decimal_int_literal (location_t loc, IsDigitFunc is_digit_func,
     }
 
   // convert value to decimal representation
-  long dec_num = std::strtol (existent_str.c_str (), nullptr, base);
-
-  existent_str = std::to_string (dec_num);
+  mpz_t dec_num;
+  mpz_init (dec_num);
+  mpz_set_str (dec_num, existent_str.c_str (), base);
+  char *s = mpz_get_str (NULL, 10, dec_num);
+  existent_str = s;
+  free (s);
+  mpz_clear (dec_num);
 
   // parse in type suffix if it exists
   auto type_suffix_pair = parse_in_type_suffix ();
@@ -2313,7 +2317,8 @@ Lexer::parse_non_decimal_int_literals (location_t loc)
   if (current_char == 'x')
     {
       // hex (integer only)
-      return parse_non_decimal_int_literal (loc, is_x_digit, str + "x", 16);
+      return parse_non_decimal_int_literal (loc, is_x_digit, std::move (str),
+					    16);
     }
   else if (current_char == 'o')
     {

gcc/testsuite/rust/execute/non_decimal_128_saturation.rs

@@ -0,0 +1,29 @@
+// { dg-do run }
+// { dg-options "-O0" }
+#![feature(no_core)]
+#![no_core]
+
+extern "C" {
+    fn abort();
+}
+
+pub fn main() -> i32 {
+    unsafe {
+        let hex_val: u128 = 0x10000000000000000_u128;
+        if *((&hex_val as *const u128 as usize + 8) as *const u8) != 1 {
+            abort();
+        }
+
+        let bin_val: u128 =
+            0b10000000000000000000000000000000000000000000000000000000000000000_u128;
+        if *((&bin_val as *const u128 as usize + 8) as *const u8) != 1 {
+            abort();
+        }
+
+        let oct_val: u128 = 0o2000000000000000000000_u128;
+        if *((&oct_val as *const u128 as usize + 8) as *const u8) != 1 {
+            abort();
+        }
+    }
+    0
+}