snapshot of cl/603397699

Author: rwgk

clif/pybind11/type_casters.h

@@ -68,6 +68,38 @@ struct type_caster<absl::uint128> {
   }
 };
 
+#ifdef ABSL_HAVE_INTRINSIC_INT128
+template <>
+struct type_caster<__int128> {
+ public:
+  PYBIND11_TYPE_CASTER(__int128, _("int128"));
+  bool load(handle src, bool convert) {
+    using ::clif::Clif_PyObjAs;
+    return Clif_PyObjAs(src.ptr(), &value);
+  }
+
+  static handle cast(__int128 src, return_value_policy, handle) {
+    using ::clif::Clif_PyObjFrom;
+    return Clif_PyObjFrom(src, {});
+  }
+};
+
+template <>
+struct type_caster<unsigned __int128> {
+ public:
+  PYBIND11_TYPE_CASTER(unsigned __int128, _("uint128"));
+  bool load(handle src, bool convert) {
+    using ::clif::Clif_PyObjAs;
+    return Clif_PyObjAs(src.ptr(), &value);
+  }
+
+  static handle cast(unsigned __int128 src, return_value_policy, handle) {
+    using ::clif::Clif_PyObjFrom;
+    return Clif_PyObjFrom(src, {});
+  }
+};
+#endif
+
 template <typename ValueAndHolder, typename Value>
 class smart_pointer_vector_caster {
   using value_conv = make_caster<Value>;

clif/python/types.cc

@@ -272,6 +272,24 @@ bool Clif_PyObjAs(PyObject* py, absl::uint128* c) {  // NOLINT: runtime/int
 }
 #endif  // HAVE_LONG_LONG
 
+#ifdef ABSL_HAVE_INTRINSIC_INT128
+bool Clif_PyObjAs(PyObject* py, __int128* c) {  // NOLINT: runtime/int
+  CHECK(c != nullptr);
+  absl::int128 tmp;
+  if (!Clif_PyObjAs(py, &tmp)) return false;
+  *c = __int128{tmp};
+  return true;
+}
+
+bool Clif_PyObjAs(PyObject* py, unsigned __int128* c) {  // NOLINT: runtime/int
+  CHECK(c != nullptr);
+  absl::uint128 tmp;
+  if (!Clif_PyObjAs(py, &tmp)) return false;
+  *c = (unsigned __int128){tmp};
+  return true;
+}
+#endif  // ABSL_HAVE_INTRINSIC_INT128
+
 // float (double)
 bool Clif_PyObjAs(PyObject* py, double* c) {
   CHECK(c != nullptr);

clif/python/types.h

@@ -129,6 +129,19 @@ inline PyObject* Clif_PyObjFrom(absl::uint128 c, const py::PostConv& pc) {
   return pc.Apply(PyNumber_Add(hi, lo));
 }
 #endif
+
+#ifdef ABSL_HAVE_INTRINSIC_INT128
+// CLIF use2 `__int128` as int
+inline PyObject* Clif_PyObjFrom(__int128 c, const py::PostConv& pc) {
+  return Clif_PyObjFrom(absl::int128{c}, pc);
+}
+
+// CLIF use2 `unsigned __int128` as int
+inline PyObject* Clif_PyObjFrom(unsigned __int128 c, const py::PostConv& pc) {
+  return Clif_PyObjFrom(absl::uint128{c}, pc);
+}
+#endif
+
 // CLIF use `unsigned char` as uint8
 inline PyObject* Clif_PyObjFrom(unsigned char c, const py::PostConv& pc) {
   return pc.Apply(PyLong_FromLong(c));
@@ -188,6 +201,10 @@ bool Clif_PyObjAs(PyObject*, long long*);           // NOLINT runtime/int
 bool Clif_PyObjAs(PyObject*, absl::int128*);        // NOLINT runtime/int
 bool Clif_PyObjAs(PyObject*, absl::uint128*);       // NOLINT runtime/int
 #endif
+#ifdef ABSL_HAVE_INTRINSIC_INT128
+bool Clif_PyObjAs(PyObject*, __int128*);
+bool Clif_PyObjAs(PyObject*, unsigned __int128*);
+#endif
 bool Clif_PyObjAs(PyObject*, short*);  // NOLINT runtime/int
 bool Clif_PyObjAs(PyObject*, int*);
 bool Clif_PyObjAs(PyObject*, long*);  // NOLINT runtime/int // Py_ssize_t on x64

clif/testing/absl_int128.h

@@ -1,8 +1,9 @@
 #ifndef CLIF_TESTING_ABSL_INT128_H_
 #define CLIF_TESTING_ABSL_INT128_H_
 
-#include <cstdint>
+#include <limits>
 
+#include "absl/base/config.h"
 #include "absl/numeric/int128.h"
 
 namespace clif_test_absl_int128 {
@@ -16,6 +17,22 @@ inline absl::int128 Min() { return std::numeric_limits<absl::int128>::min(); }
 inline absl::int128 Max() { return std::numeric_limits<absl::int128>::max(); }
 inline absl::int128 AddInt128(absl::int128 a, absl::int128 b) { return a + b; }
 
+#ifdef ABSL_HAVE_INTRINSIC_INT128
+
+inline constexpr bool kHasIntrinsicInt128 = true;
+
+inline __int128 FromAbsl(absl::int128 value) { return __int128{value}; }
+inline absl::int128 ToAbsl(__int128 value) { return absl::int128{value}; }
+
+#else
+
+inline constexpr bool kHasIntrinsicInt128 = false;
+
+inline absl::int128 FromAbsl(absl::int128 /*value*/) { return 0; }
+inline absl::int128 ToAbsl(absl::int128 /*value*/) { return 0; }
+
+#endif
+
 }  // namespace clif_test_absl_int128
 
 #endif  // CLIF_TESTING_ABSL_INT128_H_

clif/testing/absl_uint128.h

@@ -3,6 +3,7 @@
 
 #include <cstdint>
 
+#include "absl/base/config.h"
 #include "absl/numeric/int128.h"
 
 namespace clif_test_absl_uint128 {
@@ -17,6 +18,26 @@ inline absl::uint128 AddUint128(absl::uint128 a, absl::uint128 b) {
   return a + b;
 }
 
+#ifdef ABSL_HAVE_INTRINSIC_INT128
+
+inline constexpr bool kHasIntrinsicUint128 = true;
+
+inline unsigned __int128 FromAbsl(absl::uint128 value) {
+  return (unsigned __int128){value};
+}
+inline absl::uint128 ToAbsl(unsigned __int128 value) {
+  return absl::uint128{value};
+}
+
+#else
+
+inline constexpr bool kHasIntrinsicUint128 = false;
+
+inline absl::uint128 FromAbsl(absl::uint128 /*value*/) { return 0; }
+inline absl::uint128 ToAbsl(absl::uint128 /*value*/) { return 0; }
+
+#endif
+
 }  // namespace clif_test_absl_uint128
 
 #endif  // CLIF_TESTING_ABSL_UINT128_H_

clif/testing/python/absl_int128.clif

@@ -8,3 +8,6 @@ from "clif/testing/absl_int128.h":
     def Min() -> int
     def Max() -> int
     def AddInt128(a: int, b: int) -> int
+    const `kHasIntrinsicInt128` as HAS_INTRINSIC_INT_128: bool
+    def FromAbsl(value: int) -> int
+    def ToAbsl(value: int) -> int

clif/testing/python/absl_int128_test.py

@@ -48,6 +48,18 @@ def testAddNegativeInt128Long(self):
   def testAddInt128NegativeLong(self):
     self.assertEqual(absl_int128.AddInt128(HIGH_LSB, -MAX64), 1)
 
+  def testIntrinsicFromAbsl(self):
+    if absl_int128.HAS_INTRINSIC_INT_128:
+      self.assertEqual(absl_int128.FromAbsl(123), 123)
+    else:
+      self.assertEqual(absl_int128.FromAbsl(123), 0)  # Dummy implementation.
+
+  def testIntrinsicToAbsl(self):
+    if absl_int128.HAS_INTRINSIC_INT_128:
+      self.assertEqual(absl_int128.ToAbsl(123), 123)
+    else:
+      self.assertEqual(absl_int128.ToAbsl(123), 0)  # Dummy implementation.
+
 
 if __name__ == '__main__':
   absltest.main()

clif/testing/python/absl_uint128.clif

@@ -5,3 +5,6 @@ from "clif/testing/absl_uint128.h":
     def SetHighLsb() -> int
     def Max() -> int
     def AddUint128(a: int, b: int) -> int
+    const `kHasIntrinsicUint128` as HAS_INTRINSIC_UINT_128: bool
+    def FromAbsl(value: int) -> int
+    def ToAbsl(value: int) -> int

clif/testing/python/absl_uint128_test.py

@@ -29,6 +29,18 @@ def testAddUint128Int(self):
   def testAddUint128Long(self):
     self.assertEqual(absl_uint128.AddUint128(MAX64, 1), HIGH_LSB)
 
+  def testIntrinsicFromAbsl(self):
+    if absl_uint128.HAS_INTRINSIC_UINT_128:
+      self.assertEqual(absl_uint128.FromAbsl(123), 123)
+    else:
+      self.assertEqual(absl_uint128.FromAbsl(123), 0)  # Dummy implementation.
+
+  def testIntrinsicToAbsl(self):
+    if absl_uint128.HAS_INTRINSIC_UINT_128:
+      self.assertEqual(absl_uint128.ToAbsl(123), 123)
+    else:
+      self.assertEqual(absl_uint128.ToAbsl(123), 0)  # Dummy implementation.
+
 
 if __name__ == '__main__':
   absltest.main()