diff --git a/Modules/_math.h b/Modules/_math.h
index 2285b64747c0bd..b8477d2752b7cc 100644
--- a/Modules/_math.h
+++ b/Modules/_math.h
@@ -23,3 +23,42 @@ _Py_log1p(double x)
 }
 
 #define m_log1p _Py_log1p
+
+/*
+   wrapper for atan2 that deals directly with special cases before
+   delegating to the platform libm for the remaining cases.  This
+   is necessary to get consistent behaviour across platforms.
+   Windows, FreeBSD and alpha Tru64 are amongst platforms that don't
+   always follow C99.  Windows screws up atan2 for inf and nan, and
+   alpha Tru64 5.1 doesn't follow C99 for atan2(0., 0.).
+*/
+
+static double
+_Py_atan2(double y, double x)
+{
+    if (isnan(x) || isnan(y))
+        return Py_NAN;
+    if (isinf(y)) {
+        if (isinf(x)) {
+            if (copysign(1., x) == 1.)
+                /* atan2(+-inf, +inf) == +-pi/4 */
+                return copysign(0.25*Py_MATH_PI, y);
+            else
+                /* atan2(+-inf, -inf) == +-pi*3/4 */
+                return copysign(0.75*Py_MATH_PI, y);
+        }
+        /* atan2(+-inf, x) == +-pi/2 for finite x */
+        return copysign(0.5*Py_MATH_PI, y);
+    }
+    if (isinf(x) || y == 0.) {
+        if (copysign(1., x) == 1.)
+            /* atan2(+-y, +inf) = atan2(+-0, +x) = +-0. */
+            return copysign(0., y);
+        else
+            /* atan2(+-y, -inf) = atan2(+-0., -x) = +-pi. */
+            return copysign(Py_MATH_PI, y);
+    }
+    return atan2(y, x);
+}
+
+#define m_atan2 _Py_atan2
diff --git a/Modules/cmathmodule.c b/Modules/cmathmodule.c
index 3c7f0bb6453ef0..71686518d84aa7 100644
--- a/Modules/cmathmodule.c
+++ b/Modules/cmathmodule.c
@@ -324,36 +324,6 @@ cmath_atan_impl(PyObject *module, Py_complex z)
     return r;
 }
 
-/* Windows screws up atan2 for inf and nan, and alpha Tru64 5.1 doesn't follow
-   C99 for atan2(0., 0.). */
-static double
-c_atan2(Py_complex z)
-{
-    if (isnan(z.real) || isnan(z.imag))
-        return Py_NAN;
-    if (isinf(z.imag)) {
-        if (isinf(z.real)) {
-            if (copysign(1., z.real) == 1.)
-                /* atan2(+-inf, +inf) == +-pi/4 */
-                return copysign(0.25*Py_MATH_PI, z.imag);
-            else
-                /* atan2(+-inf, -inf) == +-pi*3/4 */
-                return copysign(0.75*Py_MATH_PI, z.imag);
-        }
-        /* atan2(+-inf, x) == +-pi/2 for finite x */
-        return copysign(0.5*Py_MATH_PI, z.imag);
-    }
-    if (isinf(z.real) || z.imag == 0.) {
-        if (copysign(1., z.real) == 1.)
-            /* atan2(+-y, +inf) = atan2(+-0, +x) = +-0. */
-            return copysign(0., z.imag);
-        else
-            /* atan2(+-y, -inf) = atan2(+-0., -x) = +-pi. */
-            return copysign(Py_MATH_PI, z.imag);
-    }
-    return atan2(z.imag, z.real);
-}
-
 
 static Py_complex atanh_special_values[7][7];
 
@@ -966,7 +936,7 @@ cmath_phase_impl(PyObject *module, Py_complex z)
     double phi;
 
     errno = 0;
-    phi = c_atan2(z); /* should not cause any exception */
+    phi = m_atan2(z.imag, z.real); /* should not cause any exception */
     if (errno != 0)
         return math_error();
     else
@@ -991,7 +961,7 @@ cmath_polar_impl(PyObject *module, Py_complex z)
     double r, phi;
 
     errno = 0;
-    phi = c_atan2(z); /* should not cause any exception */
+    phi = m_atan2(z.imag, z.real); /* should not cause any exception */
     r = _Py_c_abs(z); /* sets errno to ERANGE on overflow */
     if (errno != 0)
         return math_error();
diff --git a/Modules/mathmodule.c b/Modules/mathmodule.c
index 64dfceac8bfea3..d6d0702169e186 100644
--- a/Modules/mathmodule.c
+++ b/Modules/mathmodule.c
@@ -535,43 +535,6 @@ m_lgamma(double x)
     return r;
 }
 
-/*
-   wrapper for atan2 that deals directly with special cases before
-   delegating to the platform libm for the remaining cases.  This
-   is necessary to get consistent behaviour across platforms.
-   Windows, FreeBSD and alpha Tru64 are amongst platforms that don't
-   always follow C99.
-*/
-
-static double
-m_atan2(double y, double x)
-{
-    if (isnan(x) || isnan(y))
-        return Py_NAN;
-    if (isinf(y)) {
-        if (isinf(x)) {
-            if (copysign(1., x) == 1.)
-                /* atan2(+-inf, +inf) == +-pi/4 */
-                return copysign(0.25*Py_MATH_PI, y);
-            else
-                /* atan2(+-inf, -inf) == +-pi*3/4 */
-                return copysign(0.75*Py_MATH_PI, y);
-        }
-        /* atan2(+-inf, x) == +-pi/2 for finite x */
-        return copysign(0.5*Py_MATH_PI, y);
-    }
-    if (isinf(x) || y == 0.) {
-        if (copysign(1., x) == 1.)
-            /* atan2(+-y, +inf) = atan2(+-0, +x) = +-0. */
-            return copysign(0., y);
-        else
-            /* atan2(+-y, -inf) = atan2(+-0., -x) = +-pi. */
-            return copysign(Py_MATH_PI, y);
-    }
-    return atan2(y, x);
-}
-
-
 /* IEEE 754-style remainder operation: x - n*y where n*y is the nearest
    multiple of y to x, taking n even in the case of a tie. Assuming an IEEE 754
    binary floating-point format, the result is always exact. */