gh-120950: Fix overflow in math.log() with large int-like argument

Handling of arbitrary large int-like argument is now consistent with
handling arbitrary large int arguments.

Author: serhiy-storchaka

Lib/test/test_math.py

@@ -1208,6 +1208,11 @@ def testLog(self):
         self.ftest('log(10**40, 10**20)', math.log(10**40, 10**20), 2)
         self.ftest('log(10**1000)', math.log(10**1000),
                    2302.5850929940457)
+        self.ftest('log(MyIndexable(32), MyIndexable(2))',
+                   math.log(MyIndexable(32), MyIndexable(2)), 5)
+        self.ftest('log(MyIndexable(10**1000))',
+                   math.log(MyIndexable(10**1000)),
+                   2302.5850929940457)
         self.assertRaises(ValueError, math.log, -1.5)
         self.assertRaises(ValueError, math.log, -10**1000)
         self.assertRaises(ValueError, math.log, 10, -10)
@@ -1230,11 +1235,13 @@ def testLog2(self):
         self.assertEqual(math.log2(1), 0.0)
         self.assertEqual(math.log2(2), 1.0)
         self.assertEqual(math.log2(4), 2.0)
+        self.assertEqual(math.log2(MyIndexable(4)), 2.0)
 
         # Large integer values
         self.assertEqual(math.log2(2**1023), 1023.0)
         self.assertEqual(math.log2(2**1024), 1024.0)
         self.assertEqual(math.log2(2**2000), 2000.0)
+        self.assertEqual(math.log2(MyIndexable(2**2000)), 2000.0)
 
         self.assertRaises(ValueError, math.log2, -1.5)
         self.assertRaises(ValueError, math.log2, NINF)
@@ -1255,6 +1262,9 @@ def testLog10(self):
         self.ftest('log10(1)', math.log10(1), 0)
         self.ftest('log10(10)', math.log10(10), 1)
         self.ftest('log10(10**1000)', math.log10(10**1000), 1000.0)
+        self.ftest('log10(MyIndexable(10))', math.log10(MyIndexable(10)), 1)
+        self.ftest('log10(MyIndexable(10**1000))',
+                   math.log10(MyIndexable(10**1000)), 1000.0)
         self.assertRaises(ValueError, math.log10, -1.5)
         self.assertRaises(ValueError, math.log10, -10**1000)
         self.assertRaises(ValueError, math.log10, NINF)

Modules/mathmodule.c

@@ -2217,41 +2217,63 @@ math_modf_impl(PyObject *module, double x)
    in that int is larger than PY_SSIZE_T_MAX. */
 
 static PyObject*
-loghelper(PyObject* arg, double (*func)(double))
+loghelper_int(PyObject* arg, double (*func)(double))
 {
     /* If it is int, do it ourselves. */
-    if (PyLong_Check(arg)) {
-        double x, result;
-        Py_ssize_t e;
+    double x, result;
+    Py_ssize_t e;
 
-        /* Negative or zero inputs give a ValueError. */
-        if (!_PyLong_IsPositive((PyLongObject *)arg)) {
-            PyErr_SetString(PyExc_ValueError,
-                            "math domain error");
-            return NULL;
-        }
+    /* Negative or zero inputs give a ValueError. */
+    if (!_PyLong_IsPositive((PyLongObject *)arg)) {
+        PyErr_SetString(PyExc_ValueError,
+                        "math domain error");
+        return NULL;
+    }
 
-        x = PyLong_AsDouble(arg);
-        if (x == -1.0 && PyErr_Occurred()) {
-            if (!PyErr_ExceptionMatches(PyExc_OverflowError))
-                return NULL;
-            /* Here the conversion to double overflowed, but it's possible
-               to compute the log anyway.  Clear the exception and continue. */
-            PyErr_Clear();
-            x = _PyLong_Frexp((PyLongObject *)arg, &e);
-            if (x == -1.0 && PyErr_Occurred())
-                return NULL;
-            /* Value is ~= x * 2**e, so the log ~= log(x) + log(2) * e. */
-            result = func(x) + func(2.0) * e;
-        }
-        else
-            /* Successfully converted x to a double. */
-            result = func(x);
-        return PyFloat_FromDouble(result);
+    x = PyLong_AsDouble(arg);
+    if (x == -1.0 && PyErr_Occurred()) {
+        if (!PyErr_ExceptionMatches(PyExc_OverflowError))
+            return NULL;
+        /* Here the conversion to double overflowed, but it's possible
+           to compute the log anyway.  Clear the exception and continue. */
+        PyErr_Clear();
+        x = _PyLong_Frexp((PyLongObject *)arg, &e);
+        if (x == -1.0 && PyErr_Occurred())
+            return NULL;
+        /* Value is ~= x * 2**e, so the log ~= log(x) + log(2) * e. */
+        result = func(x) + func(2.0) * e;
     }
+    else
+        /* Successfully converted x to a double. */
+        result = func(x);
+    return PyFloat_FromDouble(result);
+}
 
+static PyObject*
+loghelper(PyObject* arg, double (*func)(double))
+{
+    /* If it is int, do it ourselves. */
+    if (PyLong_Check(arg)) {
+        return loghelper_int(arg, func);
+    }
     /* Else let libm handle it by itself. */
-    return math_1(arg, func, 0);
+    PyObject *res = math_1(arg, func, 0);
+    if (res == NULL &&
+        PyErr_ExceptionMatches(PyExc_OverflowError) &&
+        PyIndex_Check(arg))
+    {
+        /* Here the conversion to double overflowed, but it's possible
+           to compute the log anyway.  Clear the exception, convert to
+           integer and continue. */
+        PyErr_Clear();
+        arg = _PyNumber_Index(arg);
+        if (arg == NULL) {
+            return NULL;
+        }
+        res = loghelper_int(arg, func);
+        Py_DECREF(arg);
+    }
+    return res;
 }